1 /* 2 * Copyright (c) 2012 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 #ifndef WEBRTC_COMMON_TYPES_H_ 12 #define WEBRTC_COMMON_TYPES_H_ 13 14 #include <stddef.h> 15 #include <string.h> 16 17 #include <string> 18 #include <vector> 19 20 #include "webrtc/typedefs.h" 21 22 #if defined(_MSC_VER) 23 // Disable "new behavior: elements of array will be default initialized" 24 // warning. Affects OverUseDetectorOptions. 25 #pragma warning(disable:4351) 26 #endif 27 28 #ifdef WEBRTC_EXPORT 29 #define WEBRTC_DLLEXPORT _declspec(dllexport) 30 #elif WEBRTC_DLL 31 #define WEBRTC_DLLEXPORT _declspec(dllimport) 32 #else 33 #define WEBRTC_DLLEXPORT 34 #endif 35 36 #ifndef NULL 37 #define NULL 0 38 #endif 39 40 #define RTP_PAYLOAD_NAME_SIZE 32 41 42 #if defined(WEBRTC_WIN) || defined(WIN32) 43 // Compares two strings without regard to case. 44 #define STR_CASE_CMP(s1, s2) ::_stricmp(s1, s2) 45 // Compares characters of two strings without regard to case. 46 #define STR_NCASE_CMP(s1, s2, n) ::_strnicmp(s1, s2, n) 47 #else 48 #define STR_CASE_CMP(s1, s2) ::strcasecmp(s1, s2) 49 #define STR_NCASE_CMP(s1, s2, n) ::strncasecmp(s1, s2, n) 50 #endif 51 52 namespace webrtc { 53 54 class Config; 55 56 class InStream 57 { 58 public: 59 // Reads |length| bytes from file to |buf|. Returns the number of bytes read 60 // or -1 on error. 61 virtual int Read(void *buf, size_t len) = 0; 62 virtual int Rewind(); ~InStream()63 virtual ~InStream() {} 64 protected: InStream()65 InStream() {} 66 }; 67 68 class OutStream 69 { 70 public: 71 // Writes |length| bytes from |buf| to file. The actual writing may happen 72 // some time later. Call Flush() to force a write. 73 virtual bool Write(const void *buf, size_t len) = 0; 74 virtual int Rewind(); ~OutStream()75 virtual ~OutStream() {} 76 protected: OutStream()77 OutStream() {} 78 }; 79 80 enum TraceModule 81 { 82 kTraceUndefined = 0, 83 // not a module, triggered from the engine code 84 kTraceVoice = 0x0001, 85 // not a module, triggered from the engine code 86 kTraceVideo = 0x0002, 87 // not a module, triggered from the utility code 88 kTraceUtility = 0x0003, 89 kTraceRtpRtcp = 0x0004, 90 kTraceTransport = 0x0005, 91 kTraceSrtp = 0x0006, 92 kTraceAudioCoding = 0x0007, 93 kTraceAudioMixerServer = 0x0008, 94 kTraceAudioMixerClient = 0x0009, 95 kTraceFile = 0x000a, 96 kTraceAudioProcessing = 0x000b, 97 kTraceVideoCoding = 0x0010, 98 kTraceVideoMixer = 0x0011, 99 kTraceAudioDevice = 0x0012, 100 kTraceVideoRenderer = 0x0014, 101 kTraceVideoCapture = 0x0015, 102 kTraceRemoteBitrateEstimator = 0x0017, 103 }; 104 105 enum TraceLevel 106 { 107 kTraceNone = 0x0000, // no trace 108 kTraceStateInfo = 0x0001, 109 kTraceWarning = 0x0002, 110 kTraceError = 0x0004, 111 kTraceCritical = 0x0008, 112 kTraceApiCall = 0x0010, 113 kTraceDefault = 0x00ff, 114 115 kTraceModuleCall = 0x0020, 116 kTraceMemory = 0x0100, // memory info 117 kTraceTimer = 0x0200, // timing info 118 kTraceStream = 0x0400, // "continuous" stream of data 119 120 // used for debug purposes 121 kTraceDebug = 0x0800, // debug 122 kTraceInfo = 0x1000, // debug info 123 124 // Non-verbose level used by LS_INFO of logging.h. Do not use directly. 125 kTraceTerseInfo = 0x2000, 126 127 kTraceAll = 0xffff 128 }; 129 130 // External Trace API 131 class TraceCallback { 132 public: 133 virtual void Print(TraceLevel level, const char* message, int length) = 0; 134 135 protected: ~TraceCallback()136 virtual ~TraceCallback() {} TraceCallback()137 TraceCallback() {} 138 }; 139 140 enum FileFormats 141 { 142 kFileFormatWavFile = 1, 143 kFileFormatCompressedFile = 2, 144 kFileFormatPreencodedFile = 4, 145 kFileFormatPcm16kHzFile = 7, 146 kFileFormatPcm8kHzFile = 8, 147 kFileFormatPcm32kHzFile = 9 148 }; 149 150 enum ProcessingTypes 151 { 152 kPlaybackPerChannel = 0, 153 kPlaybackAllChannelsMixed, 154 kRecordingPerChannel, 155 kRecordingAllChannelsMixed, 156 kRecordingPreprocessing 157 }; 158 159 enum FrameType { 160 kEmptyFrame = 0, 161 kAudioFrameSpeech = 1, 162 kAudioFrameCN = 2, 163 kVideoFrameKey = 3, 164 kVideoFrameDelta = 4, 165 }; 166 167 // Statistics for an RTCP channel 168 struct RtcpStatistics { RtcpStatisticsRtcpStatistics169 RtcpStatistics() 170 : fraction_lost(0), 171 cumulative_lost(0), 172 extended_max_sequence_number(0), 173 jitter(0) {} 174 175 uint8_t fraction_lost; 176 uint32_t cumulative_lost; 177 uint32_t extended_max_sequence_number; 178 uint32_t jitter; 179 }; 180 181 class RtcpStatisticsCallback { 182 public: ~RtcpStatisticsCallback()183 virtual ~RtcpStatisticsCallback() {} 184 185 virtual void StatisticsUpdated(const RtcpStatistics& statistics, 186 uint32_t ssrc) = 0; 187 virtual void CNameChanged(const char* cname, uint32_t ssrc) = 0; 188 }; 189 190 // Statistics for RTCP packet types. 191 struct RtcpPacketTypeCounter { RtcpPacketTypeCounterRtcpPacketTypeCounter192 RtcpPacketTypeCounter() 193 : first_packet_time_ms(-1), 194 nack_packets(0), 195 fir_packets(0), 196 pli_packets(0), 197 nack_requests(0), 198 unique_nack_requests(0) {} 199 AddRtcpPacketTypeCounter200 void Add(const RtcpPacketTypeCounter& other) { 201 nack_packets += other.nack_packets; 202 fir_packets += other.fir_packets; 203 pli_packets += other.pli_packets; 204 nack_requests += other.nack_requests; 205 unique_nack_requests += other.unique_nack_requests; 206 if (other.first_packet_time_ms != -1 && 207 (other.first_packet_time_ms < first_packet_time_ms || 208 first_packet_time_ms == -1)) { 209 // Use oldest time. 210 first_packet_time_ms = other.first_packet_time_ms; 211 } 212 } 213 TimeSinceFirstPacketInMsRtcpPacketTypeCounter214 int64_t TimeSinceFirstPacketInMs(int64_t now_ms) const { 215 return (first_packet_time_ms == -1) ? -1 : (now_ms - first_packet_time_ms); 216 } 217 UniqueNackRequestsInPercentRtcpPacketTypeCounter218 int UniqueNackRequestsInPercent() const { 219 if (nack_requests == 0) { 220 return 0; 221 } 222 return static_cast<int>( 223 (unique_nack_requests * 100.0f / nack_requests) + 0.5f); 224 } 225 226 int64_t first_packet_time_ms; // Time when first packet is sent/received. 227 uint32_t nack_packets; // Number of RTCP NACK packets. 228 uint32_t fir_packets; // Number of RTCP FIR packets. 229 uint32_t pli_packets; // Number of RTCP PLI packets. 230 uint32_t nack_requests; // Number of NACKed RTP packets. 231 uint32_t unique_nack_requests; // Number of unique NACKed RTP packets. 232 }; 233 234 class RtcpPacketTypeCounterObserver { 235 public: ~RtcpPacketTypeCounterObserver()236 virtual ~RtcpPacketTypeCounterObserver() {} 237 virtual void RtcpPacketTypesCounterUpdated( 238 uint32_t ssrc, 239 const RtcpPacketTypeCounter& packet_counter) = 0; 240 }; 241 242 // Rate statistics for a stream. 243 struct BitrateStatistics { BitrateStatisticsBitrateStatistics244 BitrateStatistics() : bitrate_bps(0), packet_rate(0), timestamp_ms(0) {} 245 246 uint32_t bitrate_bps; // Bitrate in bits per second. 247 uint32_t packet_rate; // Packet rate in packets per second. 248 uint64_t timestamp_ms; // Ntp timestamp in ms at time of rate estimation. 249 }; 250 251 // Callback, used to notify an observer whenever new rates have been estimated. 252 class BitrateStatisticsObserver { 253 public: ~BitrateStatisticsObserver()254 virtual ~BitrateStatisticsObserver() {} 255 256 virtual void Notify(const BitrateStatistics& total_stats, 257 const BitrateStatistics& retransmit_stats, 258 uint32_t ssrc) = 0; 259 }; 260 261 struct FrameCounts { FrameCountsFrameCounts262 FrameCounts() : key_frames(0), delta_frames(0) {} 263 int key_frames; 264 int delta_frames; 265 }; 266 267 // Callback, used to notify an observer whenever frame counts have been updated. 268 class FrameCountObserver { 269 public: ~FrameCountObserver()270 virtual ~FrameCountObserver() {} 271 virtual void FrameCountUpdated(const FrameCounts& frame_counts, 272 uint32_t ssrc) = 0; 273 }; 274 275 // Callback, used to notify an observer whenever the send-side delay is updated. 276 class SendSideDelayObserver { 277 public: ~SendSideDelayObserver()278 virtual ~SendSideDelayObserver() {} 279 virtual void SendSideDelayUpdated(int avg_delay_ms, 280 int max_delay_ms, 281 uint32_t ssrc) = 0; 282 }; 283 284 // ================================================================== 285 // Voice specific types 286 // ================================================================== 287 288 // Each codec supported can be described by this structure. 289 struct CodecInst { 290 int pltype; 291 char plname[RTP_PAYLOAD_NAME_SIZE]; 292 int plfreq; 293 int pacsize; 294 size_t channels; 295 int rate; // bits/sec unlike {start,min,max}Bitrate elsewhere in this file! 296 297 bool operator==(const CodecInst& other) const { 298 return pltype == other.pltype && 299 (STR_CASE_CMP(plname, other.plname) == 0) && 300 plfreq == other.plfreq && 301 pacsize == other.pacsize && 302 channels == other.channels && 303 rate == other.rate; 304 } 305 306 bool operator!=(const CodecInst& other) const { 307 return !(*this == other); 308 } 309 }; 310 311 // RTP 312 enum {kRtpCsrcSize = 15}; // RFC 3550 page 13 313 314 enum PayloadFrequencies 315 { 316 kFreq8000Hz = 8000, 317 kFreq16000Hz = 16000, 318 kFreq32000Hz = 32000 319 }; 320 321 enum VadModes // degree of bandwidth reduction 322 { 323 kVadConventional = 0, // lowest reduction 324 kVadAggressiveLow, 325 kVadAggressiveMid, 326 kVadAggressiveHigh // highest reduction 327 }; 328 329 struct NetworkStatistics // NETEQ statistics 330 { 331 // current jitter buffer size in ms 332 uint16_t currentBufferSize; 333 // preferred (optimal) buffer size in ms 334 uint16_t preferredBufferSize; 335 // adding extra delay due to "peaky jitter" 336 bool jitterPeaksFound; 337 // Loss rate (network + late); fraction between 0 and 1, scaled to Q14. 338 uint16_t currentPacketLossRate; 339 // Late loss rate; fraction between 0 and 1, scaled to Q14. 340 uint16_t currentDiscardRate; 341 // fraction (of original stream) of synthesized audio inserted through 342 // expansion (in Q14) 343 uint16_t currentExpandRate; 344 // fraction (of original stream) of synthesized speech inserted through 345 // expansion (in Q14) 346 uint16_t currentSpeechExpandRate; 347 // fraction of synthesized speech inserted through pre-emptive expansion 348 // (in Q14) 349 uint16_t currentPreemptiveRate; 350 // fraction of data removed through acceleration (in Q14) 351 uint16_t currentAccelerateRate; 352 // fraction of data coming from secondary decoding (in Q14) 353 uint16_t currentSecondaryDecodedRate; 354 // clock-drift in parts-per-million (negative or positive) 355 int32_t clockDriftPPM; 356 // average packet waiting time in the jitter buffer (ms) 357 int meanWaitingTimeMs; 358 // median packet waiting time in the jitter buffer (ms) 359 int medianWaitingTimeMs; 360 // min packet waiting time in the jitter buffer (ms) 361 int minWaitingTimeMs; 362 // max packet waiting time in the jitter buffer (ms) 363 int maxWaitingTimeMs; 364 // added samples in off mode due to packet loss 365 size_t addedSamples; 366 }; 367 368 // Statistics for calls to AudioCodingModule::PlayoutData10Ms(). 369 struct AudioDecodingCallStats { AudioDecodingCallStatsAudioDecodingCallStats370 AudioDecodingCallStats() 371 : calls_to_silence_generator(0), 372 calls_to_neteq(0), 373 decoded_normal(0), 374 decoded_plc(0), 375 decoded_cng(0), 376 decoded_plc_cng(0) {} 377 378 int calls_to_silence_generator; // Number of calls where silence generated, 379 // and NetEq was disengaged from decoding. 380 int calls_to_neteq; // Number of calls to NetEq. 381 int decoded_normal; // Number of calls where audio RTP packet decoded. 382 int decoded_plc; // Number of calls resulted in PLC. 383 int decoded_cng; // Number of calls where comfort noise generated due to DTX. 384 int decoded_plc_cng; // Number of calls resulted where PLC faded to CNG. 385 }; 386 387 typedef struct 388 { 389 int min; // minumum 390 int max; // maximum 391 int average; // average 392 } StatVal; 393 394 typedef struct // All levels are reported in dBm0 395 { 396 StatVal speech_rx; // long-term speech levels on receiving side 397 StatVal speech_tx; // long-term speech levels on transmitting side 398 StatVal noise_rx; // long-term noise/silence levels on receiving side 399 StatVal noise_tx; // long-term noise/silence levels on transmitting side 400 } LevelStatistics; 401 402 typedef struct // All levels are reported in dB 403 { 404 StatVal erl; // Echo Return Loss 405 StatVal erle; // Echo Return Loss Enhancement 406 StatVal rerl; // RERL = ERL + ERLE 407 // Echo suppression inside EC at the point just before its NLP 408 StatVal a_nlp; 409 } EchoStatistics; 410 411 enum NsModes // type of Noise Suppression 412 { 413 kNsUnchanged = 0, // previously set mode 414 kNsDefault, // platform default 415 kNsConference, // conferencing default 416 kNsLowSuppression, // lowest suppression 417 kNsModerateSuppression, 418 kNsHighSuppression, 419 kNsVeryHighSuppression, // highest suppression 420 }; 421 422 enum AgcModes // type of Automatic Gain Control 423 { 424 kAgcUnchanged = 0, // previously set mode 425 kAgcDefault, // platform default 426 // adaptive mode for use when analog volume control exists (e.g. for 427 // PC softphone) 428 kAgcAdaptiveAnalog, 429 // scaling takes place in the digital domain (e.g. for conference servers 430 // and embedded devices) 431 kAgcAdaptiveDigital, 432 // can be used on embedded devices where the capture signal level 433 // is predictable 434 kAgcFixedDigital 435 }; 436 437 // EC modes 438 enum EcModes // type of Echo Control 439 { 440 kEcUnchanged = 0, // previously set mode 441 kEcDefault, // platform default 442 kEcConference, // conferencing default (aggressive AEC) 443 kEcAec, // Acoustic Echo Cancellation 444 kEcAecm, // AEC mobile 445 }; 446 447 // AECM modes 448 enum AecmModes // mode of AECM 449 { 450 kAecmQuietEarpieceOrHeadset = 0, 451 // Quiet earpiece or headset use 452 kAecmEarpiece, // most earpiece use 453 kAecmLoudEarpiece, // Loud earpiece or quiet speakerphone use 454 kAecmSpeakerphone, // most speakerphone use (default) 455 kAecmLoudSpeakerphone // Loud speakerphone 456 }; 457 458 // AGC configuration 459 typedef struct 460 { 461 unsigned short targetLeveldBOv; 462 unsigned short digitalCompressionGaindB; 463 bool limiterEnable; 464 } AgcConfig; // AGC configuration parameters 465 466 enum StereoChannel 467 { 468 kStereoLeft = 0, 469 kStereoRight, 470 kStereoBoth 471 }; 472 473 // Audio device layers 474 enum AudioLayers 475 { 476 kAudioPlatformDefault = 0, 477 kAudioWindowsWave = 1, 478 kAudioWindowsCore = 2, 479 kAudioLinuxAlsa = 3, 480 kAudioLinuxPulse = 4 481 }; 482 483 // TODO(henrika): to be removed. 484 enum NetEqModes // NetEQ playout configurations 485 { 486 // Optimized trade-off between low delay and jitter robustness for two-way 487 // communication. 488 kNetEqDefault = 0, 489 // Improved jitter robustness at the cost of increased delay. Can be 490 // used in one-way communication. 491 kNetEqStreaming = 1, 492 // Optimzed for decodability of fax signals rather than for perceived audio 493 // quality. 494 kNetEqFax = 2, 495 // Minimal buffer management. Inserts zeros for lost packets and during 496 // buffer increases. 497 kNetEqOff = 3, 498 }; 499 500 // TODO(henrika): to be removed. 501 enum OnHoldModes // On Hold direction 502 { 503 kHoldSendAndPlay = 0, // Put both sending and playing in on-hold state. 504 kHoldSendOnly, // Put only sending in on-hold state. 505 kHoldPlayOnly // Put only playing in on-hold state. 506 }; 507 508 // TODO(henrika): to be removed. 509 enum AmrMode 510 { 511 kRfc3267BwEfficient = 0, 512 kRfc3267OctetAligned = 1, 513 kRfc3267FileStorage = 2, 514 }; 515 516 // ================================================================== 517 // Video specific types 518 // ================================================================== 519 520 // Raw video types 521 enum RawVideoType 522 { 523 kVideoI420 = 0, 524 kVideoYV12 = 1, 525 kVideoYUY2 = 2, 526 kVideoUYVY = 3, 527 kVideoIYUV = 4, 528 kVideoARGB = 5, 529 kVideoRGB24 = 6, 530 kVideoRGB565 = 7, 531 kVideoARGB4444 = 8, 532 kVideoARGB1555 = 9, 533 kVideoMJPEG = 10, 534 kVideoNV12 = 11, 535 kVideoNV21 = 12, 536 kVideoBGRA = 13, 537 kVideoUnknown = 99 538 }; 539 540 // Video codec 541 enum { kConfigParameterSize = 128}; 542 enum { kPayloadNameSize = 32}; 543 enum { kMaxSimulcastStreams = 4}; 544 enum { kMaxSpatialLayers = 5 }; 545 enum { kMaxTemporalStreams = 4}; 546 547 enum VideoCodecComplexity 548 { 549 kComplexityNormal = 0, 550 kComplexityHigh = 1, 551 kComplexityHigher = 2, 552 kComplexityMax = 3 553 }; 554 555 enum VideoCodecProfile 556 { 557 kProfileBase = 0x00, 558 kProfileMain = 0x01 559 }; 560 561 enum VP8ResilienceMode { 562 kResilienceOff, // The stream produced by the encoder requires a 563 // recovery frame (typically a key frame) to be 564 // decodable after a packet loss. 565 kResilientStream, // A stream produced by the encoder is resilient to 566 // packet losses, but packets within a frame subsequent 567 // to a loss can't be decoded. 568 kResilientFrames // Same as kResilientStream but with added resilience 569 // within a frame. 570 }; 571 572 // VP8 specific 573 struct VideoCodecVP8 { 574 bool pictureLossIndicationOn; 575 bool feedbackModeOn; 576 VideoCodecComplexity complexity; 577 VP8ResilienceMode resilience; 578 unsigned char numberOfTemporalLayers; 579 bool denoisingOn; 580 bool errorConcealmentOn; 581 bool automaticResizeOn; 582 bool frameDroppingOn; 583 int keyFrameInterval; 584 585 bool operator==(const VideoCodecVP8& other) const { 586 return pictureLossIndicationOn == other.pictureLossIndicationOn && 587 feedbackModeOn == other.feedbackModeOn && 588 complexity == other.complexity && 589 resilience == other.resilience && 590 numberOfTemporalLayers == other.numberOfTemporalLayers && 591 denoisingOn == other.denoisingOn && 592 errorConcealmentOn == other.errorConcealmentOn && 593 automaticResizeOn == other.automaticResizeOn && 594 frameDroppingOn == other.frameDroppingOn && 595 keyFrameInterval == other.keyFrameInterval; 596 } 597 598 bool operator!=(const VideoCodecVP8& other) const { 599 return !(*this == other); 600 } 601 }; 602 603 // VP9 specific. 604 struct VideoCodecVP9 { 605 VideoCodecComplexity complexity; 606 int resilience; 607 unsigned char numberOfTemporalLayers; 608 bool denoisingOn; 609 bool frameDroppingOn; 610 int keyFrameInterval; 611 bool adaptiveQpMode; 612 bool automaticResizeOn; 613 unsigned char numberOfSpatialLayers; 614 bool flexibleMode; 615 }; 616 617 // H264 specific. 618 struct VideoCodecH264 { 619 VideoCodecProfile profile; 620 bool frameDroppingOn; 621 int keyFrameInterval; 622 // These are NULL/0 if not externally negotiated. 623 const uint8_t* spsData; 624 size_t spsLen; 625 const uint8_t* ppsData; 626 size_t ppsLen; 627 }; 628 629 // Video codec types 630 enum VideoCodecType { 631 kVideoCodecVP8, 632 kVideoCodecVP9, 633 kVideoCodecH264, 634 kVideoCodecI420, 635 kVideoCodecRED, 636 kVideoCodecULPFEC, 637 kVideoCodecGeneric, 638 kVideoCodecUnknown 639 }; 640 641 union VideoCodecUnion { 642 VideoCodecVP8 VP8; 643 VideoCodecVP9 VP9; 644 VideoCodecH264 H264; 645 }; 646 647 648 // Simulcast is when the same stream is encoded multiple times with different 649 // settings such as resolution. 650 struct SimulcastStream { 651 unsigned short width; 652 unsigned short height; 653 unsigned char numberOfTemporalLayers; 654 unsigned int maxBitrate; // kilobits/sec. 655 unsigned int targetBitrate; // kilobits/sec. 656 unsigned int minBitrate; // kilobits/sec. 657 unsigned int qpMax; // minimum quality 658 659 bool operator==(const SimulcastStream& other) const { 660 return width == other.width && 661 height == other.height && 662 numberOfTemporalLayers == other.numberOfTemporalLayers && 663 maxBitrate == other.maxBitrate && 664 targetBitrate == other.targetBitrate && 665 minBitrate == other.minBitrate && 666 qpMax == other.qpMax; 667 } 668 669 bool operator!=(const SimulcastStream& other) const { 670 return !(*this == other); 671 } 672 }; 673 674 struct SpatialLayer { 675 int scaling_factor_num; 676 int scaling_factor_den; 677 int target_bitrate_bps; 678 // TODO(ivica): Add max_quantizer and min_quantizer? 679 }; 680 681 enum VideoCodecMode { 682 kRealtimeVideo, 683 kScreensharing 684 }; 685 686 // Common video codec properties 687 struct VideoCodec { 688 VideoCodecType codecType; 689 char plName[kPayloadNameSize]; 690 unsigned char plType; 691 692 unsigned short width; 693 unsigned short height; 694 695 unsigned int startBitrate; // kilobits/sec. 696 unsigned int maxBitrate; // kilobits/sec. 697 unsigned int minBitrate; // kilobits/sec. 698 unsigned int targetBitrate; // kilobits/sec. 699 700 unsigned char maxFramerate; 701 702 VideoCodecUnion codecSpecific; 703 704 unsigned int qpMax; 705 unsigned char numberOfSimulcastStreams; 706 SimulcastStream simulcastStream[kMaxSimulcastStreams]; 707 SpatialLayer spatialLayers[kMaxSpatialLayers]; 708 709 VideoCodecMode mode; 710 711 // When using an external encoder/decoder this allows to pass 712 // extra options without requiring webrtc to be aware of them. 713 Config* extra_options; 714 715 bool operator==(const VideoCodec& other) const { 716 bool ret = codecType == other.codecType && 717 (STR_CASE_CMP(plName, other.plName) == 0) && 718 plType == other.plType && 719 width == other.width && 720 height == other.height && 721 startBitrate == other.startBitrate && 722 maxBitrate == other.maxBitrate && 723 minBitrate == other.minBitrate && 724 targetBitrate == other.targetBitrate && 725 maxFramerate == other.maxFramerate && 726 qpMax == other.qpMax && 727 numberOfSimulcastStreams == other.numberOfSimulcastStreams && 728 mode == other.mode; 729 if (ret && codecType == kVideoCodecVP8) { 730 ret &= (codecSpecific.VP8 == other.codecSpecific.VP8); 731 } 732 733 for (unsigned char i = 0; i < other.numberOfSimulcastStreams && ret; ++i) { 734 ret &= (simulcastStream[i] == other.simulcastStream[i]); 735 } 736 return ret; 737 } 738 739 bool operator!=(const VideoCodec& other) const { 740 return !(*this == other); 741 } 742 }; 743 744 // Bandwidth over-use detector options. These are used to drive 745 // experimentation with bandwidth estimation parameters. 746 // See modules/remote_bitrate_estimator/overuse_detector.h 747 struct OverUseDetectorOptions { OverUseDetectorOptionsOverUseDetectorOptions748 OverUseDetectorOptions() 749 : initial_slope(8.0/512.0), 750 initial_offset(0), 751 initial_e(), 752 initial_process_noise(), 753 initial_avg_noise(0.0), 754 initial_var_noise(50) { 755 initial_e[0][0] = 100; 756 initial_e[1][1] = 1e-1; 757 initial_e[0][1] = initial_e[1][0] = 0; 758 initial_process_noise[0] = 1e-13; 759 initial_process_noise[1] = 1e-2; 760 } 761 double initial_slope; 762 double initial_offset; 763 double initial_e[2][2]; 764 double initial_process_noise[2]; 765 double initial_avg_noise; 766 double initial_var_noise; 767 }; 768 769 // This structure will have the information about when packet is actually 770 // received by socket. 771 struct PacketTime { PacketTimePacketTime772 PacketTime() : timestamp(-1), not_before(-1) {} PacketTimePacketTime773 PacketTime(int64_t timestamp, int64_t not_before) 774 : timestamp(timestamp), not_before(not_before) { 775 } 776 777 int64_t timestamp; // Receive time after socket delivers the data. 778 int64_t not_before; // Earliest possible time the data could have arrived, 779 // indicating the potential error in the |timestamp| 780 // value,in case the system is busy. 781 // For example, the time of the last select() call. 782 // If unknown, this value will be set to zero. 783 }; 784 785 struct RTPHeaderExtension { 786 RTPHeaderExtension(); 787 788 bool hasTransmissionTimeOffset; 789 int32_t transmissionTimeOffset; 790 bool hasAbsoluteSendTime; 791 uint32_t absoluteSendTime; 792 bool hasTransportSequenceNumber; 793 uint16_t transportSequenceNumber; 794 795 // Audio Level includes both level in dBov and voiced/unvoiced bit. See: 796 // https://datatracker.ietf.org/doc/draft-lennox-avt-rtp-audio-level-exthdr/ 797 bool hasAudioLevel; 798 bool voiceActivity; 799 uint8_t audioLevel; 800 801 // For Coordination of Video Orientation. See 802 // http://www.etsi.org/deliver/etsi_ts/126100_126199/126114/12.07.00_60/ 803 // ts_126114v120700p.pdf 804 bool hasVideoRotation; 805 uint8_t videoRotation; 806 }; 807 808 struct RTPHeader { 809 RTPHeader(); 810 811 bool markerBit; 812 uint8_t payloadType; 813 uint16_t sequenceNumber; 814 uint32_t timestamp; 815 uint32_t ssrc; 816 uint8_t numCSRCs; 817 uint32_t arrOfCSRCs[kRtpCsrcSize]; 818 size_t paddingLength; 819 size_t headerLength; 820 int payload_type_frequency; 821 RTPHeaderExtension extension; 822 }; 823 824 struct RtpPacketCounter { RtpPacketCounterRtpPacketCounter825 RtpPacketCounter() 826 : header_bytes(0), 827 payload_bytes(0), 828 padding_bytes(0), 829 packets(0) {} 830 AddRtpPacketCounter831 void Add(const RtpPacketCounter& other) { 832 header_bytes += other.header_bytes; 833 payload_bytes += other.payload_bytes; 834 padding_bytes += other.padding_bytes; 835 packets += other.packets; 836 } 837 AddPacketRtpPacketCounter838 void AddPacket(size_t packet_length, const RTPHeader& header) { 839 ++packets; 840 header_bytes += header.headerLength; 841 padding_bytes += header.paddingLength; 842 payload_bytes += 843 packet_length - (header.headerLength + header.paddingLength); 844 } 845 TotalBytesRtpPacketCounter846 size_t TotalBytes() const { 847 return header_bytes + payload_bytes + padding_bytes; 848 } 849 850 size_t header_bytes; // Number of bytes used by RTP headers. 851 size_t payload_bytes; // Payload bytes, excluding RTP headers and padding. 852 size_t padding_bytes; // Number of padding bytes. 853 uint32_t packets; // Number of packets. 854 }; 855 856 // Data usage statistics for a (rtp) stream. 857 struct StreamDataCounters { 858 StreamDataCounters(); 859 AddStreamDataCounters860 void Add(const StreamDataCounters& other) { 861 transmitted.Add(other.transmitted); 862 retransmitted.Add(other.retransmitted); 863 fec.Add(other.fec); 864 if (other.first_packet_time_ms != -1 && 865 (other.first_packet_time_ms < first_packet_time_ms || 866 first_packet_time_ms == -1)) { 867 // Use oldest time. 868 first_packet_time_ms = other.first_packet_time_ms; 869 } 870 } 871 TimeSinceFirstPacketInMsStreamDataCounters872 int64_t TimeSinceFirstPacketInMs(int64_t now_ms) const { 873 return (first_packet_time_ms == -1) ? -1 : (now_ms - first_packet_time_ms); 874 } 875 876 // Returns the number of bytes corresponding to the actual media payload (i.e. 877 // RTP headers, padding, retransmissions and fec packets are excluded). 878 // Note this function does not have meaning for an RTX stream. MediaPayloadBytesStreamDataCounters879 size_t MediaPayloadBytes() const { 880 return transmitted.payload_bytes - retransmitted.payload_bytes - 881 fec.payload_bytes; 882 } 883 884 int64_t first_packet_time_ms; // Time when first packet is sent/received. 885 RtpPacketCounter transmitted; // Number of transmitted packets/bytes. 886 RtpPacketCounter retransmitted; // Number of retransmitted packets/bytes. 887 RtpPacketCounter fec; // Number of redundancy packets/bytes. 888 }; 889 890 // Callback, called whenever byte/packet counts have been updated. 891 class StreamDataCountersCallback { 892 public: ~StreamDataCountersCallback()893 virtual ~StreamDataCountersCallback() {} 894 895 virtual void DataCountersUpdated(const StreamDataCounters& counters, 896 uint32_t ssrc) = 0; 897 }; 898 899 // RTCP mode to use. Compound mode is described by RFC 4585 and reduced-size 900 // RTCP mode is described by RFC 5506. 901 enum class RtcpMode { kOff, kCompound, kReducedSize }; 902 903 } // namespace webrtc 904 905 #endif // WEBRTC_COMMON_TYPES_H_ 906