tor-browser

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

rtp_video_header.cc (4473B)

      1 /*
      2 *  Copyright (c) 2018 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/rtp_rtcp/source/rtp_video_header.h"
     12 
     13 #include <optional>
     14 
     15 #include "api/video/video_codec_type.h"
     16 #include "api/video/video_frame_metadata.h"
     17 #include "modules/video_coding/codecs/h264/include/h264_globals.h"
     18 #include "modules/video_coding/codecs/vp8/include/vp8_globals.h"
     19 #include "modules/video_coding/codecs/vp9/include/vp9_globals.h"
     20 
     21 namespace webrtc {
     22 
     23 RTPVideoHeader::GenericDescriptorInfo::GenericDescriptorInfo() = default;
     24 RTPVideoHeader::GenericDescriptorInfo::GenericDescriptorInfo(
     25    const GenericDescriptorInfo& other) = default;
     26 RTPVideoHeader::GenericDescriptorInfo::~GenericDescriptorInfo() = default;
     27 
     28 // static
     29 RTPVideoHeader RTPVideoHeader::FromMetadata(
     30    const VideoFrameMetadata& metadata) {
     31  RTPVideoHeader rtp_video_header;
     32  rtp_video_header.SetFromMetadata(metadata);
     33  return rtp_video_header;
     34 }
     35 
     36 RTPVideoHeader::RTPVideoHeader() : video_timing() {}
     37 RTPVideoHeader::RTPVideoHeader(const RTPVideoHeader& other) = default;
     38 RTPVideoHeader::~RTPVideoHeader() = default;
     39 
     40 VideoFrameMetadata RTPVideoHeader::GetAsMetadata() const {
     41  VideoFrameMetadata metadata;
     42  metadata.SetFrameType(frame_type);
     43  metadata.SetWidth(width);
     44  metadata.SetHeight(height);
     45  metadata.SetRotation(rotation);
     46  metadata.SetContentType(content_type);
     47  if (generic) {
     48    metadata.SetFrameId(generic->frame_id);
     49    metadata.SetSpatialIndex(generic->spatial_index);
     50    metadata.SetTemporalIndex(generic->temporal_index);
     51    metadata.SetFrameDependencies(generic->dependencies);
     52    metadata.SetDecodeTargetIndications(generic->decode_target_indications);
     53  }
     54  metadata.SetIsLastFrameInPicture(is_last_frame_in_picture);
     55  metadata.SetSimulcastIdx(simulcastIdx);
     56  metadata.SetCodec(codec);
     57  switch (codec) {
     58    case VideoCodecType::kVideoCodecVP8:
     59      metadata.SetRTPVideoHeaderCodecSpecifics(
     60          std::get<RTPVideoHeaderVP8>(video_type_header));
     61      break;
     62    case VideoCodecType::kVideoCodecVP9:
     63      metadata.SetRTPVideoHeaderCodecSpecifics(
     64          std::get<RTPVideoHeaderVP9>(video_type_header));
     65      break;
     66    case VideoCodecType::kVideoCodecH264:
     67      metadata.SetRTPVideoHeaderCodecSpecifics(
     68          std::get<RTPVideoHeaderH264>(video_type_header));
     69      break;
     70    // These codec types do not have codec-specifics.
     71    case VideoCodecType::kVideoCodecH265:
     72    case VideoCodecType::kVideoCodecAV1:
     73    case VideoCodecType::kVideoCodecGeneric:
     74      break;
     75  }
     76  return metadata;
     77 }
     78 
     79 void RTPVideoHeader::SetFromMetadata(const VideoFrameMetadata& metadata) {
     80  frame_type = metadata.GetFrameType();
     81  width = metadata.GetWidth();
     82  height = metadata.GetHeight();
     83  rotation = metadata.GetRotation();
     84  content_type = metadata.GetContentType();
     85  if (!metadata.GetFrameId().has_value()) {
     86    generic = std::nullopt;
     87  } else {
     88    generic.emplace();
     89    generic->frame_id = metadata.GetFrameId().value();
     90    generic->spatial_index = metadata.GetSpatialIndex();
     91    generic->temporal_index = metadata.GetTemporalIndex();
     92    generic->dependencies.assign(metadata.GetFrameDependencies().begin(),
     93                                 metadata.GetFrameDependencies().end());
     94    generic->decode_target_indications.assign(
     95        metadata.GetDecodeTargetIndications().begin(),
     96        metadata.GetDecodeTargetIndications().end());
     97  }
     98  is_last_frame_in_picture = metadata.GetIsLastFrameInPicture();
     99  simulcastIdx = metadata.GetSimulcastIdx();
    100  codec = metadata.GetCodec();
    101  switch (codec) {
    102    case VideoCodecType::kVideoCodecVP8:
    103      video_type_header = std::get<RTPVideoHeaderVP8>(
    104          metadata.GetRTPVideoHeaderCodecSpecifics());
    105      break;
    106    case VideoCodecType::kVideoCodecVP9:
    107      video_type_header = std::get<RTPVideoHeaderVP9>(
    108          metadata.GetRTPVideoHeaderCodecSpecifics());
    109      break;
    110    case VideoCodecType::kVideoCodecH264:
    111      video_type_header = std::get<RTPVideoHeaderH264>(
    112          metadata.GetRTPVideoHeaderCodecSpecifics());
    113      break;
    114    default:
    115      // Codec-specifics are not supported for this codec.
    116      break;
    117  }
    118 }
    119 
    120 }  // namespace webrtc