The Tor Browser: comparison content/media/omx/AudioOffloadPlayer.h

--1:000000000000
+:69cb6ffc9189
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim:set ts=2 sw=2 sts=2 et cindent: */
+/*
+* Copyright (c) 2014 The Linux Foundation. All rights reserved.
+* Copyright (C) 2009 The Android Open Source Project
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*      http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+#ifndef AUDIO_OFFLOAD_PLAYER_H_
+#define AUDIO_OFFLOAD_PLAYER_H_
+#include <stagefright/MediaBuffer.h>
+#include <stagefright/MediaSource.h>
+#include <stagefright/TimeSource.h>
+#include <utils/threads.h>
+#include <utils/RefBase.h>
+#include "AudioOutput.h"
+#include "MediaDecoderOwner.h"
+#include "MediaOmxDecoder.h"
+namespace mozilla {
+class MediaOmxDecoder;
+/**
+* AudioOffloadPlayer adds support for audio tunneling to a digital signal
+* processor (DSP) in the device chipset. With tunneling, audio decoding is
+* off-loaded to the DSP, waking the application processor less often and using
+* less battery
+*
+* This depends on offloading capability provided by Android KK AudioTrack class
+*
+* Audio playback is based on pull mechanism, whenever audio sink needs
+* data, FillBuffer() will read data from compressed audio source and provide
+* it to the sink
+*
+* Also this class passes state changes (play/pause/seek) from MediaOmxDecoder
+* to AudioSink as well as provide AudioSink status (position changed,
+* playback ended, seek complete, audio tear down) back to MediaOmxDecoder
+*
+* It acts as a bridge between MediaOmxDecoder and AudioSink during
+* offload playback
+*/
+class AudioOffloadPlayer : public AudioOffloadPlayerBase
+{
+typedef android::Mutex Mutex;
+typedef android::MetaData MetaData;
+typedef android::status_t status_t;
+typedef android::AudioTrack AudioTrack;
+typedef android::MediaBuffer MediaBuffer;
+typedef android::MediaSource MediaSource;
+public:
+enum {
+REACHED_EOS,
+SEEK_COMPLETE
+};
+AudioOffloadPlayer(MediaOmxDecoder* aDecoder = nullptr);
+~AudioOffloadPlayer();
+// Caller retains ownership of "aSource".
+void SetSource(const android::sp<MediaSource> &aSource);
+// Start the source if it's not already started and open the AudioSink to
+// create an offloaded audio track
+status_t Start(bool aSourceAlreadyStarted = false);
+double GetMediaTimeSecs();
+// To update progress bar when the element is visible
+void SetElementVisibility(bool aIsVisible);
+status_t ChangeState(MediaDecoder::PlayState aState);
+void SetVolume(double aVolume);
+// Update ready state based on current play state. Not checking data
+// availability since offloading is currently done only when whole compressed
+// data is available
+MediaDecoderOwner::NextFrameStatus GetNextFrameStatus();
+void TimeUpdate();
+// Close the audio sink, stop time updates, frees the input buffers
+void Reset();
+private:
+// Set when audio source is started and audioSink is initialized
+// Used only in main thread
+bool mStarted;
+// Set when audio sink is started. i.e. playback started
+// Used only in main thread
+bool mPlaying;
+// Set when playstate is seeking and reset when FillBUffer() acknowledged
+// seeking by seeking audio source. Used in main thread and offload
+// callback thread, protected by Mutex mLock
+bool mSeeking;
+// Once playback reached end of stream (last ~100ms), position provided by DSP
+// may be reset/corrupted. This bool is used to avoid that.
+// Used in main thread and offload callback thread, protected by Mutex
+// mLock
+bool mReachedEOS;
+// Set when there is a seek request during pause.
+// Used in main thread and offload callback thread, protected by Mutex
+// mLock
+bool mSeekDuringPause;
+// Seek can be triggered internally or by MediaDecoder. This bool is to
+// to track seek triggered by MediaDecoder so that we can send back
+// SeekingStarted and SeekingStopped events.
+// Used in main thread and offload callback thread, protected by Mutex mLock
+bool mDispatchSeekEvents;
+// Set when the HTML Audio Element is visible to the user.
+// Used only in main thread
+bool mIsElementVisible;
+// Session id given by Android::AudioSystem and used while creating audio sink
+// Used only in main thread
+int mSessionId;
+// Sample rate of current audio track. Used only in main thread
+int mSampleRate;
+// After seeking, positions returned by offlaoded tracks (DSP) will be
+// relative to the seeked position. And seeked position may be slightly
+// different than given mSeekTimeUs, if audio source cannot find a frame at
+// that position. Store seeked position in mStartPosUs and provide
+// mStartPosUs + GetPosition() (i.e. absolute position) to MediaOmxDecoder
+// Used in main thread and offload callback thread, protected by Mutex
+// mLock
+int64_t mStartPosUs;
+// Given seek time when there is a request to seek
+// Used in main thread and offload callback thread, protected by Mutex
+// mLock
+int64_t mSeekTimeUs;
+// Positions obtained from offlaoded tracks (DSP)
+// Used in main thread and offload callback thread, protected by Mutex
+// mLock
+int64_t mPositionTimeMediaUs;
+// State obtained from MediaOmxDecoder. Used only in main thread
+MediaDecoder::PlayState mPlayState;
+// Protect accessing audio position related variables between main thread and
+// offload callback thread
+Mutex mLock;
+// Compressed audio source.
+// Used in main thread first and later in offload callback thread
+android::sp<MediaSource> mSource;
+// Audio sink wrapper to access offloaded audio tracks
+// Used in main thread and offload callback thread
+// Race conditions are protected in underlying Android::AudioTrack class
+android::sp<AudioSink> mAudioSink;
+// Buffer used to get date from audio source. Used in offload callback thread
+MediaBuffer* mInputBuffer;
+// MediaOmxDecoder object used mainly to notify the audio sink status
+MediaOmxDecoder* mObserver;
+TimeStamp mLastFireUpdateTime;
+// Timer to trigger position changed events
+nsCOMPtr<nsITimer> mTimeUpdateTimer;
+// Timer to reset AudioSink when audio is paused for OFFLOAD_PAUSE_MAX_USECS.
+// It is triggered in Pause() and canceled when there is a Play() within
+// OFFLOAD_PAUSE_MAX_USECS. Used only from main thread so no lock is needed.
+nsCOMPtr<nsITimer> mResetTimer;
+int64_t GetMediaTimeUs();
+// Provide the playback position in microseconds from total number of
+// frames played by audio track
+int64_t GetOutputPlayPositionUs_l() const;
+// Fill the buffer given by audio sink with data from compressed audio
+// source. Also handles the seek by seeking audio source and stop the sink in
+// case of error
+size_t FillBuffer(void *aData, size_t aSize);
+// Called by AudioSink when it needs data, to notify EOS or tear down event
+static size_t AudioSinkCallback(AudioSink *aAudioSink,
+void *aData,
+size_t aSize,
+void *aMe,
+AudioSink::cb_event_t aEvent);
+bool IsSeeking();
+// Set mSeekTime to the given position and restart the sink. Actual seek
+// happens in FillBuffer(). If aDispatchSeekEvents is true, send
+// SeekingStarted event always and SeekingStopped event when the play state is
+// paused to MediaDecoder.
+// When decoding and playing happens separately, if there is a seek during
+// pause, we can decode and keep data ready.
+// In case of offload player, no way to seek during pause. So just fake that
+// seek is done.
+status_t SeekTo(int64_t aTimeUs, bool aDispatchSeekEvents = false);
+// Start/Resume the audio sink so that callback will start being called to get
+// compressed data
+status_t Play();
+// Stop the audio sink if we need to play till we drain the current buffer.
+// or Pause the sink in case we should stop playing immediately
+void Pause(bool aPlayPendingSamples = false);
+// When audio is offloaded, application processor wakes up less frequently
+// (>1sec) But when Player UI is visible we need to update progress bar
+// atleast once in 250ms. Start a timer when player UI becomes visible or
+// audio starts playing to send PlaybackPositionChanged events once in 250ms.
+// Stop the timer when UI goes invisible or play state is not playing.
+// Also make sure timer functions are always called from main thread
+nsresult StartTimeUpdate();
+nsresult StopTimeUpdate();
+// Notify end of stream by sending PlaybackEnded event to observer
+// (i.e.MediaDecoder)
+void NotifyAudioEOS();
+// Notify position changed event by sending PlaybackPositionChanged event to
+// observer
+void NotifyPositionChanged();
+// Offloaded audio track is invalidated due to usecase change. Notify
+// MediaDecoder to re-evaluate offloading options
+void NotifyAudioTearDown();
+// Send information from MetaData to the HAL via AudioSink
+void SendMetaDataToHal(android::sp<AudioSink>& aSink,
+const android::sp<MetaData>& aMeta);
+AudioOffloadPlayer(const AudioOffloadPlayer &);
+AudioOffloadPlayer &operator=(const AudioOffloadPlayer &);
+};
+} // namespace mozilla
+#endif  // AUDIO_OFFLOAD_PLAYER_H_

The Tor Browser / file comparison

comparison: content/media/omx/AudioOffloadPlayer.h

content/media/omx/AudioOffloadPlayer.h