1 /* 2 * Copyright (c) 2015 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 "webrtc/modules/rtp_rtcp/source/rtp_format_vp9.h" 12 13 #include <assert.h> 14 #include <string.h> 15 16 #include <cmath> 17 18 #include "webrtc/base/bitbuffer.h" 19 #include "webrtc/base/checks.h" 20 #include "webrtc/base/logging.h" 21 22 #define RETURN_FALSE_ON_ERROR(x) \ 23 if (!(x)) { \ 24 return false; \ 25 } 26 27 namespace webrtc { 28 namespace { 29 // Length of VP9 payload descriptors' fixed part. 30 const size_t kFixedPayloadDescriptorBytes = 1; 31 32 // Packet fragmentation mode. If true, packets are split into (almost) equal 33 // sizes. Otherwise, as many bytes as possible are fit into one packet. 34 const bool kBalancedMode = true; 35 36 const uint32_t kReservedBitValue0 = 0; 37 38 uint8_t TemporalIdxField(const RTPVideoHeaderVP9& hdr, uint8_t def) { 39 return (hdr.temporal_idx == kNoTemporalIdx) ? def : hdr.temporal_idx; 40 } 41 42 uint8_t SpatialIdxField(const RTPVideoHeaderVP9& hdr, uint8_t def) { 43 return (hdr.spatial_idx == kNoSpatialIdx) ? def : hdr.spatial_idx; 44 } 45 46 int16_t Tl0PicIdxField(const RTPVideoHeaderVP9& hdr, uint8_t def) { 47 return (hdr.tl0_pic_idx == kNoTl0PicIdx) ? def : hdr.tl0_pic_idx; 48 } 49 50 // Picture ID: 51 // 52 // +-+-+-+-+-+-+-+-+ 53 // I: |M| PICTURE ID | M:0 => picture id is 7 bits. 54 // +-+-+-+-+-+-+-+-+ M:1 => picture id is 15 bits. 55 // M: | EXTENDED PID | 56 // +-+-+-+-+-+-+-+-+ 57 // 58 size_t PictureIdLength(const RTPVideoHeaderVP9& hdr) { 59 if (hdr.picture_id == kNoPictureId) 60 return 0; 61 return (hdr.max_picture_id == kMaxOneBytePictureId) ? 1 : 2; 62 } 63 64 bool PictureIdPresent(const RTPVideoHeaderVP9& hdr) { 65 return PictureIdLength(hdr) > 0; 66 } 67 68 // Layer indices: 69 // 70 // Flexible mode (F=1): Non-flexible mode (F=0): 71 // 72 // +-+-+-+-+-+-+-+-+ +-+-+-+-+-+-+-+-+ 73 // L: | T |U| S |D| | T |U| S |D| 74 // +-+-+-+-+-+-+-+-+ +-+-+-+-+-+-+-+-+ 75 // | TL0PICIDX | 76 // +-+-+-+-+-+-+-+-+ 77 // 78 size_t LayerInfoLength(const RTPVideoHeaderVP9& hdr) { 79 if (hdr.temporal_idx == kNoTemporalIdx && 80 hdr.spatial_idx == kNoSpatialIdx) { 81 return 0; 82 } 83 return hdr.flexible_mode ? 1 : 2; 84 } 85 86 bool LayerInfoPresent(const RTPVideoHeaderVP9& hdr) { 87 return LayerInfoLength(hdr) > 0; 88 } 89 90 // Reference indices: 91 // 92 // +-+-+-+-+-+-+-+-+ P=1,F=1: At least one reference index 93 // P,F: | P_DIFF |N| up to 3 times has to be specified. 94 // +-+-+-+-+-+-+-+-+ N=1: An additional P_DIFF follows 95 // current P_DIFF. 96 // 97 size_t RefIndicesLength(const RTPVideoHeaderVP9& hdr) { 98 if (!hdr.inter_pic_predicted || !hdr.flexible_mode) 99 return 0; 100 101 RTC_DCHECK_GT(hdr.num_ref_pics, 0U); 102 RTC_DCHECK_LE(hdr.num_ref_pics, kMaxVp9RefPics); 103 return hdr.num_ref_pics; 104 } 105 106 // Scalability structure (SS). 107 // 108 // +-+-+-+-+-+-+-+-+ 109 // V: | N_S |Y|G|-|-|-| 110 // +-+-+-+-+-+-+-+-+ -| 111 // Y: | WIDTH | (OPTIONAL) . 112 // + + . 113 // | | (OPTIONAL) . 114 // +-+-+-+-+-+-+-+-+ . N_S + 1 times 115 // | HEIGHT | (OPTIONAL) . 116 // + + . 117 // | | (OPTIONAL) . 118 // +-+-+-+-+-+-+-+-+ -| 119 // G: | N_G | (OPTIONAL) 120 // +-+-+-+-+-+-+-+-+ -| 121 // N_G: | T |U| R |-|-| (OPTIONAL) . 122 // +-+-+-+-+-+-+-+-+ -| . N_G times 123 // | P_DIFF | (OPTIONAL) . R times . 124 // +-+-+-+-+-+-+-+-+ -| -| 125 // 126 size_t SsDataLength(const RTPVideoHeaderVP9& hdr) { 127 if (!hdr.ss_data_available) 128 return 0; 129 130 RTC_DCHECK_GT(hdr.num_spatial_layers, 0U); 131 RTC_DCHECK_LE(hdr.num_spatial_layers, kMaxVp9NumberOfSpatialLayers); 132 RTC_DCHECK_LE(hdr.gof.num_frames_in_gof, kMaxVp9FramesInGof); 133 size_t length = 1; // V 134 if (hdr.spatial_layer_resolution_present) { 135 length += 4 * hdr.num_spatial_layers; // Y 136 } 137 if (hdr.gof.num_frames_in_gof > 0) { 138 ++length; // G 139 } 140 // N_G 141 length += hdr.gof.num_frames_in_gof; // T, U, R 142 for (size_t i = 0; i < hdr.gof.num_frames_in_gof; ++i) { 143 RTC_DCHECK_LE(hdr.gof.num_ref_pics[i], kMaxVp9RefPics); 144 length += hdr.gof.num_ref_pics[i]; // R times 145 } 146 return length; 147 } 148 149 size_t PayloadDescriptorLengthMinusSsData(const RTPVideoHeaderVP9& hdr) { 150 return kFixedPayloadDescriptorBytes + PictureIdLength(hdr) + 151 LayerInfoLength(hdr) + RefIndicesLength(hdr); 152 } 153 154 size_t PayloadDescriptorLength(const RTPVideoHeaderVP9& hdr) { 155 return PayloadDescriptorLengthMinusSsData(hdr) + SsDataLength(hdr); 156 } 157 158 void QueuePacket(size_t start_pos, 159 size_t size, 160 bool layer_begin, 161 bool layer_end, 162 RtpPacketizerVp9::PacketInfoQueue* packets) { 163 RtpPacketizerVp9::PacketInfo packet_info; 164 packet_info.payload_start_pos = start_pos; 165 packet_info.size = size; 166 packet_info.layer_begin = layer_begin; 167 packet_info.layer_end = layer_end; 168 packets->push(packet_info); 169 } 170 171 // Picture ID: 172 // 173 // +-+-+-+-+-+-+-+-+ 174 // I: |M| PICTURE ID | M:0 => picture id is 7 bits. 175 // +-+-+-+-+-+-+-+-+ M:1 => picture id is 15 bits. 176 // M: | EXTENDED PID | 177 // +-+-+-+-+-+-+-+-+ 178 // 179 bool WritePictureId(const RTPVideoHeaderVP9& vp9, 180 rtc::BitBufferWriter* writer) { 181 bool m_bit = (PictureIdLength(vp9) == 2); 182 RETURN_FALSE_ON_ERROR(writer->WriteBits(m_bit ? 1 : 0, 1)); 183 RETURN_FALSE_ON_ERROR(writer->WriteBits(vp9.picture_id, m_bit ? 15 : 7)); 184 return true; 185 } 186 187 // Layer indices: 188 // 189 // Flexible mode (F=1): 190 // 191 // +-+-+-+-+-+-+-+-+ 192 // L: | T |U| S |D| 193 // +-+-+-+-+-+-+-+-+ 194 // 195 bool WriteLayerInfoCommon(const RTPVideoHeaderVP9& vp9, 196 rtc::BitBufferWriter* writer) { 197 RETURN_FALSE_ON_ERROR(writer->WriteBits(TemporalIdxField(vp9, 0), 3)); 198 RETURN_FALSE_ON_ERROR(writer->WriteBits(vp9.temporal_up_switch ? 1 : 0, 1)); 199 RETURN_FALSE_ON_ERROR(writer->WriteBits(SpatialIdxField(vp9, 0), 3)); 200 RETURN_FALSE_ON_ERROR(writer->WriteBits(vp9.inter_layer_predicted ? 1: 0, 1)); 201 return true; 202 } 203 204 // Non-flexible mode (F=0): 205 // 206 // +-+-+-+-+-+-+-+-+ 207 // L: | T |U| S |D| 208 // +-+-+-+-+-+-+-+-+ 209 // | TL0PICIDX | 210 // +-+-+-+-+-+-+-+-+ 211 // 212 bool WriteLayerInfoNonFlexibleMode(const RTPVideoHeaderVP9& vp9, 213 rtc::BitBufferWriter* writer) { 214 RETURN_FALSE_ON_ERROR(writer->WriteUInt8(Tl0PicIdxField(vp9, 0))); 215 return true; 216 } 217 218 bool WriteLayerInfo(const RTPVideoHeaderVP9& vp9, 219 rtc::BitBufferWriter* writer) { 220 if (!WriteLayerInfoCommon(vp9, writer)) 221 return false; 222 223 if (vp9.flexible_mode) 224 return true; 225 226 return WriteLayerInfoNonFlexibleMode(vp9, writer); 227 } 228 229 // Reference indices: 230 // 231 // +-+-+-+-+-+-+-+-+ P=1,F=1: At least one reference index 232 // P,F: | P_DIFF |N| up to 3 times has to be specified. 233 // +-+-+-+-+-+-+-+-+ N=1: An additional P_DIFF follows 234 // current P_DIFF. 235 // 236 bool WriteRefIndices(const RTPVideoHeaderVP9& vp9, 237 rtc::BitBufferWriter* writer) { 238 if (!PictureIdPresent(vp9) || 239 vp9.num_ref_pics == 0 || vp9.num_ref_pics > kMaxVp9RefPics) { 240 return false; 241 } 242 for (uint8_t i = 0; i < vp9.num_ref_pics; ++i) { 243 bool n_bit = !(i == vp9.num_ref_pics - 1); 244 RETURN_FALSE_ON_ERROR(writer->WriteBits(vp9.pid_diff[i], 7)); 245 RETURN_FALSE_ON_ERROR(writer->WriteBits(n_bit ? 1 : 0, 1)); 246 } 247 return true; 248 } 249 250 // Scalability structure (SS). 251 // 252 // +-+-+-+-+-+-+-+-+ 253 // V: | N_S |Y|G|-|-|-| 254 // +-+-+-+-+-+-+-+-+ -| 255 // Y: | WIDTH | (OPTIONAL) . 256 // + + . 257 // | | (OPTIONAL) . 258 // +-+-+-+-+-+-+-+-+ . N_S + 1 times 259 // | HEIGHT | (OPTIONAL) . 260 // + + . 261 // | | (OPTIONAL) . 262 // +-+-+-+-+-+-+-+-+ -| 263 // G: | N_G | (OPTIONAL) 264 // +-+-+-+-+-+-+-+-+ -| 265 // N_G: | T |U| R |-|-| (OPTIONAL) . 266 // +-+-+-+-+-+-+-+-+ -| . N_G times 267 // | P_DIFF | (OPTIONAL) . R times . 268 // +-+-+-+-+-+-+-+-+ -| -| 269 // 270 bool WriteSsData(const RTPVideoHeaderVP9& vp9, rtc::BitBufferWriter* writer) { 271 RTC_DCHECK_GT(vp9.num_spatial_layers, 0U); 272 RTC_DCHECK_LE(vp9.num_spatial_layers, kMaxVp9NumberOfSpatialLayers); 273 RTC_DCHECK_LE(vp9.gof.num_frames_in_gof, kMaxVp9FramesInGof); 274 bool g_bit = vp9.gof.num_frames_in_gof > 0; 275 276 RETURN_FALSE_ON_ERROR(writer->WriteBits(vp9.num_spatial_layers - 1, 3)); 277 RETURN_FALSE_ON_ERROR( 278 writer->WriteBits(vp9.spatial_layer_resolution_present ? 1 : 0, 1)); 279 RETURN_FALSE_ON_ERROR(writer->WriteBits(g_bit ? 1 : 0, 1)); // G 280 RETURN_FALSE_ON_ERROR(writer->WriteBits(kReservedBitValue0, 3)); 281 282 if (vp9.spatial_layer_resolution_present) { 283 for (size_t i = 0; i < vp9.num_spatial_layers; ++i) { 284 RETURN_FALSE_ON_ERROR(writer->WriteUInt16(vp9.width[i])); 285 RETURN_FALSE_ON_ERROR(writer->WriteUInt16(vp9.height[i])); 286 } 287 } 288 if (g_bit) { 289 RETURN_FALSE_ON_ERROR(writer->WriteUInt8(vp9.gof.num_frames_in_gof)); 290 } 291 for (size_t i = 0; i < vp9.gof.num_frames_in_gof; ++i) { 292 RETURN_FALSE_ON_ERROR(writer->WriteBits(vp9.gof.temporal_idx[i], 3)); 293 RETURN_FALSE_ON_ERROR( 294 writer->WriteBits(vp9.gof.temporal_up_switch[i] ? 1 : 0, 1)); 295 RETURN_FALSE_ON_ERROR(writer->WriteBits(vp9.gof.num_ref_pics[i], 2)); 296 RETURN_FALSE_ON_ERROR(writer->WriteBits(kReservedBitValue0, 2)); 297 for (uint8_t r = 0; r < vp9.gof.num_ref_pics[i]; ++r) { 298 RETURN_FALSE_ON_ERROR(writer->WriteUInt8(vp9.gof.pid_diff[i][r])); 299 } 300 } 301 return true; 302 } 303 304 // Picture ID: 305 // 306 // +-+-+-+-+-+-+-+-+ 307 // I: |M| PICTURE ID | M:0 => picture id is 7 bits. 308 // +-+-+-+-+-+-+-+-+ M:1 => picture id is 15 bits. 309 // M: | EXTENDED PID | 310 // +-+-+-+-+-+-+-+-+ 311 // 312 bool ParsePictureId(rtc::BitBuffer* parser, RTPVideoHeaderVP9* vp9) { 313 uint32_t picture_id; 314 uint32_t m_bit; 315 RETURN_FALSE_ON_ERROR(parser->ReadBits(&m_bit, 1)); 316 if (m_bit) { 317 RETURN_FALSE_ON_ERROR(parser->ReadBits(&picture_id, 15)); 318 vp9->max_picture_id = kMaxTwoBytePictureId; 319 } else { 320 RETURN_FALSE_ON_ERROR(parser->ReadBits(&picture_id, 7)); 321 vp9->max_picture_id = kMaxOneBytePictureId; 322 } 323 vp9->picture_id = picture_id; 324 return true; 325 } 326 327 // Layer indices (flexible mode): 328 // 329 // +-+-+-+-+-+-+-+-+ 330 // L: | T |U| S |D| 331 // +-+-+-+-+-+-+-+-+ 332 // 333 bool ParseLayerInfoCommon(rtc::BitBuffer* parser, RTPVideoHeaderVP9* vp9) { 334 uint32_t t, u_bit, s, d_bit; 335 RETURN_FALSE_ON_ERROR(parser->ReadBits(&t, 3)); 336 RETURN_FALSE_ON_ERROR(parser->ReadBits(&u_bit, 1)); 337 RETURN_FALSE_ON_ERROR(parser->ReadBits(&s, 3)); 338 RETURN_FALSE_ON_ERROR(parser->ReadBits(&d_bit, 1)); 339 vp9->temporal_idx = t; 340 vp9->temporal_up_switch = u_bit ? true : false; 341 vp9->spatial_idx = s; 342 vp9->inter_layer_predicted = d_bit ? true : false; 343 return true; 344 } 345 346 // Layer indices (non-flexible mode): 347 // 348 // +-+-+-+-+-+-+-+-+ 349 // L: | T |U| S |D| 350 // +-+-+-+-+-+-+-+-+ 351 // | TL0PICIDX | 352 // +-+-+-+-+-+-+-+-+ 353 // 354 bool ParseLayerInfoNonFlexibleMode(rtc::BitBuffer* parser, 355 RTPVideoHeaderVP9* vp9) { 356 uint8_t tl0picidx; 357 RETURN_FALSE_ON_ERROR(parser->ReadUInt8(&tl0picidx)); 358 vp9->tl0_pic_idx = tl0picidx; 359 return true; 360 } 361 362 bool ParseLayerInfo(rtc::BitBuffer* parser, RTPVideoHeaderVP9* vp9) { 363 if (!ParseLayerInfoCommon(parser, vp9)) 364 return false; 365 366 if (vp9->flexible_mode) 367 return true; 368 369 return ParseLayerInfoNonFlexibleMode(parser, vp9); 370 } 371 372 // Reference indices: 373 // 374 // +-+-+-+-+-+-+-+-+ P=1,F=1: At least one reference index 375 // P,F: | P_DIFF |N| up to 3 times has to be specified. 376 // +-+-+-+-+-+-+-+-+ N=1: An additional P_DIFF follows 377 // current P_DIFF. 378 // 379 bool ParseRefIndices(rtc::BitBuffer* parser, RTPVideoHeaderVP9* vp9) { 380 if (vp9->picture_id == kNoPictureId) 381 return false; 382 383 vp9->num_ref_pics = 0; 384 uint32_t n_bit; 385 do { 386 if (vp9->num_ref_pics == kMaxVp9RefPics) 387 return false; 388 389 uint32_t p_diff; 390 RETURN_FALSE_ON_ERROR(parser->ReadBits(&p_diff, 7)); 391 RETURN_FALSE_ON_ERROR(parser->ReadBits(&n_bit, 1)); 392 393 vp9->pid_diff[vp9->num_ref_pics] = p_diff; 394 uint32_t scaled_pid = vp9->picture_id; 395 if (p_diff > scaled_pid) { 396 // TODO(asapersson): Max should correspond to the picture id of last wrap. 397 scaled_pid += vp9->max_picture_id + 1; 398 } 399 vp9->ref_picture_id[vp9->num_ref_pics++] = scaled_pid - p_diff; 400 } while (n_bit); 401 402 return true; 403 } 404 405 // Scalability structure (SS). 406 // 407 // +-+-+-+-+-+-+-+-+ 408 // V: | N_S |Y|G|-|-|-| 409 // +-+-+-+-+-+-+-+-+ -| 410 // Y: | WIDTH | (OPTIONAL) . 411 // + + . 412 // | | (OPTIONAL) . 413 // +-+-+-+-+-+-+-+-+ . N_S + 1 times 414 // | HEIGHT | (OPTIONAL) . 415 // + + . 416 // | | (OPTIONAL) . 417 // +-+-+-+-+-+-+-+-+ -| 418 // G: | N_G | (OPTIONAL) 419 // +-+-+-+-+-+-+-+-+ -| 420 // N_G: | T |U| R |-|-| (OPTIONAL) . 421 // +-+-+-+-+-+-+-+-+ -| . N_G times 422 // | P_DIFF | (OPTIONAL) . R times . 423 // +-+-+-+-+-+-+-+-+ -| -| 424 // 425 bool ParseSsData(rtc::BitBuffer* parser, RTPVideoHeaderVP9* vp9) { 426 uint32_t n_s, y_bit, g_bit; 427 RETURN_FALSE_ON_ERROR(parser->ReadBits(&n_s, 3)); 428 RETURN_FALSE_ON_ERROR(parser->ReadBits(&y_bit, 1)); 429 RETURN_FALSE_ON_ERROR(parser->ReadBits(&g_bit, 1)); 430 RETURN_FALSE_ON_ERROR(parser->ConsumeBits(3)); 431 vp9->num_spatial_layers = n_s + 1; 432 vp9->spatial_layer_resolution_present = y_bit ? true : false; 433 vp9->gof.num_frames_in_gof = 0; 434 435 if (y_bit) { 436 for (size_t i = 0; i < vp9->num_spatial_layers; ++i) { 437 RETURN_FALSE_ON_ERROR(parser->ReadUInt16(&vp9->width[i])); 438 RETURN_FALSE_ON_ERROR(parser->ReadUInt16(&vp9->height[i])); 439 } 440 } 441 if (g_bit) { 442 uint8_t n_g; 443 RETURN_FALSE_ON_ERROR(parser->ReadUInt8(&n_g)); 444 vp9->gof.num_frames_in_gof = n_g; 445 } 446 for (size_t i = 0; i < vp9->gof.num_frames_in_gof; ++i) { 447 uint32_t t, u_bit, r; 448 RETURN_FALSE_ON_ERROR(parser->ReadBits(&t, 3)); 449 RETURN_FALSE_ON_ERROR(parser->ReadBits(&u_bit, 1)); 450 RETURN_FALSE_ON_ERROR(parser->ReadBits(&r, 2)); 451 RETURN_FALSE_ON_ERROR(parser->ConsumeBits(2)); 452 vp9->gof.temporal_idx[i] = t; 453 vp9->gof.temporal_up_switch[i] = u_bit ? true : false; 454 vp9->gof.num_ref_pics[i] = r; 455 456 for (uint8_t p = 0; p < vp9->gof.num_ref_pics[i]; ++p) { 457 uint8_t p_diff; 458 RETURN_FALSE_ON_ERROR(parser->ReadUInt8(&p_diff)); 459 vp9->gof.pid_diff[i][p] = p_diff; 460 } 461 } 462 return true; 463 } 464 465 // Gets the size of next payload chunk to send. Returns 0 on error. 466 size_t CalcNextSize(size_t max_length, size_t rem_bytes) { 467 if (max_length == 0 || rem_bytes == 0) { 468 return 0; 469 } 470 if (kBalancedMode) { 471 size_t num_frags = std::ceil(static_cast<double>(rem_bytes) / max_length); 472 return static_cast<size_t>( 473 static_cast<double>(rem_bytes) / num_frags + 0.5); 474 } 475 return max_length >= rem_bytes ? rem_bytes : max_length; 476 } 477 } // namespace 478 479 480 RtpPacketizerVp9::RtpPacketizerVp9(const RTPVideoHeaderVP9& hdr, 481 size_t max_payload_length) 482 : hdr_(hdr), 483 max_payload_length_(max_payload_length), 484 payload_(nullptr), 485 payload_size_(0) { 486 } 487 488 RtpPacketizerVp9::~RtpPacketizerVp9() { 489 } 490 491 ProtectionType RtpPacketizerVp9::GetProtectionType() { 492 bool protect = 493 hdr_.temporal_idx == 0 || hdr_.temporal_idx == kNoTemporalIdx; 494 return protect ? kProtectedPacket : kUnprotectedPacket; 495 } 496 497 StorageType RtpPacketizerVp9::GetStorageType(uint32_t retransmission_settings) { 498 StorageType storage = kAllowRetransmission; 499 if (hdr_.temporal_idx == 0 && 500 !(retransmission_settings & kRetransmitBaseLayer)) { 501 storage = kDontRetransmit; 502 } else if (hdr_.temporal_idx != kNoTemporalIdx && hdr_.temporal_idx > 0 && 503 !(retransmission_settings & kRetransmitHigherLayers)) { 504 storage = kDontRetransmit; 505 } 506 return storage; 507 } 508 509 std::string RtpPacketizerVp9::ToString() { 510 return "RtpPacketizerVp9"; 511 } 512 513 void RtpPacketizerVp9::SetPayloadData( 514 const uint8_t* payload, 515 size_t payload_size, 516 const RTPFragmentationHeader* fragmentation) { 517 payload_ = payload; 518 payload_size_ = payload_size; 519 GeneratePackets(); 520 } 521 522 void RtpPacketizerVp9::GeneratePackets() { 523 if (max_payload_length_ < PayloadDescriptorLength(hdr_) + 1) { 524 LOG(LS_ERROR) << "Payload header and one payload byte won't fit."; 525 return; 526 } 527 size_t bytes_processed = 0; 528 while (bytes_processed < payload_size_) { 529 size_t rem_bytes = payload_size_ - bytes_processed; 530 size_t rem_payload_len = max_payload_length_ - 531 (bytes_processed ? PayloadDescriptorLengthMinusSsData(hdr_) 532 : PayloadDescriptorLength(hdr_)); 533 534 size_t packet_bytes = CalcNextSize(rem_payload_len, rem_bytes); 535 if (packet_bytes == 0) { 536 LOG(LS_ERROR) << "Failed to generate VP9 packets."; 537 while (!packets_.empty()) 538 packets_.pop(); 539 return; 540 } 541 QueuePacket(bytes_processed, packet_bytes, bytes_processed == 0, 542 rem_bytes == packet_bytes, &packets_); 543 bytes_processed += packet_bytes; 544 } 545 assert(bytes_processed == payload_size_); 546 } 547 548 bool RtpPacketizerVp9::NextPacket(uint8_t* buffer, 549 size_t* bytes_to_send, 550 bool* last_packet) { 551 if (packets_.empty()) { 552 return false; 553 } 554 PacketInfo packet_info = packets_.front(); 555 packets_.pop(); 556 557 if (!WriteHeaderAndPayload(packet_info, buffer, bytes_to_send)) { 558 return false; 559 } 560 *last_packet = 561 packets_.empty() && (hdr_.spatial_idx == kNoSpatialIdx || 562 hdr_.spatial_idx == hdr_.num_spatial_layers - 1); 563 return true; 564 } 565 566 // VP9 format: 567 // 568 // Payload descriptor for F = 1 (flexible mode) 569 // 0 1 2 3 4 5 6 7 570 // +-+-+-+-+-+-+-+-+ 571 // |I|P|L|F|B|E|V|-| (REQUIRED) 572 // +-+-+-+-+-+-+-+-+ 573 // I: |M| PICTURE ID | (RECOMMENDED) 574 // +-+-+-+-+-+-+-+-+ 575 // M: | EXTENDED PID | (RECOMMENDED) 576 // +-+-+-+-+-+-+-+-+ 577 // L: | T |U| S |D| (CONDITIONALLY RECOMMENDED) 578 // +-+-+-+-+-+-+-+-+ -| 579 // P,F: | P_DIFF |N| (CONDITIONALLY RECOMMENDED) . up to 3 times 580 // +-+-+-+-+-+-+-+-+ -| 581 // V: | SS | 582 // | .. | 583 // +-+-+-+-+-+-+-+-+ 584 // 585 // Payload descriptor for F = 0 (non-flexible mode) 586 // 0 1 2 3 4 5 6 7 587 // +-+-+-+-+-+-+-+-+ 588 // |I|P|L|F|B|E|V|-| (REQUIRED) 589 // +-+-+-+-+-+-+-+-+ 590 // I: |M| PICTURE ID | (RECOMMENDED) 591 // +-+-+-+-+-+-+-+-+ 592 // M: | EXTENDED PID | (RECOMMENDED) 593 // +-+-+-+-+-+-+-+-+ 594 // L: | T |U| S |D| (CONDITIONALLY RECOMMENDED) 595 // +-+-+-+-+-+-+-+-+ 596 // | TL0PICIDX | (CONDITIONALLY REQUIRED) 597 // +-+-+-+-+-+-+-+-+ 598 // V: | SS | 599 // | .. | 600 // +-+-+-+-+-+-+-+-+ 601 602 bool RtpPacketizerVp9::WriteHeaderAndPayload(const PacketInfo& packet_info, 603 uint8_t* buffer, 604 size_t* bytes_to_send) const { 605 size_t header_length; 606 if (!WriteHeader(packet_info, buffer, &header_length)) 607 return false; 608 609 // Copy payload data. 610 memcpy(&buffer[header_length], 611 &payload_[packet_info.payload_start_pos], packet_info.size); 612 613 *bytes_to_send = header_length + packet_info.size; 614 return true; 615 } 616 617 bool RtpPacketizerVp9::WriteHeader(const PacketInfo& packet_info, 618 uint8_t* buffer, 619 size_t* header_length) const { 620 // Required payload descriptor byte. 621 bool i_bit = PictureIdPresent(hdr_); 622 bool p_bit = hdr_.inter_pic_predicted; 623 bool l_bit = LayerInfoPresent(hdr_); 624 bool f_bit = hdr_.flexible_mode; 625 bool b_bit = packet_info.layer_begin; 626 bool e_bit = packet_info.layer_end; 627 bool v_bit = hdr_.ss_data_available && b_bit; 628 629 rtc::BitBufferWriter writer(buffer, max_payload_length_); 630 RETURN_FALSE_ON_ERROR(writer.WriteBits(i_bit ? 1 : 0, 1)); 631 RETURN_FALSE_ON_ERROR(writer.WriteBits(p_bit ? 1 : 0, 1)); 632 RETURN_FALSE_ON_ERROR(writer.WriteBits(l_bit ? 1 : 0, 1)); 633 RETURN_FALSE_ON_ERROR(writer.WriteBits(f_bit ? 1 : 0, 1)); 634 RETURN_FALSE_ON_ERROR(writer.WriteBits(b_bit ? 1 : 0, 1)); 635 RETURN_FALSE_ON_ERROR(writer.WriteBits(e_bit ? 1 : 0, 1)); 636 RETURN_FALSE_ON_ERROR(writer.WriteBits(v_bit ? 1 : 0, 1)); 637 RETURN_FALSE_ON_ERROR(writer.WriteBits(kReservedBitValue0, 1)); 638 639 // Add fields that are present. 640 if (i_bit && !WritePictureId(hdr_, &writer)) { 641 LOG(LS_ERROR) << "Failed writing VP9 picture id."; 642 return false; 643 } 644 if (l_bit && !WriteLayerInfo(hdr_, &writer)) { 645 LOG(LS_ERROR) << "Failed writing VP9 layer info."; 646 return false; 647 } 648 if (p_bit && f_bit && !WriteRefIndices(hdr_, &writer)) { 649 LOG(LS_ERROR) << "Failed writing VP9 ref indices."; 650 return false; 651 } 652 if (v_bit && !WriteSsData(hdr_, &writer)) { 653 LOG(LS_ERROR) << "Failed writing VP9 SS data."; 654 return false; 655 } 656 657 size_t offset_bytes = 0; 658 size_t offset_bits = 0; 659 writer.GetCurrentOffset(&offset_bytes, &offset_bits); 660 assert(offset_bits == 0); 661 662 *header_length = offset_bytes; 663 return true; 664 } 665 666 bool RtpDepacketizerVp9::Parse(ParsedPayload* parsed_payload, 667 const uint8_t* payload, 668 size_t payload_length) { 669 assert(parsed_payload != nullptr); 670 if (payload_length == 0) { 671 LOG(LS_ERROR) << "Payload length is zero."; 672 return false; 673 } 674 675 // Parse mandatory first byte of payload descriptor. 676 rtc::BitBuffer parser(payload, payload_length); 677 uint32_t i_bit, p_bit, l_bit, f_bit, b_bit, e_bit, v_bit; 678 RETURN_FALSE_ON_ERROR(parser.ReadBits(&i_bit, 1)); 679 RETURN_FALSE_ON_ERROR(parser.ReadBits(&p_bit, 1)); 680 RETURN_FALSE_ON_ERROR(parser.ReadBits(&l_bit, 1)); 681 RETURN_FALSE_ON_ERROR(parser.ReadBits(&f_bit, 1)); 682 RETURN_FALSE_ON_ERROR(parser.ReadBits(&b_bit, 1)); 683 RETURN_FALSE_ON_ERROR(parser.ReadBits(&e_bit, 1)); 684 RETURN_FALSE_ON_ERROR(parser.ReadBits(&v_bit, 1)); 685 RETURN_FALSE_ON_ERROR(parser.ConsumeBits(1)); 686 687 // Parsed payload. 688 parsed_payload->type.Video.width = 0; 689 parsed_payload->type.Video.height = 0; 690 parsed_payload->type.Video.simulcastIdx = 0; 691 parsed_payload->type.Video.codec = kRtpVideoVp9; 692 693 parsed_payload->frame_type = p_bit ? kVideoFrameDelta : kVideoFrameKey; 694 695 RTPVideoHeaderVP9* vp9 = &parsed_payload->type.Video.codecHeader.VP9; 696 vp9->InitRTPVideoHeaderVP9(); 697 vp9->inter_pic_predicted = p_bit ? true : false; 698 vp9->flexible_mode = f_bit ? true : false; 699 vp9->beginning_of_frame = b_bit ? true : false; 700 vp9->end_of_frame = e_bit ? true : false; 701 vp9->ss_data_available = v_bit ? true : false; 702 vp9->spatial_idx = 0; 703 704 // Parse fields that are present. 705 if (i_bit && !ParsePictureId(&parser, vp9)) { 706 LOG(LS_ERROR) << "Failed parsing VP9 picture id."; 707 return false; 708 } 709 if (l_bit && !ParseLayerInfo(&parser, vp9)) { 710 LOG(LS_ERROR) << "Failed parsing VP9 layer info."; 711 return false; 712 } 713 if (p_bit && f_bit && !ParseRefIndices(&parser, vp9)) { 714 LOG(LS_ERROR) << "Failed parsing VP9 ref indices."; 715 return false; 716 } 717 if (v_bit) { 718 if (!ParseSsData(&parser, vp9)) { 719 LOG(LS_ERROR) << "Failed parsing VP9 SS data."; 720 return false; 721 } 722 if (vp9->spatial_layer_resolution_present) { 723 // TODO(asapersson): Add support for spatial layers. 724 parsed_payload->type.Video.width = vp9->width[0]; 725 parsed_payload->type.Video.height = vp9->height[0]; 726 } 727 } 728 parsed_payload->type.Video.isFirstPacket = 729 b_bit && (!l_bit || !vp9->inter_layer_predicted); 730 731 uint64_t rem_bits = parser.RemainingBitCount(); 732 assert(rem_bits % 8 == 0); 733 parsed_payload->payload_length = rem_bits / 8; 734 if (parsed_payload->payload_length == 0) { 735 LOG(LS_ERROR) << "Failed parsing VP9 payload data."; 736 return false; 737 } 738 parsed_payload->payload = 739 payload + payload_length - parsed_payload->payload_length; 740 741 return true; 742 } 743 } // namespace webrtc 744
