void Initialize(bool StartThread)
	{
		RingbufData = new char[BUFF_SIZE*sizeof(float)];

		WaitForRingbufferSpace = false;

		PaUtil_InitializeRingBuffer(&RingBuf, sizeof(float), BUFF_SIZE, RingbufData);

		Threaded = StartThread;
		Stream = nullptr;

		if (StartThread)
		{
			thread(&PaMixer::Run, this).detach();
		}
#ifdef WIN32
		if (UseWasapi)
		{
			OpenStream(&Stream, GetWasapiDevice(), 44100, (void*) this, Latency, Mix);

			if (!Stream)
			{
				// This was a Wasapi problem. Retry without it.
				Log::Logf("Problem initializing WASAPI. Falling back to default API.");
				UseWasapi = false;
				OpenStream(&Stream, Pa_GetDefaultOutputDevice(), 44100, (void*) this, Latency, Mix);
			}

		}
		else
		{
			OpenStream(&Stream, DefaultDSDevice, 44100, (void*) this, Latency, Mix);
		}
#else
		OpenStream( &Stream, Pa_GetDefaultOutputDevice(), 44100, (void*) this, Latency, Mix );

#endif

		if (Stream)
		{
			Pa_StartStream(Stream);
			std::this_thread::sleep_for(std::chrono::milliseconds(16));
			Latency = Pa_GetStreamInfo(Stream)->outputLatency;
			Log::Logf("AUDIO: Latency after opening stream = %f \n", Latency);
		}

		ConstFactor = 1.0;
	}

static void
print_stream(const char *fname) {
	fprintf(OutputFile, "File %s:", fname);
	if (!OpenStream(fname)) {
		fprintf(OutputFile, " cannot open\n");
		return;
	}

	fprintf(OutputFile, " showing token stream:\nnl_cnt, tk_cnt: tokens");

	lex_token = EOL;
	do {
		if (TOKEN_EQ(lex_token, EOL)) {
			fprintf(OutputFile, "\n%u,%u:",
				lex_nl_cnt, lex_tk_cnt
			);
		}
		else {
			print_token(OutputFile, lex_token);
		}
	} while (NextStreamTokenObtained());

	fprintf(OutputFile, "\n");

	CloseStream();

}

HRESULT MuPDFDoc::InitDocument(unsigned char *buffer, int bufferLen, const char *mimeType)
{
	fz_stream *stream = OpenStream(buffer, bufferLen);
	if (!stream)
	{
		return E_OUTOFMEMORY;
	}
	else
	{
		fz_try(m_context)
		{
			m_document = fz_open_document_with_stream(m_context, mimeType, stream);
			m_outline = fz_load_outline(m_document);
			//AlertsInit();
		}
		fz_always(m_context)
		{
			fz_close(stream);
		}
		fz_catch(m_context)
		{
			return E_INVALIDARG;
		}
		return S_OK;
	}
}

bool CVideoPlayerAudio::OpenStream(CDVDStreamInfo &hints)
{
  m_processInfo.ResetAudioCodecInfo();

  CLog::Log(LOGNOTICE, "Finding audio codec for: %i", hints.codec);
  bool allowpassthrough = !CSettings::GetInstance().GetBool(CSettings::SETTING_VIDEOPLAYER_USEDISPLAYASCLOCK);
  if (hints.realtime)
    allowpassthrough = false;
  CDVDAudioCodec* codec = CDVDFactoryCodec::CreateAudioCodec(hints, m_processInfo, allowpassthrough, m_processInfo.AllowDTSHDDecode());
  if(!codec)
  {
    CLog::Log(LOGERROR, "Unsupported audio codec");
    return false;
  }

  if(m_messageQueue.IsInited())
    m_messageQueue.Put(new CDVDMsgAudioCodecChange(hints, codec), 0);
  else
  {
    OpenStream(hints, codec);
    m_messageQueue.Init();
    CLog::Log(LOGNOTICE, "Creating audio thread");
    Create();
  }
  return true;
}

int JackPortAudioDriver::SetBufferSize(jack_nframes_t buffer_size)
{
    PaError err;

    if (fStream && (err = Pa_CloseStream(fStream)) != paNoError) {
        jack_error("Pa_CloseStream error = %s", Pa_GetErrorText(err));
        goto error;
    }

    // It seems that some ASIO drivers (like ASIO4All) needs this to restart correctly;
    delete fPaDevices;
    fPaDevices = new PortAudioDevices();

    err = OpenStream(buffer_size);
    if (err != paNoError) {
        jack_error("Pa_OpenStream error = %s", Pa_GetErrorText(err));
        goto error;
    } else {
        JackAudioDriver::SetBufferSize(buffer_size); // Generic change, never fails
        return 0;
    }

error:
    fStream = NULL;
    return -1;
}

bool OMXPlayerAudio::OpenStream(CDVDStreamInfo hints)
{
  m_bad_state = false;

  m_processInfo.ResetAudioCodecInfo();
  COMXAudioCodecOMX *codec = new COMXAudioCodecOMX(m_processInfo);

  if(!codec || !codec->Open(hints))
  {
    CLog::Log(LOGERROR, "Unsupported audio codec");
    delete codec; codec = NULL;
    return false;
  }

  if(m_messageQueue.IsInited())
    m_messageQueue.Put(new COMXMsgAudioCodecChange(hints, codec), 0);
  else
  {
    OpenStream(hints, codec);
    m_messageQueue.Init();
    CLog::Log(LOGNOTICE, "Creating audio thread");
    Create();
  }

  return true;
}

long LogClient::LogFile_ForThread::BufToFile(void)
{
	if (0 == _str_buf.size())
	{
		return 1;
	}
	if(!_ofstream.is_open())
	{
		if(!OpenStream())
		{
			if(1024 * 1024 <  _str_buf.size())
			{
				_str_buf.clear();
				PutLogInfo("本地日志文件不能写入，超过缓冲数量，进行清除");
			}
			return 1;
		}
	}
	string tmp;
	EnterCriticalSection(&_critical_section);
	tmp = _str_buf;
	_str_buf.clear();
	_buf_is_null = true;
	LeaveCriticalSection(&_critical_section);

	_ofstream<<tmp;
	return 0;
}

PageCond plRegistryPageNode::IVerify()
{
    // Check the checksum values first, to make sure the files aren't corrupt
    uint32_t ourChecksum = 0;
    hsStream* stream = OpenStream();
    if (stream)
    {
        ourChecksum = stream->GetEOF() - fPageInfo.GetDataStart();
        CloseStream();
    }
    if (ourChecksum != fPageInfo.GetChecksum())
        return kPageCorrupt;

    // If major version out-of-date, entire location is screwed
    if (fPageInfo.GetMajorVersion() > plVersion::GetMajorVersion())
        return kPageTooNew;
    else if (fPageInfo.GetMajorVersion() < plVersion::GetMajorVersion())
        return kPageOutOfDate;

    // Check the minor versions
    const plPageInfo::ClassVerVec& classVersions = fPageInfo.GetClassVersions();
    for (int i = 0; i < classVersions.size(); i++)
    {
        const plPageInfo::ClassVersion& cv = classVersions[i];
        uint16_t curVersion = plVersion::GetCreatableVersion(cv.Class);

        if (curVersion > cv.Version)
            return kPageOutOfDate;
        else if (curVersion < cv.Version)
            return kPageTooNew;
    }

    return kPageOk;
}

STDMETHODIMP CFolderInStream::Read(void *data, UInt32 size, UInt32 *processedSize)
{
  UInt32 realProcessedSize = 0;
  while ((_fileIndex < _numFiles || _fileIsOpen) && size > 0)
  {
    if (_fileIsOpen)
    {
      UInt32 localProcessedSize;
      RINOK(_inStreamWithHash->Read(
          ((Byte *)data) + realProcessedSize, size, &localProcessedSize));
      if (localProcessedSize == 0)
      {
        RINOK(CloseStream());
        continue;
      }
      realProcessedSize += localProcessedSize;
      _filePos += localProcessedSize;
      size -= localProcessedSize;
      break;
    }
    else
    {
      RINOK(OpenStream());
    }
  }
  if (processedSize != 0)
    *processedSize = realProcessedSize;
  return S_OK;
}

STDMETHODIMP CFolderInStream::Read(void *data, UInt32 size, UInt32 *processedSize)
{
  UInt32 realProcessedSize = 0;
  while ((_curIndex < _refItem.NumItems || _fileIsOpen) && size > 0)
  {
    if (_fileIsOpen)
    {
      UInt32 localProcessedSize;
      RINOK(_stream->Read(
          ((Byte *)data) + realProcessedSize, size, &localProcessedSize));
      _crc = CrcUpdate(_crc, ((Byte *)data) + realProcessedSize, localProcessedSize);
      if (localProcessedSize == 0)
      {
        RINOK(CloseStream());
        continue;
      }
      realProcessedSize += localProcessedSize;
      size -= localProcessedSize;
      break;
    }
    else
    {
      RINOK(OpenStream());
    }
  }
  if (processedSize != 0)
    *processedSize = realProcessedSize;
  return S_OK;
}

HRESULT CClientSession::DoPutFile( const string& strSrcFile, const string& strDstFile )
{
	if( !IsFileExist( strSrcFile.c_str() ) ){
		return E_NOENT;
	}

	//step 1. request passive mode to get the data channel address
	u_int nPasPort = 0;
	HRESULT hRet = DoPassive( nPasPort );
	if( FAILED(hRet) )return hRet;

	//step 2. send the put file command.
	CMessage1Param<char*>* pMsgPut = (CMessage1Param<char*>*)CMessageBase::Alloc( sizeof(CMessageBase)+strDstFile.length()+1 );
	pMsgPut->Init( NCM_PUTFILE, GetAddr(), GetServAddr(), strDstFile.c_str() );
	CMessageTrash trash1(pMsgPut);
	m_pClntProxy->SendMessage( pMsgPut );

	CMessage1Param<int>* pMsgAck = (CMessage1Param<int>*)WaitForMessage( NCF_ACK|NCM_PUTFILE );
	CMessageTrash trash2(pMsgAck);
	if( !pMsgAck->IsSucceeded() )return pMsgAck->GetResult();

	pMsgAck->ntoh( false );
	int nFileMode = pMsgAck->GetParam();

	//step 3. now the server agrees on the file transfer, connect the data channel and send file
	SOCKET sock_stream = OpenStream( nPasPort );
	if( sock_stream==INVALID_SOCKET )return E_OPENSTREAM;

	//open the data stream channel.
/*	CMessageBase msg;
	msg.Init( NCM_OPENSTREAM, GetAddr(), GetServAddr() );
	SendMessage( sock_stream, &msg );
	CMessageBase* pMsg = RecvMessage<CMessageBase>( sock_stream );
	if( pMsg==NULL ){
		closesocket( sock_stream );
		return E_OPENSTREAM;
	}

	CMessageTrash trash3(pMsg);
	if( pMsg->IsFailed() ){
		closesocket( sock_stream );
		return pMsg->GetResult();
	}*/

	//send the file stream
	int nLen = SendFileEx( sock_stream, strSrcFile.c_str(), nFileMode );
	shutdown( sock_stream, SD_BOTH );
	closesocket( sock_stream );

	//step 4. exchange the error code.
	CMessageBase msg;
	msg.Init( NCM_STREAMLENGTH, GetAddr(), GetServAddr(), nLen );
	m_pClntProxy->SendMessage( &msg );

	CMessageBase* pMsg = WaitForMessage( NCF_ACK|NCM_STREAMLENGTH );
	CMessageTrash trash4(pMsg);

	return pMsg->GetResult();
}

DWORD MP3decoder::GetTotalTime(char * pcfilename)			// 1/1000 sec
{
	int ntmp = 0;

	if(!OpenStream(pcfilename, &ntmp, &ntmp, &ntmp, NULL, &ntmp))
		return 0;
	CloseStream();
	return m_length;
}

XnStatus PlayerNode::SetInputStream(void *pStreamCookie, XnPlayerInputStreamInterface *pStream)
{
	XN_VALIDATE_INPUT_PTR(pStream);
	m_pStreamCookie = pStreamCookie;
	m_pInputStream = pStream;
	XnStatus nRetVal = OpenStream();
	XN_IS_STATUS_OK(nRetVal);
	return XN_STATUS_OK;
}

attachment::attachment(message& mapi_message, const uint32_t attach_num) throw(mapi_exception)
: object(mapi_message.get_session(), "attachment"), m_attach_num(attach_num), m_bin_data(NULL), m_data_size(0), m_filename("")
{
	if (OpenAttach(&mapi_message.data(), attach_num, &m_object) != MAPI_E_SUCCESS)
		throw mapi_exception(GetLastError(), "attachment::attachment : OpenAttach");

	property_container properties = get_property_container();
	properties << PR_ATTACH_FILENAME << PR_ATTACH_LONG_FILENAME << PR_ATTACH_SIZE << PR_ATTACH_DATA_BIN << PR_ATTACH_METHOD;
	properties.fetch();

	const char* filename = static_cast<const char*>(properties[PR_ATTACH_LONG_FILENAME]);
	if (!filename) {
		filename = static_cast<const char*>(properties[PR_ATTACH_FILENAME]);
	}

	if (filename)
		m_filename = filename;

	m_data_size = *(static_cast<const uint32_t*>(properties[PR_ATTACH_SIZE]));

	const Binary_r* attachment_data = static_cast<const Binary_r*>(properties[PR_ATTACH_DATA_BIN]);

	// Don't load PR_ATTACH_DATA_BIN if it's embedded in message.
	// NOTE: Use RopOpenEmbeddedMessage when it is implemented.
	const uint32_t attach_method = *static_cast<const uint32_t*>(properties[PR_ATTACH_METHOD]);
	if (attach_method != ATTACH_BY_VALUE)
		return;

	// Get Binary Data.
	if (attachment_data) {
		m_data_size = attachment_data->cb;
		m_bin_data = new uint8_t[m_data_size];
		memcpy(m_bin_data, attachment_data->lpb, attachment_data->cb);
	} else {
		mapi_object_t obj_stream;
		mapi_object_init(&obj_stream);
		if (OpenStream(&m_object, (enum MAPITAGS)PidTagAttachDataBinary, OpenStream_ReadOnly, &obj_stream) != MAPI_E_SUCCESS)
			throw mapi_exception(GetLastError(), "attachment::attachment : OpenStream");

		if (GetStreamSize(&obj_stream, &m_data_size) != MAPI_E_SUCCESS)
			throw mapi_exception(GetLastError(), "attachment::attachment : GetStreamSize");

		m_bin_data = new uint8_t[m_data_size];

		uint32_t pos = 0;
		uint16_t bytes_read = 0;
		do {
			if (ReadStream(&obj_stream, m_bin_data+pos, 1024, &bytes_read) != MAPI_E_SUCCESS)
				throw mapi_exception(GetLastError(), "attachment::attachment : ReadStream");

			pos += bytes_read;

		} while (bytes_read && pos < m_data_size);

		mapi_object_release(&obj_stream);
	}
}

//==============================
// ovrFileSysLocal::FileExists
bool ovrFileSysLocal::FileExists( char const * uri )
{
	ovrStream * stream = OpenStream( uri, OVR_STREAM_MODE_READ );
	if ( stream == NULL )
	{
		return false;
	}
	CloseStream( stream );
	return true;
}

bool CRTSPClient::Play(double fStart,double fDuration)
{
  LogDebug("CRTSPClient::Play from %f / %f", (float)fStart,(float)fDuration);
  m_bPaused=false;
  m_fStart=fStart;
  m_fDuration=fDuration;
  if (m_BufferThreadActive)
  {
    Stop();
    m_buffer.Clear();
    if (Initialize()==false) 
    {
      shutdown();
      return false;
    }
    if (OpenStream(m_url)==false) 
    {
      shutdown();
      return false;
    }
  }
  if (m_ourClient==NULL||m_session==NULL)
  {
    m_buffer.Clear();
    if (Initialize()==false) 
    {
      shutdown();
      return false;
    }
    if (OpenStream(m_url)==false) 
    {
      shutdown();
      return false;
    }
  }
  if (!startPlayingStreams()) 
  {			
    shutdown();
    return false;
  }
  StartBufferThread();
  return true;
}

void cSoundStream::BindFile(const std::string &path, ALenum format)
{
    if(!IsValid())
        return;

    m_Format = format;

    DeleteChunks();

    if(OpenStream(path))
        CreateChunks();
};

_CGUL_EXPORT CGUL::PortAudio::SineWave::SineWave(Device device) : Stream()
{
    for (unsigned int i = 0; i < 200; i++)
    {
        sine[i] = (float)CGUL::Math::Sin(((double)i/200.0)*CGUL::Math::pi * 2.0);
    }
    position = 0;

    framesPerBuffer = 64;

    OpenStream(device);
}

bool OMXPlayerVideo::OpenStream(CDVDStreamInfo &hints)
{
  /*
  if(IsRunning())
    CloseStream(false);
  */

  m_hints       = hints;
  m_Deinterlace = ( CMediaSettings::Get().GetCurrentVideoSettings().m_DeinterlaceMode == VS_DEINTERLACEMODE_OFF ) ? false : true;
  m_hdmi_clock_sync = (g_guiSettings.GetInt("videoplayer.adjustrefreshrate") != ADJUST_REFRESHRATE_OFF);
  m_started     = false;
  m_flush       = false;
  m_stalled     = m_messageQueue.GetPacketCount(CDVDMsg::DEMUXER_PACKET) == 0;
  m_autosync    = 1;
  m_iSleepEndTime = DVD_NOPTS_VALUE;
  // force SetVideoRect to be called initially
  m_dst_rect.SetRect(0, 0, 0, 0);

  m_audio_count = m_av_clock->HasAudio();

  if (!m_DllBcmHost.Load())
    return false;

  if(!OpenDecoder())
  {
    return false;
  }

  if(m_messageQueue.IsInited())
    m_messageQueue.Put(new COMXMsgVideoCodecChange(hints, NULL), 0);
  else
  {
    if(!OpenStream(hints, NULL))
      return false;
    CLog::Log(LOGNOTICE, "Creating video thread");
    m_messageQueue.Init();
    Create();
  }

  /*
  if(!OpenStream(hints, NULL))
    return false;

  CLog::Log(LOGNOTICE, "Creating video thread");
  m_messageQueue.Init();
  Create();
  */

  m_open        = true;
  m_send_eos    = false;

  return true;
}

bool CVideoPlayerVideo::OpenStream(CDVDStreamInfo hint)
{
  if (hint.flags & AV_DISPOSITION_ATTACHED_PIC)
    return false;
  if (hint.extrasize == 0)
  {
    // codecs which require extradata
    if (hint.codec == AV_CODEC_ID_NONE ||
        hint.codec == AV_CODEC_ID_MPEG1VIDEO ||
        hint.codec == AV_CODEC_ID_MPEG2VIDEO ||
        hint.codec == AV_CODEC_ID_H264 ||
        hint.codec == AV_CODEC_ID_HEVC ||
        hint.codec == AV_CODEC_ID_MPEG4 ||
        hint.codec == AV_CODEC_ID_WMV3 ||
        hint.codec == AV_CODEC_ID_VC1)
      return false;
  }

  CLog::Log(LOGNOTICE, "Creating video codec with codec id: %i", hint.codec);

  if (m_messageQueue.IsInited())
  {
    if (m_pVideoCodec && !m_processInfo.IsVideoHwDecoder())
    {
      hint.codecOptions |= CODEC_ALLOW_FALLBACK;
    }
    CDVDVideoCodec* codec = CDVDFactoryCodec::CreateVideoCodec(hint, m_processInfo);
    if (!codec)
    {
      CLog::Log(LOGINFO, "CVideoPlayerVideo::OpenStream - could not open video codec");
    }
    SendMessage(new CDVDMsgVideoCodecChange(hint, codec), 0);
  }
  else
  {
    m_processInfo.ResetVideoCodecInfo();
    hint.codecOptions |= CODEC_ALLOW_FALLBACK;
    CDVDVideoCodec* codec = CDVDFactoryCodec::CreateVideoCodec(hint, m_processInfo);
    if (!codec)
    {
      CLog::Log(LOGERROR, "CVideoPlayerVideo::OpenStream - could not open video codec");
      return false;
    }
    OpenStream(hint, codec);
    CLog::Log(LOGNOTICE, "Creating video thread");
    m_messageQueue.Init();
    m_processInfo.SetLevelVQ(0);
    Create();
  }
  return true;
}