zqz/platform-external-webrtc
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Moving src/webrtc into src/.

Browse Source 
In order to eliminate the WebRTC Subtree mirror in Chromium, 
WebRTC is moving the content of the src/webrtc directory up
to the src/ directory.

NOPRESUBMIT=true
NOTREECHECKS=true
NOTRY=true
TBR=tommi@webrtc.org

Bug: chromium:611808
Change-Id: Iac59c5b51b950f174119565bac87955a7994bc38
Reviewed-on: https://webrtc-review.googlesource.com/1560
Commit-Queue: Mirko Bonadei <mbonadei@webrtc.org>
Reviewed-by: Henrik Kjellander <kjellander@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#19845}
This commit is contained in:
Mirko Bonadei
2017-09-15 06:15:48 +02:00
committed by Commit Bot
parent 6674846b4a
commit bb547203bf
4576 changed files with 1092 additions and 1196 deletions
Download Patch File Download Diff File Expand all files Collapse all files

32
api/video_codecs/BUILD.gn Normal file
View File

@ -0,0 +1,32 @@
# Copyright (c) 2017 The WebRTC project authors. All Rights Reserved.
#
# Use of this source code is governed by a BSD-style license
# that can be found in the LICENSE file in the root of the source
# tree. An additional intellectual property rights grant can be found
# in the file PATENTS. All contributing project authors may
# be found in the AUTHORS file in the root of the source tree.
import("../../webrtc.gni")
if (is_android) {
import("//build/config/android/config.gni")
import("//build/config/android/rules.gni")
}
rtc_source_set("video_codecs_api") {
sources = [
"sdp_video_format.h",
"video_decoder.h",
"video_decoder_factory.h",
"video_encoder.cc",
"video_encoder.h",
"video_encoder_factory.h",
]
deps = [
"..:optional",
"..:video_frame_api",
"../..:webrtc_common",
"../../common_video",
"../../rtc_base:rtc_base_approved",
]
}

42
api/video_codecs/sdp_video_format.h Normal file
View File

@ -0,0 +1,42 @@
/*
* Copyright (c) 2017 The WebRTC project authors. All Rights Reserved.
*
* Use of this source code is governed by a BSD-style license
* that can be found in the LICENSE file in the root of the source
* tree. An additional intellectual property rights grant can be found
* in the file PATENTS. All contributing project authors may
* be found in the AUTHORS file in the root of the source tree.
*/
#ifndef WEBRTC_API_VIDEO_CODECS_SDP_VIDEO_FORMAT_H_
#define WEBRTC_API_VIDEO_CODECS_SDP_VIDEO_FORMAT_H_
#include <map>
#include <string>
namespace webrtc {
// SDP specification for a single video codec.
// NOTE: This class is still under development and may change without notice.
struct SdpVideoFormat {
using Parameters = std::map<std::string, std::string>;
explicit SdpVideoFormat(const std::string& name) : name(name) {}
SdpVideoFormat(const std::string& name, const Parameters& parameters)
: name(name), parameters(parameters) {}
friend bool operator==(const SdpVideoFormat& a, const SdpVideoFormat& b) {
return a.name == b.name && a.parameters == b.parameters;
}
friend bool operator!=(const SdpVideoFormat& a, const SdpVideoFormat& b) {
return !(a == b);
}
std::string name;
Parameters parameters;
};
} // namespace webrtc
#endif // WEBRTC_API_VIDEO_CODECS_SDP_VIDEO_FORMAT_H_

87
api/video_codecs/video_decoder.h Normal file
View File

@ -0,0 +1,87 @@
/*
* Copyright (c) 2014 The WebRTC project authors. All Rights Reserved.
*
* Use of this source code is governed by a BSD-style license
* that can be found in the LICENSE file in the root of the source
* tree. An additional intellectual property rights grant can be found
* in the file PATENTS. All contributing project authors may
* be found in the AUTHORS file in the root of the source tree.
*/
#ifndef WEBRTC_API_VIDEO_CODECS_VIDEO_DECODER_H_
#define WEBRTC_API_VIDEO_CODECS_VIDEO_DECODER_H_
#include <memory>
#include <string>
#include <vector>
#include "webrtc/api/video/video_frame.h"
#include "webrtc/common_types.h"
#include "webrtc/common_video/include/video_frame.h"
#include "webrtc/typedefs.h"
namespace webrtc {
class RTPFragmentationHeader;
// TODO(pbos): Expose these through a public (root) header or change these APIs.
struct CodecSpecificInfo;
class VideoCodec;
class DecodedImageCallback {
public:
virtual ~DecodedImageCallback() {}
virtual int32_t Decoded(VideoFrame& decodedImage) = 0;
// Provides an alternative interface that allows the decoder to specify the
// decode time excluding waiting time for any previous pending frame to
// return. This is necessary for breaking positive feedback in the delay
// estimation when the decoder has a single output buffer.
virtual int32_t Decoded(VideoFrame& decodedImage, int64_t decode_time_ms) {
// The default implementation ignores custom decode time value.
return Decoded(decodedImage);
}
// TODO(sakal): Remove other implementations when upstream projects have been
// updated.
virtual void Decoded(VideoFrame& decodedImage,
rtc::Optional<int32_t> decode_time_ms,
rtc::Optional<uint8_t> qp) {
Decoded(decodedImage,
decode_time_ms ? static_cast<int32_t>(*decode_time_ms) : -1);
}
virtual int32_t ReceivedDecodedReferenceFrame(const uint64_t pictureId) {
return -1;
}
virtual int32_t ReceivedDecodedFrame(const uint64_t pictureId) { return -1; }
};
class VideoDecoder {
public:
virtual ~VideoDecoder() {}
virtual int32_t InitDecode(const VideoCodec* codec_settings,
int32_t number_of_cores) = 0;
virtual int32_t Decode(const EncodedImage& input_image,
bool missing_frames,
const RTPFragmentationHeader* fragmentation,
const CodecSpecificInfo* codec_specific_info = NULL,
int64_t render_time_ms = -1) = 0;
virtual int32_t RegisterDecodeCompleteCallback(
DecodedImageCallback* callback) = 0;
virtual int32_t Release() = 0;
// Returns true if the decoder prefer to decode frames late.
// That is, it can not decode infinite number of frames before the decoded
// frame is consumed.
virtual bool PrefersLateDecoding() const { return true; }
virtual const char* ImplementationName() const { return "unknown"; }
};
} // namespace webrtc
#endif // WEBRTC_API_VIDEO_CODECS_VIDEO_DECODER_H_

39
api/video_codecs/video_decoder_factory.h Normal file
View File

@ -0,0 +1,39 @@
/*
* Copyright (c) 2017 The WebRTC project authors. All Rights Reserved.
*
* Use of this source code is governed by a BSD-style license
* that can be found in the LICENSE file in the root of the source
* tree. An additional intellectual property rights grant can be found
* in the file PATENTS. All contributing project authors may
* be found in the AUTHORS file in the root of the source tree.
*/
#ifndef WEBRTC_API_VIDEO_CODECS_VIDEO_DECODER_FACTORY_H_
#define WEBRTC_API_VIDEO_CODECS_VIDEO_DECODER_FACTORY_H_
#include <memory>
#include <vector>
namespace webrtc {
class VideoDecoder;
struct SdpVideoFormat;
// A factory that creates VideoDecoders.
// NOTE: This class is still under development and may change without notice.
class VideoDecoderFactory {
public:
// Returns a list of supported video formats in order of preference, to use
// for signaling etc.
virtual std::vector<SdpVideoFormat> GetSupportedFormats() const = 0;
// Creates a VideoDecoder for the specified format.
virtual std::unique_ptr<VideoDecoder> CreateVideoDecoder(
const SdpVideoFormat& format) = 0;
virtual ~VideoDecoderFactory() {}
};
} // namespace webrtc
#endif // WEBRTC_API_VIDEO_CODECS_VIDEO_DECODER_FACTORY_H_

109
api/video_codecs/video_encoder.cc Normal file
View File

@ -0,0 +1,109 @@
/*
* Copyright (c) 2017 The WebRTC project authors. All Rights Reserved.
*
* Use of this source code is governed by a BSD-style license
* that can be found in the LICENSE file in the root of the source
* tree. An additional intellectual property rights grant can be found
* in the file PATENTS. All contributing project authors may
* be found in the AUTHORS file in the root of the source tree.
*/
#include "webrtc/api/video_codecs/video_encoder.h"
namespace webrtc {
// TODO(mflodman): Add default complexity for VP9 and VP9.
VideoCodecVP8 VideoEncoder::GetDefaultVp8Settings() {
VideoCodecVP8 vp8_settings;
memset(&vp8_settings, 0, sizeof(vp8_settings));
vp8_settings.resilience = kResilientStream;
vp8_settings.numberOfTemporalLayers = 1;
vp8_settings.denoisingOn = true;
vp8_settings.errorConcealmentOn = false;
vp8_settings.automaticResizeOn = false;
vp8_settings.frameDroppingOn = true;
vp8_settings.keyFrameInterval = 3000;
return vp8_settings;
}
VideoCodecVP9 VideoEncoder::GetDefaultVp9Settings() {
VideoCodecVP9 vp9_settings;
memset(&vp9_settings, 0, sizeof(vp9_settings));
vp9_settings.resilienceOn = true;
vp9_settings.numberOfTemporalLayers = 1;
vp9_settings.denoisingOn = true;
vp9_settings.frameDroppingOn = true;
vp9_settings.keyFrameInterval = 3000;
vp9_settings.adaptiveQpMode = true;
vp9_settings.automaticResizeOn = true;
vp9_settings.numberOfSpatialLayers = 1;
vp9_settings.flexibleMode = false;
return vp9_settings;
}
VideoCodecH264 VideoEncoder::GetDefaultH264Settings() {
VideoCodecH264 h264_settings;
memset(&h264_settings, 0, sizeof(h264_settings));
h264_settings.frameDroppingOn = true;
h264_settings.keyFrameInterval = 3000;
h264_settings.spsData = nullptr;
h264_settings.spsLen = 0;
h264_settings.ppsData = nullptr;
h264_settings.ppsLen = 0;
h264_settings.profile = H264::kProfileConstrainedBaseline;
return h264_settings;
}
VideoEncoder::ScalingSettings::ScalingSettings(bool on, int low, int high)
: enabled(on),
thresholds(rtc::Optional<QpThresholds>(QpThresholds(low, high))) {}
VideoEncoder::ScalingSettings::ScalingSettings(bool on,
int low,
int high,
int min_pixels)
: enabled(on),
thresholds(rtc::Optional<QpThresholds>(QpThresholds(low, high))),
min_pixels_per_frame(min_pixels) {}
VideoEncoder::ScalingSettings::ScalingSettings(bool on, int min_pixels)
: enabled(on), min_pixels_per_frame(min_pixels) {}
VideoEncoder::ScalingSettings::ScalingSettings(bool on) : enabled(on) {}
VideoEncoder::ScalingSettings::~ScalingSettings() {}
int32_t VideoEncoder::SetRates(uint32_t bitrate, uint32_t framerate) {
RTC_NOTREACHED() << "SetRate(uint32_t, uint32_t) is deprecated.";
return -1;
}
int32_t VideoEncoder::SetRateAllocation(
const BitrateAllocation& allocation,
uint32_t framerate) {
return SetRates(allocation.get_sum_kbps(), framerate);
}
VideoEncoder::ScalingSettings VideoEncoder::GetScalingSettings() const {
return ScalingSettings(false);
}
int32_t VideoEncoder::SetPeriodicKeyFrames(bool enable) {
return -1;
}
bool VideoEncoder::SupportsNativeHandle() const {
return false;
}
const char* VideoEncoder::ImplementationName() const {
return "unknown";
}
} // namespace webrtc

183
api/video_codecs/video_encoder.h Normal file
View File

@ -0,0 +1,183 @@
/*
* Copyright (c) 2014 The WebRTC project authors. All Rights Reserved.
*
* Use of this source code is governed by a BSD-style license
* that can be found in the LICENSE file in the root of the source
* tree. An additional intellectual property rights grant can be found
* in the file PATENTS. All contributing project authors may
* be found in the AUTHORS file in the root of the source tree.
*/
#ifndef WEBRTC_API_VIDEO_CODECS_VIDEO_ENCODER_H_
#define WEBRTC_API_VIDEO_CODECS_VIDEO_ENCODER_H_
#include <memory>
#include <string>
#include <vector>
#include "webrtc/api/optional.h"
#include "webrtc/api/video/video_frame.h"
#include "webrtc/common_types.h"
#include "webrtc/common_video/include/video_frame.h"
#include "webrtc/rtc_base/checks.h"
#include "webrtc/typedefs.h"
namespace webrtc {
class RTPFragmentationHeader;
// TODO(pbos): Expose these through a public (root) header or change these APIs.
struct CodecSpecificInfo;
class VideoCodec;
class EncodedImageCallback {
public:
virtual ~EncodedImageCallback() {}
struct Result {
enum Error {
OK,
// Failed to send the packet.
ERROR_SEND_FAILED,
};
explicit Result(Error error) : error(error) {}
Result(Error error, uint32_t frame_id) : error(error), frame_id(frame_id) {}
Error error;
// Frame ID assigned to the frame. The frame ID should be the same as the ID
// seen by the receiver for this frame. RTP timestamp of the frame is used
// as frame ID when RTP is used to send video. Must be used only when
// error=OK.
uint32_t frame_id = 0;
// Tells the encoder that the next frame is should be dropped.
bool drop_next_frame = false;
};
// Callback function which is called when an image has been encoded.
virtual Result OnEncodedImage(
const EncodedImage& encoded_image,
const CodecSpecificInfo* codec_specific_info,
const RTPFragmentationHeader* fragmentation) = 0;
virtual void OnDroppedFrame() {}
};
class VideoEncoder {
public:
struct QpThresholds {
QpThresholds(int l, int h) : low(l), high(h) {}
QpThresholds() : low(-1), high(-1) {}
int low;
int high;
};
struct ScalingSettings {
ScalingSettings(bool on, int low, int high);
ScalingSettings(bool on, int low, int high, int min_pixels);
ScalingSettings(bool on, int min_pixels);
explicit ScalingSettings(bool on);
ScalingSettings(const ScalingSettings&);
~ScalingSettings();
const bool enabled;
const rtc::Optional<QpThresholds> thresholds;
// We will never ask for a resolution lower than this.
// TODO(kthelgason): Lower this limit when better testing
// on MediaCodec and fallback implementations are in place.
// See https://bugs.chromium.org/p/webrtc/issues/detail?id=7206
const int min_pixels_per_frame = 320 * 180;
};
static VideoCodecVP8 GetDefaultVp8Settings();
static VideoCodecVP9 GetDefaultVp9Settings();
static VideoCodecH264 GetDefaultH264Settings();
virtual ~VideoEncoder() {}
// Initialize the encoder with the information from the codecSettings
//
// Input:
// - codec_settings : Codec settings
// - number_of_cores : Number of cores available for the encoder
// - max_payload_size : The maximum size each payload is allowed
// to have. Usually MTU - overhead.
//
// Return value : Set bit rate if OK
// <0 - Errors:
// WEBRTC_VIDEO_CODEC_ERR_PARAMETER
// WEBRTC_VIDEO_CODEC_ERR_SIZE
// WEBRTC_VIDEO_CODEC_LEVEL_EXCEEDED
// WEBRTC_VIDEO_CODEC_MEMORY
// WEBRTC_VIDEO_CODEC_ERROR
virtual int32_t InitEncode(const VideoCodec* codec_settings,
int32_t number_of_cores,
size_t max_payload_size) = 0;
// Register an encode complete callback object.
//
// Input:
// - callback : Callback object which handles encoded images.
//
// Return value : WEBRTC_VIDEO_CODEC_OK if OK, < 0 otherwise.
virtual int32_t RegisterEncodeCompleteCallback(
EncodedImageCallback* callback) = 0;
// Free encoder memory.
// Return value : WEBRTC_VIDEO_CODEC_OK if OK, < 0 otherwise.
virtual int32_t Release() = 0;
// Encode an I420 image (as a part of a video stream). The encoded image
// will be returned to the user through the encode complete callback.
//
// Input:
// - frame : Image to be encoded
// - frame_types : Frame type to be generated by the encoder.
//
// Return value : WEBRTC_VIDEO_CODEC_OK if OK
// <0 - Errors:
// WEBRTC_VIDEO_CODEC_ERR_PARAMETER
// WEBRTC_VIDEO_CODEC_MEMORY
// WEBRTC_VIDEO_CODEC_ERROR
// WEBRTC_VIDEO_CODEC_TIMEOUT
virtual int32_t Encode(const VideoFrame& frame,
const CodecSpecificInfo* codec_specific_info,
const std::vector<FrameType>* frame_types) = 0;
// Inform the encoder of the new packet loss rate and the round-trip time of
// the network.
//
// Input:
// - packet_loss : Fraction lost
// (loss rate in percent = 100 * packetLoss / 255)
// - rtt : Round-trip time in milliseconds
// Return value : WEBRTC_VIDEO_CODEC_OK if OK
// <0 - Errors: WEBRTC_VIDEO_CODEC_ERROR
virtual int32_t SetChannelParameters(uint32_t packet_loss, int64_t rtt) = 0;
// Inform the encoder about the new target bit rate.
//
// Input:
// - bitrate : New target bit rate
// - framerate : The target frame rate
//
// Return value : WEBRTC_VIDEO_CODEC_OK if OK, < 0 otherwise.
virtual int32_t SetRates(uint32_t bitrate, uint32_t framerate);
// Default fallback: Just use the sum of bitrates as the single target rate.
// TODO(sprang): Remove this default implementation when we remove SetRates().
virtual int32_t SetRateAllocation(const BitrateAllocation& allocation,
uint32_t framerate);
// Any encoder implementation wishing to use the WebRTC provided
// quality scaler must implement this method.
virtual ScalingSettings GetScalingSettings() const;
virtual int32_t SetPeriodicKeyFrames(bool enable);
virtual bool SupportsNativeHandle() const;
virtual const char* ImplementationName() const;
};
} // namespace webrtc
#endif // WEBRTC_API_VIDEO_CODECS_VIDEO_ENCODER_H_

57
api/video_codecs/video_encoder_factory.h Normal file
View File

@ -0,0 +1,57 @@
/*
* Copyright (c) 2017 The WebRTC project authors. All Rights Reserved.
*
* Use of this source code is governed by a BSD-style license
* that can be found in the LICENSE file in the root of the source
* tree. An additional intellectual property rights grant can be found
* in the file PATENTS. All contributing project authors may
* be found in the AUTHORS file in the root of the source tree.
*/
#ifndef WEBRTC_API_VIDEO_CODECS_VIDEO_ENCODER_FACTORY_H_
#define WEBRTC_API_VIDEO_CODECS_VIDEO_ENCODER_FACTORY_H_
#include <memory>
#include <vector>
namespace webrtc {
class VideoEncoder;
struct SdpVideoFormat;
// A factory that creates VideoEncoders.
// NOTE: This class is still under development and may change without notice.
class VideoEncoderFactory {
public:
// TODO(magjed): Try to get rid of this struct.
struct CodecInfo {
// |is_hardware_accelerated| is true if the encoders created by this factory
// of the given codec will use hardware support.
bool is_hardware_accelerated;
// |has_internal_source| is true if encoders created by this factory of the
// given codec will use internal camera sources, meaning that they don't
// require/expect frames to be delivered via webrtc::VideoEncoder::Encode.
// This flag is used as the internal_source parameter to
// webrtc::ViEExternalCodec::RegisterExternalSendCodec.
bool has_internal_source;
};
// Returns a list of supported video formats in order of preference, to use
// for signaling etc.
virtual std::vector<SdpVideoFormat> GetSupportedFormats() const = 0;
// Returns information about how this format will be encoded. The specified
// format must be one of the supported formats by this factory.
// TODO(magjed): Try to get rid of this method.
virtual CodecInfo QueryVideoEncoder(const SdpVideoFormat& format) const = 0;
// Creates a VideoEncoder for the specified format.
virtual std::unique_ptr<VideoEncoder> CreateVideoEncoder(
const SdpVideoFormat& format) = 0;
virtual ~VideoEncoderFactory() {}
};
} // namespace webrtc
#endif // WEBRTC_API_VIDEO_CODECS_VIDEO_ENCODER_FACTORY_H_