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