audio_renderer_common.h

Go to the documentation of this file.

// Copyright 2020 Google LLC
//
// 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
//
//     https://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 SHAKA_EMBEDDED_MEDIA_AUDIO_RENDERER_COMMON_H_
#define SHAKA_EMBEDDED_MEDIA_AUDIO_RENDERER_COMMON_H_

#include <memory>

#include "shaka/media/frames.h"
#include "shaka/media/renderer.h"
#include "src/debug/mutex.h"
#include "src/debug/thread.h"
#include "src/debug/thread_event.h"
#include "src/util/buffer_writer.h"
#include "src/util/clock.h"

namespace shaka {
namespace media {

class AudioRendererCommon : public AudioRenderer, MediaPlayer::Client {
 public:
  AudioRendererCommon();
  ~AudioRendererCommon() override;

  void SetPlayer(const MediaPlayer* player) override;
  void Attach(const DecodedStream* stream) override;
  void Detach() override;

  double Volume() const override;
  void SetVolume(double volume) override;
  bool Muted() const override;
  void SetMuted(bool muted) override;

 protected:
  void Stop();

 private:
  enum class SyncStatus {
    Success,
    NoFrame,
    FatalError,
  };

  virtual bool InitDevice(std::shared_ptr<DecodedFrame> frame,
                          double volume) = 0;

  virtual bool AppendBuffer(const uint8_t* data, size_t size) = 0;

  virtual void ClearBuffer() = 0;

  virtual size_t GetBytesBuffered() const = 0;

  virtual void SetDeviceState(bool is_playing) = 0;

  virtual void UpdateVolume(double volume) = 0;

  bool FillSilence(size_t bytes);

  bool IsFrameSimilar(std::shared_ptr<DecodedFrame> frame1,
                      std::shared_ptr<DecodedFrame> frame2) const;

  bool WriteFrame(std::shared_ptr<DecodedFrame> frame, size_t sync_bytes);

  void SetClock(const util::Clock* clock);

  void ThreadMain();


  void OnPlaybackStateChanged(VideoPlaybackState old_state,
                              VideoPlaybackState new_state) override;
  void OnPlaybackRateChanged(double old_rate, double new_rate) override;
  void OnSeeking() override;


  friend class AudioRendererCommonTest;
  mutable Mutex mutex_;
  ThreadEvent<void> on_play_;

  const util::Clock* clock_;
  const MediaPlayer* player_;
  const DecodedStream* input_;

  std::shared_ptr<DecodedFrame> cur_frame_;
  double sync_time_;
  uint64_t bytes_written_;
  double volume_;
  bool muted_;
  bool needs_resync_;
  bool shutdown_;

  Thread thread_;
};

}  // namespace media
}  // namespace shaka

#endif  // SHAKA_EMBEDDED_MEDIA_AUDIO_RENDERER_COMMON_H_