1 /*
2 * Copyright (C) 2010 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17 //#define LOG_NDEBUG 0
18 #define LOG_TAG "ARTPWriter"
19 #include <utils/Log.h>
20
21 #include "ARTPWriter.h"
22
23 #include <media/stagefright/MediaSource.h>
24 #include <media/stagefright/foundation/ABuffer.h>
25 #include <media/stagefright/foundation/ADebug.h>
26 #include <media/stagefright/foundation/AMessage.h>
27 #include <media/stagefright/foundation/hexdump.h>
28 #include <media/stagefright/MediaBuffer.h>
29 #include <media/stagefright/MediaDefs.h>
30 #include <media/stagefright/MetaData.h>
31 #include <utils/ByteOrder.h>
32
33 #include <fcntl.h>
34 #include <strings.h>
35
36 #define PT 97
37 #define PT_STR "97"
38
39 #define H264_NALU_MASK 0x1F
40 #define H264_NALU_SPS 0x7
41 #define H264_NALU_PPS 0x8
42 #define H264_NALU_IFRAME 0x5
43 #define H264_NALU_PFRAME 0x1
44
45 #define H265_NALU_MASK 0x3F
46 #define H265_NALU_VPS 0x20
47 #define H265_NALU_SPS 0x21
48 #define H265_NALU_PPS 0x22
49
50 #define IPV4_HEADER_SIZE 20
51 #define IPV6_HEADER_SIZE 40
52 #define UDP_HEADER_SIZE 8
53 #define TCPIPV4_HEADER_SIZE (IPV4_HEADER_SIZE + UDP_HEADER_SIZE)
54 #define TCPIPV6_HEADER_SIZE (IPV6_HEADER_SIZE + UDP_HEADER_SIZE)
55 #define TCPIP_HEADER_SIZE TCPIPV4_HEADER_SIZE
56 #define RTP_HEADER_SIZE 12
57 #define RTP_HEADER_EXT_SIZE 8
58 #define RTP_FU_HEADER_SIZE 2
59 #define RTP_PAYLOAD_ROOM_SIZE 100 // ROOM size for IPv6 header, ESP and etc.
60
61
62 namespace android {
63
64 // static const size_t kMaxPacketSize = 65507; // maximum payload in UDP over IP
65 static const size_t kMaxPacketSize = 1280;
66 static char kCNAME[255] = "someone@somewhere";
67
68 static const size_t kTrafficRecorderMaxEntries = 128;
69 static const size_t kTrafficRecorderMaxTimeSpanMs = 2000;
70
UniformRand(int limit)71 static int UniformRand(int limit) {
72 return ((double)rand() * limit) / RAND_MAX;
73 }
74
ARTPWriter(int fd)75 ARTPWriter::ARTPWriter(int fd)
76 : mFlags(0),
77 mFd(dup(fd)),
78 mLooper(new ALooper),
79 mReflector(new AHandlerReflector<ARTPWriter>(this)),
80 mTrafficRec(new TrafficRecorder<uint32_t /* Time */, Bytes>(
81 kTrafficRecorderMaxEntries, kTrafficRecorderMaxTimeSpanMs)) {
82 CHECK_GE(fd, 0);
83 mIsIPv6 = false;
84
85 mLooper->setName("rtp writer");
86 mLooper->registerHandler(mReflector);
87 mLooper->start();
88
89 mRTPSocket = socket(AF_INET, SOCK_DGRAM, 0);
90 CHECK_GE(mRTPSocket, 0);
91 mRTCPSocket = socket(AF_INET, SOCK_DGRAM, 0);
92 CHECK_GE(mRTCPSocket, 0);
93
94 memset(mRTPAddr.sin_zero, 0, sizeof(mRTPAddr.sin_zero));
95 mRTPAddr.sin_family = AF_INET;
96
97 #if 1
98 mRTPAddr.sin_addr.s_addr = INADDR_ANY;
99 #else
100 mRTPAddr.sin_addr.s_addr = inet_addr("172.19.18.246");
101 #endif
102
103 mRTPAddr.sin_port = htons(5634);
104 CHECK_EQ(0, ntohs(mRTPAddr.sin_port) & 1);
105
106 mRTCPAddr = mRTPAddr;
107 mRTCPAddr.sin_port = htons(ntohs(mRTPAddr.sin_port) | 1);
108 mSPSBuf = NULL;
109 mPPSBuf = NULL;
110
111 #if LOG_TO_FILES
112 mRTPFd = open(
113 "/data/misc/rtpout.bin",
114 O_WRONLY | O_CREAT | O_TRUNC,
115 0644);
116 CHECK_GE(mRTPFd, 0);
117
118 mRTCPFd = open(
119 "/data/misc/rtcpout.bin",
120 O_WRONLY | O_CREAT | O_TRUNC,
121 0644);
122 CHECK_GE(mRTCPFd, 0);
123 #endif
124 }
125
ARTPWriter(int fd,String8 & localIp,int localPort,String8 & remoteIp,int remotePort,uint32_t seqNo)126 ARTPWriter::ARTPWriter(int fd, String8& localIp, int localPort, String8& remoteIp,
127 int remotePort, uint32_t seqNo)
128 : mFlags(0),
129 mFd(dup(fd)),
130 mLooper(new ALooper),
131 mReflector(new AHandlerReflector<ARTPWriter>(this)),
132 mTrafficRec(new TrafficRecorder<uint32_t /* Time */, Bytes>(
133 kTrafficRecorderMaxEntries, kTrafficRecorderMaxTimeSpanMs)) {
134 CHECK_GE(fd, 0);
135 mIsIPv6 = false;
136
137 mLooper->setName("rtp writer");
138 mLooper->registerHandler(mReflector);
139 mLooper->start();
140
141 makeSocketPairAndBind(localIp, localPort, remoteIp , remotePort);
142 mVPSBuf = NULL;
143 mSPSBuf = NULL;
144 mPPSBuf = NULL;
145
146 initState();
147 mSeqNo = seqNo; // Must use explicit # of seq for RTP continuity
148
149 #if LOG_TO_FILES
150 mRTPFd = open(
151 "/data/misc/rtpout.bin",
152 O_WRONLY | O_CREAT | O_TRUNC,
153 0644);
154 CHECK_GE(mRTPFd, 0);
155
156 mRTCPFd = open(
157 "/data/misc/rtcpout.bin",
158 O_WRONLY | O_CREAT | O_TRUNC,
159 0644);
160 CHECK_GE(mRTCPFd, 0);
161 #endif
162 }
163
~ARTPWriter()164 ARTPWriter::~ARTPWriter() {
165 if (mVPSBuf != NULL) {
166 mVPSBuf->release();
167 mVPSBuf = NULL;
168 }
169
170 if (mSPSBuf != NULL) {
171 mSPSBuf->release();
172 mSPSBuf = NULL;
173 }
174
175 if (mPPSBuf != NULL) {
176 mPPSBuf->release();
177 mPPSBuf = NULL;
178 }
179
180 #if LOG_TO_FILES
181 close(mRTCPFd);
182 mRTCPFd = -1;
183
184 close(mRTPFd);
185 mRTPFd = -1;
186 #endif
187
188 close(mRTPSocket);
189 mRTPSocket = -1;
190
191 close(mRTCPSocket);
192 mRTCPSocket = -1;
193
194 close(mFd);
195 mFd = -1;
196 }
197
initState()198 void ARTPWriter::initState() {
199 if (mSourceID == 0)
200 mSourceID = rand();
201 mPayloadType = 0;
202 if (mSeqNo == 0)
203 mSeqNo = UniformRand(65536);
204 mRTPTimeBase = 0;
205 mNumRTPSent = 0;
206 mNumRTPOctetsSent = 0;
207
208 mOpponentID = 0;
209 mBitrate = 192000;
210
211 mNumSRsSent = 0;
212 mRTPCVOExtMap = -1;
213 mRTPCVODegrees = 0;
214 mRTPSockNetwork = 0;
215
216 mMode = INVALID;
217 mClockRate = 16000;
218 }
219
addSource(const sp<MediaSource> & source)220 status_t ARTPWriter::addSource(const sp<MediaSource> &source) {
221 mSource = source;
222 return OK;
223 }
224
reachedEOS()225 bool ARTPWriter::reachedEOS() {
226 Mutex::Autolock autoLock(mLock);
227 return (mFlags & kFlagEOS) != 0;
228 }
229
start(MetaData * params)230 status_t ARTPWriter::start(MetaData * params) {
231 Mutex::Autolock autoLock(mLock);
232 if (mFlags & kFlagStarted) {
233 return INVALID_OPERATION;
234 }
235
236 mFlags &= ~kFlagEOS;
237 initState();
238
239 const char *mime;
240 CHECK(mSource->getFormat()->findCString(kKeyMIMEType, &mime));
241
242 int32_t selfID = 0;
243 if (params->findInt32(kKeySelfID, &selfID))
244 mSourceID = selfID;
245
246 int32_t payloadType = 0;
247 if (params->findInt32(kKeyPayloadType, &payloadType))
248 mPayloadType = payloadType;
249
250 int32_t rtpExtMap = 0;
251 if (params->findInt32(kKeyRtpExtMap, &rtpExtMap))
252 mRTPCVOExtMap = rtpExtMap;
253
254 int32_t rtpCVODegrees = 0;
255 if (params->findInt32(kKeyRtpCvoDegrees, &rtpCVODegrees))
256 mRTPCVODegrees = rtpCVODegrees;
257
258 int32_t dscp = 0;
259 if (params->findInt32(kKeyRtpDscp, &dscp))
260 updateSocketDscp(dscp);
261
262 int64_t sockNetwork = 0;
263 if (params->findInt64(kKeySocketNetwork, &sockNetwork))
264 updateSocketNetwork(sockNetwork);
265
266 if (!strcasecmp(mime, MEDIA_MIMETYPE_VIDEO_AVC)) {
267 // rfc6184: RTP Payload Format for H.264 Video
268 // The clock rate in the "a=rtpmap" line MUST be 90000.
269 mMode = H264;
270 mClockRate = 90000;
271 } else if (!strcasecmp(mime, MEDIA_MIMETYPE_VIDEO_HEVC)) {
272 // rfc7798: RTP Payload Format for High Efficiency Video Coding (HEVC)
273 // The clock rate in the "a=rtpmap" line MUST be 90000.
274 mMode = H265;
275 mClockRate = 90000;
276 } else if (!strcasecmp(mime, MEDIA_MIMETYPE_VIDEO_H263)) {
277 mMode = H263;
278 // rfc4629: RTP Payload Format for ITU-T Rec. H.263 Video
279 // The clock rate in the "a=rtpmap" line MUST be 90000.
280 mClockRate = 90000;
281 } else if (!strcasecmp(mime, MEDIA_MIMETYPE_AUDIO_AMR_NB)) {
282 mMode = AMR_NB;
283 // rfc4867: RTP Payload Format ... (AMR) and (AMR-WB)
284 // The RTP clock rate in "a=rtpmap" MUST be 8000 for AMR and 16000 for AMR-WB
285 mClockRate = 8000;
286 } else if (!strcasecmp(mime, MEDIA_MIMETYPE_AUDIO_AMR_WB)) {
287 mMode = AMR_WB;
288 mClockRate = 16000;
289 } else {
290 TRESPASS();
291 }
292
293 (new AMessage(kWhatStart, mReflector))->post();
294
295 while (!(mFlags & kFlagStarted)) {
296 mCondition.wait(mLock);
297 }
298
299 return OK;
300 }
301
stop()302 status_t ARTPWriter::stop() {
303 Mutex::Autolock autoLock(mLock);
304 if (!(mFlags & kFlagStarted)) {
305 return OK;
306 }
307
308 (new AMessage(kWhatStop, mReflector))->post();
309
310 while (mFlags & kFlagStarted) {
311 mCondition.wait(mLock);
312 }
313 return OK;
314 }
315
pause()316 status_t ARTPWriter::pause() {
317 return OK;
318 }
319
StripStartcode(MediaBufferBase * buffer)320 static void StripStartcode(MediaBufferBase *buffer) {
321 if (buffer->range_length() < 4) {
322 return;
323 }
324
325 const uint8_t *ptr =
326 (const uint8_t *)buffer->data() + buffer->range_offset();
327
328 if (!memcmp(ptr, "\x00\x00\x00\x01", 4)) {
329 buffer->set_range(
330 buffer->range_offset() + 4, buffer->range_length() - 4);
331 }
332 }
333
334 static const uint8_t SPCSize = 4; // Start Prefix Code Size
335 static const uint8_t startPrefixCode[SPCSize] = {0, 0, 0, 1};
336 static const uint8_t spcKMPidx[SPCSize] = {0, 0, 2, 0};
SpsPpsParser(MediaBufferBase * buffer,MediaBufferBase ** spsBuffer,MediaBufferBase ** ppsBuffer)337 static void SpsPpsParser(MediaBufferBase *buffer,
338 MediaBufferBase **spsBuffer, MediaBufferBase **ppsBuffer) {
339
340 while (buffer->range_length() > 0) {
341 const uint8_t *NALPtr = (const uint8_t *)buffer->data() + buffer->range_offset();
342 uint8_t nalType = (*NALPtr) & H264_NALU_MASK;
343
344 MediaBufferBase **targetPtr = NULL;
345 if (nalType == H264_NALU_SPS) {
346 targetPtr = spsBuffer;
347 } else if (nalType == H264_NALU_PPS) {
348 targetPtr = ppsBuffer;
349 } else {
350 return;
351 }
352 ALOGV("SPS(7) or PPS(8) found. Type %d", nalType);
353
354 uint32_t bufferSize = buffer->range_length();
355 MediaBufferBase *&target = *targetPtr;
356 uint32_t i = 0, j = 0;
357 bool isBoundFound = false;
358 for (i = 0; i < bufferSize; i++) {
359 while (j > 0 && NALPtr[i] != startPrefixCode[j]) {
360 j = spcKMPidx[j - 1];
361 }
362 if (NALPtr[i] == startPrefixCode[j]) {
363 j++;
364 if (j == SPCSize) {
365 isBoundFound = true;
366 break;
367 }
368 }
369 }
370
371 uint32_t targetSize;
372 if (target != NULL) {
373 target->release();
374 }
375 // note that targetSize is never 0 as the first byte is never part
376 // of a start prefix
377 if (isBoundFound) {
378 targetSize = i - SPCSize + 1;
379 target = MediaBufferBase::Create(targetSize);
380 memcpy(target->data(),
381 (const uint8_t *)buffer->data() + buffer->range_offset(),
382 targetSize);
383 buffer->set_range(buffer->range_offset() + targetSize + SPCSize,
384 buffer->range_length() - targetSize - SPCSize);
385 } else {
386 targetSize = bufferSize;
387 target = MediaBufferBase::Create(targetSize);
388 memcpy(target->data(),
389 (const uint8_t *)buffer->data() + buffer->range_offset(),
390 targetSize);
391 buffer->set_range(buffer->range_offset() + bufferSize, 0);
392 return;
393 }
394 }
395 }
396
VpsSpsPpsParser(MediaBufferBase * buffer,MediaBufferBase ** vpsBuffer,MediaBufferBase ** spsBuffer,MediaBufferBase ** ppsBuffer)397 static void VpsSpsPpsParser(MediaBufferBase *buffer,
398 MediaBufferBase **vpsBuffer, MediaBufferBase **spsBuffer, MediaBufferBase **ppsBuffer) {
399
400 while (buffer->range_length() > 0) {
401 const uint8_t *NALPtr = (const uint8_t *)buffer->data() + buffer->range_offset();
402 uint8_t nalType = ((*NALPtr) >> 1) & H265_NALU_MASK;
403
404 MediaBufferBase **targetPtr = NULL;
405 if (nalType == H265_NALU_VPS) {
406 targetPtr = vpsBuffer;
407 } else if (nalType == H265_NALU_SPS) {
408 targetPtr = spsBuffer;
409 } else if (nalType == H265_NALU_PPS) {
410 targetPtr = ppsBuffer;
411 } else {
412 return;
413 }
414 ALOGV("VPS(32) SPS(33) or PPS(34) found. Type %d", nalType);
415
416 uint32_t bufferSize = buffer->range_length();
417 MediaBufferBase *&target = *targetPtr;
418 uint32_t i = 0, j = 0;
419 bool isBoundFound = false;
420 for (i = 0; i < bufferSize; i++) {
421 while (j > 0 && NALPtr[i] != startPrefixCode[j]) {
422 j = spcKMPidx[j - 1];
423 }
424 if (NALPtr[i] == startPrefixCode[j]) {
425 j++;
426 if (j == SPCSize) {
427 isBoundFound = true;
428 break;
429 }
430 }
431 }
432
433 uint32_t targetSize;
434 if (target != NULL) {
435 target->release();
436 }
437 // note that targetSize is never 0 as the first byte is never part
438 // of a start prefix
439 if (isBoundFound) {
440 targetSize = i - SPCSize + 1;
441 target = MediaBufferBase::Create(targetSize);
442 memcpy(target->data(),
443 (const uint8_t *)buffer->data() + buffer->range_offset(),
444 targetSize);
445 buffer->set_range(buffer->range_offset() + targetSize + SPCSize,
446 buffer->range_length() - targetSize - SPCSize);
447 } else {
448 targetSize = bufferSize;
449 target = MediaBufferBase::Create(targetSize);
450 memcpy(target->data(),
451 (const uint8_t *)buffer->data() + buffer->range_offset(),
452 targetSize);
453 buffer->set_range(buffer->range_offset() + bufferSize, 0);
454 return;
455 }
456 }
457 }
458
onMessageReceived(const sp<AMessage> & msg)459 void ARTPWriter::onMessageReceived(const sp<AMessage> &msg) {
460 switch (msg->what()) {
461 case kWhatStart:
462 {
463 sp<MetaData> meta = new MetaData();
464 meta->setInt64(kKeyTime, 10ll);
465 CHECK_EQ(mSource->start(meta.get()), (status_t)OK);
466
467 #if 0
468 if (mMode == H264) {
469 MediaBufferBase *buffer;
470 CHECK_EQ(mSource->read(&buffer), (status_t)OK);
471
472 StripStartcode(buffer);
473 makeH264SPropParamSets(buffer);
474 buffer->release();
475 buffer = NULL;
476 }
477
478 dumpSessionDesc();
479 #endif
480
481 {
482 Mutex::Autolock autoLock(mLock);
483 mFlags |= kFlagStarted;
484 mCondition.signal();
485 }
486
487 (new AMessage(kWhatRead, mReflector))->post();
488 (new AMessage(kWhatSendSR, mReflector))->post();
489 break;
490 }
491
492 case kWhatStop:
493 {
494 CHECK_EQ(mSource->stop(), (status_t)OK);
495
496 sendBye();
497
498 {
499 Mutex::Autolock autoLock(mLock);
500 mFlags &= ~kFlagStarted;
501 mCondition.signal();
502 }
503 break;
504 }
505
506 case kWhatRead:
507 {
508 {
509 Mutex::Autolock autoLock(mLock);
510 if (!(mFlags & kFlagStarted)) {
511 break;
512 }
513 }
514
515 onRead(msg);
516 break;
517 }
518
519 case kWhatSendSR:
520 {
521 {
522 Mutex::Autolock autoLock(mLock);
523 if (!(mFlags & kFlagStarted)) {
524 break;
525 }
526 }
527
528 onSendSR(msg);
529 break;
530 }
531
532 default:
533 TRESPASS();
534 break;
535 }
536 }
537
setTMMBNInfo(uint32_t opponentID,uint32_t bitrate)538 void ARTPWriter::setTMMBNInfo(uint32_t opponentID, uint32_t bitrate) {
539 mOpponentID = opponentID;
540 mBitrate = bitrate;
541
542 sp<ABuffer> buffer = new ABuffer(65536);
543 buffer->setRange(0, 0);
544
545 addTMMBN(buffer);
546
547 send(buffer, true /* isRTCP */);
548 }
549
onRead(const sp<AMessage> & msg)550 void ARTPWriter::onRead(const sp<AMessage> &msg) {
551 MediaBufferBase *mediaBuf;
552 status_t err = mSource->read(&mediaBuf);
553
554 if (err != OK) {
555 ALOGI("reached EOS.");
556
557 Mutex::Autolock autoLock(mLock);
558 mFlags |= kFlagEOS;
559 return;
560 }
561
562 if (mediaBuf->range_length() > 0) {
563 ALOGV("read buffer of size %zu", mediaBuf->range_length());
564
565 if (mMode == H264) {
566 StripStartcode(mediaBuf);
567 SpsPpsParser(mediaBuf, &mSPSBuf, &mPPSBuf);
568 if (mediaBuf->range_length() > 0) {
569 sendAVCData(mediaBuf);
570 }
571 } else if (mMode == H265) {
572 StripStartcode(mediaBuf);
573 VpsSpsPpsParser(mediaBuf, &mVPSBuf, &mSPSBuf, &mPPSBuf);
574 if (mediaBuf->range_length() > 0) {
575 sendHEVCData(mediaBuf);
576 }
577 } else if (mMode == H263) {
578 sendH263Data(mediaBuf);
579 } else if (mMode == AMR_NB || mMode == AMR_WB) {
580 sendAMRData(mediaBuf);
581 }
582 }
583
584 mediaBuf->release();
585 mediaBuf = NULL;
586
587 msg->post();
588 }
589
onSendSR(const sp<AMessage> & msg)590 void ARTPWriter::onSendSR(const sp<AMessage> &msg) {
591 sp<ABuffer> buffer = new ABuffer(65536);
592 buffer->setRange(0, 0);
593
594 addSR(buffer);
595 addSDES(buffer);
596
597 send(buffer, true /* isRTCP */);
598
599 ++mNumSRsSent;
600 msg->post(3000000);
601 }
602
send(const sp<ABuffer> & buffer,bool isRTCP)603 void ARTPWriter::send(const sp<ABuffer> &buffer, bool isRTCP) {
604 int sizeSockSt;
605 struct sockaddr *remAddr;
606
607 if (mIsIPv6) {
608 sizeSockSt = sizeof(struct sockaddr_in6);
609 if (isRTCP)
610 remAddr = (struct sockaddr *)&mRTCPAddr6;
611 else
612 remAddr = (struct sockaddr *)&mRTPAddr6;
613 } else {
614 sizeSockSt = sizeof(struct sockaddr_in);
615 if (isRTCP)
616 remAddr = (struct sockaddr *)&mRTCPAddr;
617 else
618 remAddr = (struct sockaddr *)&mRTPAddr;
619 }
620
621 // Unseal code if moderator is needed (prevent overflow of instant bandwidth)
622 // Set limit bits per period through the moderator.
623 // ex) 6KByte/10ms = 48KBit/10ms = 4.8MBit/s instant limit
624 // ModerateInstantTraffic(10, 6 * 1024);
625
626 ssize_t n = sendto(isRTCP ? mRTCPSocket : mRTPSocket,
627 buffer->data(), buffer->size(), 0, remAddr, sizeSockSt);
628
629 if (n != (ssize_t)buffer->size()) {
630 ALOGW("packets can not be sent. ret=%d, buf=%d", (int)n, (int)buffer->size());
631 } else {
632 // Record current traffic & Print bits while last 1sec (1000ms)
633 mTrafficRec->writeBytes(buffer->size() +
634 (mIsIPv6 ? TCPIPV6_HEADER_SIZE : TCPIPV4_HEADER_SIZE));
635 mTrafficRec->printAccuBitsForLastPeriod(1000, 1000);
636 }
637
638 #if LOG_TO_FILES
639 int fd = isRTCP ? mRTCPFd : mRTPFd;
640
641 uint32_t ms = tolel(ALooper::GetNowUs() / 1000ll);
642 uint32_t length = tolel(buffer->size());
643 write(fd, &ms, sizeof(ms));
644 write(fd, &length, sizeof(length));
645 write(fd, buffer->data(), buffer->size());
646 #endif
647 }
648
addSR(const sp<ABuffer> & buffer)649 void ARTPWriter::addSR(const sp<ABuffer> &buffer) {
650 uint8_t *data = buffer->data() + buffer->size();
651
652 data[0] = 0x80 | 0;
653 data[1] = 200; // SR
654 data[2] = 0;
655 data[3] = 6;
656 data[4] = mSourceID >> 24;
657 data[5] = (mSourceID >> 16) & 0xff;
658 data[6] = (mSourceID >> 8) & 0xff;
659 data[7] = mSourceID & 0xff;
660
661 uint64_t ntpTime = GetNowNTP();
662 data[8] = ntpTime >> (64 - 8);
663 data[9] = (ntpTime >> (64 - 16)) & 0xff;
664 data[10] = (ntpTime >> (64 - 24)) & 0xff;
665 data[11] = (ntpTime >> 32) & 0xff;
666 data[12] = (ntpTime >> 24) & 0xff;
667 data[13] = (ntpTime >> 16) & 0xff;
668 data[14] = (ntpTime >> 8) & 0xff;
669 data[15] = ntpTime & 0xff;
670
671 // A current rtpTime can be calculated from ALooper::GetNowUs().
672 // This is expecting a timestamp of raw frame from a media source is
673 // on the same time context across components in android media framework
674 // which can be queried by ALooper::GetNowUs().
675 // In other words, ALooper::GetNowUs() is on the same timeline as the time
676 // of kKeyTime in a MediaBufferBase
677 uint32_t rtpTime = getRtpTime(ALooper::GetNowUs());
678 data[16] = (rtpTime >> 24) & 0xff;
679 data[17] = (rtpTime >> 16) & 0xff;
680 data[18] = (rtpTime >> 8) & 0xff;
681 data[19] = rtpTime & 0xff;
682
683 data[20] = mNumRTPSent >> 24;
684 data[21] = (mNumRTPSent >> 16) & 0xff;
685 data[22] = (mNumRTPSent >> 8) & 0xff;
686 data[23] = mNumRTPSent & 0xff;
687
688 data[24] = mNumRTPOctetsSent >> 24;
689 data[25] = (mNumRTPOctetsSent >> 16) & 0xff;
690 data[26] = (mNumRTPOctetsSent >> 8) & 0xff;
691 data[27] = mNumRTPOctetsSent & 0xff;
692
693 buffer->setRange(buffer->offset(), buffer->size() + 28);
694 }
695
addSDES(const sp<ABuffer> & buffer)696 void ARTPWriter::addSDES(const sp<ABuffer> &buffer) {
697 uint8_t *data = buffer->data() + buffer->size();
698 data[0] = 0x80 | 1;
699 data[1] = 202; // SDES
700 data[4] = mSourceID >> 24;
701 data[5] = (mSourceID >> 16) & 0xff;
702 data[6] = (mSourceID >> 8) & 0xff;
703 data[7] = mSourceID & 0xff;
704
705 size_t offset = 8;
706
707 data[offset++] = 1; // CNAME
708
709 data[offset++] = strlen(kCNAME);
710
711 memcpy(&data[offset], kCNAME, strlen(kCNAME));
712 offset += strlen(kCNAME);
713
714 data[offset++] = 7; // NOTE
715
716 static const char *kNOTE = "Hell's frozen over.";
717 data[offset++] = strlen(kNOTE);
718
719 memcpy(&data[offset], kNOTE, strlen(kNOTE));
720 offset += strlen(kNOTE);
721
722 data[offset++] = 0;
723
724 if ((offset % 4) > 0) {
725 size_t count = 4 - (offset % 4);
726 switch (count) {
727 case 3:
728 data[offset++] = 0;
729 [[fallthrough]];
730 case 2:
731 data[offset++] = 0;
732 [[fallthrough]];
733 case 1:
734 data[offset++] = 0;
735 }
736 }
737
738 size_t numWords = (offset / 4) - 1;
739 data[2] = numWords >> 8;
740 data[3] = numWords & 0xff;
741
742 buffer->setRange(buffer->offset(), buffer->size() + offset);
743 }
744
addTMMBN(const sp<ABuffer> & buffer)745 void ARTPWriter::addTMMBN(const sp<ABuffer> &buffer) {
746 if (buffer->size() + 20 > buffer->capacity()) {
747 ALOGW("RTCP buffer too small to accommodate SR.");
748 return;
749 }
750 if (mOpponentID == 0)
751 return;
752
753 uint8_t *data = buffer->data() + buffer->size();
754
755 data[0] = 0x80 | 4; // TMMBN
756 data[1] = 205; // TSFB
757 data[2] = 0;
758 data[3] = 4; // total (4+1) * sizeof(int32_t) = 20 bytes
759 data[4] = mSourceID >> 24;
760 data[5] = (mSourceID >> 16) & 0xff;
761 data[6] = (mSourceID >> 8) & 0xff;
762 data[7] = mSourceID & 0xff;
763
764 *(int32_t*)(&data[8]) = 0; // 4 bytes blank
765
766 data[12] = mOpponentID >> 24;
767 data[13] = (mOpponentID >> 16) & 0xff;
768 data[14] = (mOpponentID >> 8) & 0xff;
769 data[15] = mOpponentID & 0xff;
770
771 // Find the first bit '1' from left & right side of the value.
772 int32_t leftEnd = 31 - __builtin_clz(mBitrate);
773 int32_t rightEnd = ffs(mBitrate) - 1;
774
775 // Mantissa have only 17bit space by RTCP specification.
776 if ((leftEnd - rightEnd) > 16) {
777 rightEnd = leftEnd - 16;
778 }
779 int32_t mantissa = mBitrate >> rightEnd;
780
781 data[16] = ((rightEnd << 2) & 0xfc) | ((mantissa & 0x18000) >> 15);
782 data[17] = (mantissa & 0x07f80) >> 7;
783 data[18] = (mantissa & 0x0007f) << 1;
784 data[19] = 40; // 40 bytes overhead;
785
786 buffer->setRange(buffer->offset(), buffer->size() + 20);
787
788 ALOGI("UE -> Op Noti Tx bitrate : %d ", mantissa << rightEnd);
789 }
790
791 // static
GetNowNTP()792 uint64_t ARTPWriter::GetNowNTP() {
793 uint64_t nowUs = systemTime(SYSTEM_TIME_REALTIME) / 1000ll;
794
795 nowUs += ((70LL * 365 + 17) * 24) * 60 * 60 * 1000000LL;
796
797 uint64_t hi = nowUs / 1000000LL;
798 uint64_t lo = ((1LL << 32) * (nowUs % 1000000LL)) / 1000000LL;
799
800 return (hi << 32) | lo;
801 }
802
getRtpTime(int64_t timeUs)803 uint32_t ARTPWriter::getRtpTime(int64_t timeUs) {
804 int32_t clockPerMs = mClockRate / 1000;
805 int64_t rtpTime = mRTPTimeBase + (timeUs * clockPerMs / 1000LL);
806
807 return (uint32_t)rtpTime;
808 }
809
dumpSessionDesc()810 void ARTPWriter::dumpSessionDesc() {
811 AString sdp;
812 sdp = "v=0\r\n";
813
814 sdp.append("o=- ");
815
816 uint64_t ntp = GetNowNTP();
817 sdp.append(ntp);
818 sdp.append(" ");
819 sdp.append(ntp);
820 sdp.append(" IN IP4 127.0.0.0\r\n");
821
822 sdp.append(
823 "s=Sample\r\n"
824 "i=Playing around\r\n"
825 "c=IN IP4 ");
826
827 struct in_addr addr;
828 addr.s_addr = ntohl(INADDR_LOOPBACK);
829
830 sdp.append(inet_ntoa(addr));
831
832 sdp.append(
833 "\r\n"
834 "t=0 0\r\n"
835 "a=range:npt=now-\r\n");
836
837 sp<MetaData> meta = mSource->getFormat();
838
839 if (mMode == H264 || mMode == H263) {
840 sdp.append("m=video ");
841 } else {
842 sdp.append("m=audio ");
843 }
844
845 sdp.append(AStringPrintf("%d", mIsIPv6 ? ntohs(mRTPAddr6.sin6_port) : ntohs(mRTPAddr.sin_port)));
846 sdp.append(
847 " RTP/AVP " PT_STR "\r\n"
848 "b=AS 320000\r\n"
849 "a=rtpmap:" PT_STR " ");
850
851 if (mMode == H264) {
852 sdp.append("H264/90000");
853 } else if (mMode == H263) {
854 sdp.append("H263-1998/90000");
855 } else if (mMode == AMR_NB || mMode == AMR_WB) {
856 int32_t sampleRate, numChannels;
857 CHECK(mSource->getFormat()->findInt32(kKeySampleRate, &sampleRate));
858 CHECK(mSource->getFormat()->findInt32(kKeyChannelCount, &numChannels));
859
860 CHECK_EQ(numChannels, 1);
861 CHECK_EQ(sampleRate, (mMode == AMR_NB) ? 8000 : 16000);
862
863 sdp.append(mMode == AMR_NB ? "AMR" : "AMR-WB");
864 sdp.append(AStringPrintf("/%d/%d", sampleRate, numChannels));
865 } else {
866 TRESPASS();
867 }
868
869 sdp.append("\r\n");
870
871 if (mMode == H264 || mMode == H263) {
872 int32_t width, height;
873 CHECK(meta->findInt32(kKeyWidth, &width));
874 CHECK(meta->findInt32(kKeyHeight, &height));
875
876 sdp.append("a=cliprect 0,0,");
877 sdp.append(height);
878 sdp.append(",");
879 sdp.append(width);
880 sdp.append("\r\n");
881
882 sdp.append(
883 "a=framesize:" PT_STR " ");
884 sdp.append(width);
885 sdp.append("-");
886 sdp.append(height);
887 sdp.append("\r\n");
888 }
889
890 if (mMode == H264) {
891 sdp.append(
892 "a=fmtp:" PT_STR " profile-level-id=");
893 sdp.append(mProfileLevel);
894 sdp.append(";sprop-parameter-sets=");
895
896 sdp.append(mSeqParamSet);
897 sdp.append(",");
898 sdp.append(mPicParamSet);
899 sdp.append(";packetization-mode=1\r\n");
900 } else if (mMode == AMR_NB || mMode == AMR_WB) {
901 sdp.append("a=fmtp:" PT_STR " octed-align\r\n");
902 }
903
904 ALOGI("%s", sdp.c_str());
905 }
906
makeH264SPropParamSets(MediaBufferBase * buffer)907 void ARTPWriter::makeH264SPropParamSets(MediaBufferBase *buffer) {
908 static const char kStartCode[] = "\x00\x00\x00\x01";
909
910 const uint8_t *data =
911 (const uint8_t *)buffer->data() + buffer->range_offset();
912 size_t size = buffer->range_length();
913
914 CHECK_GE(size, 0u);
915
916 size_t startCodePos = 0;
917 while (startCodePos + 3 < size
918 && memcmp(kStartCode, &data[startCodePos], 4)) {
919 ++startCodePos;
920 }
921
922 CHECK_LT(startCodePos + 3, size);
923
924 CHECK_EQ((unsigned)data[0], 0x67u);
925
926 mProfileLevel =
927 AStringPrintf("%02X%02X%02X", data[1], data[2], data[3]);
928
929 encodeBase64(data, startCodePos, &mSeqParamSet);
930
931 encodeBase64(&data[startCodePos + 4], size - startCodePos - 4,
932 &mPicParamSet);
933 }
934
sendBye()935 void ARTPWriter::sendBye() {
936 sp<ABuffer> buffer = new ABuffer(8);
937 uint8_t *data = buffer->data();
938 *data++ = (2 << 6) | 1;
939 *data++ = 203;
940 *data++ = 0;
941 *data++ = 1;
942 *data++ = mSourceID >> 24;
943 *data++ = (mSourceID >> 16) & 0xff;
944 *data++ = (mSourceID >> 8) & 0xff;
945 *data++ = mSourceID & 0xff;
946 buffer->setRange(0, 8);
947
948 send(buffer, true /* isRTCP */);
949 }
950
sendSPSPPSIfIFrame(MediaBufferBase * mediaBuf,int64_t timeUs)951 void ARTPWriter::sendSPSPPSIfIFrame(MediaBufferBase *mediaBuf, int64_t timeUs) {
952 CHECK(mediaBuf->range_length() > 0);
953 const uint8_t *mediaData =
954 (const uint8_t *)mediaBuf->data() + mediaBuf->range_offset();
955
956 if ((mediaData[0] & H264_NALU_MASK) != H264_NALU_IFRAME) {
957 return;
958 }
959
960 if (mSPSBuf != NULL) {
961 mSPSBuf->meta_data().setInt64(kKeyTime, timeUs);
962 mSPSBuf->meta_data().setInt32(kKeySps, 1);
963 sendAVCData(mSPSBuf);
964 }
965
966 if (mPPSBuf != NULL) {
967 mPPSBuf->meta_data().setInt64(kKeyTime, timeUs);
968 mPPSBuf->meta_data().setInt32(kKeyPps, 1);
969 sendAVCData(mPPSBuf);
970 }
971 }
972
sendVPSSPSPPSIfIFrame(MediaBufferBase * mediaBuf,int64_t timeUs)973 void ARTPWriter::sendVPSSPSPPSIfIFrame(MediaBufferBase *mediaBuf, int64_t timeUs) {
974 CHECK(mediaBuf->range_length() > 0);
975 const uint8_t *mediaData =
976 (const uint8_t *)mediaBuf->data() + mediaBuf->range_offset();
977
978 int nalType = ((mediaData[0] >> 1) & H265_NALU_MASK);
979 if (!(nalType >= 16 && nalType <= 21) /*H265_NALU_IFRAME*/) {
980 return;
981 }
982
983 if (mVPSBuf != NULL) {
984 mVPSBuf->meta_data().setInt64(kKeyTime, timeUs);
985 mVPSBuf->meta_data().setInt32(kKeyVps, 1);
986 sendHEVCData(mVPSBuf);
987 }
988
989 if (mSPSBuf != NULL) {
990 mSPSBuf->meta_data().setInt64(kKeyTime, timeUs);
991 mSPSBuf->meta_data().setInt32(kKeySps, 1);
992 sendHEVCData(mSPSBuf);
993 }
994
995 if (mPPSBuf != NULL) {
996 mPPSBuf->meta_data().setInt64(kKeyTime, timeUs);
997 mPPSBuf->meta_data().setInt32(kKeyPps, 1);
998 sendHEVCData(mPPSBuf);
999 }
1000 }
1001
sendHEVCData(MediaBufferBase * mediaBuf)1002 void ARTPWriter::sendHEVCData(MediaBufferBase *mediaBuf) {
1003 // 12 bytes RTP header + 2 bytes for the FU-indicator and FU-header.
1004 CHECK_GE(kMaxPacketSize, 12u + 2u);
1005
1006 int64_t timeUs;
1007 CHECK(mediaBuf->meta_data().findInt64(kKeyTime, &timeUs));
1008
1009 sendVPSSPSPPSIfIFrame(mediaBuf, timeUs);
1010
1011 uint32_t rtpTime = getRtpTime(timeUs);
1012
1013 CHECK(mediaBuf->range_length() > 0);
1014 const uint8_t *mediaData =
1015 (const uint8_t *)mediaBuf->data() + mediaBuf->range_offset();
1016
1017 int32_t isNonVCL = 0;
1018 if (mediaBuf->meta_data().findInt32(kKeyVps, &isNonVCL) ||
1019 mediaBuf->meta_data().findInt32(kKeySps, &isNonVCL) ||
1020 mediaBuf->meta_data().findInt32(kKeyPps, &isNonVCL)) {
1021 isNonVCL = 1;
1022 }
1023
1024 sp<ABuffer> buffer = new ABuffer(kMaxPacketSize);
1025 if (mediaBuf->range_length() + TCPIP_HEADER_SIZE + RTP_HEADER_SIZE + RTP_HEADER_EXT_SIZE
1026 + RTP_PAYLOAD_ROOM_SIZE <= buffer->capacity()) {
1027 // The data fits into a single packet
1028 uint8_t *data = buffer->data();
1029 data[0] = 0x80;
1030 if (mRTPCVOExtMap > 0) {
1031 data[0] |= 0x10;
1032 }
1033 if (isNonVCL) {
1034 data[1] = mPayloadType; // Marker bit should not be set in case of Non-VCL
1035 } else {
1036 data[1] = (1 << 7) | mPayloadType; // M-bit
1037 }
1038 data[2] = (mSeqNo >> 8) & 0xff;
1039 data[3] = mSeqNo & 0xff;
1040 data[4] = rtpTime >> 24;
1041 data[5] = (rtpTime >> 16) & 0xff;
1042 data[6] = (rtpTime >> 8) & 0xff;
1043 data[7] = rtpTime & 0xff;
1044 data[8] = mSourceID >> 24;
1045 data[9] = (mSourceID >> 16) & 0xff;
1046 data[10] = (mSourceID >> 8) & 0xff;
1047 data[11] = mSourceID & 0xff;
1048
1049 int rtpExtIndex = 0;
1050 if (mRTPCVOExtMap > 0) {
1051 /*
1052 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
1053 +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
1054 | 0xBE | 0xDE | length=3 |
1055 +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
1056 | ID | L=0 | data | ID | L=1 | data...
1057 +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
1058 ...data | 0 (pad) | 0 (pad) | ID | L=3 |
1059 +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
1060 | data |
1061 +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
1062
1063
1064 In the one-byte header form of extensions, the 16-bit value required
1065 by the RTP specification for a header extension, labeled in the RTP
1066 specification as "defined by profile", takes the fixed bit pattern
1067 0xBEDE (the first version of this specification was written on the
1068 feast day of the Venerable Bede).
1069 */
1070 data[12] = 0xBE;
1071 data[13] = 0xDE;
1072 // put a length of RTP Extension.
1073 data[14] = 0x00;
1074 data[15] = 0x01;
1075 // put extmap of RTP assigned for CVO.
1076 data[16] = (mRTPCVOExtMap << 4) | 0x0;
1077 // put image degrees as per CVO specification.
1078 data[17] = mRTPCVODegrees;
1079 data[18] = 0x0;
1080 data[19] = 0x0;
1081 rtpExtIndex = 8;
1082 }
1083
1084 memcpy(&data[12 + rtpExtIndex],
1085 mediaData, mediaBuf->range_length());
1086
1087 buffer->setRange(0, mediaBuf->range_length() + (12 + rtpExtIndex));
1088
1089 send(buffer, false /* isRTCP */);
1090
1091 ++mSeqNo;
1092 ++mNumRTPSent;
1093 mNumRTPOctetsSent += buffer->size() - (12 + rtpExtIndex);
1094 } else {
1095 // FU-A
1096
1097 unsigned nalType = (mediaData[0] >> 1) & H265_NALU_MASK;
1098 ALOGV("H265 nalType 0x%x, data[0]=0x%x", nalType, mediaData[0]);
1099 size_t offset = 2; //H265 payload header is 16 bit.
1100
1101 bool firstPacket = true;
1102 while (offset < mediaBuf->range_length()) {
1103 size_t size = mediaBuf->range_length() - offset;
1104 bool lastPacket = true;
1105 if (size + TCPIP_HEADER_SIZE + RTP_HEADER_SIZE + RTP_HEADER_EXT_SIZE +
1106 RTP_FU_HEADER_SIZE + RTP_PAYLOAD_ROOM_SIZE > buffer->capacity()) {
1107 lastPacket = false;
1108 size = buffer->capacity() - TCPIP_HEADER_SIZE - RTP_HEADER_SIZE -
1109 RTP_HEADER_EXT_SIZE - RTP_FU_HEADER_SIZE - RTP_PAYLOAD_ROOM_SIZE;
1110 }
1111
1112 uint8_t *data = buffer->data();
1113 data[0] = 0x80;
1114 if (lastPacket && mRTPCVOExtMap > 0) {
1115 data[0] |= 0x10;
1116 }
1117 data[1] = (lastPacket ? (1 << 7) : 0x00) | mPayloadType; // M-bit
1118 data[2] = (mSeqNo >> 8) & 0xff;
1119 data[3] = mSeqNo & 0xff;
1120 data[4] = rtpTime >> 24;
1121 data[5] = (rtpTime >> 16) & 0xff;
1122 data[6] = (rtpTime >> 8) & 0xff;
1123 data[7] = rtpTime & 0xff;
1124 data[8] = mSourceID >> 24;
1125 data[9] = (mSourceID >> 16) & 0xff;
1126 data[10] = (mSourceID >> 8) & 0xff;
1127 data[11] = mSourceID & 0xff;
1128
1129 int rtpExtIndex = 0;
1130 if (lastPacket && mRTPCVOExtMap > 0) {
1131 data[12] = 0xBE;
1132 data[13] = 0xDE;
1133 data[14] = 0x00;
1134 data[15] = 0x01;
1135 data[16] = (mRTPCVOExtMap << 4) | 0x0;
1136 data[17] = mRTPCVODegrees;
1137 data[18] = 0x0;
1138 data[19] = 0x0;
1139 rtpExtIndex = 8;
1140 }
1141
1142 /* H265 payload header is 16 bit
1143 0 1 2 3 4 5 6 7 0 1 2 3 4 5 6 7
1144 +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
1145 |F| Type | Layer ID | TID |
1146 +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
1147 */
1148 ALOGV("H265 payload header 0x%x %x", mediaData[0], mediaData[1]);
1149 // excludes Type from 1st byte of H265 payload header.
1150 data[12 + rtpExtIndex] = mediaData[0] & 0x81;
1151 // fills Type as FU (49 == 0x31)
1152 data[12 + rtpExtIndex] = data[12 + rtpExtIndex] | (0x31 << 1);
1153 data[13 + rtpExtIndex] = mediaData[1];
1154
1155 ALOGV("H265 FU header 0x%x %x", data[12 + rtpExtIndex], data[13 + rtpExtIndex]);
1156
1157 CHECK(!firstPacket || !lastPacket);
1158 /*
1159 FU INDICATOR HDR
1160 0 1 2 3 4 5 6 7
1161 +-+-+-+-+-+-+-+-+
1162 |S|E| Type |
1163 +-+-+-+-+-+-+-+-+
1164 */
1165
1166 data[14 + rtpExtIndex] =
1167 (firstPacket ? 0x80 : 0x00)
1168 | (lastPacket ? 0x40 : 0x00)
1169 | (nalType & H265_NALU_MASK);
1170 ALOGV("H265 FU indicator 0x%x", data[14]);
1171
1172 memcpy(&data[15 + rtpExtIndex], &mediaData[offset], size);
1173
1174 buffer->setRange(0, 15 + rtpExtIndex + size);
1175
1176 send(buffer, false /* isRTCP */);
1177
1178 ++mSeqNo;
1179 ++mNumRTPSent;
1180 mNumRTPOctetsSent += buffer->size() - (12 + rtpExtIndex);
1181
1182 firstPacket = false;
1183 offset += size;
1184 }
1185 }
1186 }
1187
sendAVCData(MediaBufferBase * mediaBuf)1188 void ARTPWriter::sendAVCData(MediaBufferBase *mediaBuf) {
1189 // 12 bytes RTP header + 2 bytes for the FU-indicator and FU-header.
1190 CHECK_GE(kMaxPacketSize, 12u + 2u);
1191
1192 int64_t timeUs;
1193 CHECK(mediaBuf->meta_data().findInt64(kKeyTime, &timeUs));
1194
1195 sendSPSPPSIfIFrame(mediaBuf, timeUs);
1196
1197 uint32_t rtpTime = getRtpTime(timeUs);
1198
1199 CHECK(mediaBuf->range_length() > 0);
1200 const uint8_t *mediaData =
1201 (const uint8_t *)mediaBuf->data() + mediaBuf->range_offset();
1202
1203 int32_t sps, pps;
1204 bool isSpsPps = false;
1205 if (mediaBuf->meta_data().findInt32(kKeySps, &sps) ||
1206 mediaBuf->meta_data().findInt32(kKeyPps, &pps)) {
1207 isSpsPps = true;
1208 }
1209
1210 mTrafficRec->updateClock(ALooper::GetNowUs() / 1000);
1211 sp<ABuffer> buffer = new ABuffer(kMaxPacketSize);
1212 if (mediaBuf->range_length() + TCPIP_HEADER_SIZE + RTP_HEADER_SIZE + RTP_HEADER_EXT_SIZE
1213 + RTP_PAYLOAD_ROOM_SIZE <= buffer->capacity()) {
1214 // The data fits into a single packet
1215 uint8_t *data = buffer->data();
1216 data[0] = 0x80;
1217 if (mRTPCVOExtMap > 0) {
1218 data[0] |= 0x10;
1219 }
1220 if (isSpsPps) {
1221 data[1] = mPayloadType; // Marker bit should not be set in case of sps/pps
1222 } else {
1223 data[1] = (1 << 7) | mPayloadType;
1224 }
1225 data[2] = (mSeqNo >> 8) & 0xff;
1226 data[3] = mSeqNo & 0xff;
1227 data[4] = rtpTime >> 24;
1228 data[5] = (rtpTime >> 16) & 0xff;
1229 data[6] = (rtpTime >> 8) & 0xff;
1230 data[7] = rtpTime & 0xff;
1231 data[8] = mSourceID >> 24;
1232 data[9] = (mSourceID >> 16) & 0xff;
1233 data[10] = (mSourceID >> 8) & 0xff;
1234 data[11] = mSourceID & 0xff;
1235
1236 int rtpExtIndex = 0;
1237 if (mRTPCVOExtMap > 0) {
1238 /*
1239 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
1240 +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
1241 | 0xBE | 0xDE | length=3 |
1242 +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
1243 | ID | L=0 | data | ID | L=1 | data...
1244 +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
1245 ...data | 0 (pad) | 0 (pad) | ID | L=3 |
1246 +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
1247 | data |
1248 +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
1249
1250
1251 In the one-byte header form of extensions, the 16-bit value required
1252 by the RTP specification for a header extension, labeled in the RTP
1253 specification as "defined by profile", takes the fixed bit pattern
1254 0xBEDE (the first version of this specification was written on the
1255 feast day of the Venerable Bede).
1256 */
1257 data[12] = 0xBE;
1258 data[13] = 0xDE;
1259 // put a length of RTP Extension.
1260 data[14] = 0x00;
1261 data[15] = 0x01;
1262 // put extmap of RTP assigned for CVO.
1263 data[16] = (mRTPCVOExtMap << 4) | 0x0;
1264 // put image degrees as per CVO specification.
1265 data[17] = mRTPCVODegrees;
1266 data[18] = 0x0;
1267 data[19] = 0x0;
1268 rtpExtIndex = 8;
1269 }
1270
1271 memcpy(&data[12 + rtpExtIndex],
1272 mediaData, mediaBuf->range_length());
1273
1274 buffer->setRange(0, mediaBuf->range_length() + (12 + rtpExtIndex));
1275
1276 send(buffer, false /* isRTCP */);
1277
1278 ++mSeqNo;
1279 ++mNumRTPSent;
1280 mNumRTPOctetsSent += buffer->size() - (12 + rtpExtIndex);
1281 } else {
1282 // FU-A
1283
1284 unsigned nalType = mediaData[0] & H264_NALU_MASK;
1285 ALOGV("H264 nalType 0x%x, data[0]=0x%x", nalType, mediaData[0]);
1286 size_t offset = 1;
1287
1288 bool firstPacket = true;
1289 while (offset < mediaBuf->range_length()) {
1290 size_t size = mediaBuf->range_length() - offset;
1291 bool lastPacket = true;
1292 if (size + TCPIP_HEADER_SIZE + RTP_HEADER_SIZE + RTP_HEADER_EXT_SIZE +
1293 RTP_FU_HEADER_SIZE + RTP_PAYLOAD_ROOM_SIZE > buffer->capacity()) {
1294 lastPacket = false;
1295 size = buffer->capacity() - TCPIP_HEADER_SIZE - RTP_HEADER_SIZE -
1296 RTP_HEADER_EXT_SIZE - RTP_FU_HEADER_SIZE - RTP_PAYLOAD_ROOM_SIZE;
1297 }
1298
1299 uint8_t *data = buffer->data();
1300 data[0] = 0x80;
1301 if (lastPacket && mRTPCVOExtMap > 0) {
1302 data[0] |= 0x10;
1303 }
1304 data[1] = (lastPacket ? (1 << 7) : 0x00) | mPayloadType; // M-bit
1305 data[2] = (mSeqNo >> 8) & 0xff;
1306 data[3] = mSeqNo & 0xff;
1307 data[4] = rtpTime >> 24;
1308 data[5] = (rtpTime >> 16) & 0xff;
1309 data[6] = (rtpTime >> 8) & 0xff;
1310 data[7] = rtpTime & 0xff;
1311 data[8] = mSourceID >> 24;
1312 data[9] = (mSourceID >> 16) & 0xff;
1313 data[10] = (mSourceID >> 8) & 0xff;
1314 data[11] = mSourceID & 0xff;
1315
1316 int rtpExtIndex = 0;
1317 if (lastPacket && mRTPCVOExtMap > 0) {
1318 data[12] = 0xBE;
1319 data[13] = 0xDE;
1320 data[14] = 0x00;
1321 data[15] = 0x01;
1322 data[16] = (mRTPCVOExtMap << 4) | 0x0;
1323 data[17] = mRTPCVODegrees;
1324 data[18] = 0x0;
1325 data[19] = 0x0;
1326 rtpExtIndex = 8;
1327 }
1328
1329 /* H264 payload header is 8 bit
1330 0 1 2 3 4 5 6 7
1331 +-+-+-+-+-+-+-+-+
1332 |F|NRI| Type |
1333 +-+-+-+-+-+-+-+-+
1334 */
1335 ALOGV("H264 payload header 0x%x", mediaData[0]);
1336 // excludes Type from 1st byte of H264 payload header.
1337 data[12 + rtpExtIndex] = mediaData[0] & 0xe0;
1338 // fills Type as FU (28 == 0x1C)
1339 data[12 + rtpExtIndex] = data[12 + rtpExtIndex] | 0x1C;
1340
1341 CHECK(!firstPacket || !lastPacket);
1342 /*
1343 FU header
1344 0 1 2 3 4 5 6 7
1345 +-+-+-+-+-+-+-+-+
1346 |S|E|R| Type |
1347 +-+-+-+-+-+-+-+-+
1348 */
1349
1350 data[13 + rtpExtIndex] =
1351 (firstPacket ? 0x80 : 0x00)
1352 | (lastPacket ? 0x40 : 0x00)
1353 | (nalType & H264_NALU_MASK);
1354 ALOGV("H264 FU header 0x%x", data[13]);
1355
1356 memcpy(&data[14 + rtpExtIndex], &mediaData[offset], size);
1357
1358 buffer->setRange(0, 14 + rtpExtIndex + size);
1359
1360 send(buffer, false /* isRTCP */);
1361
1362 ++mSeqNo;
1363 ++mNumRTPSent;
1364 mNumRTPOctetsSent += buffer->size() - (12 + rtpExtIndex);
1365
1366 firstPacket = false;
1367 offset += size;
1368 }
1369 }
1370 }
1371
sendH263Data(MediaBufferBase * mediaBuf)1372 void ARTPWriter::sendH263Data(MediaBufferBase *mediaBuf) {
1373 CHECK_GE(kMaxPacketSize, 12u + 2u);
1374
1375 int64_t timeUs;
1376 CHECK(mediaBuf->meta_data().findInt64(kKeyTime, &timeUs));
1377
1378 uint32_t rtpTime = getRtpTime(timeUs);
1379
1380 const uint8_t *mediaData =
1381 (const uint8_t *)mediaBuf->data() + mediaBuf->range_offset();
1382
1383 // hexdump(mediaData, mediaBuf->range_length());
1384
1385 CHECK_EQ((unsigned)mediaData[0], 0u);
1386 CHECK_EQ((unsigned)mediaData[1], 0u);
1387
1388 size_t offset = 2;
1389 size_t size = mediaBuf->range_length();
1390
1391 while (offset < size) {
1392 sp<ABuffer> buffer = new ABuffer(kMaxPacketSize);
1393 // CHECK_LE(mediaBuf->range_length() -2 + 14, buffer->capacity());
1394
1395 size_t remaining = size - offset;
1396 bool lastPacket = (remaining + 14 <= buffer->capacity());
1397 if (!lastPacket) {
1398 remaining = buffer->capacity() - 14;
1399 }
1400
1401 uint8_t *data = buffer->data();
1402 data[0] = 0x80;
1403 data[1] = (lastPacket ? 0x80 : 0x00) | mPayloadType; // M-bit
1404 data[2] = (mSeqNo >> 8) & 0xff;
1405 data[3] = mSeqNo & 0xff;
1406 data[4] = rtpTime >> 24;
1407 data[5] = (rtpTime >> 16) & 0xff;
1408 data[6] = (rtpTime >> 8) & 0xff;
1409 data[7] = rtpTime & 0xff;
1410 data[8] = mSourceID >> 24;
1411 data[9] = (mSourceID >> 16) & 0xff;
1412 data[10] = (mSourceID >> 8) & 0xff;
1413 data[11] = mSourceID & 0xff;
1414
1415 data[12] = (offset == 2) ? 0x04 : 0x00; // P=?, V=0
1416 data[13] = 0x00; // PLEN = PEBIT = 0
1417
1418 memcpy(&data[14], &mediaData[offset], remaining);
1419 offset += remaining;
1420
1421 buffer->setRange(0, remaining + 14);
1422
1423 send(buffer, false /* isRTCP */);
1424
1425 ++mSeqNo;
1426 ++mNumRTPSent;
1427 mNumRTPOctetsSent += buffer->size() - 12;
1428 }
1429 }
1430
updateCVODegrees(int32_t cvoDegrees)1431 void ARTPWriter::updateCVODegrees(int32_t cvoDegrees) {
1432 Mutex::Autolock autoLock(mLock);
1433 mRTPCVODegrees = cvoDegrees;
1434 }
1435
updatePayloadType(int32_t payloadType)1436 void ARTPWriter::updatePayloadType(int32_t payloadType) {
1437 Mutex::Autolock autoLock(mLock);
1438 mPayloadType = payloadType;
1439 }
1440
updateSocketDscp(int32_t dscp)1441 void ARTPWriter::updateSocketDscp(int32_t dscp) {
1442 mRtpLayer3Dscp = dscp << 2;
1443
1444 /* mRtpLayer3Dscp will be mapped to WMM(Wifi) as per operator's requirement */
1445 if (setsockopt(mRTPSocket, IPPROTO_IP, IP_TOS,
1446 (int *)&mRtpLayer3Dscp, sizeof(mRtpLayer3Dscp)) < 0) {
1447 ALOGE("failed to set dscp on rtpsock. err=%s", strerror(errno));
1448 } else {
1449 ALOGD("successfully set dscp on rtpsock. opt=%d", mRtpLayer3Dscp);
1450 setsockopt(mRTCPSocket, IPPROTO_IP, IP_TOS,
1451 (int *)&mRtpLayer3Dscp, sizeof(mRtpLayer3Dscp));
1452 ALOGD("successfully set dscp on rtcpsock. opt=%d", mRtpLayer3Dscp);
1453 }
1454 }
1455
updateSocketNetwork(int64_t socketNetwork)1456 void ARTPWriter::updateSocketNetwork(int64_t socketNetwork) {
1457 mRTPSockNetwork = (net_handle_t)socketNetwork;
1458 ALOGI("trying to bind rtp socket(%d) to network(%llu).",
1459 mRTPSocket, (unsigned long long)mRTPSockNetwork);
1460
1461 int result = android_setsocknetwork(mRTPSockNetwork, mRTPSocket);
1462 if (result != 0) {
1463 ALOGW("failed(%d) to bind rtp socket(%d) to network(%llu)",
1464 result, mRTPSocket, (unsigned long long)mRTPSockNetwork);
1465 }
1466 result = android_setsocknetwork(mRTPSockNetwork, mRTCPSocket);
1467 if (result != 0) {
1468 ALOGW("failed(%d) to bind rtcp socket(%d) to network(%llu)",
1469 result, mRTCPSocket, (unsigned long long)mRTPSockNetwork);
1470 }
1471 ALOGI("done. bind rtp socket(%d) to network(%llu)",
1472 mRTPSocket, (unsigned long long)mRTPSockNetwork);
1473 }
1474
getSequenceNum()1475 uint32_t ARTPWriter::getSequenceNum() {
1476 return mSeqNo;
1477 }
1478
getAccumulativeBytes()1479 uint64_t ARTPWriter::getAccumulativeBytes() {
1480 return mTrafficRec->readBytesForTotal();
1481 }
1482
getFrameSize(bool isWide,unsigned FT)1483 static size_t getFrameSize(bool isWide, unsigned FT) {
1484 static const size_t kFrameSizeNB[8] = {
1485 95, 103, 118, 134, 148, 159, 204, 244
1486 };
1487 static const size_t kFrameSizeWB[9] = {
1488 132, 177, 253, 285, 317, 365, 397, 461, 477
1489 };
1490
1491 size_t frameSize = isWide ? kFrameSizeWB[FT] : kFrameSizeNB[FT];
1492
1493 // Round up bits to bytes and add 1 for the header byte.
1494 frameSize = (frameSize + 7) / 8 + 1;
1495
1496 return frameSize;
1497 }
1498
sendAMRData(MediaBufferBase * mediaBuf)1499 void ARTPWriter::sendAMRData(MediaBufferBase *mediaBuf) {
1500 const uint8_t *mediaData =
1501 (const uint8_t *)mediaBuf->data() + mediaBuf->range_offset();
1502
1503 size_t mediaLength = mediaBuf->range_length();
1504
1505 CHECK_GE(kMaxPacketSize, 12u + 1u + mediaLength);
1506
1507 const bool isWide = (mMode == AMR_WB);
1508
1509 int64_t timeUs;
1510 CHECK(mediaBuf->meta_data().findInt64(kKeyTime, &timeUs));
1511 uint32_t rtpTime = getRtpTime(timeUs);
1512
1513 // hexdump(mediaData, mediaLength);
1514
1515 Vector<uint8_t> tableOfContents;
1516 size_t srcOffset = 0;
1517 while (srcOffset < mediaLength) {
1518 uint8_t toc = mediaData[srcOffset];
1519
1520 unsigned FT = (toc >> 3) & 0x0f;
1521 CHECK((isWide && FT <= 8) || (!isWide && FT <= 7));
1522
1523 tableOfContents.push(toc);
1524 srcOffset += getFrameSize(isWide, FT);
1525 }
1526 CHECK_EQ(srcOffset, mediaLength);
1527
1528 sp<ABuffer> buffer = new ABuffer(kMaxPacketSize);
1529 CHECK_LE(mediaLength + 12 + 1, buffer->capacity());
1530
1531 // The data fits into a single packet
1532 uint8_t *data = buffer->data();
1533 data[0] = 0x80;
1534 data[1] = mPayloadType;
1535 if (mNumRTPSent == 0) {
1536 // Signal start of talk-spurt.
1537 data[1] |= 0x80; // M-bit
1538 }
1539 data[2] = (mSeqNo >> 8) & 0xff;
1540 data[3] = mSeqNo & 0xff;
1541 data[4] = rtpTime >> 24;
1542 data[5] = (rtpTime >> 16) & 0xff;
1543 data[6] = (rtpTime >> 8) & 0xff;
1544 data[7] = rtpTime & 0xff;
1545 data[8] = mSourceID >> 24;
1546 data[9] = (mSourceID >> 16) & 0xff;
1547 data[10] = (mSourceID >> 8) & 0xff;
1548 data[11] = mSourceID & 0xff;
1549
1550 data[12] = 0xf0; // CMR=15, RR=0
1551
1552 size_t dstOffset = 13;
1553
1554 for (size_t i = 0; i < tableOfContents.size(); ++i) {
1555 uint8_t toc = tableOfContents[i];
1556
1557 if (i + 1 < tableOfContents.size()) {
1558 toc |= 0x80;
1559 } else {
1560 toc &= ~0x80;
1561 }
1562
1563 data[dstOffset++] = toc;
1564 }
1565
1566 srcOffset = 0;
1567 for (size_t i = 0; i < tableOfContents.size(); ++i) {
1568 uint8_t toc = tableOfContents[i];
1569 unsigned FT = (toc >> 3) & 0x0f;
1570 size_t frameSize = getFrameSize(isWide, FT);
1571
1572 ++srcOffset; // skip toc
1573 memcpy(&data[dstOffset], &mediaData[srcOffset], frameSize - 1);
1574 srcOffset += frameSize - 1;
1575 dstOffset += frameSize - 1;
1576 }
1577
1578 buffer->setRange(0, dstOffset);
1579
1580 send(buffer, false /* isRTCP */);
1581
1582 ++mSeqNo;
1583 ++mNumRTPSent;
1584 mNumRTPOctetsSent += buffer->size() - 12;
1585 }
1586
makeSocketPairAndBind(String8 & localIp,int localPort,String8 & remoteIp,int remotePort)1587 void ARTPWriter::makeSocketPairAndBind(String8& localIp, int localPort,
1588 String8& remoteIp, int remotePort) {
1589 static char kSomeone[16] = "someone@";
1590 int nameLength = strlen(kSomeone);
1591 memcpy(kCNAME, kSomeone, nameLength);
1592 memcpy(kCNAME + nameLength, localIp.c_str(), localIp.length() + 1);
1593
1594 if (localIp.contains(":"))
1595 mIsIPv6 = true;
1596 else
1597 mIsIPv6 = false;
1598
1599 mRTPSocket = socket(mIsIPv6 ? AF_INET6 : AF_INET, SOCK_DGRAM, 0);
1600 CHECK_GE(mRTPSocket, 0);
1601 mRTCPSocket = socket(mIsIPv6 ? AF_INET6 : AF_INET, SOCK_DGRAM, 0);
1602 CHECK_GE(mRTCPSocket, 0);
1603
1604 int sockopt = 1;
1605 setsockopt(mRTPSocket, SOL_SOCKET, SO_REUSEADDR, (int *)&sockopt, sizeof(sockopt));
1606 setsockopt(mRTCPSocket, SOL_SOCKET, SO_REUSEADDR, (int *)&sockopt, sizeof(sockopt));
1607
1608 if (mIsIPv6) {
1609 memset(&mLocalAddr6, 0, sizeof(mLocalAddr6));
1610 memset(&mRTPAddr6, 0, sizeof(mRTPAddr6));
1611 memset(&mRTCPAddr6, 0, sizeof(mRTCPAddr6));
1612
1613 mLocalAddr6.sin6_family = AF_INET6;
1614 inet_pton(AF_INET6, localIp.string(), &mLocalAddr6.sin6_addr);
1615 mLocalAddr6.sin6_port = htons((uint16_t)localPort);
1616
1617 mRTPAddr6.sin6_family = AF_INET6;
1618 inet_pton(AF_INET6, remoteIp.string(), &mRTPAddr6.sin6_addr);
1619 mRTPAddr6.sin6_port = htons((uint16_t)remotePort);
1620
1621 mRTCPAddr6 = mRTPAddr6;
1622 mRTCPAddr6.sin6_port = htons((uint16_t)(remotePort + 1));
1623 } else {
1624 memset(&mLocalAddr, 0, sizeof(mLocalAddr));
1625 memset(&mRTPAddr, 0, sizeof(mRTPAddr));
1626 memset(&mRTCPAddr, 0, sizeof(mRTCPAddr));
1627
1628 mLocalAddr.sin_family = AF_INET;
1629 mLocalAddr.sin_addr.s_addr = inet_addr(localIp.string());
1630 mLocalAddr.sin_port = htons((uint16_t)localPort);
1631
1632 mRTPAddr.sin_family = AF_INET;
1633 mRTPAddr.sin_addr.s_addr = inet_addr(remoteIp.string());
1634 mRTPAddr.sin_port = htons((uint16_t)remotePort);
1635
1636 mRTCPAddr = mRTPAddr;
1637 mRTCPAddr.sin_port = htons((uint16_t)(remotePort + 1));
1638 }
1639
1640 struct sockaddr *localAddr = mIsIPv6 ?
1641 (struct sockaddr*)&mLocalAddr6 : (struct sockaddr*)&mLocalAddr;
1642
1643 int sizeSockSt = mIsIPv6 ? sizeof(mLocalAddr6) : sizeof(mLocalAddr);
1644
1645 if (bind(mRTPSocket, localAddr, sizeSockSt) == -1) {
1646 ALOGE("failed to bind rtp %s:%d err=%s", localIp.string(), localPort, strerror(errno));
1647 } else {
1648 ALOGD("succeed to bind rtp %s:%d", localIp.string(), localPort);
1649 }
1650
1651 if (mIsIPv6)
1652 mLocalAddr6.sin6_port = htons((uint16_t)(localPort + 1));
1653 else
1654 mLocalAddr.sin_port = htons((uint16_t)(localPort + 1));
1655
1656 if (bind(mRTCPSocket, localAddr, sizeSockSt) == -1) {
1657 ALOGE("failed to bind rtcp %s:%d err=%s", localIp.string(), localPort + 1, strerror(errno));
1658 } else {
1659 ALOGD("succeed to bind rtcp %s:%d", localIp.string(), localPort + 1);
1660 }
1661 }
1662
1663 // TODO : Develop more advanced moderator based on AS & TMMBR value
ModerateInstantTraffic(uint32_t samplePeriod,uint32_t limitBytes)1664 void ARTPWriter::ModerateInstantTraffic(uint32_t samplePeriod, uint32_t limitBytes) {
1665 unsigned int bytes = mTrafficRec->readBytesForLastPeriod(samplePeriod);
1666 if (bytes > limitBytes) {
1667 ALOGI("Nuclear moderator. #seq = %d \t\t %d bits / 10ms",
1668 mSeqNo, bytes * 8);
1669 usleep(4000);
1670 mTrafficRec->updateClock(ALooper::GetNowUs() / 1000);
1671 }
1672 }
1673
1674 } // namespace android
1675