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