// Write sample data into the supplied PCM sample buffers
void CWinGlkOGGSound::WriteSampleData(unsigned char* pSample, int iSampleLen)
{
  int iStream, iCurrent = 0;
  while (iCurrent < iSampleLen)
  {
    long lRead =
      ov_read(&m_Stream,(char*)(pSample+iCurrent),(iSampleLen-iCurrent),0,2,1,&iStream);
    if (lRead > 0)
      iCurrent += lRead;
    else
    {
      if (m_iRepeat > 0)
      {
        ov_pcm_seek(&m_Stream,0);
        m_iRepeat--;
      }
      else if (m_iRepeat == -1)
        ov_pcm_seek(&m_Stream,0);
      else
      {
        while (iCurrent < iSampleLen)
          pSample[iCurrent++] = 0;
      }
    }
  }
}

 unsigned long OggDecoder::Render( unsigned long size, void *buf )
 {
     OggDecoderData *data = OGGDATA(this);
     
     if (!data){
         outOfData = true;
         return 0;
     }
     
     int ret = 1;
     unsigned long pos=0;
     
     if (seekOffset != -1)
     {
         long seek = (long)(((float)seekOffset/1000.0f) * (float)samplerate);
         ov_pcm_seek(&data->vf, seek);
         seekOffset = -1;
         outOfData = false;
     }
     
     while(ret && pos<size)
     {
         ret = ov_read(&data->vf, (char*)buf+pos, size-pos, 0, 2, 1, &data->sec);
         pos += ret;
     }
     
     // reached the end?
     if (!ret && (loopsRemaining!=0))
     {
         // we are looping so restart from the beginning
         ret = 1;
         ov_pcm_seek(&data->vf, 0);  // Loop back position, TODO: If we want to loop to a specific point, here is the code for that!
         while(ret && pos<size)
         {
             ret = ov_read(&data->vf, (char*)buf+pos, size-pos, 0, 2, 1, &data->sec);
             pos += ret;
         }
         
         // Decrease from Loops Remaining (don't touch the -1 infinite loop stuff)
         if (loopsRemaining > 0)
             loopsRemaining--;
     }
     else if (!ret && (loopsRemaining==0)){
         outOfData = true;
     }
     
     return pos;
 }

void
SoundD3D::RewindOggStream()
{
	if (!ov_file || !buffer)
	return;

	// rewind the stream and keep going...
	eos_written = false;
	eos_latch   = 0;
	read_size   = wfex.nAvgBytesPerSec / 2;

	// set the stream pointer back to the beginning:
	ov_pcm_seek(ov_file, 0);

	// find the size of the file:
	stream_left    = (DWORD) ov_pcm_total(ov_file,-1);
	stream_offset  = 0;

	total_time     = (double) stream_left /
	(double) wfex.nAvgBytesPerSec;

	if (stream_left < read_size) {
		status = DONE;
		buffer->Stop();
	}
}

    int OggStream::decodeNextBlock(bool looped, void* data, int bufferSize)
    {
        unsigned int bytesUnpacked = 0;

        int p = (int)ov_pcm_tell(&_vorbisFile);

        while (1)
        {
            int r = (int)ov_read(&_vorbisFile, (char*)data, bufferSize, &_section);
            if (!r)
            {
                if (looped)
                {
                    ov_pcm_seek(&_vorbisFile, 0);

                }
                else
                {
                    _streamEnded = true;
                    break;
                }
            }

            data = (char*)data + r;
            bufferSize -= r;

            bytesUnpacked += r;
            if (bufferSize == 0)
                break;
        }

        p = int(ov_pcm_tell(&_vorbisFile)) - p;

        return bytesUnpacked;
    }

	bool SPOggFile::NextStreamData( BYTE* pData, DWORD length, DWORD &readBytes, bool &eof )
	{
		if (!isLoaded)
		{
			return false;
		}

		DWORD pos = 0;
		int sec = 0;
		int ret = 1;

		while(ret && pos < length)
		{
			ret = ov_read(&vf, (char*)pData + pos, length - pos, 0, 2, 1, &sec);
			pos += ret;
		}

		readBytes = pos;

		if (!ret)
		{
			eof = true;
			ov_pcm_seek(&vf, 0);
		}
		else
		{
			eof = false;
		}

		return true;
	}

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;
}

	void OGG_Source::rewind()
	{
		if (this->streamOpen)
		{
			ov_pcm_seek(&this->oggStream, 0);
		}
	}

	bool OGG_Source::open()
	{
		Source::open();
		if (!this->streamOpen)
		{
			return false;
		}
		// setting the special callbacks
		ov_callbacks callbacks;
		callbacks.read_func = &_dataRead;
		callbacks.seek_func = &_dataSeek;
		callbacks.close_func = &_dataClose; // may not be NULL because it may crash on Android otherwise
		callbacks.tell_func = &_dataTell;
		if (ov_open_callbacks((void*)this->stream, &this->oggStream, NULL, 0, callbacks) == 0)
		{
			vorbis_info* info = ov_info(&this->oggStream, -1);
			this->channels = (int)info->channels;
			this->samplingRate = (int)info->rate;
			this->bitsPerSample = 16; // always 16 bit data
			int logicalSamples = (int)ov_pcm_total(&this->oggStream, -1);
			this->size = logicalSamples * this->channels * this->bitsPerSample / 8;
			this->duration = (float)logicalSamples / this->samplingRate;
			ov_pcm_seek(&this->oggStream, 0); // make sure the PCM stream is at the beginning to avoid nasty surprises
		}
		else
		{
			hlog::error(logTag, "OGG: error reading data!");
			this->close();
		}
		return this->streamOpen;
	}

bool C4MusicFileOgg::Play(bool loop)
{
	// Valid file?
	if (!loaded) return false;
	// stop previous
	Stop();
	// Get channel to use
	alGenSources(1, (ALuint*)&channel);
	if (!channel) return false;

	playing = true;
	streaming_done = false;
	this->loop = loop;
	byte_pos_total = 0;

	// initial volume setting
	SetVolume(float(::Config.Sound.MusicVolume) / 100.0f);

	// prepare read
	ogg_info.sound_data.resize(num_buffers * buffer_size);
	alGenBuffers(num_buffers, buffers);
	ov_pcm_seek(&ogg_file, 0);

	// Fill initial buffers
	for (size_t i=0; i<num_buffers; ++i)
		if (!FillBuffer(i)) break; // if this fails, the piece is shorter than the initial buffers

	// play!
	alErrorCheck(alSourcePlay(channel));
	
	return true;
}

long SoundSourceOggVorbis::seek(long filepos)
{
    // In our speak, filepos is a sample in the file abstraction (i.e. it's
    // stereo no matter what). filepos/2 is the frame we want to seek to.
    if (filepos % 2 != 0) {
        qDebug() << "SoundSourceOggVorbis got non-even seek target.";
        filepos--;
    }

    if (ov_seekable(&vf)) {
        if (ov_pcm_seek(&vf, filepos/2) != 0) {
            // This is totally common (i.e. you're at EOF). Let's not leave this
            // qDebug on.

            // qDebug() << "ogg vorbis: Seek ERR on seekable.";
        }

        // Even if an error occured, return them the current position because
        // that's what we promised. (Double it because ov_pcm_tell returns
        // frames and we pretend to the world that everything is stereo)
        return ov_pcm_tell(&vf) * 2;
    } else {
        qDebug() << "ogg vorbis: Seek ERR at file " << getFilename();
        return 0;
    }
}

	//-------------------------------------------------------------------------------------------------------
	//
	std::shared_ptr<char> ogg_reader::read(size_t bufferSize, uint64_t *readBytes) {
		char* buffer = new char[bufferSize];
		int requestSize(bufferSize);
		int bitStream(0);
		long readSize(0);
		uint32_t comSize(0);
		while (true) {
			readSize = ov_read(&vorbisFile_, buffer + comSize, requestSize, 0, 2, 1, &bitStream);
			// 曲が終わってた
			if (!readSize) {
				ov_pcm_seek(&vorbisFile_, 0);
				break;
			}

			// 書き込んだサイズを加える
			comSize += readSize;
			
			// 波形データ配列の次の書き込み位置がバッファサイズを超えてたらループを抜ける
			if (comSize >= bufferSize) {
				break;
			}
			// バッファを全部書き込んでなかったら次の書き込み要求サイズをバッファサイズから書き込んだサイズを引いたものにする
			if (bufferSize - comSize < 4096) {
				requestSize = bufferSize - comSize;
			}
		}
		*readBytes = comSize;
		//スマートポインタの管理下に置く
		return std::shared_ptr<char>(
			buffer, std::default_delete<char[]>());
	}

static int
cvorbis_seek_sample (DB_fileinfo_t *_info, int sample) {
    ogg_info_t *info = (ogg_info_t *)_info;
    if (sample < 0) {
        trace ("vorbis: negative seek sample - ignored, but it is a bug!\n");
        return -1;
    }
    if (!info->info.file) {
        trace ("vorbis: file is NULL on seek\n");
        return -1;
    }
    if (sample == 0) {
        deadbeef->pl_lock ();
        const char *filetype = deadbeef->pl_find_meta_raw(info->it, ":FILETYPE");
        if (filetype && strncmp(filetype, "Ogg Vorbis", 10)) {
            sample = 1; // workaround libvorbis bug #1486 (ddb issue #1116)
        }
        deadbeef->pl_unlock ();
    }
    sample += info->it->startsample;
    trace ("vorbis: seek to sample %d\n", sample);
    int res = ov_pcm_seek (&info->vorbis_file, sample);
    if (res != 0 && res != OV_ENOSEEK) {
        trace ("vorbis: error %x seeking to sample %d\n", res, sample);
        return -1;
    }
    int tell = ov_pcm_tell (&info->vorbis_file);
    if (tell != sample) {
        trace ("vorbis: failed to do sample-accurate seek (%d->%d)\n", sample, tell);
    }
    trace ("vorbis: seek successful\n")
    _info->readpos = (float)(sample - info->it->startsample)/_info->fmt.samplerate;
    info->next_update = -2;
    return 0;
}

void OggAudioSource::setDecoderPosition(Int64 startFrame)
{
	RScopedLock l(&mDecodeLock);

	ov_pcm_seek(&mOggFile, startFrame * getNumChannels());
	if(startFrame < getLength() * getSampleRate())
		mEOF = false;
}

void SeekVorbisStream(MFAudioStream *pStream, float seconds)
{
	MFVorbisStream *pVS = (MFVorbisStream*)pStream->pStreamData;
#if defined(VORBIS_TREMOR)
	ov_pcm_seek(&pVS->vorbisFile, (ogg_int64_t)(seconds*(float)pVS->pInfo->rate));
#else
	ov_time_seek(&pVS->vorbisFile, seconds);
#endif
}

        void OggFileStream::init(const ALuint& source,
                                 const int& position_in_file,
                                 const int& position_in_buffer,
                                 const bool& is_event)
        {
          // create buffers for reading in flip mode
          alGenBuffers(2,m_buffers) ;
          
          InternalMessage("Sound", "enter oggreader Init") ;

          // Create Ogg Stream on the file
          m_stream = new OggVorbis_File() ;
          int error = ov_fopen((char*)m_file_name.c_str(),m_stream) ;
          if (error < 0)
          {
            ErrorMessage("[OpenAL::OggReader] Can't read the samples") ;
            return ;
          }

          // Get sound information
          vorbis_info* Infos = ov_info(m_stream,-1) ;

          m_sample_rate = Infos->rate ;
          m_samples_by_buffer = (ALsizei)(Infos->channels * Infos->rate * m_update_time) ;
          switch (Infos->channels)
          {
          case 1:
            m_format = AL_FORMAT_MONO16 ;
            break;
          case 2:
            m_format = AL_FORMAT_STEREO16 ;
            break;
          default:
            ErrorMessage("[OpenAL::OggReader] Audio Format audio not supported (more than 2 channel)") ;
            return ;
          }

          int pos = 0 ;
          if (position_in_file > 0)
          {
            pos = position_in_file-m_samples_by_buffer+position_in_buffer+1 ;
          }
          ov_pcm_seek(m_stream,pos) ;

          // Load the buffers
          loadBuffer(m_buffers[0],is_event) ;
          loadBuffer(m_buffers[1],is_event) ;
          alSourceQueueBuffers(source,2,m_buffers) ;
          if (alGetError() != AL_NO_ERROR)
          {
            InformationMessage("Sound",
                "[OpenAL::OggReader] Impossible to queue the buffers") ;
            return ;
          }

          InternalMessage("Sound", "leave oggreader Init") ;
        }

long long int
StreamOGGSoundBuffer::filler(ALBuffer& buf, size_t size, bool repeat)
{
	const int endianness(0);  // 0 LittleEndian, 1 BigEndian. Usually 0
	const int sign(1);        // Signed(1) or unsigned(0) data. Usually 1.
	const short BPS(16);	  // Bits per sample. We default to 16
	int chunk(size < OGG_BUFF_SIZE ? ((int)size) : OGG_BUFF_SIZE);
	char* array = new char[chunk]();
	long read(0);
	int err(0);
	ALenum alErr(AL_NO_ERROR);
	SSerror error(SSerror::SS_NO_ERROR);

	/* Try to read 'size' bytes into pcmData field. */
	pcmData.clear();
	do {
		/* Read from Ogg file into temporal array */
		read = ov_read(oggFile, array, chunk, endianness, BPS/8, sign, &bitStreamSection);

		if (read > 0) {
			/* Store fetched audio data */
			pcmData.insert(pcmData.end(), array, &array[read]);
			size -= read;
			chunk = size < OGG_BUFF_SIZE ? ((int)size) : OGG_BUFF_SIZE;

		} else if (read == 0 && repeat) {
			/* End of audio data, must repeat. */
			read = ov_pcm_seek(oggFile, 0);
			bitStreamSection = 0;
			ASSERT(read==0);
			read = 1;  // continue iteration
		}

	} while (read > 0 && chunk > 0);

	if (read < 0) {
		/* Error fetching audio data from Ogg file */
		std::map<int, const char*> strErr = {{OV_HOLE, "OV_HOLE"},
											{OV_EBADLINK, "OV_EBADLINK"},
											{OV_EINVAL, "OV_EINVAL"}};
		debug("Can't read OGG file. Error: %s\n", strErr[read]);
		delete[] array;
		return -1ll;

	} else {
		/* Fill OpenAL buffer with fetched audio data */
		alBufferData(buf, format, &pcmData[0], pcmData.size(), freq);
	}

	delete[] array;
	if (alGetError() != AL_NO_ERROR) {
		return -1ll;
	}

	return ((long long int)pcmData.size());
}

gc_int32 gauX_sample_source_ogg_seek(void* in_context, gc_int32 in_sampleOffset)
{
  gau_SampleSourceOggContext* ctx = &((gau_SampleSourceOgg*)in_context)->context;
  gc_int32 ret;
  gc_mutex_lock(ctx->oggMutex);
  ret = ov_pcm_seek(&ctx->oggFile, in_sampleOffset);
  ctx->endOfSamples = 0;
  gc_mutex_unlock(ctx->oggMutex);
  return ret;
}

// QC:U
size_t VorbisPCMSource::seek(size_t position, int whence) {
	assert(canSeek);
	xerror(whence == SEEK_SET, "VorbisPCMSource::seek : whence parameter not supported.");
	if(!ov_pcm_seek(&of, position)) {
		eofReached = false;
		return position;
	}

	xerror(false, "VorbisPCMSource::seek : Could not seek at position %d in %s.", position, f->name());
	return 0;
}

	bool VorbisDecoder::rewind()
	{
		int result = ov_pcm_seek(&handle, 0);

		if(result == 0)
		{
			eof = false;
			return true;
		}

		return false;
	}

bool VorbisStream::seek(const Timestamp &where) {
	// Vorbisfile uses the sample pair number, thus we always use "false" for the isStereo parameter
	// of the convertTimeToStreamPos helper.
	int res = ov_pcm_seek(&_ovFile, convertTimeToStreamPos(where, getRate(), false).totalNumberOfFrames());
	if (res) {
		warning("Error seeking in Vorbis stream (%d)", res);
		_pos = _bufferEnd;
		return false;
	}

	return refill();
}