void ProcessPTA(
BACNET_PRIVATE_TRANSFER_DATA * data)
{
int iLen; /* Index to current location in data */
uint32_t uiErrorCode;
char cBlockNumber;
uint32_t ulTemp;
int tag_len;
uint8_t tag_number;
uint32_t len_value_type;
iLen = 0;
/* Error code is returned for read and write operations */
tag_len =
decode_tag_number_and_value(&data->serviceParameters[iLen],
&tag_number, &len_value_type);
iLen += tag_len;
if (tag_number != BACNET_APPLICATION_TAG_UNSIGNED_INT) {
#if PRINT_ENABLED
printf("CPTA: Bad Encoding!\n");
#endif
return;
}
iLen +=
decode_unsigned(&data->serviceParameters[iLen], len_value_type,
&uiErrorCode);
if (data->serviceNumber == MY_SVC_READ) { /* Read I/O block so should be full block of data or error */
/* Decode the error type and if necessary block number and then fetch the info */
if (uiErrorCode == MY_ERR_OK) {
/* Block Number */
tag_len =
decode_tag_number_and_value(&data->serviceParameters[iLen],
&tag_number, &len_value_type);
iLen += tag_len;
if (tag_number != BACNET_APPLICATION_TAG_UNSIGNED_INT) {
#if PRINT_ENABLED
printf("CPTA: Bad Encoding!\n");
#endif
return;
}
iLen +=
decode_unsigned(&data->serviceParameters[iLen], len_value_type,
&ulTemp);
cBlockNumber = (char) ulTemp;
DecodeBlock(cBlockNumber, &data->serviceParameters[iLen]);
} else { /* Read error */
printf("Private Transfer read operation returned error code: %u\n",
uiErrorCode);
return;
}
} else { /* Write I/O block - should just be an OK type message */
printf("Private Transfer write operation returned error code: %u\n",
uiErrorCode);
}
}
LPMIMEBLOCK CMime::AddBlock(LPMIMEBLOCK node)
{_STT();
if ( node == NULL ) return NULL;
// Count an attachment
if ( ( node->f1 & MBF1_ATTACHMENT ) != 0 )
m_dwAttachments++;
// Is it an extra file?
else if ( *node->fname )
node->f1 |= MBF1_EXTRA, m_dwExtras++;
else if ( *node->ctype )
if ( strnicmp( node->ctype, "multipart/", strlen( "multipart/" ) ) != 0 &&
strnicmp( node->ctype, "text/", strlen( "text/" ) ) != 0 )
node->f1 |= MBF1_EXTRA, m_dwExtras++;
// Decode the data
DecodeBlock( node );
// Add this node to the list
node->pNext = NULL;
node->pPrev = m_pTail;
if ( m_pTail == NULL ) m_pHead = node;
else m_pTail->pNext = node;
m_pTail = node;
m_dwSize++;
return node;
}
void DecodeBlock(Binary::InputStream& stream, std::size_t srcSize, Dump& dst)
{
const std::size_t LOOKUP = 1;
const uint8_t* const src = stream.ReadData(LOOKUP);
const std::size_t used = DecodeBlock(src, srcSize, &dst[0], dst.size());
stream.ReadData(used - LOOKUP);
}
int ReadNextWinZipJPEGSlice(WinZipJPEGDecompressor *self)
{
self->currheight=self->sliceheight;
if(self->finishedrows+self->currheight>=self->jpeg.verticalmcus)
{
self->currheight=self->jpeg.verticalmcus-self->finishedrows;
self->slicesavailable=false;
}
for(int i=0;i<self->jpeg.numscancomponents;i++)
{
InitializeWinZipJPEGArithmeticDecoder(&self->decoder,self->readfunc,self->inputcontext);
int hblocks=self->jpeg.scancomponents[i].component->horizontalfactor;
int vblocks=self->jpeg.scancomponents[i].component->verticalfactor;
int blocksperrow=self->jpeg.horizontalmcus*hblocks;
const WinZipJPEGQuantizationTable *quantization=self->jpeg.scancomponents[i].component->quantizationtable;
// NOTE: Blocks are processed in cartesian order, not MCU order.
for(int y=0;y<self->currheight*vblocks;y++)
for(int x=0;x<self->jpeg.horizontalmcus*hblocks;x++)
{
WinZipJPEGBlock *currblock=&self->blocks[i][x+y*blocksperrow];
const WinZipJPEGBlock *northblock;
if(y!=0) northblock=&self->blocks[i][x+(y-1)*blocksperrow];
else if(self->finishedrows!=0) northblock=&self->blocks[i][x+(self->sliceheight*vblocks-1)*blocksperrow];
else northblock=NULL;
const WinZipJPEGBlock *westblock;
if(x!=0) westblock=&self->blocks[i][x-1+y*blocksperrow];
else westblock=NULL;
DecodeBlock(self,i,currblock,northblock,westblock,quantization);
if(WinZipJPEGArithmeticDecoderEncounteredEOF(&self->decoder)) return WinZipJPEGEndOfStreamError;
}
FlushWinZipJPEGArithmeticDecoder(&self->decoder);
}
self->finishedrows+=self->currheight;
// Initialize writer state.
self->mcusavailable=true;
self->currblock=self->blocks[0];
self->mcurow=0;
self->mcucol=0;
self->mcucomp=0;
self->mcux=0;
self->mcuy=0;
self->mcucoeff=0;
// TODO: Error handling.
return WinZipJPEGNoError;
}
static block_t *Packetize( decoder_t *p_dec, block_t **pp_block )
{
if( pp_block == NULL ) /* No Drain */
return NULL;
block_t *p_block = *pp_block; *pp_block = NULL;
if( p_block == NULL )
return NULL;
return DecodeBlock( p_dec, p_block );
}
static int DecodeVideo( decoder_t *p_dec, block_t *p_block )
{
if( p_block == NULL ) /* No Drain */
return VLCDEC_SUCCESS;
picture_t *p_pic = DecodeBlock( p_dec, p_block );
if( p_pic != NULL )
decoder_QueueVideo( p_dec, p_pic );
return VLCDEC_SUCCESS;
}
static int DecodeAudio( decoder_t *p_dec, block_t *p_block )
{
if( p_block == NULL ) /* No Drain */
return VLCDEC_SUCCESS;
block_t **pp_block = &p_block, *p_out;
while( ( p_out = DecodeBlock( p_dec, pp_block ) ) != NULL )
decoder_QueueAudio( p_dec, p_out );
return VLCDEC_SUCCESS;
}
void CIRLC<T>::Decode(CBitstream * pBstr, CImage<T> * pImg)
{
for(int k=0;k<pImg->getComponents(); k++)
{
CSize size((*pImg)[k].getHeight(), (*pImg)[k].getWidth());
for(int y=0; y < (*pImg)[k].getHeight(); y+=8)
{
for(int x=0; x < (*pImg)[k].getWidth(); x+=8)
{
DecodeBlock(pBstr, &(*pImg)[k][0][0], CPoint(k, y, x), size);
}
}
}
}
/// SequentialScan::ParseMCU
// Parse a single MCU in this scan. Return true if there are more blocks in this row.
bool SequentialScan::ParseMCU(void)
{
bool more = true;
int c;
assert(m_pBlockCtrl);
bool valid = BeginReadMCU(m_Stream.ByteStreamOf());
for(c = 0;c < m_ucCount;c++) {
class Component *comp = m_pComponent[c];
class QuantizedRow *q = m_pBlockCtrl->CurrentQuantizedRow(comp->IndexOf());
class HuffmanDecoder *dc = m_pDCDecoder[c];
class HuffmanDecoder *ac = m_pACDecoder[c];
UWORD &skip = m_usSkip[c];
LONG &prevdc = m_lDC[c];
UBYTE mcux = (m_ucCount > 1)?(comp->MCUWidthOf() ):(1);
UBYTE mcuy = (m_ucCount > 1)?(comp->MCUHeightOf()):(1);
ULONG xmin = m_ulX[c];
ULONG xmax = xmin + mcux;
ULONG x,y;
if (xmax >= q->WidthOf()) {
more = false;
}
for(y = 0;y < mcuy;y++) {
for(x = xmin;x < xmax;x++) {
LONG *block,dummy[64];
if (q && x < q->WidthOf()) {
block = q->BlockAt(x)->m_Data;
} else {
block = dummy;
}
if (valid) {
DecodeBlock(block,dc,ac,prevdc,skip);
} else {
for(UBYTE i = m_ucScanStart;i <= m_ucScanStop;i++) {
block[i] = 0;
}
}
}
if (q) q = q->NextOf();
}
// Done with this component, advance the block.
m_ulX[c] = xmax;
}
return more;
}
/// RefinementScan::ParseMCU
// Parse a single MCU in this scan. Return true if there are more blocks in this row.
bool RefinementScan::ParseMCU(void)
{
bool more = true;
int c;
assert(m_pBlockCtrl);
bool valid = BeginReadMCU(m_Stream.ByteStreamOf());
for(c = 0;c < m_ucCount;c++) {
class Component *comp = m_pComponent[c];
class QuantizedRow *q = m_pBlockCtrl->CurrentQuantizedRow(comp->IndexOf());
class HuffmanDecoder *ac = m_pACDecoder[c];
UWORD &skip = m_usSkip[c];
UBYTE mcux = (m_ucCount > 1)?(comp->MCUWidthOf() ):(1);
UBYTE mcuy = (m_ucCount > 1)?(comp->MCUHeightOf()):(1);
ULONG xmin = m_ulX[c];
ULONG xmax = xmin + mcux;
ULONG x,y;
if (xmax >= q->WidthOf()) {
more = false;
}
for(y = 0;y < mcuy;y++) {
for(x = xmin;x < xmax;x++) {
LONG *block,dummy[64];
if (q && x < q->WidthOf()) {
block = q->BlockAt(x)->m_Data;
} else {
block = dummy;
}
if (valid) {
DecodeBlock(block,ac,skip);
}
// Do not modify the data in here otherwise, keep the data unrefined...
// actually, all further refinement scans should better be skipped as the
// data is likely nonsense anyhow.
}
if (q) q = q->NextOf();
}
// Done with this component, advance the block.
m_ulX[c] = xmax;
}
return more;
}
/// ACRefinementScan::ParseMCU
// Parse a single MCU in this scan. Return true if there are more blocks in this row.
bool ACRefinementScan::ParseMCU(void)
{
#if ACCUSOFT_CODE
bool more = true;
int c;
assert(m_pBlockCtrl);
bool valid = BeginReadMCU(m_Coder.ByteStreamOf());
for(c = 0;c < m_ucCount;c++) {
class Component *comp = m_pComponent[c];
class QuantizedRow *q = m_pBlockCtrl->CurrentQuantizedRow(comp->IndexOf());
UBYTE mcux = (m_ucCount > 1)?(comp->MCUWidthOf() ):(1);
UBYTE mcuy = (m_ucCount > 1)?(comp->MCUHeightOf()):(1);
ULONG xmin = m_ulX[c];
ULONG xmax = xmin + mcux;
ULONG x,y;
if (xmax >= q->WidthOf()) {
more = false;
}
for(y = 0;y < mcuy;y++) {
for(x = xmin;x < xmax;x++) {
LONG *block,dummy[64];
if (q && x < q->WidthOf()) {
block = q->BlockAt(x)->m_Data;
} else {
block = dummy;
}
if (valid) {
DecodeBlock(block);
}
}
if (q) q = q->NextOf();
}
// Done with this component, advance the block.
m_ulX[c] = xmax;
}
return more;
#else
return false;
#endif
}
/*****************************************************************************
* DecodeFrame: decodes a video frame.
*****************************************************************************/
static int DecodeFrame( decoder_t *p_dec, block_t *p_block )
{
if( p_block == NULL ) /* No Drain */
return VLCDEC_SUCCESS;
p_block = DecodeBlock( p_dec, p_block );
if( p_block == NULL )
return VLCDEC_SUCCESS;
decoder_sys_t *p_sys = p_dec->p_sys;
/* Get a new picture */
picture_t *p_pic = NULL;
if( !decoder_UpdateVideoFormat( p_dec ) )
p_pic = decoder_NewPicture( p_dec );
if( p_pic == NULL )
{
block_Release( p_block );
return VLCDEC_SUCCESS;
}
FillPicture( p_dec, p_block, p_pic );
/* Date management: 1 frame per packet */
p_pic->date = date_Get( &p_dec->p_sys->pts );
date_Increment( &p_sys->pts, 1 );
if( p_block->i_flags & BLOCK_FLAG_INTERLACED_MASK )
{
p_pic->b_progressive = false;
p_pic->i_nb_fields = (p_block->i_flags & BLOCK_FLAG_SINGLE_FIELD) ? 1 : 2;
if( p_block->i_flags & BLOCK_FLAG_TOP_FIELD_FIRST )
p_pic->b_top_field_first = true;
else
p_pic->b_top_field_first = false;
}
else
p_pic->b_progressive = true;
block_Release( p_block );
decoder_QueueVideo( p_dec, p_pic );
return VLCDEC_SUCCESS;
}
Formats::Packed::Container::Ptr Version1_45::Decode(Binary::InputStream& stream)
{
const Version1_45::Header hdr = stream.ReadField<Version1_45::Header>();
const std::size_t restSize = stream.GetRestSize();
const std::size_t TARGET_SIZE = 49152;
const uint32_t FOOTER = 0x00eded00;
if (0 == (hdr.Flag1 & hdr.COMPRESSED))
{
Require(restSize >= TARGET_SIZE);
const Binary::Container::Ptr rest = stream.ReadRestData();
return CreatePackedContainer(rest->GetSubcontainer(0, TARGET_SIZE), sizeof(hdr) + TARGET_SIZE);
}
Require(restSize > sizeof(FOOTER));
std::auto_ptr<Dump> res(new Dump(TARGET_SIZE));
DecodeBlock(stream, restSize - sizeof(FOOTER), *res);
const uint32_t footer = fromLE(stream.ReadField<uint32_t>());
Require(footer == FOOTER);
return CreatePackedContainer(res, stream.GetPosition());
}
Formats::Packed::Container::Ptr DecodeNew(Binary::InputStream& stream)
{
const std::size_t ZX_PAGE_SIZE = 16384;
const Version2_0::Header hdr = stream.ReadField<Version2_0::Header>();
const std::size_t additionalSize = fromLE(hdr.AdditionalSize);
const std::size_t readAdditionalSize = sizeof(hdr) - sizeof(Version1_45::Header) - sizeof(hdr.AdditionalSize);
Require(additionalSize >= readAdditionalSize);
stream.ReadData(additionalSize - readAdditionalSize);
const PlatformTraits traits(additionalSize, hdr.HardwareMode, hdr.Port7ffd);
std::auto_ptr<Dump> res(new Dump(ZX_PAGE_SIZE * traits.PagesCount()));
Dump curPage(ZX_PAGE_SIZE);
for (uint_t idx = 0; idx != traits.PagesCount(); ++idx)
{
const bool isPageRequired = idx < traits.MinimalPagesCount();
if (!isPageRequired && stream.GetRestSize() < sizeof(Version2_0::MemoryPage))
{
break;
}
const Version2_0::MemoryPage page = stream.ReadField<Version2_0::MemoryPage>();
const int_t pageNumber = traits.PageNumber(page.Number);
const bool isPageValid = pageNumber != PlatformTraits::NO_PAGE;
if (!isPageRequired && !isPageValid)
{
break;
}
Require(isPageValid);
const std::size_t pageSize = fromLE(page.DataSize);
const uint8_t* pageSource = 0;
if (pageSize == page.UNCOMPRESSED)
{
pageSource = stream.ReadData(ZX_PAGE_SIZE);
}
else
{
Require(pageSize <= stream.GetRestSize());
DecodeBlock(stream, pageSize, curPage);
pageSource = &curPage.front();
}
std::memcpy(&res->front() + pageNumber * ZX_PAGE_SIZE, pageSource, ZX_PAGE_SIZE);
}
return CreatePackedContainer(res, stream.GetPosition());
}
/*****************************************************************************
* SendFrame: send a video frame to the stream output.
*****************************************************************************/
static block_t *SendFrame( decoder_t *p_dec, block_t **pp_block )
{
if( pp_block == NULL ) /* No Drain */
return NULL;
block_t *p_block = *pp_block;
if( p_block == NULL )
return NULL;
*pp_block = NULL;
p_block = DecodeBlock( p_dec, p_block );
if( p_block == NULL )
return NULL;
decoder_sys_t *p_sys = p_dec->p_sys;
/* Date management: 1 frame per packet */
p_block->i_dts = p_block->i_pts = date_Get( &p_sys->pts );
date_Increment( &p_sys->pts, 1 );
return p_block;
}
void CState::ThreadFunc()
{
for (;;)
{
Decoder->CanProcessEvent.Lock();
Decoder->CS.Enter();
if (Decoder->CloseThreads)
{
Decoder->CS.Leave();
return;
}
if (Decoder->StreamWasFinished1)
{
FinishStream();
continue;
}
HRESULT res = S_OK;
UInt32 blockIndex = Decoder->NextBlockIndex;
UInt32 nextBlockIndex = blockIndex + 1;
if (nextBlockIndex == Decoder->NumThreads)
nextBlockIndex = 0;
Decoder->NextBlockIndex = nextBlockIndex;
UInt32 crc;
UInt64 packSize = 0;
CBlockProps props;
try
{
res = Decoder->ReadSignature(crc);
if (res != S_OK)
{
Decoder->Result1 = res;
FinishStream();
continue;
}
if (Decoder->BzWasFinished)
{
Decoder->Result1 = res;
FinishStream();
continue;
}
props.randMode = true;
res = Decoder->Base.ReadBlock(Counters, Decoder->BlockSizeMax, &props);
if (res != S_OK)
{
Decoder->Result1 = res;
FinishStream();
continue;
}
packSize = Decoder->Base.BitDecoder.GetProcessedSize();
}
catch(const CInBufferException &e) { res = e.ErrorCode; if (res != S_OK) res = E_FAIL; }
catch(...) { res = E_FAIL; }
if (res != S_OK)
{
Decoder->Result1 = res;
FinishStream();
continue;
}
Decoder->CS.Leave();
DecodeBlock1(Counters, props.blockSize);
bool needFinish = true;
try
{
Decoder->m_States[blockIndex].CanWriteEvent.Lock();
needFinish = Decoder->StreamWasFinished2;
if (!needFinish)
{
if (DecodeBlock(props, Counters + 256, Decoder->m_OutStream) == crc)
res = Decoder->SetRatioProgress(packSize);
else
res = S_FALSE;
}
}
catch(const COutBufferException &e) { res = e.ErrorCode; if (res != S_OK) res = E_FAIL; }
catch(...) { res = E_FAIL; }
if (res != S_OK)
{
Decoder->Result2 = res;
Decoder->StreamWasFinished2 = true;
}
Decoder->m_States[nextBlockIndex].CanWriteEvent.Set();
if (res != S_OK || needFinish)
{
StreamWasFinishedEvent.Set();
Decoder->CanStartWaitingEvent.Lock();
WaitingWasStartedEvent.Set();
}
}
}
HRESULT CDecoder::DecodeFile(ICompressProgressInfo *progress)
{
Progress = progress;
#ifndef _7ZIP_ST
RINOK(Create());
for (UInt32 t = 0; t < NumThreads; t++)
{
CState &s = m_States[t];
if (!s.Alloc())
return E_OUTOFMEMORY;
if (MtMode)
{
RINOK(s.StreamWasFinishedEvent.Reset());
RINOK(s.WaitingWasStartedEvent.Reset());
RINOK(s.CanWriteEvent.Reset());
}
}
#else
if (!m_States[0].Alloc())
return E_OUTOFMEMORY;
#endif
IsBz = false;
/*
if (Base.BitDecoder.ExtraBitsWereRead())
return E_FAIL;
*/
Byte s[4];
int i;
for (i = 0; i < 4; i++)
s[i] = ReadByte();
if (Base.BitDecoder.ExtraBitsWereRead())
return S_FALSE;
if (s[0] != kArSig0 ||
s[1] != kArSig1 ||
s[2] != kArSig2 ||
s[3] <= kArSig3 ||
s[3] > kArSig3 + kBlockSizeMultMax)
return S_FALSE;
UInt32 dicSize = (UInt32)(s[3] - kArSig3) * kBlockSizeStep;
CombinedCrc.Init();
#ifndef _7ZIP_ST
if (MtMode)
{
NextBlockIndex = 0;
StreamWasFinished1 = StreamWasFinished2 = false;
CloseThreads = false;
CanStartWaitingEvent.Reset();
m_States[0].CanWriteEvent.Set();
BlockSizeMax = dicSize;
Result1 = Result2 = S_OK;
CanProcessEvent.Set();
UInt32 t;
for (t = 0; t < NumThreads; t++)
m_States[t].StreamWasFinishedEvent.Lock();
CanProcessEvent.Reset();
CanStartWaitingEvent.Set();
for (t = 0; t < NumThreads; t++)
m_States[t].WaitingWasStartedEvent.Lock();
CanStartWaitingEvent.Reset();
RINOK(Result2);
RINOK(Result1);
}
else
#endif
{
CState &state = m_States[0];
for (;;)
{
RINOK(SetRatioProgress(Base.BitDecoder.GetProcessedSize()));
UInt32 crc;
RINOK(ReadSignature(crc));
if (BzWasFinished)
return S_OK;
CBlockProps props;
props.randMode = true;
RINOK(Base.ReadBlock(state.Counters, dicSize, &props));
DecodeBlock1(state.Counters, props.blockSize);
if (DecodeBlock(props, state.Counters + 256, m_OutStream) != crc)
{
CrcError = true;
return S_FALSE;
}
}
}
return SetRatioProgress(Base.BitDecoder.GetProcessedSize());
}
