bool InFileRTMPStream::AVCBuilder::BuildFrame(MediaFile* pFile, MediaFrame& mediaFrame, IOBuffer& buffer) { if (mediaFrame.isBinaryHeader) { buffer.ReadFromBuffer(_videoCodecHeaderInit, sizeof (_videoCodecHeaderInit)); } else { if (mediaFrame.isKeyFrame) { // video key frame buffer.ReadFromBuffer(_videoCodecHeaderKeyFrame, sizeof (_videoCodecHeaderKeyFrame)); } else { //video normal frame buffer.ReadFromBuffer(_videoCodecHeader, sizeof (_videoCodecHeader)); } uint32_t cts = (EHTONL(((uint32_t) mediaFrame.cts) & 0x00ffffff)) >> 8; buffer.ReadFromBuffer((uint8_t *) & cts, 3); } if (!pFile->SeekTo(mediaFrame.start)) { FATAL("Unable to seek to position %"PRIu64, mediaFrame.start); return false; } if (!buffer.ReadFromFs(*pFile, (uint32_t) mediaFrame.length)) { FATAL("Unable to read %"PRIu64" bytes from offset %"PRIu64, mediaFrame.length, mediaFrame.start); return false; } return true; }
bool _AUDIO_AAC::Serialize(IOBuffer &dest) { uint8_t temp[sizeof (_aacLength)]; EHTONLP(temp, _aacLength); dest.ReadFromBuffer(temp, sizeof (_aacLength)); dest.ReadFromBuffer(_pAAC, _aacLength); return true; }
bool MP44HTTPStream::FeedData(uint8_t *pData, uint32_t dataLength, uint32_t processedLength, uint32_t totalLength, double absoluteTimestamp, bool isAudio) { IOBuffer *pBuffer = _pAVProtocol->GetProtocolOutputBuffer(); pBuffer->ReadFromBuffer(pData, dataLength); return _pAVProtocol->EnqueueForOutbound(); }
string IOBuffer::DumpBuffer(MSGHDR &message, uint32_t limit) { IOBuffer temp; for (MSGHDR_MSG_IOVLEN_TYPE i = 0; i < message.MSGHDR_MSG_IOVLEN; i++) { temp.ReadFromBuffer((uint8_t *) message.MSGHDR_MSG_IOV[i].IOVEC_IOV_BASE, message.MSGHDR_MSG_IOV[i].IOVEC_IOV_LEN); } return temp.ToString(0, limit); }
bool AMF0Serializer::WriteDouble(IOBuffer &buffer, double value, bool writeType) { if (writeType) buffer.ReadFromRepeat(AMF0_NUMBER, 1); uint64_t temp = 0; EHTOND(value, temp); buffer.ReadFromBuffer((uint8_t *) & temp, 8); return true; }
bool AMF0Serializer::WriteShortString(IOBuffer &buffer, string &value, bool writeType) { if (writeType) buffer.ReadFromRepeat(AMF0_SHORT_STRING, 1); uint16_t length = EHTONS((uint16_t) value.length()); //----MARKED-SHORT---- buffer.ReadFromBuffer((uint8_t *) & length, 2); buffer.ReadFromString(value); return true; }
bool AMF0Serializer::WriteLongString(IOBuffer &buffer, string &value, bool writeType) { if (writeType) buffer.ReadFromRepeat(AMF0_LONG_STRING, 1); uint32_t length = EHTONL((uint32_t) value.length()); buffer.ReadFromBuffer((uint8_t *) & length, 4); buffer.ReadFromString(value); return true; }
bool InFileRTMPStream::AACBuilder::BuildFrame(MediaFile* pFile, MediaFrame& mediaFrame, IOBuffer& buffer) { //1. add the binary header if (mediaFrame.isBinaryHeader) { buffer.ReadFromBuffer(_audioCodecHeaderInit, sizeof (_audioCodecHeaderInit)); } else { buffer.ReadFromBuffer(_audioCodecHeader, sizeof (_audioCodecHeader)); } //2. Seek into the data file at the correct position if (!pFile->SeekTo(mediaFrame.start)) { FATAL("Unable to seek to position %"PRIu64, mediaFrame.start); return false; } //3. Read the data if (!buffer.ReadFromFs(*pFile, (uint32_t) mediaFrame.length)) { FATAL("Unable to read %"PRIu64" bytes from offset %"PRIu64, mediaFrame.length, mediaFrame.start); return false; } return true; }
bool Header::Write(IOBuffer &buffer) { if (ci < 64) { buffer.ReadFromByte((ht << 6) | ((uint8_t) ci)); } else if (ci < 319) { buffer.ReadFromByte(ht << 6); buffer.ReadFromByte((uint8_t) (ci - 64)); } else if (ci < 65599) { uint16_t temp = EHTONS((uint16_t) (ci - 64)); buffer.ReadFromByte((ht << 6) | 0x01); buffer.ReadFromBuffer((uint8_t *) & temp, 2); } else { FATAL("Invalid channel index"); return false; } switch (ht) { case HT_FULL: { if (hf.s.ts < 0x00ffffff) { hf.s.ts = EHTONL(hf.s.ts); //----MARKED-LONG--- hf.s.ml = EHTONL(hf.s.ml << 8); //----MARKED-LONG--- buffer.ReadFromBuffer(&hf.datac[1], 11); hf.s.ts = ENTOHL(hf.s.ts); //----MARKED-LONG--- hf.s.ml = ENTOHL(hf.s.ml) >> 8; //----MARKED-LONG--- return true; } else { uint32_t temp = EHTONL(hf.s.ts); //----MARKED-LONG--- hf.s.ts = EHTONL(0x00ffffff); //----MARKED-LONG--- hf.s.ml = EHTONL(hf.s.ml << 8); //----MARKED-LONG--- buffer.ReadFromBuffer(&hf.datac[1], 11); hf.s.ts = ENTOHL(temp); //----MARKED-LONG--- hf.s.ml = ENTOHL(hf.s.ml) >> 8; //----MARKED-LONG--- buffer.ReadFromBuffer((uint8_t *) & temp, 4); return true; } }
bool _VIDEO_AVC::Serialize(IOBuffer &dest) { uint8_t temp[sizeof (_spsLength) + sizeof (_ppsLength) + sizeof (uint32_t)]; EHTONSP(temp, _spsLength); dest.ReadFromBuffer(temp, sizeof (_spsLength)); dest.ReadFromBuffer(_pSPS, _spsLength); EHTONSP(temp, _ppsLength); dest.ReadFromBuffer(temp, sizeof (_ppsLength)); dest.ReadFromBuffer(_pPPS, _ppsLength); EHTONLP(temp, _widthOverride); dest.ReadFromBuffer(temp, sizeof (uint32_t)); EHTONLP(temp, _heightOverride); dest.ReadFromBuffer(temp, sizeof (uint32_t)); return true; }
void AtomMVHD::SerializeToBuffer(IOBuffer& data, uint32_t maxFrames) { uint32_t start=GETAVAILABLEBYTESCOUNT(data); VersionedAtom::SerializeToBuffer(data, maxFrames); data.ReadFromDataType<uint32_t>(endianSwap32(_creationTime)); data.ReadFromDataType<uint32_t>(endianSwap32(_modificationTime)); data.ReadFromDataType<uint32_t>(endianSwap32(_timeScale)); _offset=GETAVAILABLEBYTESCOUNT(data); data.ReadFromDataType<uint32_t>(endianSwap32(_duration)); data.ReadFromDataType<uint32_t>(endianSwap32(_preferredRate)); data.ReadFromDataType<uint16_t>(endianSwap16(_preferredVolume)); data.ReadFromBuffer(_reserved, sizeof(_reserved)); for (uint32_t i=0; i<9; i++) data.ReadFromDataType<uint32_t>(endianSwap32(_matrixStructure[i])); for (uint32_t i=0; i<6; i++) { data.ReadFromRepeat(0x00, 4); } data.ReadFromDataType<uint32_t>(endianSwap32(_nextTrakId)); _size=GETAVAILABLEBYTESCOUNT(data)-start; *(uint32_t*)(GETIBPOINTER(data)+start) = endianSwap32(_size); }
bool StreamCapabilities::Serialize(IOBuffer &dest) { uint8_t temp[28]; EHTONLLP(temp, __STREAM_CAPABILITIES_VERSION); EHTONLLP(temp + 8, videoCodecId); EHTONLLP(temp + 16, audioCodecId); EHTONLP(temp + 24, bandwidthHint); dest.ReadFromBuffer(temp, 28); switch (videoCodecId) { case CODEC_VIDEO_AVC: { if (!avc.Serialize(dest)) { FATAL("Unable to serialize avc"); return false; } break; } default: { break; } } switch (audioCodecId) { case CODEC_AUDIO_AAC: { if (!aac.Serialize(dest)) { FATAL("Unable to serialize aac"); return false; } break; } default: { break; } } return true; }
string IOBuffer::DumpBuffer(const uint8_t *pBuffer, uint32_t length) { IOBuffer temp; temp.ReadFromBuffer(pBuffer, length); return temp.ToString(); }
bool OutNetRTMP4TSStream::FeedAudioData(uint8_t *pData, uint32_t dataLength, double absoluteTimestamp) { if (!_videoCodecSent) return true; //the payload here respects this format: //6.2 Audio Data Transport Stream, ADTS //iso13818-7 page 26/206 //1. Send the audio codec setup if necessary if (!_audioCodecSent) { StreamCapabilities *pCapabilities = GetCapabilities(); if ((pCapabilities != NULL) && (pCapabilities->audioCodecId == CODEC_AUDIO_AAC)) { IOBuffer codecSetup; codecSetup.ReadFromRepeat(0xaf, 1); codecSetup.ReadFromRepeat(0x00, 1); codecSetup.ReadFromBuffer(pCapabilities->aac._pAAC, pCapabilities->aac._aacLength); if (!BaseOutNetRTMPStream::FeedData( GETIBPOINTER(codecSetup), //pData GETAVAILABLEBYTESCOUNT(codecSetup), //dataLength 0, //processedLength GETAVAILABLEBYTESCOUNT(codecSetup), //totalLength absoluteTimestamp, //absoluteTimestamp true //isAudio )) { FATAL("Unable to send audio codec setup"); return false; } } _audioCodecSent = true; } if (_inboundStreamIsRTP) { pData[0] = 0xaf; pData[1] = 0x01; return BaseOutNetRTMPStream::FeedData( pData, //pData dataLength, //dataLength 0, //processedLength dataLength, //totalLength absoluteTimestamp, //absoluteTimestamp true //isAudio ); } else { //2. Skip the ADTS headers and re-position the buffer uint32_t totalADTSHeaderLength = 0; if (((pData[1])&0x01) == 0) totalADTSHeaderLength = 9; else totalADTSHeaderLength = 7; pData += totalADTSHeaderLength - 2; //3. Setup the RTMP header pData[0] = 0xaf; pData[1] = 0x01; //4. Feed return BaseOutNetRTMPStream::FeedData( pData, //pData dataLength - totalADTSHeaderLength + 2, //dataLength 0, //processedLength dataLength - totalADTSHeaderLength + 2, //totalLength absoluteTimestamp, //absoluteTimestamp true //isAudio ); } }