dom/media/ipc/MediaIPCUtils.h

   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 #ifndef mozilla_dom_media_MediaIPCUtils_h
   8 #define mozilla_dom_media_MediaIPCUtils_h
   9
  10 #include "DecoderDoctorDiagnostics.h"
  11 #include "PlatformDecoderModule.h"
  12 #include "ipc/EnumSerializer.h"
  13 #include "mozilla/EnumSet.h"
  14 #include "mozilla/GfxMessageUtils.h"
  15 #include "mozilla/gfx/Rect.h"
  16
  17 namespace IPC {
  18 template <>
  19 struct ParamTraits<mozilla::VideoInfo> {
  20   typedef mozilla::VideoInfo paramType;
  21
  22   static void Write(MessageWriter* aWriter, const paramType& aParam) {
  23     // TrackInfo
  24     WriteParam(aWriter, aParam.mMimeType);
  25
  26     // VideoInfo
  27     WriteParam(aWriter, aParam.mDisplay);
  28     WriteParam(aWriter, aParam.mStereoMode);
  29     WriteParam(aWriter, aParam.mImage);
  30     WriteParam(aWriter, aParam.mImageRect);
  31     WriteParam(aWriter, *aParam.mCodecSpecificConfig);
  32     WriteParam(aWriter, *aParam.mExtraData);
  33     WriteParam(aWriter, aParam.mRotation);
  34     WriteParam(aWriter, aParam.mColorDepth);
  35     WriteParam(aWriter, aParam.mColorSpace);
  36     WriteParam(aWriter, aParam.mColorPrimaries);
  37     WriteParam(aWriter, aParam.mTransferFunction);
  38     WriteParam(aWriter, aParam.mColorRange);
  39     WriteParam(aWriter, aParam.HasAlpha());
  40   }
  41
  42   static bool Read(MessageReader* aReader, paramType* aResult) {
  43     mozilla::gfx::IntRect imageRect;
  44     bool alphaPresent;
  45     if (ReadParam(aReader, &aResult->mMimeType) &&
  46         ReadParam(aReader, &aResult->mDisplay) &&
  47         ReadParam(aReader, &aResult->mStereoMode) &&
  48         ReadParam(aReader, &aResult->mImage) &&
  49         ReadParam(aReader, &aResult->mImageRect) &&
  50         ReadParam(aReader, aResult->mCodecSpecificConfig.get()) &&
  51         ReadParam(aReader, aResult->mExtraData.get()) &&
  52         ReadParam(aReader, &aResult->mRotation) &&
  53         ReadParam(aReader, &aResult->mColorDepth) &&
  54         ReadParam(aReader, &aResult->mColorSpace) &&
  55         ReadParam(aReader, &aResult->mColorPrimaries) &&
  56         ReadParam(aReader, &aResult->mTransferFunction) &&
  57         ReadParam(aReader, &aResult->mColorRange) &&
  58         ReadParam(aReader, &alphaPresent)) {
  59       aResult->SetAlpha(alphaPresent);
  60       return true;
  61     }
  62     return false;
  63   }
  64 };
  65
  66 template <>
  67 struct ParamTraits<mozilla::TrackInfo::TrackType>
  68     : public ContiguousEnumSerializerInclusive<
  69           mozilla::TrackInfo::TrackType,
  70           mozilla::TrackInfo::TrackType::kUndefinedTrack,
  71           mozilla::TrackInfo::TrackType::kTextTrack> {};
  72
  73 template <>
  74 struct ParamTraits<mozilla::VideoInfo::Rotation>
  75     : public ContiguousEnumSerializerInclusive<
  76           mozilla::VideoInfo::Rotation, mozilla::VideoInfo::Rotation::kDegree_0,
  77           mozilla::VideoInfo::Rotation::kDegree_270> {};
  78
  79 template <>
  80 struct ParamTraits<mozilla::MediaByteBuffer>
  81     : public ParamTraits<nsTArray<uint8_t>> {
  82   typedef mozilla::MediaByteBuffer paramType;
  83 };
  84
  85 // Traits for AudioCodecSpecificVariant types.
  86
  87 template <>
  88 struct ParamTraits<mozilla::NoCodecSpecificData>
  89     : public EmptyStructSerializer<mozilla::NoCodecSpecificData> {};
  90
  91 template <>
  92 struct ParamTraits<mozilla::AudioCodecSpecificBinaryBlob> {
  93   using paramType = mozilla::AudioCodecSpecificBinaryBlob;
  94
  95   static void Write(MessageWriter* aWriter, const paramType& aParam) {
  96     WriteParam(aWriter, *aParam.mBinaryBlob);
  97   }
  98   static bool Read(MessageReader* aReader, paramType* aResult) {
  99     return ReadParam(aReader, aResult->mBinaryBlob.get());
 100   }
 101 };
 102
 103 template <>
 104 struct ParamTraits<mozilla::AacCodecSpecificData> {
 105   using paramType = mozilla::AacCodecSpecificData;
 106
 107   static void Write(MessageWriter* aWriter, const paramType& aParam) {
 108     WriteParam(aWriter, *aParam.mEsDescriptorBinaryBlob);
 109     WriteParam(aWriter, *aParam.mDecoderConfigDescriptorBinaryBlob);
 110   }
 111   static bool Read(MessageReader* aReader, paramType* aResult) {
 112     return ReadParam(aReader, aResult->mEsDescriptorBinaryBlob.get()) &&
 113            ReadParam(aReader,
 114                      aResult->mDecoderConfigDescriptorBinaryBlob.get());
 115   }
 116 };
 117
 118 template <>
 119 struct ParamTraits<mozilla::FlacCodecSpecificData> {
 120   using paramType = mozilla::FlacCodecSpecificData;
 121
 122   static void Write(MessageWriter* aWriter, const paramType& aParam) {
 123     WriteParam(aWriter, *aParam.mStreamInfoBinaryBlob);
 124   }
 125   static bool Read(MessageReader* aReader, paramType* aResult) {
 126     return ReadParam(aReader, aResult->mStreamInfoBinaryBlob.get());
 127   }
 128 };
 129
 130 template <>
 131 struct ParamTraits<mozilla::Mp3CodecSpecificData>
 132     : public PlainOldDataSerializer<mozilla::Mp3CodecSpecificData> {};
 133
 134 template <>
 135 struct ParamTraits<mozilla::OpusCodecSpecificData> {
 136   using paramType = mozilla::OpusCodecSpecificData;
 137
 138   static void Write(MessageWriter* aWriter, const paramType& aParam) {
 139     WriteParam(aWriter, aParam.mContainerCodecDelayMicroSeconds);
 140     WriteParam(aWriter, *aParam.mHeadersBinaryBlob);
 141   }
 142   static bool Read(MessageReader* aReader, paramType* aResult) {
 143     return ReadParam(aReader, &aResult->mContainerCodecDelayMicroSeconds) &&
 144            ReadParam(aReader, aResult->mHeadersBinaryBlob.get());
 145   }
 146 };
 147
 148 template <>
 149 struct ParamTraits<mozilla::VorbisCodecSpecificData> {
 150   using paramType = mozilla::VorbisCodecSpecificData;
 151
 152   static void Write(MessageWriter* aWriter, const paramType& aParam) {
 153     WriteParam(aWriter, *aParam.mHeadersBinaryBlob);
 154   }
 155   static bool Read(MessageReader* aReader, paramType* aResult) {
 156     return ReadParam(aReader, aResult->mHeadersBinaryBlob.get());
 157   }
 158 };
 159
 160 template <>
 161 struct ParamTraits<mozilla::WaveCodecSpecificData>
 162     : public EmptyStructSerializer<mozilla::WaveCodecSpecificData> {};
 163
 164 // End traits for AudioCodecSpecificVariant types.
 165
 166 template <>
 167 struct ParamTraits<mozilla::AudioInfo> {
 168   typedef mozilla::AudioInfo paramType;
 169
 170   static void Write(MessageWriter* aWriter, const paramType& aParam) {
 171     // TrackInfo
 172     WriteParam(aWriter, aParam.mMimeType);
 173
 174     // AudioInfo
 175     WriteParam(aWriter, aParam.mRate);
 176     WriteParam(aWriter, aParam.mChannels);
 177     WriteParam(aWriter, aParam.mChannelMap);
 178     WriteParam(aWriter, aParam.mBitDepth);
 179     WriteParam(aWriter, aParam.mProfile);
 180     WriteParam(aWriter, aParam.mExtendedProfile);
 181     WriteParam(aWriter, aParam.mCodecSpecificConfig);
 182   }
 183
 184   static bool Read(MessageReader* aReader, paramType* aResult) {
 185     if (ReadParam(aReader, &aResult->mMimeType) &&
 186         ReadParam(aReader, &aResult->mRate) &&
 187         ReadParam(aReader, &aResult->mChannels) &&
 188         ReadParam(aReader, &aResult->mChannelMap) &&
 189         ReadParam(aReader, &aResult->mBitDepth) &&
 190         ReadParam(aReader, &aResult->mProfile) &&
 191         ReadParam(aReader, &aResult->mExtendedProfile) &&
 192         ReadParam(aReader, &aResult->mCodecSpecificConfig)) {
 193       return true;
 194     }
 195     return false;
 196   }
 197 };
 198
 199 template <>
 200 struct ParamTraits<mozilla::MediaDataDecoder::ConversionRequired>
 201     : public ContiguousEnumSerializerInclusive<
 202           mozilla::MediaDataDecoder::ConversionRequired,
 203           mozilla::MediaDataDecoder::ConversionRequired(0),
 204           mozilla::MediaDataDecoder::ConversionRequired(
 205               mozilla::MediaDataDecoder::ConversionRequired::kNeedAnnexB)> {};
 206
 207 template <>
 208 struct ParamTraits<mozilla::media::TimeUnit> {
 209   typedef mozilla::media::TimeUnit paramType;
 210
 211   static void Write(MessageWriter* aWriter, const paramType& aParam) {
 212     WriteParam(aWriter, aParam.IsValid());
 213     WriteParam(aWriter, aParam.IsValid() ? aParam.ToMicroseconds() : 0);
 214   }
 215
 216   static bool Read(MessageReader* aReader, paramType* aResult) {
 217     bool valid;
 218     int64_t value;
 219     if (ReadParam(aReader, &valid) && ReadParam(aReader, &value)) {
 220       if (!valid) {
 221         *aResult = mozilla::media::TimeUnit::Invalid();
 222       } else {
 223         *aResult = mozilla::media::TimeUnit::FromMicroseconds(value);
 224       }
 225       return true;
 226     }
 227     return false;
 228   };
 229 };
 230
 231 template <>
 232 struct ParamTraits<mozilla::media::TimeInterval> {
 233   typedef mozilla::media::TimeInterval paramType;
 234
 235   static void Write(MessageWriter* aWriter, const paramType& aParam) {
 236     WriteParam(aWriter, aParam.mStart);
 237     WriteParam(aWriter, aParam.mEnd);
 238     WriteParam(aWriter, aParam.mFuzz);
 239   }
 240
 241   static bool Read(MessageReader* aReader, paramType* aResult) {
 242     if (ReadParam(aReader, &aResult->mStart) &&
 243         ReadParam(aReader, &aResult->mEnd) &&
 244         ReadParam(aReader, &aResult->mFuzz)) {
 245       return true;
 246     }
 247     return false;
 248   }
 249 };
 250
 251 template <>
 252 struct ParamTraits<mozilla::MediaResult> {
 253   typedef mozilla::MediaResult paramType;
 254
 255   static void Write(MessageWriter* aWriter, const paramType& aParam) {
 256     WriteParam(aWriter, aParam.Code());
 257     WriteParam(aWriter, aParam.Message());
 258   }
 259
 260   static bool Read(MessageReader* aReader, paramType* aResult) {
 261     nsresult result;
 262     nsCString message;
 263     if (ReadParam(aReader, &result) && ReadParam(aReader, &message)) {
 264       *aResult = paramType(result, std::move(message));
 265       return true;
 266     }
 267     return false;
 268   };
 269 };
 270
 271 template <>
 272 struct ParamTraits<mozilla::DecoderDoctorDiagnostics> {
 273   typedef mozilla::DecoderDoctorDiagnostics paramType;
 274
 275   static void Write(MessageWriter* aWriter, const paramType& aParam) {
 276     WriteParam(aWriter, aParam.mDiagnosticsType);
 277     WriteParam(aWriter, aParam.mFormat);
 278     WriteParam(aWriter, aParam.mFlags);
 279     WriteParam(aWriter, aParam.mEvent);
 280   }
 281
 282   static bool Read(MessageReader* aReader, paramType* aResult) {
 283     if (ReadParam(aReader, &aResult->mDiagnosticsType) &&
 284         ReadParam(aReader, &aResult->mFormat) &&
 285         ReadParam(aReader, &aResult->mFlags) &&
 286         ReadParam(aReader, &aResult->mEvent)) {
 287       return true;
 288     }
 289     return false;
 290   };
 291 };
 292
 293 template <>
 294 struct ParamTraits<mozilla::DecoderDoctorDiagnostics::DiagnosticsType>
 295     : public ContiguousEnumSerializerInclusive<
 296           mozilla::DecoderDoctorDiagnostics::DiagnosticsType,
 297           mozilla::DecoderDoctorDiagnostics::DiagnosticsType::eUnsaved,
 298           mozilla::DecoderDoctorDiagnostics::DiagnosticsType::eDecodeWarning> {
 299 };
 300
 301 template <>
 302 struct ParamTraits<mozilla::DecoderDoctorEvent> {
 303   typedef mozilla::DecoderDoctorEvent paramType;
 304
 305   static void Write(MessageWriter* aWriter, const paramType& aParam) {
 306     int domain = aParam.mDomain;
 307     WriteParam(aWriter, domain);
 308     WriteParam(aWriter, aParam.mResult);
 309   }
 310
 311   static bool Read(MessageReader* aReader, paramType* aResult) {
 312     int domain = 0;
 313     if (ReadParam(aReader, &domain) && ReadParam(aReader, &aResult->mResult)) {
 314       aResult->mDomain = paramType::Domain(domain);
 315       return true;
 316     }
 317     return false;
 318   };
 319 };
 320
 321 }  // namespace IPC
 322
 323 #endif  // mozilla_dom_media_MediaIPCUtils_h