From 5f8de423f190bbb79a62f804151bc24824fa32d8 Mon Sep 17 00:00:00 2001 From: "Matt A. Tobin" Date: Fri, 2 Feb 2018 04:16:08 -0500 Subject: Add m-esr52 at 52.6.0 --- dom/media/MP3FrameParser.h | 219 +++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 219 insertions(+) create mode 100644 dom/media/MP3FrameParser.h (limited to 'dom/media/MP3FrameParser.h') 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 + +#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 -- cgit v1.2.3