tor-browser

The Tor Browser
git clone https://git.dasho.dev/tor-browser.git
Log | Files | Refs | README | LICENSE

MediaMIMETypes.cpp (8546B)

      1 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
      2 /* vim: set ts=8 sts=2 et sw=2 tw=80: */
      3 /* This Source Code Form is subject to the terms of the Mozilla Public
      4 * License, v. 2.0. If a copy of the MPL was not distributed with this
      5 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
      6 
      7 #include "MediaMIMETypes.h"
      8 
      9 #include "mozilla/dom/MediaCapabilitiesBinding.h"
     10 #include "mozilla/dom/MimeType.h"
     11 #include "nsContentTypeParser.h"
     12 
     13 namespace mozilla {
     14 
     15 template <int N>
     16 static bool StartsWith(const nsACString& string, const char (&prefix)[N]) {
     17  if (N - 1 > string.Length()) {
     18    return false;
     19  }
     20  return memcmp(string.Data(), prefix, N - 1) == 0;
     21 }
     22 
     23 bool MediaMIMEType::HasApplicationMajorType() const {
     24  return StartsWith(mMIMEType, "application/");
     25 }
     26 
     27 bool MediaMIMEType::HasAudioMajorType() const {
     28  return StartsWith(mMIMEType, "audio/");
     29 }
     30 
     31 bool MediaMIMEType::HasVideoMajorType() const {
     32  return StartsWith(mMIMEType, "video/");
     33 }
     34 
     35 size_t MediaMIMEType::SizeOfExcludingThis(MallocSizeOf aMallocSizeOf) const {
     36  return mMIMEType.SizeOfExcludingThisIfUnshared(aMallocSizeOf);
     37 }
     38 
     39 MediaMIMEType::MediaMIMEType(const nsACString& aType) : mMIMEType(aType) {}
     40 
     41 Maybe<MediaMIMEType> MakeMediaMIMEType(const nsAString& aType) {
     42  nsContentTypeParser parser(aType);
     43  nsAutoString mime;
     44  nsresult rv = parser.GetType(mime);
     45  if (!NS_SUCCEEDED(rv) || mime.IsEmpty()) {
     46    return Nothing();
     47  }
     48 
     49  NS_ConvertUTF16toUTF8 mime8{mime};
     50  if (!IsMediaMIMEType(mime8)) {
     51    return Nothing();
     52  }
     53 
     54  return Some(MediaMIMEType(mime8));
     55 }
     56 
     57 Maybe<MediaMIMEType> MakeMediaMIMEType(const nsACString& aType) {
     58  return MakeMediaMIMEType(NS_ConvertUTF8toUTF16(aType));
     59 }
     60 
     61 Maybe<MediaMIMEType> MakeMediaMIMEType(const char* aType) {
     62  if (!aType) {
     63    return Nothing();
     64  }
     65  return MakeMediaMIMEType(nsDependentCString(aType));
     66 }
     67 
     68 bool MediaCodecs::Contains(const nsAString& aCodec) const {
     69  for (const auto& myCodec : Range()) {
     70    if (myCodec == aCodec) {
     71      return true;
     72    }
     73  }
     74  return false;
     75 }
     76 
     77 bool MediaCodecs::ContainsAll(const MediaCodecs& aCodecs) const {
     78  const auto& codecsToTest = aCodecs.Range();
     79  for (const auto& codecToTest : codecsToTest) {
     80    if (!Contains(codecToTest)) {
     81      return false;
     82    }
     83  }
     84  return true;
     85 }
     86 
     87 bool MediaCodecs::ContainsPrefix(const nsAString& aCodecPrefix) const {
     88  const size_t prefixLength = aCodecPrefix.Length();
     89  for (const auto& myCodec : Range()) {
     90    if (myCodec.Length() >= prefixLength &&
     91        memcmp(myCodec.Data(), aCodecPrefix.Data(),
     92               prefixLength * sizeof(char16_t)) == 0) {
     93      return true;
     94    }
     95  }
     96  return false;
     97 }
     98 
     99 size_t MediaCodecs::SizeOfExcludingThis(MallocSizeOf aMallocSizeOf) const {
    100  return mCodecs.SizeOfExcludingThisIfUnshared(aMallocSizeOf);
    101 }
    102 
    103 static int32_t GetParameterAsNumber(const nsContentTypeParser& aParser,
    104                                    const char* aParameter,
    105                                    const int32_t aErrorReturn) {
    106  nsAutoString parameterString;
    107  nsresult rv = aParser.GetParameter(aParameter, parameterString);
    108  if (NS_FAILED_impl(rv)) {
    109    return aErrorReturn;
    110  }
    111  int32_t number = parameterString.ToInteger(&rv);
    112  if (MOZ_UNLIKELY(NS_FAILED_impl(rv))) {
    113    return aErrorReturn;
    114  }
    115  return number;
    116 }
    117 
    118 MediaExtendedMIMEType::MediaExtendedMIMEType(
    119    const nsACString& aOriginalString, const nsACString& aMIMEType,
    120    bool aHaveCodecs, const nsAString& aCodecs, int32_t aWidth, int32_t aHeight,
    121    double aFramerate, int32_t aBitrate)
    122    : mOriginalString(aOriginalString),
    123      mMIMEType(aMIMEType),
    124      mHaveCodecs(aHaveCodecs),
    125      mCodecs(aCodecs),
    126      mWidth(aWidth),
    127      mHeight(aHeight),
    128      mFramerate(aFramerate),
    129      mBitrate(aBitrate) {}
    130 
    131 MediaExtendedMIMEType::MediaExtendedMIMEType(
    132    const nsACString& aOriginalString, const nsACString& aMIMEType,
    133    bool aHaveCodecs, const nsAString& aCodecs, int32_t aChannels,
    134    int32_t aSamplerate, int32_t aBitrate)
    135    : mOriginalString(aOriginalString),
    136      mMIMEType(aMIMEType),
    137      mHaveCodecs(aHaveCodecs),
    138      mCodecs(aCodecs),
    139      mChannels(aChannels),
    140      mSamplerate(aSamplerate),
    141      mBitrate(aBitrate) {}
    142 
    143 MediaExtendedMIMEType::MediaExtendedMIMEType(const MediaMIMEType& aType)
    144    : mOriginalString(aType.AsString()), mMIMEType(aType) {}
    145 
    146 MediaExtendedMIMEType::MediaExtendedMIMEType(MediaMIMEType&& aType)
    147    : mOriginalString(aType.AsString()), mMIMEType(std::move(aType)) {}
    148 
    149 Maybe<MediaExtendedMIMEType> MakeMediaExtendedMIMEType(const nsAString& aType) {
    150  nsContentTypeParser parser(aType);
    151  nsAutoString mime;
    152  nsresult rv = parser.GetType(mime);
    153  if (!NS_SUCCEEDED(rv) || mime.IsEmpty()) {
    154    return Nothing();
    155  }
    156 
    157  NS_ConvertUTF16toUTF8 mime8{mime};
    158  if (!IsMediaMIMEType(mime8)) {
    159    return Nothing();
    160  }
    161 
    162  nsAutoString codecs;
    163  rv = parser.GetParameter("codecs", codecs);
    164  bool haveCodecs = NS_SUCCEEDED(rv);
    165 
    166  int32_t width = GetParameterAsNumber(parser, "width", -1);
    167  int32_t height = GetParameterAsNumber(parser, "height", -1);
    168  double framerate = GetParameterAsNumber(parser, "framerate", -1);
    169  int32_t bitrate = GetParameterAsNumber(parser, "bitrate", -1);
    170 
    171  return Some(MediaExtendedMIMEType(NS_ConvertUTF16toUTF8(aType), mime8,
    172                                    haveCodecs, codecs, width, height,
    173                                    framerate, bitrate));
    174 }
    175 
    176 Maybe<MediaExtendedMIMEType> MakeMediaExtendedMIMEType(
    177    const dom::VideoConfiguration& aConfig) {
    178  if (aConfig.mContentType.IsEmpty()) {
    179    return Nothing();
    180  }
    181  nsContentTypeParser parser(aConfig.mContentType);
    182  nsAutoString mime;
    183  nsresult rv = parser.GetType(mime);
    184  if (!NS_SUCCEEDED(rv) || mime.IsEmpty()) {
    185    return Nothing();
    186  }
    187 
    188  NS_ConvertUTF16toUTF8 mime8{mime};
    189  if (!IsMediaMIMEType(mime8)) {
    190    return Nothing();
    191  }
    192 
    193  nsAutoString codecs;
    194  rv = parser.GetParameter("codecs", codecs);
    195  bool haveCodecs = NS_SUCCEEDED(rv);
    196 
    197  if (!std::isfinite(aConfig.mFramerate) || aConfig.mFramerate <= 0.0) {
    198    return Nothing();
    199  }
    200 
    201  return Some(MediaExtendedMIMEType(
    202      NS_ConvertUTF16toUTF8(aConfig.mContentType), mime8, haveCodecs, codecs,
    203      aConfig.mWidth, aConfig.mHeight, aConfig.mFramerate, aConfig.mBitrate));
    204 }
    205 
    206 Maybe<MediaExtendedMIMEType> MakeMediaExtendedMIMEType(
    207    const dom::AudioConfiguration& aConfig) {
    208  if (aConfig.mContentType.IsEmpty()) {
    209    return Nothing();
    210  }
    211  nsContentTypeParser parser(aConfig.mContentType);
    212  nsAutoString mime;
    213  nsresult rv = parser.GetType(mime);
    214  if (!NS_SUCCEEDED(rv) || mime.IsEmpty()) {
    215    return Nothing();
    216  }
    217 
    218  NS_ConvertUTF16toUTF8 mime8{mime};
    219  if (!IsMediaMIMEType(mime8)) {
    220    return Nothing();
    221  }
    222 
    223  nsAutoString codecs;
    224  rv = parser.GetParameter("codecs", codecs);
    225  bool haveCodecs = NS_SUCCEEDED(rv);
    226 
    227  int32_t channels = 2;  // use a stereo config if not known.
    228  if (aConfig.mChannels.WasPassed()) {
    229    // A channels string was passed. Make sure it is valid.
    230    nsresult error;
    231    double value = aConfig.mChannels.Value().ToDouble(&error);
    232    if (NS_FAILED(error)) {
    233      return Nothing();
    234    }
    235    // Value is a channel configuration such as 5.1. We want to treat this as 6.
    236    channels = value;
    237    double fp = value - channels;
    238    // round up as .1 and .2 aren't exactly expressible in binary.
    239    channels += (fp * 10) + .5;
    240  }
    241 
    242  return Some(MediaExtendedMIMEType(
    243      NS_ConvertUTF16toUTF8(aConfig.mContentType), mime8, haveCodecs, codecs,
    244      channels,
    245      aConfig.mSamplerate.WasPassed() ? aConfig.mSamplerate.Value() : 48000,
    246      aConfig.mBitrate.WasPassed() ? aConfig.mBitrate.Value() : 131072));
    247 }
    248 
    249 size_t MediaExtendedMIMEType::GetParameterCount() const {
    250  if (mNumParamsCached) {
    251    return mNumParams;
    252  }
    253  mNumParamsCached = true;
    254  RefPtr<CMimeType> parsed = CMimeType::Parse(mOriginalString);
    255  mNumParams = parsed ? parsed->GetParameterCount() : 0;
    256  return mNumParams;
    257 }
    258 
    259 size_t MediaExtendedMIMEType::SizeOfExcludingThis(
    260    MallocSizeOf aMallocSizeOf) const {
    261  return mOriginalString.SizeOfExcludingThisIfUnshared(aMallocSizeOf) +
    262         mMIMEType.SizeOfExcludingThis(aMallocSizeOf) +
    263         mCodecs.SizeOfExcludingThis(aMallocSizeOf);
    264 }
    265 
    266 Maybe<MediaExtendedMIMEType> MakeMediaExtendedMIMEType(
    267    const nsACString& aType) {
    268  return MakeMediaExtendedMIMEType(NS_ConvertUTF8toUTF16(aType));
    269 }
    270 
    271 Maybe<MediaExtendedMIMEType> MakeMediaExtendedMIMEType(const char* aType) {
    272  if (!aType) {
    273    return Nothing();
    274  }
    275  return MakeMediaExtendedMIMEType(nsDependentCString(aType));
    276 }
    277 
    278 }  // namespace mozilla