Bug 1316205: P1. Remove unused WaveReader. r=kaku
authorJean-Yves Avenard <jyavenard@mozilla.com>
Wed, 09 Nov 2016 12:52:53 +1100
changeset 321852 c61363a3c27106bc7f27929969d87348d84b591e
parent 321851 87e4efe2210fcf79a4731cf7da59327b011147ef
child 321853 133477f27fe6a4aa490cded021cbcb5dd025793d
push id34092
push userjyavenard@mozilla.com
push dateThu, 10 Nov 2016 02:41:34 +0000
treeherderautoland@60bf1293eabf [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
reviewerskaku
bugs1316205
milestone52.0a1
first release with
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
last release without
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
Bug 1316205: P1. Remove unused WaveReader. r=kaku MozReview-Commit-ID: 6pMFt9jrFED
dom/media/DecoderTraits.cpp
dom/media/wave/WaveDecoder.cpp
dom/media/wave/WaveReader.cpp
dom/media/wave/WaveReader.h
dom/media/wave/moz.build
modules/libpref/init/all.js
--- a/dom/media/DecoderTraits.cpp
+++ b/dom/media/DecoderTraits.cpp
@@ -33,17 +33,16 @@
 #endif
 #include "MediaFormatReader.h"
 
 #include "MP3Decoder.h"
 #include "MP3Demuxer.h"
 
 #include "WaveDecoder.h"
 #include "WaveDemuxer.h"
-#include "WaveReader.h"
 
 #include "ADTSDecoder.h"
 #include "ADTSDemuxer.h"
 
 #include "FlacDecoder.h"
 #include "FlacDemuxer.h"
 
 #include "nsPluginHost.h"
@@ -497,18 +496,16 @@ MediaDecoderReader* DecoderTraits::Creat
   if (IsWAVSupportedType(aType)) {
     decoderReader = new MediaFormatReader(aDecoder, new WAVDemuxer(aDecoder->GetResource()));
   } else
   if (IsFlacSupportedType(aType)) {
     decoderReader = new MediaFormatReader(aDecoder, new FlacDemuxer(aDecoder->GetResource()));
   } else
   if (IsOggSupportedType(aType)) {
     decoderReader = new MediaFormatReader(aDecoder, new OggDemuxer(aDecoder->GetResource()));
-  } else if (IsWaveType(aType)) {
-    decoderReader = new WaveReader(aDecoder);
   } else
 #ifdef MOZ_ANDROID_OMX
   if (MediaDecoder::IsAndroidMediaPluginEnabled() &&
       EnsureAndroidMediaPluginHost()->FindDecoder(aType, nullptr)) {
     decoderReader = new AndroidMediaReader(aDecoder, aType);
   } else
 #endif
   if (IsWebMSupportedType(aType)) {
--- a/dom/media/wave/WaveDecoder.cpp
+++ b/dom/media/wave/WaveDecoder.cpp
@@ -1,59 +1,49 @@
 /* -*- 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/. */
 
 #include "WaveDemuxer.h"
-#include "mozilla/Preferences.h"
 #include "MediaDecoderStateMachine.h"
-#include "WaveReader.h"
 #include "WaveDecoder.h"
 #include "MediaFormatReader.h"
 #include "PDMFactory.h"
 
 namespace mozilla {
 
 MediaDecoder*
 WaveDecoder::Clone(MediaDecoderOwner* aOwner)
 {
   return new WaveDecoder(aOwner);
 }
 
 MediaDecoderStateMachine*
 WaveDecoder::CreateStateMachine()
 {
-  if (Preferences::GetBool("media.wave.decoder.enabled", false)) {
-    RefPtr<MediaDecoderReader> reader =
-        new MediaFormatReader(this, new WAVDemuxer(GetResource()));
-    return new MediaDecoderStateMachine(this, reader);
-  } else {
-    return new MediaDecoderStateMachine(this, new WaveReader(this));
-  }
+  return new MediaDecoderStateMachine(
+    this, new MediaFormatReader(this, new WAVDemuxer(GetResource())));
 }
 
 /* static */
 bool
 WaveDecoder::IsEnabled()
 {
   MOZ_ASSERT(NS_IsMainThread());
-  if (!Preferences::GetBool("media.wave.decoder.enabled", false)) {
-    return false;
-  }
   RefPtr<PDMFactory> platform = new PDMFactory();
   return platform->SupportsMimeType(NS_LITERAL_CSTRING("audio/x-wav"),
                                     /* DecoderDoctorDiagnostics* */ nullptr);
 }
 
 /* static */
 bool
 WaveDecoder::CanHandleMediaType(const nsACString& aType,
-                               const nsAString& aCodecs)
+                                const nsAString& aCodecs)
 {
   if (aType.EqualsASCII("audio/wave") || aType.EqualsASCII("audio/x-wav") ||
       aType.EqualsASCII("audio/wav")  || aType.EqualsASCII("audio/x-pn-wav")) {
     return IsEnabled() && (aCodecs.IsEmpty() ||
                            aCodecs.EqualsASCII("1") ||
                            aCodecs.EqualsASCII("6") ||
                            aCodecs.EqualsASCII("7"));
   }
deleted file mode 100644
--- a/dom/media/wave/WaveReader.cpp
+++ /dev/null
@@ -1,689 +0,0 @@
-/* -*- 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/. */
-#include "nsError.h"
-#include "AbstractMediaDecoder.h"
-#include "WaveReader.h"
-#include "MediaDecoderStateMachine.h"
-#include "VideoUtils.h"
-#include "nsISeekableStream.h"
-
-#include <stdint.h>
-#include "mozilla/ArrayUtils.h"
-#include "mozilla/CheckedInt.h"
-#include "mozilla/EndianUtils.h"
-#include "mozilla/UniquePtr.h"
-#include <algorithm>
-
-using namespace mozilla::media;
-
-namespace mozilla {
-
-// Un-comment to enable logging of seek bisections.
-//#define SEEK_LOGGING
-
-extern LazyLogModule gMediaDecoderLog;
-#define LOG(type, msg) MOZ_LOG(gMediaDecoderLog, type, msg)
-#ifdef SEEK_LOGGING
-#define SEEK_LOG(type, msg) MOZ_LOG(gMediaDecoderLog, type, msg)
-#else
-#define SEEK_LOG(type, msg)
-#endif
-
-struct waveIdToName {
-  uint32_t id;
-  nsCString name;
-};
-
-
-// Magic values that identify RIFF chunks we're interested in.
-static const uint32_t RIFF_CHUNK_MAGIC = 0x52494646;
-static const uint32_t WAVE_CHUNK_MAGIC = 0x57415645;
-static const uint32_t FRMT_CHUNK_MAGIC = 0x666d7420;
-static const uint32_t DATA_CHUNK_MAGIC = 0x64617461;
-static const uint32_t LIST_CHUNK_MAGIC = 0x4c495354;
-
-// Size of chunk header.  4 byte chunk header type and 4 byte size field.
-static const uint16_t CHUNK_HEADER_SIZE = 8;
-
-// Size of RIFF header.  RIFF chunk and 4 byte RIFF type.
-static const uint16_t RIFF_INITIAL_SIZE = CHUNK_HEADER_SIZE + 4;
-
-// Size of required part of format chunk.  Actual format chunks may be
-// extended (for non-PCM encodings), but we skip any extended data.
-static const uint16_t WAVE_FORMAT_CHUNK_SIZE = 16;
-
-// PCM encoding type from format chunk.  Linear PCM is the only encoding
-// supported by AudioStream.
-static const uint16_t WAVE_FORMAT_ENCODING_PCM = 1;
-
-// We reject files with more than this number of channels if we're decoding for
-// playback.
-static const uint8_t MAX_CHANNELS = 2;
-
-namespace {
-  uint32_t
-  ReadUint32BE(const char** aBuffer)
-  {
-    uint32_t result = BigEndian::readUint32(*aBuffer);
-    *aBuffer += sizeof(uint32_t);
-    return result;
-  }
-
-  uint32_t
-  ReadUint32LE(const char** aBuffer)
-  {
-    uint32_t result = LittleEndian::readUint32(*aBuffer);
-    *aBuffer += sizeof(uint32_t);
-    return result;
-  }
-
-  int32_t
-  ReadInt24LE(const char** aBuffer)
-  {
-    int32_t result = int32_t((uint8_t((*aBuffer)[2]) << 16) |
-                             (uint8_t((*aBuffer)[1]) << 8 ) |
-                             (uint8_t((*aBuffer)[0])));
-    if (((*aBuffer)[2] & 0x80) == 0x80) {
-      result = (result | 0xff000000);
-    }
-
-    *aBuffer += 3 * sizeof(char);
-    return result;
-  }
-
-  uint16_t
-  ReadUint16LE(const char** aBuffer)
-  {
-    uint16_t result = LittleEndian::readUint16(*aBuffer);
-    *aBuffer += sizeof(uint16_t);
-    return result;
-  }
-
-  int16_t
-  ReadInt16LE(const char** aBuffer)
-  {
-    uint16_t result = LittleEndian::readInt16(*aBuffer);
-    *aBuffer += sizeof(int16_t);
-    return result;
-  }
-
-  uint8_t
-  ReadUint8(const char** aBuffer)
-  {
-    uint8_t result = uint8_t((*aBuffer)[0]);
-    *aBuffer += sizeof(uint8_t);
-    return result;
-  }
-} // namespace
-
-WaveReader::WaveReader(AbstractMediaDecoder* aDecoder)
-  : MediaDecoderReader(aDecoder)
-  , mResource(aDecoder->GetResource())
-{
-  MOZ_COUNT_CTOR(WaveReader);
-}
-
-WaveReader::~WaveReader()
-{
-  MOZ_COUNT_DTOR(WaveReader);
-}
-
-nsresult WaveReader::ReadMetadata(MediaInfo* aInfo,
-                                  MetadataTags** aTags)
-{
-  MOZ_ASSERT(OnTaskQueue());
-
-  bool loaded = LoadRIFFChunk();
-  if (!loaded) {
-    return NS_ERROR_FAILURE;
-  }
-
-  nsAutoPtr<dom::HTMLMediaElement::MetadataTags> tags;
-
-  bool loadAllChunks = LoadAllChunks(tags);
-  if (!loadAllChunks) {
-    return NS_ERROR_FAILURE;
-  }
-
-  mInfo.mAudio.mRate = mSampleRate;
-  mInfo.mAudio.mChannels = mChannels;
-  mInfo.mMetadataDuration.emplace(TimeUnit::FromSeconds(BytesToTime(GetDataLength())));
-
-  *aInfo = mInfo;
-
-  *aTags = tags.forget();
-
-
-  return NS_OK;
-}
-
-template <typename T> T UnsignedByteToAudioSample(uint8_t aValue);
-template <typename T> T SignedShortToAudioSample(int16_t aValue);
-template <typename T> T Signed24bIntToAudioSample(int32_t aValue);
-
-template <> inline float
-UnsignedByteToAudioSample<float>(uint8_t aValue)
-{
-  return aValue * (2.0f / UINT8_MAX) - 1.0f;
-}
-template <> inline int16_t
-UnsignedByteToAudioSample<int16_t>(uint8_t aValue)
-{
-  return int16_t(aValue * UINT16_MAX / UINT8_MAX + INT16_MIN);
-}
-
-template <> inline float
-SignedShortToAudioSample<float>(int16_t aValue)
-{
-  return AudioSampleToFloat(aValue);
-}
-template <> inline int16_t
-SignedShortToAudioSample<int16_t>(int16_t aValue)
-{
-  return aValue;
-}
-
-template <> inline float
-Signed24bIntToAudioSample<float>(int32_t aValue)
-{
-  return aValue / 8388608.0f;
-}
-
-template <> inline int16_t
-Signed24bIntToAudioSample<int16_t>(int32_t aValue)
-{
-  return aValue / 256;
-}
-
-bool WaveReader::DecodeAudioData()
-{
-  MOZ_ASSERT(OnTaskQueue());
-
-  int64_t pos = GetPosition() - mWavePCMOffset;
-  int64_t len = GetDataLength();
-  int64_t remaining = len - pos;
-  NS_ASSERTION(remaining >= 0, "Current wave position is greater than wave file length");
-
-  static const int64_t BLOCK_SIZE = 6144;
-  int64_t readSize = std::min(BLOCK_SIZE, remaining);
-  int64_t frames = readSize / mFrameSize;
-
-  MOZ_ASSERT(BLOCK_SIZE % 3 == 0);
-  MOZ_ASSERT(BLOCK_SIZE % 2 == 0);
-
-  static_assert(uint64_t(BLOCK_SIZE) < UINT_MAX /
-                sizeof(AudioDataValue) / MAX_CHANNELS,
-                "bufferSize calculation could overflow.");
-  const size_t bufferSize = static_cast<size_t>(frames * mChannels);
-  AlignedAudioBuffer sampleBuffer(bufferSize);
-  if (!sampleBuffer) {
-    return false;
-  }
-
-  static_assert(uint64_t(BLOCK_SIZE) < UINT_MAX / sizeof(char),
-                "BLOCK_SIZE too large for enumerator.");
-  auto dataBuffer = MakeUnique<char[]>(static_cast<size_t>(readSize));
-
-  if (!ReadAll(dataBuffer.get(), readSize)) {
-    return false;
-  }
-
-  // convert data to samples
-  const char* d = dataBuffer.get();
-  AudioDataValue* s = sampleBuffer.get();
-  for (int i = 0; i < frames; ++i) {
-    for (unsigned int j = 0; j < mChannels; ++j) {
-      if (mSampleFormat == FORMAT_U8) {
-        uint8_t v =  ReadUint8(&d);
-        *s++ = UnsignedByteToAudioSample<AudioDataValue>(v);
-      } else if (mSampleFormat == FORMAT_S16) {
-        int16_t v =  ReadInt16LE(&d);
-        *s++ = SignedShortToAudioSample<AudioDataValue>(v);
-      } else if (mSampleFormat == FORMAT_S24) {
-        int32_t v =  ReadInt24LE(&d);
-        *s++ = Signed24bIntToAudioSample<AudioDataValue>(v);
-      }
-    }
-  }
-
-  double posTime = BytesToTime(pos);
-  double readSizeTime = BytesToTime(readSize);
-  NS_ASSERTION(posTime <= INT64_MAX / USECS_PER_S, "posTime overflow");
-  NS_ASSERTION(readSizeTime <= INT64_MAX / USECS_PER_S, "readSizeTime overflow");
-  NS_ASSERTION(frames < INT32_MAX, "frames overflow");
-
-  mAudioQueue.Push(new AudioData(pos,
-                                 static_cast<int64_t>(posTime * USECS_PER_S),
-                                 static_cast<int64_t>(readSizeTime * USECS_PER_S),
-                                 static_cast<int32_t>(frames),
-                                 Move(sampleBuffer),
-                                 mChannels,
-                                 mSampleRate));
-
-  return true;
-}
-
-bool WaveReader::DecodeVideoFrame(bool &aKeyframeSkip,
-                                      int64_t aTimeThreshold)
-{
-  MOZ_ASSERT(OnTaskQueue());
-
-  return false;
-}
-
-RefPtr<MediaDecoderReader::SeekPromise>
-WaveReader::Seek(SeekTarget aTarget, int64_t aEndTime)
-{
-  MOZ_ASSERT(OnTaskQueue());
-  LOG(LogLevel::Debug, ("%p About to seek to %lld", mDecoder, aTarget.GetTime().ToMicroseconds()));
-
-  if (NS_FAILED(ResetDecode())) {
-    return SeekPromise::CreateAndReject(NS_ERROR_FAILURE, __func__);
-  }
-  double d = BytesToTime(GetDataLength());
-  NS_ASSERTION(d < INT64_MAX / USECS_PER_S, "Duration overflow");
-  media::TimeUnit duration = media::TimeUnit::FromSeconds(d);
-  double seekTime = std::min(aTarget.GetTime(), duration).ToSeconds();
-  int64_t position = RoundDownToFrame(static_cast<int64_t>(TimeToBytes(seekTime)));
-  NS_ASSERTION(INT64_MAX - mWavePCMOffset > position, "Integer overflow during wave seek");
-  position += mWavePCMOffset;
-  nsresult res = mResource.Seek(nsISeekableStream::NS_SEEK_SET, position);
-  if (NS_FAILED(res)) {
-    return SeekPromise::CreateAndReject(res, __func__);
-  } else {
-    return SeekPromise::CreateAndResolve(aTarget.GetTime(), __func__);
-  }
-}
-
-media::TimeIntervals WaveReader::GetBuffered()
-{
-  MOZ_ASSERT(OnTaskQueue());
-  if (!mInfo.HasAudio()) {
-    return media::TimeIntervals();
-  }
-  media::TimeIntervals buffered;
-  AutoPinned<MediaResource> resource(mDecoder->GetResource());
-  int64_t startOffset = resource->GetNextCachedData(mWavePCMOffset);
-  while (startOffset >= 0) {
-    int64_t endOffset = resource->GetCachedDataEnd(startOffset);
-    // Bytes [startOffset..endOffset] are cached.
-    NS_ASSERTION(startOffset >= mWavePCMOffset, "Integer underflow in GetBuffered");
-    NS_ASSERTION(endOffset >= mWavePCMOffset, "Integer underflow in GetBuffered");
-
-    // We need to round the buffered ranges' times to microseconds so that they
-    // have the same precision as the currentTime and duration attribute on
-    // the media element.
-    buffered += media::TimeInterval(
-      media::TimeUnit::FromSeconds(BytesToTime(startOffset - mWavePCMOffset)),
-      media::TimeUnit::FromSeconds(BytesToTime(endOffset - mWavePCMOffset)));
-    startOffset = resource->GetNextCachedData(endOffset);
-  }
-  return buffered;
-}
-
-bool
-WaveReader::ReadAll(char* aBuf, int64_t aSize, int64_t* aBytesRead)
-{
-  MOZ_ASSERT(OnTaskQueue());
-
-  if (aBytesRead) {
-    *aBytesRead = 0;
-  }
-  uint32_t read = 0;
-  if (NS_FAILED(mResource.Read(aBuf, uint32_t(aSize), &read))) {
-    NS_WARNING("Resource read failed");
-    return false;
-  }
-  if (!read) {
-    return false;
-  }
-  if (aBytesRead) {
-    *aBytesRead = read;
-  }
-  return true;
-}
-
-bool
-WaveReader::LoadRIFFChunk()
-{
-  MOZ_ASSERT(OnTaskQueue());
-
-  char riffHeader[RIFF_INITIAL_SIZE];
-  const char* p = riffHeader;
-
-  MOZ_ASSERT(mResource.Tell() == 0,
-             "LoadRIFFChunk called when resource in invalid state");
-
-  if (!ReadAll(riffHeader, sizeof(riffHeader))) {
-    return false;
-  }
-
-  static_assert(sizeof(uint32_t) * 3 <= RIFF_INITIAL_SIZE,
-                "Reads would overflow riffHeader buffer.");
-  if (ReadUint32BE(&p) != RIFF_CHUNK_MAGIC) {
-    NS_WARNING("resource data not in RIFF format");
-    return false;
-  }
-
-  // Skip over RIFF size field.
-  p += sizeof(uint32_t);
-
-  if (ReadUint32BE(&p) != WAVE_CHUNK_MAGIC) {
-    NS_WARNING("Expected WAVE chunk");
-    return false;
-  }
-
-  return true;
-}
-
-bool
-WaveReader::LoadFormatChunk(uint32_t aChunkSize)
-{
-  MOZ_ASSERT(OnTaskQueue());
-
-  uint32_t rate, channels, frameSize, sampleFormat;
-  char waveFormat[WAVE_FORMAT_CHUNK_SIZE];
-  const char* p = waveFormat;
-
-  // RIFF chunks are always word (two byte) aligned.
-  MOZ_ASSERT(mResource.Tell() % 2 == 0,
-             "LoadFormatChunk called with unaligned resource");
-
-  if (!ReadAll(waveFormat, sizeof(waveFormat))) {
-    return false;
-  }
-
-  static_assert(sizeof(uint16_t) +
-                sizeof(uint16_t) +
-                sizeof(uint32_t) +
-                4 +
-                sizeof(uint16_t) +
-                sizeof(uint16_t) <= sizeof(waveFormat),
-                "Reads would overflow waveFormat buffer.");
-  if (ReadUint16LE(&p) != WAVE_FORMAT_ENCODING_PCM) {
-    NS_WARNING("WAVE is not uncompressed PCM, compressed encodings are not supported");
-    return false;
-  }
-
-  channels = ReadUint16LE(&p);
-  rate = ReadUint32LE(&p);
-
-  // Skip over average bytes per second field.
-  p += 4;
-
-  frameSize = ReadUint16LE(&p);
-
-  sampleFormat = ReadUint16LE(&p);
-
-  // PCM encoded WAVEs are not expected to have an extended "format" chunk,
-  // but I have found WAVEs that have a extended "format" chunk with an
-  // extension size of 0 bytes.  Be polite and handle this rather than
-  // considering the file invalid.  This code skips any extension of the
-  // "format" chunk.
-  if (aChunkSize > WAVE_FORMAT_CHUNK_SIZE) {
-    uint16_t extra = aChunkSize - WAVE_FORMAT_CHUNK_SIZE;
-    extra += extra % 2;
-    if (NS_FAILED(mResource.Seek(nsISeekableStream::NS_SEEK_CUR, extra))) {
-      return false;
-    }
-  }
-
-  // RIFF chunks are always word (two byte) aligned.
-  MOZ_ASSERT(mResource.Tell() % 2 == 0,
-             "LoadFormatChunk left resource unaligned");
-
-  // Make sure metadata is fairly sane.  The rate check is fairly arbitrary,
-  // but the channels check is intentionally limited to mono or stereo
-  // when the media is intended for direct playback because that's what the
-  // audio backend currently supports.
-  unsigned int actualFrameSize = sampleFormat * channels / 8;
-  if (rate < 100 || rate > 96000 ||
-      (((channels < 1 || channels > MAX_CHANNELS) ||
-       (frameSize != 1 && frameSize != 2 && frameSize != 3 &&
-        frameSize != 4 && frameSize != 6)) &&
-       !mIgnoreAudioOutputFormat) ||
-       (sampleFormat != 8 && sampleFormat != 16 && sampleFormat != 24) ||
-      frameSize != actualFrameSize) {
-    NS_WARNING("Invalid WAVE metadata");
-    return false;
-  }
-
-  mSampleRate = rate;
-  mChannels = channels;
-  mFrameSize = frameSize;
-  if (sampleFormat == 8) {
-    mSampleFormat = FORMAT_U8;
-  } else if (sampleFormat == 24) {
-    mSampleFormat = FORMAT_S24;
-  } else {
-    mSampleFormat = FORMAT_S16;
-  }
-  return true;
-}
-
-bool
-WaveReader::FindDataOffset(uint32_t aChunkSize)
-{
-  MOZ_ASSERT(OnTaskQueue());
-
-  // RIFF chunks are always word (two byte) aligned.
-  MOZ_ASSERT(mResource.Tell() % 2 == 0,
-             "FindDataOffset called with unaligned resource");
-
-  int64_t offset = mResource.Tell();
-  if (offset <= 0 || offset > UINT32_MAX) {
-    NS_WARNING("PCM data offset out of range");
-    return false;
-  }
-
-  mWaveLength = aChunkSize;
-  mWavePCMOffset = uint32_t(offset);
-  return true;
-}
-
-double
-WaveReader::BytesToTime(int64_t aBytes) const
-{
-  MOZ_ASSERT(OnTaskQueue());
-  MOZ_ASSERT(aBytes >= 0, "Must be >= 0");
-  return float(aBytes) / mSampleRate / mFrameSize;
-}
-
-int64_t
-WaveReader::TimeToBytes(double aTime) const
-{
-  MOZ_ASSERT(OnTaskQueue());
-  MOZ_ASSERT(aTime >= 0.0f, "Must be >= 0");
-  return RoundDownToFrame(int64_t(aTime * mSampleRate * mFrameSize));
-}
-
-int64_t
-WaveReader::RoundDownToFrame(int64_t aBytes) const
-{
-  MOZ_ASSERT(OnTaskQueue());
-  MOZ_ASSERT(aBytes >= 0, "Must be >= 0");
-  return aBytes - (aBytes % mFrameSize);
-}
-
-int64_t
-WaveReader::GetDataLength()
-{
-  MOZ_ASSERT(OnTaskQueue());
-
-  int64_t length = mWaveLength;
-  // If the decoder has a valid content length, and it's shorter than the
-  // expected length of the PCM data, calculate the playback duration from
-  // the content length rather than the expected PCM data length.
-  int64_t streamLength = mDecoder->GetResource()->GetLength();
-  if (streamLength >= 0) {
-    int64_t dataLength = std::max<int64_t>(0, streamLength - mWavePCMOffset);
-    length = std::min(dataLength, length);
-  }
-  return length;
-}
-
-int64_t
-WaveReader::GetPosition()
-{
-  return mResource.Tell();
-}
-
-bool
-WaveReader::LoadListChunk(uint32_t aChunkSize,
-                          nsAutoPtr<dom::HTMLMediaElement::MetadataTags> &aTags)
-{
-  MOZ_ASSERT(OnTaskQueue());
-
-  // List chunks are always word (two byte) aligned.
-  MOZ_ASSERT(mResource.Tell() % 2 == 0,
-             "LoadListChunk called with unaligned resource");
-
-  static const unsigned int MAX_CHUNK_SIZE = 1 << 16;
-  static_assert(uint64_t(MAX_CHUNK_SIZE) < UINT_MAX / sizeof(char),
-                "MAX_CHUNK_SIZE too large for enumerator.");
-
-  if (aChunkSize > MAX_CHUNK_SIZE || aChunkSize < 4) {
-    return false;
-  }
-
-  auto chunk = MakeUnique<char[]>(aChunkSize);
-  if (!ReadAll(chunk.get(), aChunkSize)) {
-    return false;
-  }
-
-  static const uint32_t INFO_LIST_MAGIC = 0x494e464f;
-  const char* p = chunk.get();
-  if (ReadUint32BE(&p) != INFO_LIST_MAGIC) {
-    return false;
-  }
-
-  const waveIdToName ID_TO_NAME[] = {
-    { 0x49415254, NS_LITERAL_CSTRING("artist") },   // IART
-    { 0x49434d54, NS_LITERAL_CSTRING("comments") }, // ICMT
-    { 0x49474e52, NS_LITERAL_CSTRING("genre") },    // IGNR
-    { 0x494e414d, NS_LITERAL_CSTRING("name") },     // INAM
-  };
-
-  const char* const end = chunk.get() + aChunkSize;
-
-  aTags = new dom::HTMLMediaElement::MetadataTags;
-
-  while (p + 8 < end) {
-    uint32_t id = ReadUint32BE(&p);
-    // Uppercase tag id, inspired by GStreamer's Wave parser.
-    id &= 0xDFDFDFDF;
-
-    uint32_t length = ReadUint32LE(&p);
-
-    // Subchunk shall not exceed parent chunk.
-    if (uint32_t(end - p) < length) {
-      break;
-    }
-
-    // Wrap the string, adjusting length to account for optional
-    // null termination in the chunk.
-    nsCString val(p, length);
-    if (length > 0 && val[length - 1] == '\0') {
-      val.SetLength(length - 1);
-    }
-
-    // Chunks in List::INFO are always word (two byte) aligned. So round up if
-    // necessary.
-    length += length % 2;
-    p += length;
-
-    if (!IsUTF8(val)) {
-      continue;
-    }
-
-    for (size_t i = 0; i < mozilla::ArrayLength(ID_TO_NAME); ++i) {
-      if (id == ID_TO_NAME[i].id) {
-        aTags->Put(ID_TO_NAME[i].name, val);
-        break;
-      }
-    }
-  }
-
-  return true;
-}
-
-bool
-WaveReader::LoadAllChunks(nsAutoPtr<dom::HTMLMediaElement::MetadataTags> &aTags)
-{
-  MOZ_ASSERT(OnTaskQueue());
-
-  // Chunks are always word (two byte) aligned.
-  MOZ_ASSERT(mResource.Tell() % 2 == 0,
-             "LoadAllChunks called with unaligned resource");
-
-  bool loadFormatChunk = false;
-  bool findDataOffset = false;
-
-  for (;;) {
-    static const unsigned int CHUNK_HEADER_SIZE = 8;
-    char chunkHeader[CHUNK_HEADER_SIZE];
-    const char* p = chunkHeader;
-
-    if (!ReadAll(chunkHeader, sizeof(chunkHeader))) {
-      return false;
-    }
-
-    static_assert(sizeof(uint32_t) * 2 <= CHUNK_HEADER_SIZE,
-                  "Reads would overflow chunkHeader buffer.");
-
-    uint32_t magic = ReadUint32BE(&p);
-    uint32_t chunkSize = ReadUint32LE(&p);
-    int64_t chunkStart = GetPosition();
-
-    switch (magic) {
-      case FRMT_CHUNK_MAGIC:
-        loadFormatChunk = LoadFormatChunk(chunkSize);
-        if (!loadFormatChunk) {
-          return false;
-        }
-        break;
-
-      case LIST_CHUNK_MAGIC:
-        if (!aTags) {
-          LoadListChunk(chunkSize, aTags);
-        }
-        break;
-
-      case DATA_CHUNK_MAGIC:
-        findDataOffset = FindDataOffset(chunkSize);
-        return loadFormatChunk && findDataOffset;
-
-      default:
-        break;
-    }
-
-    // RIFF chunks are two-byte aligned, so round up if necessary.
-    chunkSize += chunkSize % 2;
-
-    // Move forward to next chunk
-    CheckedInt64 forward = CheckedInt64(chunkStart) + chunkSize - GetPosition();
-
-    if (!forward.isValid() || forward.value() < 0) {
-      return false;
-    }
-
-    static const int64_t MAX_CHUNK_SIZE = 1 << 16;
-    static_assert(uint64_t(MAX_CHUNK_SIZE) < UINT_MAX / sizeof(char),
-                  "MAX_CHUNK_SIZE too large for enumerator.");
-    auto chunk = MakeUnique<char[]>(MAX_CHUNK_SIZE);
-    while (forward.value() > 0) {
-      int64_t size = std::min(forward.value(), MAX_CHUNK_SIZE);
-      if (!ReadAll(chunk.get(), size)) {
-        return false;
-      }
-      forward -= size;
-    }
-  }
-
-  return false;
-}
-
-} // namespace mozilla
deleted file mode 100644
--- a/dom/media/wave/WaveReader.h
+++ /dev/null
@@ -1,95 +0,0 @@
-/* -*- 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/. */
-#if !defined(WaveReader_h_)
-#define WaveReader_h_
-
-#include "MediaDecoderReader.h"
-#include "MediaResource.h"
-
-#include "mozilla/dom/HTMLMediaElement.h"
-#include "nsAutoPtr.h"
-
-namespace mozilla {
-
-class WaveReader : public MediaDecoderReader
-{
-public:
-  explicit WaveReader(AbstractMediaDecoder* aDecoder);
-
-protected:
-  ~WaveReader();
-
-public:
-  bool DecodeAudioData() override;
-  bool DecodeVideoFrame(bool &aKeyframeSkip,
-                        int64_t aTimeThreshold) override;
-
-  nsresult ReadMetadata(MediaInfo* aInfo, MetadataTags** aTags) override;
-  RefPtr<SeekPromise> Seek(SeekTarget aTarget, int64_t aEndTime) override;
-
-  media::TimeIntervals GetBuffered() override;
-
-private:
-  bool ReadAll(char* aBuf, int64_t aSize, int64_t* aBytesRead = nullptr);
-  bool LoadRIFFChunk();
-  bool LoadFormatChunk(uint32_t aChunkSize);
-  bool FindDataOffset(uint32_t aChunkSize);
-  bool LoadListChunk(uint32_t aChunkSize, nsAutoPtr<dom::HTMLMediaElement::MetadataTags> &aTags);
-  bool LoadAllChunks(nsAutoPtr<dom::HTMLMediaElement::MetadataTags> &aTags);
-
-  // Returns the number of seconds that aBytes represents based on the
-  // current audio parameters.  e.g.  176400 bytes is 1 second at 16-bit
-  // stereo 44.1kHz. The time is rounded to the nearest microsecond.
-  double BytesToTime(int64_t aBytes) const;
-
-  // Returns the number of bytes that aTime represents based on the current
-  // audio parameters.  e.g.  1 second is 176400 bytes at 16-bit stereo
-  // 44.1kHz.
-  int64_t TimeToBytes(double aTime) const;
-
-  // Rounds aBytes down to the nearest complete audio frame.  Assumes
-  // beginning of byte range is already frame aligned by caller.
-  int64_t RoundDownToFrame(int64_t aBytes) const;
-  int64_t GetDataLength();
-  int64_t GetPosition();
-
-  /*
-    Metadata extracted from the WAVE header.  Used to initialize the audio
-    stream, and for byte<->time domain conversions.
-  */
-
-  // Number of samples per second.  Limited to range [100, 96000] in LoadFormatChunk.
-  uint32_t mSampleRate;
-
-  // Number of channels.  Limited to range [1, 2] in LoadFormatChunk.
-  uint32_t mChannels;
-
-  // Size of a single audio frame, which includes a sample for each channel
-  // (interleaved).
-  uint32_t mFrameSize;
-
-  // The sample format of the PCM data. AudioStream::SampleFormat doesn't
-  // support U8.
-  enum {
-    FORMAT_U8,
-    FORMAT_S16,
-    FORMAT_S24
-  } mSampleFormat;
-
-  // Size of PCM data stored in the WAVE as reported by the data chunk in
-  // the media.
-  int64_t mWaveLength;
-
-  // Start offset of the PCM data in the media stream.  Extends mWaveLength
-  // bytes.
-  int64_t mWavePCMOffset;
-
-  MediaResourceIndex mResource;
-};
-
-} // namespace mozilla
-
-#endif
--- a/dom/media/wave/moz.build
+++ b/dom/media/wave/moz.build
@@ -2,21 +2,19 @@
 # vim: set filetype=python:
 # 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/.
 
 EXPORTS += [
     'WaveDecoder.h',
     'WaveDemuxer.h',
-    'WaveReader.h',
 ]
 
 UNIFIED_SOURCES += [
     'WaveDecoder.cpp',
     'WaveDemuxer.cpp',
-    'WaveReader.cpp',
 ]
 
 FINAL_LIBRARY = 'xul'
 
 if CONFIG['GNU_CXX']:
     CXXFLAGS += ['-Wno-error=shadow']
--- a/modules/libpref/init/all.js
+++ b/modules/libpref/init/all.js
@@ -376,17 +376,16 @@ pref("media.gmp.decoder.enabled", false)
 pref("media.gmp.decoder.aac", 0);
 pref("media.gmp.decoder.h264", 0);
 #ifdef MOZ_RAW
 pref("media.raw.enabled", true);
 #endif
 pref("media.ogg.enabled", true);
 pref("media.opus.enabled", true);
 pref("media.wave.enabled", true);
-pref("media.wave.decoder.enabled", true);
 pref("media.webm.enabled", true);
 
 #ifdef MOZ_APPLEMEDIA
 #ifdef MOZ_WIDGET_UIKIT
 pref("media.mp3.enabled", true);
 #endif
 pref("media.apple.mp3.enabled", true);
 pref("media.apple.mp4.enabled", true);