summaryrefslogtreecommitdiffstats
path: root/dom/media/MP3FrameParser.h
diff options
context:
space:
mode:
Diffstat (limited to 'dom/media/MP3FrameParser.h')
-rw-r--r--dom/media/MP3FrameParser.h219
1 files changed, 219 insertions, 0 deletions
diff --git a/dom/media/MP3FrameParser.h b/dom/media/MP3FrameParser.h
new file mode 100644
index 000000000..d2ba791fd
--- /dev/null
+++ b/dom/media/MP3FrameParser.h
@@ -0,0 +1,219 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim:set ts=2 sw=2 sts=2 et cindent: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef MP3FrameParser_h
+#define MP3FrameParser_h
+
+#include <stdint.h>
+
+#include "mozilla/Mutex.h"
+#include "nsString.h"
+#include "Intervals.h"
+
+namespace mozilla {
+
+// Simple parser to tell whether we've found an ID3 header and how long it is,
+// so that we can skip it.
+// XXX maybe actually parse this stuff?
+class ID3Parser
+{
+public:
+ ID3Parser();
+
+ void Reset();
+ bool ParseChar(char ch);
+ bool IsParsed() const;
+ uint32_t GetHeaderLength() const;
+
+private:
+ uint32_t mCurrentChar;
+ uint8_t mVersion;
+ uint8_t mFlags;
+ uint32_t mHeaderLength;
+};
+
+struct MP3Frame {
+ uint16_t mSync1 : 8; // Always all set
+ uint16_t mProtected : 1; // Ignored
+ uint16_t mLayer : 2;
+ uint16_t mVersion : 2;
+ uint16_t mSync2 : 3; // Always all set
+ uint16_t mPrivate : 1; // Ignored
+ uint16_t mPad : 1;
+ uint16_t mSampleRate : 2; // Index into mpeg_srates above
+ uint16_t mBitrate : 4; // Index into mpeg_bitrates above
+
+ uint16_t CalculateLength();
+};
+
+// Buffering parser for MP3 frames.
+class MP3Parser
+{
+public:
+ MP3Parser();
+
+ // Forget all data the parser has seen so far.
+ void Reset();
+
+ // Parse the given byte. If we have found a frame header, return the length of
+ // the frame.
+ uint16_t ParseFrameLength(uint8_t ch);
+
+ // Get the sample rate from the current header.
+ uint32_t GetSampleRate();
+
+ // Get the number of samples per frame.
+ uint32_t GetSamplesPerFrame();
+
+private:
+ uint32_t mCurrentChar;
+ union {
+ uint8_t mRaw[3];
+ MP3Frame mFrame;
+ } mData;
+};
+
+
+// A description of the MP3 format and its extensions is available at
+//
+// http://www.codeproject.com/Articles/8295/MPEG-Audio-Frame-Header
+//
+// The data in MP3 streams is split into small frames, with each frame
+// containing a fixed number of samples. The duration of a frame depends
+// on the frame's bit rate and sample rate. Both values can vary among
+// frames, so it is necessary to examine each individual frame of an MP3
+// stream to calculate the stream's overall duration.
+//
+// The MP3 frame parser extracts information from an MP3 data stream. It
+// accepts a range of frames of an MP3 stream as input, and parses all
+// frames for their duration. Callers can query the stream's overall
+// duration from the parser.
+//
+// Call the methods NotifyDataArrived or Parse to add new data. If you added
+// information for a certain stream position, you cannot go back to previous
+// positions. The parser will simply ignore the input. If you skip stream
+// positions, the duration of the related MP3 frames will be estimated from
+// the stream's average.
+//
+// The method GetDuration returns calculated duration of the stream, including
+// estimates for skipped ranges.
+//
+// All public methods are thread-safe.
+
+class MP3FrameParser
+{
+public:
+ explicit MP3FrameParser(int64_t aLength=-1);
+
+ bool IsMP3() {
+ MutexAutoLock mon(mLock);
+ return mIsMP3 != NOT_MP3;
+ }
+
+ void Parse(const uint8_t* aBuffer, uint32_t aLength, uint64_t aStreamOffset);
+
+ // Returns the duration, in microseconds. If the entire stream has not
+ // been parsed yet, this is an estimate based on the bitrate of the
+ // frames parsed so far.
+ int64_t GetDuration();
+
+ // Returns the offset of the first MP3 frame in the stream, or -1 of
+ // no MP3 frame has been detected yet.
+ int64_t GetMP3Offset();
+
+ // Returns true if we've seen the whole first frame of the MP3 stream, and
+ // therefore can make an estimate on the stream duration.
+ // Otherwise, returns false.
+ bool ParsedHeaders();
+
+ // Returns true if we know the exact duration of the MP3 stream;
+ // false otherwise.
+ bool HasExactDuration();
+
+ // Returns true if the parser needs more data for duration estimation.
+ bool NeedsData();
+ // Assign the total lenght of this mp3 stream
+ void SetLength(int64_t aLength) {
+ MutexAutoLock mon(mLock);
+ mLength = aLength;
+ }
+private:
+
+ // Parses aBuffer, starting at offset 0. Returns the number of bytes
+ // parsed, relative to the start of the buffer. Note this may be
+ // greater than aLength if the headers in the buffer indicate that
+ // the frame or ID3 tag extends outside of aBuffer. Returns failure
+ // if too many non-MP3 bytes are parsed.
+ nsresult ParseBuffer(const uint8_t* aBuffer,
+ uint32_t aLength,
+ int64_t aStreamOffset,
+ uint32_t* aOutBytesRead);
+
+ // A low-contention lock for protecting the parser results
+ Mutex mLock;
+
+ // ID3 header parser. Keeps state between reads in case the header falls
+ // in between.
+ ID3Parser mID3Parser;
+
+ // MP3 frame header parser.
+ MP3Parser mMP3Parser;
+
+ // If we read |MAX_SKIPPED_BYTES| from the stream without finding any MP3
+ // frames, we give up and report |NOT_MP3|. Here we track the cumulative size
+ // of any ID3 headers we've seen so big ID3 sections aren't counted towards
+ // skipped bytes.
+ uint32_t mTotalID3Size;
+
+ // All fields below are protected by mLock
+
+ // We keep stats on the size of all the frames we've seen, as well as how many
+ // so that we can estimate the duration of the rest of the stream.
+ uint64_t mTotalFrameSize;
+ uint64_t mFrameCount;
+
+ // Offset of the last data parsed. This is the end offset of the last data
+ // block parsed, so it's the start offset we expect to get on the next
+ // call to Parse().
+ uint64_t mOffset;
+
+ // Total length of the stream in bytes.
+ int64_t mLength;
+
+ // Offset of first MP3 frame in the bitstream. Has value -1 until the
+ // first MP3 frame is found.
+ int64_t mMP3Offset;
+
+ // The exact number of frames in this stream, if we know it. -1 otherwise.
+ int64_t mNumFrames;
+
+ // Number of audio samples per second and per frame. Fixed through the whole
+ // file. If we know these variables as well as the number of frames in the
+ // file, we can get an exact duration for the stream.
+ uint16_t mSamplesPerSecond;
+ uint16_t mSamplesPerFrame;
+
+ // If the MP3 has a variable bitrate, then there *should* be metadata about
+ // the encoding in the first frame. We buffer the first frame here.
+ nsCString mFirstFrame;
+
+ // While we are reading the first frame, this is the stream offset of the
+ // last byte of that frame. -1 at all other times.
+ int64_t mFirstFrameEnd;
+
+ enum eIsMP3 {
+ MAYBE_MP3, // We're giving the stream the benefit of the doubt...
+ DEFINITELY_MP3, // We've hit at least one ID3 tag or MP3 frame.
+ NOT_MP3 // Not found any evidence of the stream being MP3.
+ };
+
+ eIsMP3 mIsMP3;
+
+};
+
+} // namespace mozilla
+
+#endif