tor-browser

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

video_receiver2.cc (3959B)

      1 /*
      2 *  Copyright (c) 2013 The WebRTC project authors. All Rights Reserved.
      3 *
      4 *  Use of this source code is governed by a BSD-style license
      5 *  that can be found in the LICENSE file in the root of the source
      6 *  tree. An additional intellectual property rights grant can be found
      7 *  in the file PATENTS.  All contributing project authors may
      8 *  be found in the AUTHORS file in the root of the source tree.
      9 */
     10 
     11 #include "modules/video_coding/video_receiver2.h"
     12 
     13 #include <cstddef>
     14 #include <cstdint>
     15 #include <memory>
     16 #include <utility>
     17 
     18 #include "api/field_trials_view.h"
     19 #include "api/sequence_checker.h"
     20 #include "api/video/encoded_frame.h"
     21 #include "api/video_codecs/video_decoder.h"
     22 #include "common_video/include/corruption_score_calculator.h"
     23 #include "modules/video_coding/decoder_database.h"
     24 #include "modules/video_coding/generic_decoder.h"
     25 #include "modules/video_coding/include/video_coding_defines.h"
     26 #include "modules/video_coding/timing/timing.h"
     27 #include "rtc_base/checks.h"
     28 #include "rtc_base/trace_event.h"
     29 #include "system_wrappers/include/clock.h"
     30 
     31 namespace webrtc {
     32 
     33 VideoReceiver2::VideoReceiver2(
     34    Clock* clock,
     35    VCMTiming* timing,
     36    const FieldTrialsView& field_trials,
     37    CorruptionScoreCalculator* corruption_score_calculator)
     38    : clock_(clock),
     39      decoded_frame_callback_(timing,
     40                              clock_,
     41                              field_trials,
     42                              corruption_score_calculator),
     43      codec_database_() {
     44  decoder_sequence_checker_.Detach();
     45 }
     46 
     47 VideoReceiver2::~VideoReceiver2() {
     48  RTC_DCHECK_RUN_ON(&construction_sequence_checker_);
     49 }
     50 
     51 // Register a receive callback. Will be called whenever there is a new frame
     52 // ready for rendering.
     53 int32_t VideoReceiver2::RegisterReceiveCallback(
     54    VCMReceiveCallback* receive_callback) {
     55  RTC_DCHECK_RUN_ON(&construction_sequence_checker_);
     56  // This value is set before the decoder thread starts and unset after
     57  // the decoder thread has been stopped.
     58  decoded_frame_callback_.SetUserReceiveCallback(receive_callback);
     59  return VCM_OK;
     60 }
     61 
     62 void VideoReceiver2::RegisterExternalDecoder(
     63    std::unique_ptr<VideoDecoder> decoder,
     64    uint8_t payload_type) {
     65  RTC_DCHECK_RUN_ON(&decoder_sequence_checker_);
     66  RTC_DCHECK(decoded_frame_callback_.UserReceiveCallback());
     67 
     68  if (decoder) {
     69    RTC_DCHECK(!codec_database_.IsExternalDecoderRegistered(payload_type));
     70    codec_database_.RegisterExternalDecoder(payload_type, std::move(decoder));
     71  } else {
     72    codec_database_.DeregisterExternalDecoder(payload_type);
     73  }
     74 }
     75 
     76 bool VideoReceiver2::IsExternalDecoderRegistered(uint8_t payload_type) const {
     77  RTC_DCHECK_RUN_ON(&decoder_sequence_checker_);
     78  return codec_database_.IsExternalDecoderRegistered(payload_type);
     79 }
     80 
     81 // Must be called from inside the receive side critical section.
     82 int32_t VideoReceiver2::Decode(const EncodedFrame* frame) {
     83  RTC_DCHECK_RUN_ON(&decoder_sequence_checker_);
     84  TRACE_EVENT0("webrtc", "VideoReceiver2::Decode");
     85  // Change decoder if payload type has changed.
     86  VCMGenericDecoder* decoder =
     87      codec_database_.GetDecoder(*frame, &decoded_frame_callback_);
     88  if (decoder == nullptr) {
     89    return VCM_NO_CODEC_REGISTERED;
     90  }
     91  return decoder->Decode(*frame, clock_->CurrentTime());
     92 }
     93 
     94 // Register possible receive codecs, can be called multiple times.
     95 // Called before decoder thread is started.
     96 void VideoReceiver2::RegisterReceiveCodec(
     97    uint8_t payload_type,
     98    const VideoDecoder::Settings& settings) {
     99  RTC_DCHECK_RUN_ON(&construction_sequence_checker_);
    100  codec_database_.RegisterReceiveCodec(payload_type, settings);
    101 }
    102 
    103 void VideoReceiver2::DeregisterReceiveCodec(uint8_t payload_type) {
    104  RTC_DCHECK_RUN_ON(&construction_sequence_checker_);
    105  codec_database_.DeregisterReceiveCodec(payload_type);
    106 }
    107 
    108 void VideoReceiver2::DeregisterReceiveCodecs() {
    109  RTC_DCHECK_RUN_ON(&construction_sequence_checker_);
    110  codec_database_.DeregisterReceiveCodecs();
    111 }
    112 
    113 }  // namespace webrtc