winamp/Src/external_dependencies/openmpt-trunk/include/unrar/rawread.cpp
2024-09-24 14:54:57 +02:00

198 lines
3.9 KiB
C++
Vendored

#include "rar.hpp"
RawRead::RawRead()
{
RawRead::SrcFile=NULL;
Reset();
}
RawRead::RawRead(File *SrcFile)
{
RawRead::SrcFile=SrcFile;
Reset();
}
void RawRead::Reset()
{
Data.SoftReset();
ReadPos=0;
DataSize=0;
Crypt=NULL;
}
size_t RawRead::Read(size_t Size)
{
size_t ReadSize=0;
#if !defined(RAR_NOCRYPT)
if (Crypt!=NULL)
{
// Full size of buffer with already read data including data read
// for encryption block alignment.
size_t FullSize=Data.Size();
// Data read for alignment and not processed yet.
size_t DataLeft=FullSize-DataSize;
if (Size>DataLeft) // Need to read more than we already have.
{
size_t SizeToRead=Size-DataLeft;
size_t AlignedReadSize=SizeToRead+((~SizeToRead+1) & CRYPT_BLOCK_MASK);
Data.Add(AlignedReadSize);
ReadSize=SrcFile->Read(&Data[FullSize],AlignedReadSize);
Crypt->DecryptBlock(&Data[FullSize],AlignedReadSize);
DataSize+=ReadSize==0 ? 0:Size;
}
else // Use buffered data, no real read.
{
ReadSize=Size;
DataSize+=Size;
}
}
else
#endif
if (Size!=0)
{
Data.Add(Size);
ReadSize=SrcFile->Read(&Data[DataSize],Size);
DataSize+=ReadSize;
}
return ReadSize;
}
void RawRead::Read(byte *SrcData,size_t Size)
{
if (Size!=0)
{
Data.Add(Size);
memcpy(&Data[DataSize],SrcData,Size);
DataSize+=Size;
}
}
byte RawRead::Get1()
{
return ReadPos<DataSize ? Data[ReadPos++]:0;
}
ushort RawRead::Get2()
{
if (ReadPos+1<DataSize)
{
ushort Result=Data[ReadPos]+(Data[ReadPos+1]<<8);
ReadPos+=2;
return Result;
}
return 0;
}
uint RawRead::Get4()
{
if (ReadPos+3<DataSize)
{
uint Result=Data[ReadPos]+(Data[ReadPos+1]<<8)+(Data[ReadPos+2]<<16)+
(Data[ReadPos+3]<<24);
ReadPos+=4;
return Result;
}
return 0;
}
uint64 RawRead::Get8()
{
uint Low=Get4(),High=Get4();
return INT32TO64(High,Low);
}
uint64 RawRead::GetV()
{
uint64 Result=0;
// Need to check Shift<64, because for shift greater than or equal to
// the width of the promoted left operand, the behavior is undefined.
for (uint Shift=0;ReadPos<DataSize && Shift<64;Shift+=7)
{
byte CurByte=Data[ReadPos++];
Result+=uint64(CurByte & 0x7f)<<Shift;
if ((CurByte & 0x80)==0)
return Result; // Decoded successfully.
}
return 0; // Out of buffer border.
}
// Return a number of bytes in current variable length integer.
uint RawRead::GetVSize(size_t Pos)
{
for (size_t CurPos=Pos;CurPos<DataSize;CurPos++)
if ((Data[CurPos] & 0x80)==0)
return int(CurPos-Pos+1);
return 0; // Buffer overflow.
}
size_t RawRead::GetB(void *Field,size_t Size)
{
byte *F=(byte *)Field;
size_t CopySize=Min(DataSize-ReadPos,Size);
if (CopySize>0)
memcpy(F,&Data[ReadPos],CopySize);
if (Size>CopySize)
memset(F+CopySize,0,Size-CopySize);
ReadPos+=CopySize;
return CopySize;
}
void RawRead::GetW(wchar *Field,size_t Size)
{
if (ReadPos+2*Size-1<DataSize)
{
RawToWide(&Data[ReadPos],Field,Size);
ReadPos+=sizeof(wchar)*Size;
}
else
memset(Field,0,sizeof(wchar)*Size);
}
uint RawRead::GetCRC15(bool ProcessedOnly) // RAR 1.5 block CRC.
{
if (DataSize<=2)
return 0;
uint HeaderCRC=CRC32(0xffffffff,&Data[2],(ProcessedOnly ? ReadPos:DataSize)-2);
return ~HeaderCRC & 0xffff;
}
uint RawRead::GetCRC50() // RAR 5.0 block CRC.
{
if (DataSize<=4)
return 0xffffffff;
return CRC32(0xffffffff,&Data[4],DataSize-4) ^ 0xffffffff;
}
// Read vint from arbitrary byte array.
uint64 RawGetV(const byte *Data,uint &ReadPos,uint DataSize,bool &Overflow)
{
Overflow=false;
uint64 Result=0;
for (uint Shift=0;ReadPos<DataSize;Shift+=7)
{
byte CurByte=Data[ReadPos++];
Result+=uint64(CurByte & 0x7f)<<Shift;
if ((CurByte & 0x80)==0)
return Result; // Decoded successfully.
}
Overflow=true;
return 0; // Out of buffer border.
}