The Tor Browser: content/media/VideoUtils.h@97036ab72558 (annotated)

content/media/VideoUtils.h@97036ab72558 (annotated)

content/media/VideoUtils.h

Tue, 06 Jan 2015 21:39:09 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Tue, 06 Jan 2015 21:39:09 +0100
branch: TOR_BUG_9701
changeset 8: 97036ab72558
permissions: -rw-r--r--

Conditionally force memory storage according to privacy.thirdparty.isolate;
This solves Tor bug #9701, complying with disk avoidance documented in
https://www.torproject.org/projects/torbrowser/design/#disk-avoidance.

 /* -*- 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 VideoUtils_h
 #define VideoUtils_h
 #include "mozilla/Attributes.h"
 #include "mozilla/ReentrantMonitor.h"
 #include "mozilla/CheckedInt.h"
 #if !(defined(XP_WIN) || defined(XP_MACOSX) || defined(LINUX)) || \
     defined(MOZ_ASAN)
 // For MEDIA_THREAD_STACK_SIZE
 #include "nsIThreadManager.h"
 #endif
 #include "nsThreadUtils.h"
 #include "prtime.h"
 #include "AudioSampleFormat.h"
 using mozilla::CheckedInt64;
 using mozilla::CheckedUint64;
 using mozilla::CheckedInt32;
 using mozilla::CheckedUint32;
 struct nsIntSize;
 struct nsIntRect;
 // This file contains stuff we'd rather put elsewhere, but which is
 // dependent on other changes which we don't want to wait for. We plan to
 // remove this file in the near future.
 // This belongs in xpcom/monitor/Monitor.h, once we've made
 // mozilla::Monitor non-reentrant.
 namespace mozilla {
 /**
  * ReentrantMonitorConditionallyEnter
  *
  * Enters the supplied monitor only if the conditional value |aEnter| is true.
  * E.g. Used to allow unmonitored read access on the decode thread,
  * and monitored access on all other threads.
  */
 class MOZ_STACK_CLASS ReentrantMonitorConditionallyEnter
 {
 public:
   ReentrantMonitorConditionallyEnter(bool aEnter,
                                      ReentrantMonitor &aReentrantMonitor) :
     mReentrantMonitor(nullptr)
   {
     MOZ_COUNT_CTOR(ReentrantMonitorConditionallyEnter);
     if (aEnter) {
       mReentrantMonitor = &aReentrantMonitor;
       NS_ASSERTION(mReentrantMonitor, "null monitor");
       mReentrantMonitor->Enter();
     }
   }
   ~ReentrantMonitorConditionallyEnter(void)
   {
     if (mReentrantMonitor) {
       mReentrantMonitor->Exit();
     }
     MOZ_COUNT_DTOR(ReentrantMonitorConditionallyEnter);
   }
 private:
   // Restrict to constructor and destructor defined above.
   ReentrantMonitorConditionallyEnter();
   ReentrantMonitorConditionallyEnter(const ReentrantMonitorConditionallyEnter&);
   ReentrantMonitorConditionallyEnter& operator =(const ReentrantMonitorConditionallyEnter&);
   static void* operator new(size_t) CPP_THROW_NEW;
   static void operator delete(void*);
   ReentrantMonitor* mReentrantMonitor;
 };
 // Shuts down a thread asynchronously.
 class ShutdownThreadEvent : public nsRunnable
 {
 public:
   ShutdownThreadEvent(nsIThread* aThread) : mThread(aThread) {}
   ~ShutdownThreadEvent() {}
   NS_IMETHOD Run() MOZ_OVERRIDE {
     mThread->Shutdown();
     mThread = nullptr;
     return NS_OK;
   }
 private:
   nsCOMPtr<nsIThread> mThread;
 };
 class MediaResource;
 namespace dom {
 class TimeRanges;
 }
 // Estimates the buffered ranges of a MediaResource using a simple
 // (byteOffset/length)*duration method. Probably inaccurate, but won't
 // do file I/O, and can be used when we don't have detailed knowledge
 // of the byte->time mapping of a resource. aDurationUsecs is the duration
 // of the media in microseconds. Estimated buffered ranges are stored in
 // aOutBuffered. Ranges are 0-normalized, i.e. in the range of (0,duration].
 void GetEstimatedBufferedTimeRanges(mozilla::MediaResource* aStream,
                                     int64_t aDurationUsecs,
                                     mozilla::dom::TimeRanges* aOutBuffered);
 // Converts from number of audio frames (aFrames) to microseconds, given
 // the specified audio rate (aRate). Stores result in aOutUsecs. Returns true
 // if the operation succeeded, or false if there was an integer overflow
 // while calulating the conversion.
 CheckedInt64 FramesToUsecs(int64_t aFrames, uint32_t aRate);
 // Converts from microseconds (aUsecs) to number of audio frames, given the
 // specified audio rate (aRate). Stores the result in aOutFrames. Returns
 // true if the operation succeeded, or false if there was an integer
 // overflow while calulating the conversion.
 CheckedInt64 UsecsToFrames(int64_t aUsecs, uint32_t aRate);
 // Number of microseconds per second. 1e6.
 static const int64_t USECS_PER_S = 1000000;
 // Number of microseconds per millisecond.
 static const int64_t USECS_PER_MS = 1000;
 // Converts seconds to milliseconds.
 #define MS_TO_SECONDS(s) ((double)(s) / (PR_MSEC_PER_SEC))
 // Converts from seconds to microseconds. Returns failure if the resulting
 // integer is too big to fit in an int64_t.
 nsresult SecondsToUsecs(double aSeconds, int64_t& aOutUsecs);
 // The maximum height and width of the video. Used for
 // sanitizing the memory allocation of the RGB buffer.
 // The maximum resolution we anticipate encountering in the
 // wild is 2160p - 3840x2160 pixels.
 static const int32_t MAX_VIDEO_WIDTH = 4000;
 static const int32_t MAX_VIDEO_HEIGHT = 3000;
 // Scales the display rect aDisplay by aspect ratio aAspectRatio.
 // Note that aDisplay must be validated by IsValidVideoRegion()
 // before being used!
 void ScaleDisplayByAspectRatio(nsIntSize& aDisplay, float aAspectRatio);
 // The amount of virtual memory reserved for thread stacks.
 #if (defined(XP_WIN) || defined(XP_MACOSX) || defined(LINUX)) && \
     !defined(MOZ_ASAN)
 #define MEDIA_THREAD_STACK_SIZE (128 * 1024)
 #else
 // All other platforms use their system defaults.
 #define MEDIA_THREAD_STACK_SIZE nsIThreadManager::DEFAULT_STACK_SIZE
 #endif
 // Downmix multichannel Audio samples to Stereo.
 // Input are the buffer contains multichannel data,
 // the number of channels and the number of frames.
 int DownmixAudioToStereo(mozilla::AudioDataValue* buffer,
                          int channels,
                          uint32_t frames);
 bool IsVideoContentType(const nsCString& aContentType);
 // Returns true if it's safe to use aPicture as the picture to be
 // extracted inside a frame of size aFrame, and scaled up to and displayed
 // at a size of aDisplay. You should validate the frame, picture, and
 // display regions before using them to display video frames.
 bool IsValidVideoRegion(const nsIntSize& aFrame, const nsIntRect& aPicture,
                         const nsIntSize& aDisplay);
 } // end namespace mozilla
 #endif

The Tor Browser / annotate

content/media/VideoUtils.h@97036ab72558 (annotated)

content/media/VideoUtils.h