bool CEncoderVorbis::Close() { int eos = 0; // tell vorbis we are encoding the end of the stream m_VorbisDll.vorbis_analysis_wrote(&m_sVorbisDspState, 0); while (m_VorbisDll.vorbis_analysis_blockout(&m_sVorbisDspState, &m_sVorbisBlock) == 1) { /* analysis, assume we want to use bitrate management */ m_VorbisDll.vorbis_analysis(&m_sVorbisBlock, NULL); m_VorbisDll.vorbis_bitrate_addblock(&m_sVorbisBlock); while (m_VorbisDll.vorbis_bitrate_flushpacket(&m_sVorbisDspState, &m_sOggPacket)) { /* weld the packet into the bitstream */ m_OggDll.ogg_stream_packetin(&m_sOggStreamState, &m_sOggPacket); /* write out pages (if any) */ while (!eos) { int result = m_OggDll.ogg_stream_pageout(&m_sOggStreamState, &m_sOggPage); if (result == 0)break; WriteStream(m_sOggPage.header, m_sOggPage.header_len); WriteStream(m_sOggPage.body, m_sOggPage.body_len); /* this could be set above, but for illustrative purposes, I do it here (to show that vorbis does know where the stream ends) */ if (m_OggDll.ogg_page_eos(&m_sOggPage)) eos = 1; } } } /* clean up and exit. vorbis_info_clear() must be called last */ m_OggDll.ogg_stream_clear(&m_sOggStreamState); m_VorbisDll.vorbis_block_clear(&m_sVorbisBlock); m_VorbisDll.vorbis_dsp_clear(&m_sVorbisDspState); m_VorbisDll.vorbis_comment_clear(&m_sVorbisComment); m_VorbisDll.vorbis_info_clear(&m_sVorbisInfo); /* ogg_page and ogg_packet structs always point to storage in libvorbis. They're never freed or manipulated directly */ FlushStream(); FileClose(); delete []m_pBuffer; m_pBuffer = NULL; m_VorbisEncDll.Unload(); m_OggDll.Unload(); m_VorbisDll.Unload(); return true; }
LONG WriteStreamLong (struct IFFHandle *iff, APTR valptr, struct IFFParseBase_intern *IFFParseBase) { LONG val; #if AROS_BIG_ENDIAN # define bytes valptr #else UBYTE bytes[4]; val = *(LONG *)valptr; bytes[0] = val >> 24; bytes[1] = val >> 16; bytes[2] = val >> 8; bytes[3] = val; #endif D(bug("WriteStreamLong(iff=%p valptr=%p)\n", iff, valptr)); val = WriteStream (iff, bytes, sizeof(LONG), IFFParseBase); D(bug("WriteStreamLong: val %ld\n", val)); if (val < 0) return val; else if (val != sizeof(LONG)) return IFFERR_EOF; return sizeof(LONG); } /* WriteStreamLong */
BOOL CCLITerminal::RemoteDoOption(CLISESSION *pSession, int nOption, BOOL bEnable, BOOL bRemote) { BOOL doFlag = bEnable; if (pSession->nRemoteOptions[nOption] == bEnable) return TRUE; switch(nOption) { case TELOPT_BINARY : case TELOPT_ECHO : SetOption(pSession, nOption, bEnable); break; case TELOPT_SGA : break; default : doFlag = FALSE; break; } if ((pSession->nRemoteOptions[nOption] != doFlag) || bRemote) { unsigned char msg[3]; msg[0] = IAC; msg[1] = doFlag ? DO : DONT; msg[2] = nOption; WriteStream(pSession, (char *)msg, 3); pSession->nRemoteOptions[nOption] = doFlag; } return (doFlag == bEnable) ? TRUE : FALSE; }
STDMETHODIMP CDecoder::Code(ISequentialInStream *inStream, ISequentialOutStream *outStream, const UInt64 * /* inSize */, const UInt64 *outSize, ICompressProgressInfo *progress) { if (!_outBuf) { _outBuf = (Byte *)::MidAlloc(kBufSize); if (!_outBuf) return E_OUTOFMEMORY; } _inStream.Stream = inStream; SetOutStreamSize(outSize); do { const UInt64 startPos = _processedSize; HRESULT res = CodeSpec(_outBuf, kBufSize); size_t processed = (size_t)(_processedSize - startPos); RINOK(WriteStream(outStream, _outBuf, processed)); RINOK(res); if (_status == kStatus_Finished) break; if (progress) { UInt64 inSize = _inStream.GetProcessed(); RINOK(progress->SetRatioInfo(&inSize, &_processedSize)); } } while (!_outSizeDefined || _processedSize < _outSize); return S_OK; }
bool RealSoundOgg::ServiceBuffer() { if( m_bMute ) return true; if (m_pDSB == NULL) return false; DWORD pos = 0; m_pDSB->GetCurrentPosition(&pos, NULL); m_nCurSection = ((int)pos < m_nBufSize) ? 0:1; if (m_nCurSection != m_nLastSection) { if (m_bDone && !m_bLoop) { if (m_bOpened) { if (m_bPlaying) { ov_pcm_seek(&m_vf, 0); m_pDSB->Stop(); m_bPlaying = false; } } return false; } if (m_bAlmostDone && !m_bLoop) m_bDone = true; WriteStream(m_nBufSize); } return true; }
STDMETHODIMP CEncoder::WriteCoderProperties(ISequentialOutStream *outStream) { Byte props[LZMA_PROPS_SIZE]; size_t size = LZMA_PROPS_SIZE; RINOK(LzmaEnc_WriteProperties(_encoder, props, &size)); return WriteStream(outStream, props, size); }
STDMETHODIMP CCopyCoder::Code(ISequentialInStream *inStream, ISequentialOutStream *outStream, const UInt64 * /* inSize */, const UInt64 *outSize, ICompressProgressInfo *progress) { if (_buffer == 0) { _buffer = (Byte *)::MidAlloc(kBufferSize); if (_buffer == 0) return E_OUTOFMEMORY; } TotalSize = 0; for (;;) { UInt32 size = kBufferSize; if (outSize != 0) if (size > *outSize - TotalSize) size = (UInt32)(*outSize - TotalSize); RINOK(inStream->Read(_buffer, size, &size)); if (size == 0) break; if (outStream) { RINOK(WriteStream(outStream, _buffer, size)); } TotalSize += size; if (progress != NULL) { RINOK(progress->SetRatioInfo(&TotalSize, &TotalSize)); } } return S_OK; }
BOOL CCLITerminal::LocalDoOption(CLISESSION *pSession, int nOption, BOOL bEnable, BOOL bRemote) { BOOL bWill = bEnable; if (pSession->nLocalOptions[nOption] == bEnable) return TRUE; switch(nOption) { case TELOPT_BINARY : case TELOPT_ECHO : SetOption(pSession, nOption, bEnable); break; case TELOPT_SGA : break; default : bWill = FALSE; break; } if ((pSession->nLocalOptions[nOption] != bWill) || bRemote) { unsigned char msg[3]; msg[0] = IAC; msg[1] = bWill ? WILL : WONT; msg[2] = nOption; WriteStream(pSession, (char *)msg, 3); pSession->nLocalOptions[nOption] = bWill; } return (bWill == bEnable) ? TRUE : FALSE; }
static size_t MyWrite(void *object, const void *data, size_t size) { CSeqOutStream *p = (CSeqOutStream *)object; p->Res = WriteStream(p->RealStream, data, size); if (p->Res != 0) return 0; return size; }
STDMETHODIMP CEncoder::WriteCoderProperties(ISequentialOutStream *outStream) { const UInt32 kPropSize = 5; Byte props[kPropSize]; props[0] = (Byte)_props.Order; SetUi32(props + 1, _props.MemSize); return WriteStream(outStream, props, kPropSize); }
void CCLITerminal::DisplaySplash(CLISESSION *pSession) { char szVersion[128]; if (pSession->nMode == CLIMODE_USER) { DisplayUserMenu(pSession); return; } WriteStream(pSession, "\033[H\033[J"); sprintf(szVersion, "AIMIR Management Console (%s)\xd\xa", m_pMcuVersionString); WriteStream(pSession, szVersion); WriteStream(pSession, COPYRIGHT "\xd\xa"); WriteStream(pSession, "\xd\xa"); DisplayPrompt(pSession); }
BOOL CCLITerminal::ExecuteBackspace(CLISESSION *pSession) { if (pSession->nCmdLength == 0) return FALSE; pSession->nCmdLength--; WriteStream(pSession, "\x8 \x8"); return TRUE; }
HRESULT CEncoder::WriteHeader(ISequentialOutStream *outStream, UInt32 crc) { Byte h[kHeaderSize]; g_RandomGenerator.Generate(h, kHeaderSize - 2); h[kHeaderSize - 1] = (Byte)(crc >> 24); h[kHeaderSize - 2] = (Byte)(crc >> 16); RestoreKeys(); Filter(h, kHeaderSize); return WriteStream(outStream, h, kHeaderSize); }
int CCLITerminal::DisplayAllParameter(CLISESSION *pSession, CLIHANDLER *pHandler, int nIndex) { CLIPARAMCHECKER *pChecker; int i, n, nCount = 0; char szTag[32]; char szName[64]; char szBuffer[1024]; if (!pHandler) return -1; WriteStream(pSession, "\xd\xa"); if (!pHandler->pszParam) return 0; for(i=0; pHandler->pszParam[i]; i++) { if (pHandler->pszParam[i] == '*') { WriteStream(pSession, " <enter>\xd\xa"); } else if (pHandler->pszParam[i] == '%') { n = UntilCopy(szTag, const_cast<char *>(&pHandler->pszParam[i+1]), 32); pChecker = FindParamHandler(szTag); if (pChecker != NULL) { sprintf(szName, "<%s>", pChecker->pszLabel); sprintf(szBuffer, " %-20s %s\xd\xa", szName, pChecker->pszDescr); WriteStream(pSession, szBuffer); } else { sprintf(szBuffer, " '%s'\xd\xa", szTag); WriteStream(pSession, szBuffer); } i += n; nCount++; } } return nCount; }
void LogPut( const char *str ) { int len; if( LogHndl == NIL_HANDLE ) return; len = strlen( str ); if( WriteStream( LogHndl, str, len ) != len ) { LogFini(); } }
HRESULT CEncoder::WriteHeader(ISequentialOutStream *outStream) { Byte header[kHeaderSize]; g_RandomGenerator.Generate(header, kHeaderSize - 2); header[kHeaderSize - 1] = Byte(_crc >> 24); header[kHeaderSize - 2] = Byte(_crc >> 16); _cipher.EncryptHeader(header); return WriteStream(outStream, header, kHeaderSize); }
HRESULT CByteOutBufWrap::Flush() { if (Res == S_OK) { size_t size = (Cur - Buf); Res = WriteStream(Stream, Buf, size); if (Res == S_OK) Processed += size; Cur = Buf; } return Res; }
HRESULT CFilterCoder::WriteWithLimit(ISequentialOutStream *outStream, UInt32 size) { if (_outSizeIsDefined) { UInt64 remSize = _outSize - _nowPos64; if (size > remSize) size = (UInt32)remSize; } RINOK(WriteStream(outStream, _buffer, size)); _nowPos64 += size; return S_OK; }
void CCLITerminal::ReplaceCommand(CLISESSION *pSession, const char *pszCommand) { char szWhite[256]; char * pszCmd = NULL; if (pszCommand == NULL) pszCmd = const_cast<char*>(""); else pszCmd = const_cast<char*>(pszCommand); strcpy(pSession->szCommand, pszCmd); pSession->nCmdLength = strlen(pszCmd); WriteStream(pSession, "\xd"); memset(szWhite, ' ', 79); szWhite[79] = 0; WriteStream(pSession, szWhite); WriteStream(pSession, "\xd"); DisplayPrompt(pSession); WriteStream(pSession, pSession->szCommand); }
void CCLITerminal::DisplayUserMenu(CLISESSION *pSession) { WriteStream(pSession, "\xd\xa"); WriteStream(pSession, "FIRMWARE DOWNLOAD MENU\xd\xa"); WriteStream(pSession, "\xd\xa"); WriteStream(pSession, "1. Download\xd\xa"); WriteStream(pSession, "2. Run\xd\xa"); WriteStream(pSession, "\xd\xa"); WriteStream(pSession, "SELECT> "); }
inline HRESULT write_int(ISequentialOutStream *outStream, long long data_size, UInt64 *outSizeProcessed) { do { unsigned char b = data_size & 0x7F; data_size >>= 7; if (data_size > 0) b |= 0x80; RINOK(WriteStream(outStream, &b, 1)); *outSizeProcessed += 1; } while (data_size != 0); return S_OK; }
int CCLITerminal::DisplayWideParameter(CLISESSION *pSession, CLIHANDLER *pHandler) { CLIPARAMCHECKER *pChecker; int i, n, nCount = 0; char szTag[32]; char szBuffer[64]; if (!pHandler) return -1; if (!pHandler->pszParam) return 0; for(i=0; pHandler->pszParam[i]; i++) { if (pHandler->pszParam[i] == '*') continue; if (pHandler->pszParam[i] == '%') { n = UntilCopy(szTag, const_cast<char *>(&pHandler->pszParam[i+1]), 32); pChecker = FindParamHandler(szTag); if (pChecker != NULL) { sprintf(szBuffer, "<%s> ", pChecker->pszLabel); WriteStream(pSession, szBuffer); } else { sprintf(szBuffer, "'%s' ", szTag); WriteStream(pSession, szBuffer); } i += n; nCount++; } } return nCount; }
static size_t MyWrite(void *object, const void *data, size_t size) { CSeqOutStreamWrap *p = (CSeqOutStreamWrap *)object; if (p->Stream) { p->Res = WriteStream(p->Stream, data, size); if (p->Res != 0) return 0; } else p->Res = S_OK; p->Processed += size; return size; }
HRESULT CEncoder::WriteHeader(ISequentialOutStream *outStream) { Byte header[kHeaderSize]; g_RandomGenerator.Generate(header, kHeaderSize - 2); header[kHeaderSize - 1] = Byte(_crc >> 24); header[kHeaderSize - 2] = Byte(_crc >> 16); UInt32 processedSize; _cipher.EncryptHeader(header); RINOK(WriteStream(outStream, header, kHeaderSize, &processedSize)); if (processedSize != kHeaderSize) return E_FAIL; return S_OK; }
bool CEncoder::CloseEncode() { int iBytes = m_impl->Flush(m_buffer); if (iBytes < 0) { CLog::Log(LOGERROR, "Internal encoder error: %i", iBytes); return false; } WriteStream(m_buffer, iBytes); FlushStream(); FileClose(); return m_impl->Close(); }
bool WriteStream( const std::string &strdata, const std::string &strpath ) { std::ofstream stream; stream.open( strpath.data() ); if ( stream.is_open() ) { WriteStream( stream, strdata ); stream.close(); return true; } return false; }
void BaseConnection::EventWrite() { if (state_ != STATE_CONNECTED) { return; } if (outgoing_.empty()) { handler_->GetPoll()->RemoveWrite(this); return; } std::list<OutgoingMessage::sptr> outgoing; outgoing.swap(outgoing_); for (std::list<OutgoingMessage::sptr>::const_iterator i = outgoing.begin(); i != outgoing.end(); ++i) { if (state_ != STATE_CONNECTED) { return; } const OutgoingMessage::sptr& message = *i; const char* response = message->GetSerializedMessage(); try { while (WriteStream(response, message->GetLength()) == 0) { threads::Yield(); } } catch (const sockets::SocketException& e) { GetLogger_().warnStream() << "WriteStream failed with error: " << e.why(); Close(); break; } catch (const std::exception& e) { GetLogger_().warnStream() << "WriteStream failed with error: " << e.what(); Close(); break; } AfterEventWrite_(message); if (!message->IsPersistent()) { Close(); break; } } }
int CEncoder::Encode(int nNumBytesRead, uint8_t* pbtStream) { int iBytes = m_impl->Encode(nNumBytesRead, pbtStream, m_buffer); if (iBytes < 0) { CLog::Log(LOGERROR, "Internal encoder error: %i", iBytes); return 0; } if (WriteStream(m_buffer, iBytes) != iBytes) { CLog::Log(LOGERROR, "Error writing buffer to file"); return 0; } return 1; }
BOOL CCLITerminal::SetupTerminal(CLISESSION *pSession) { /* struct termios new_settings; struct termios stored_settings; // Change Local Echo Option tcgetattr(pSession->sSocket, &stored_settings); new_settings = stored_settings; new_settings.c_lflag &= (~ECHO); new_settings.c_lflag &= (~ICANON); tcsetattr(pSession->sSocket,TCSANOW, &new_settings); */ if (pSession->nType != CLITYPE_SERIAL) WriteStream(pSession, (char *)kludge_telopt, 31); // LocalDoOption(pTerminal, TELOPT_ECHO, FALSE, FALSE); return TRUE; }
DynamicArray<uint8> MeshDatabase::BuildNativeVertexBuffer(const NativeVBLayout& outputLayout) const { // // Write the data into the vertex buffer // auto size = outputLayout._vertexStride * _unifiedVertexCount; auto finalVertexBuffer = std::make_unique<uint8[]>(size); XlSetMemory(finalVertexBuffer.get(), 0, size); for (unsigned elementIndex = 0; elementIndex <_streams.size(); ++elementIndex) { const auto& nativeElement = outputLayout._elements[elementIndex]; const auto& stream = _streams[elementIndex]; WriteStream( stream, PtrAdd(finalVertexBuffer.get(), nativeElement._alignedByteOffset), nativeElement._nativeFormat, outputLayout._vertexStride, size - nativeElement._alignedByteOffset); } return DynamicArray<uint8>(std::move(finalVertexBuffer), size); }