bool PngDecodeImage(PngT *png, PixBufT *pixbuf) { if (png->ihdr.interlace_method != 0) { LOG("Interlaced PNG not supported."); } else if (png->ihdr.bit_depth != 8) { LOG("Non 8-bit components not supported."); } else { uint32_t pixelWidth = GetPixelWidth(png); uint32_t length = png->ihdr.width * png->ihdr.height * pixelWidth; uint32_t dstLength = length + png->ihdr.height; uint8_t *encoded = MemNew(dstLength); MergeIDATs(png); LOG("Uncompressing the image."); Inflate(png->idat.data + 2, encoded); LOG("Decoding pixels."); ReconstructImage(pixbuf->data, encoded, png->ihdr.width, png->ihdr.height, pixelWidth); MemUnref(encoded); return true; } return false; }
void FZipPackage::LoadAsset( FZipAsset* Asset ) { guard; Seek( Asset->Location, Begin ); Asset->Ptr = new uint8[Asset->Size]; switch (Asset->CompressType) { case 0: { //No compression Read( Asset->Ptr, Asset->Size ); break; } case 8: { //Deflate uint8* CompressData = new uint8[Asset->CompressSize]; Read( CompressData, Asset->CompressSize ); Inflate( CompressData, Asset->Ptr, Asset->CompressSize, Asset->Size ); if (Asset->Type == AT_Text || Asset->Type == AT_Script) { //Null terminate the data if it has formatted text Asset->Ptr[Asset->Size] = 0; } break; } default: { Logf( LOG_ERR, L"Asset '%s' is compressed with an unknown method.", Asset->Name ); } } unguard; }
int Unzip::fileDecode(unsigned char *data) { unsigned char *src=NULL; // Go to compressed data: fseek(file,compPos,SEEK_SET); // Allocate memory: src=(unsigned char *)malloc(srcLen); if (src==NULL) { fclose(file); return 1; } memset(src,0,srcLen); // Read in compressed version and decompress fread(src,1,srcLen,file); Inflate(data,dataLen, src,srcLen); free(src); src=NULL; srcLen=0; return 0; }
void ComboBox::PopupDropDownWindow() { auto window = GetWindow(); if (window == nullptr) { return; } auto window_rect = GetAbsoluteRect(); window_rect.Inflate(-1, 0); window_rect.position.y += GetHeight() - 2; std::size_t visible_item_count = drop_down_list_box_->GetItemCount(); visible_item_count = std::max(visible_item_count, GetMinimumVisibleItemCount()); visible_item_count = std::min(visible_item_count, GetMaximumVisibleItemCount()); window_rect.size.height = CalculateDropDownListHeight(visible_item_count) + drop_down_list_box_->GetBorderThickness() * 2; POINT screen_position = window_rect.position.ToPOINT(); ClientToScreen(window->GetHandle(), &screen_position); window_rect.position = Point::FromPOINT(screen_position); drop_down_window_->SetOwner(window); drop_down_window_->SetRect(window_rect); drop_down_window_->Show(); }
BOOL Flate::Uncompress(CByteArray& dst, const BYTE* src, UINT srcLen) { CBAStreamReader sr(src, srcLen); CBAStreamWriter sw(dst); Inflate(&sw, &sr); return dst.GetSize() != 0; }
std::optional<int> PointToNoteNumber(wxPoint pt) { auto rect = GetClientRect(); int const disp_half = rect.GetWidth() / 2; int const disp_shift = kFullKeysWidth / 2 - disp_half; double const x = (pt.x + disp_shift); int const kOctaveWidth = 7.0 * kKeyWidth; int octave = (int)(x / (double)kOctaveWidth); int x_in_oct = x - (kOctaveWidth * octave); std::optional<int> found; for(auto index: kBlackKeyIndices) { auto key = kKeyPropertyList[index]; auto rc = key.rect_; rc.SetWidth(kBlackKeyDispWidth); rc.Inflate(1, 1); if(rc.Contains(x_in_oct - kBlackKeyDispOffset, pt.y)) { if(!found) { found = (index + octave * 12); } break; } } for(auto index: kWhiteKeyIndices) { auto key = kKeyPropertyList[index]; auto rc = key.rect_; rc.Inflate(1, 1); if(rc.Contains(x_in_oct, pt.y)) { if(!found) { found = (index + octave * 12); } break; } } if(found && 0 <= *found && *found < 128) { return *found; } else { return std::nullopt; } }
UnicodeString& UnicodeString::Append(const char *lpszAdd, UINT CodePage) { if (lpszAdd && *lpszAdd) { size_t nAddSize = MultiByteToWideChar(CodePage,0,lpszAdd,-1,nullptr,0); size_t nNewLength = m_pData->GetLength() + nAddSize - 1; Inflate(nNewLength + 1); MultiByteToWideChar(CodePage,0,lpszAdd,(int)nAddSize,m_pData->GetData() + m_pData->GetLength(),(int)m_pData->GetSize()); m_pData->SetLength(nNewLength); } return *this; }
void Code(FILE *input_file, FILE *output_file) { switch (test_mode) { case DEFLATE_MODE: { Deflate(input_file, output_file); break; } case INFLATE_MODE: { Inflate(input_file, output_file); break; } default: { ERROR("invalid mode: %d", test_mode); } } }
qint64 CCompressedConnection::readFromNetwork(qint64 nBytes) { qint64 nRet = CNetworkConnection::readFromNetwork(nBytes); if(m_bCompressedInput) { Inflate(); if(m_pZInput->size()) { emit readyRead(); } } return nRet; }
size_t UnicodeString::SetLength(size_t nLength) { if (nLength < m_pData->GetLength()) { if (!nLength && m_pData->GetRef() > 1) { m_pData->DecRef(); SetEUS(); } else { Inflate(nLength+1); return m_pData->SetLength(nLength); } } return m_pData->GetLength(); }
int CZlib::Decompress(CString strFileName, CString strOutput) { // Open the files FILE * in = fopen(strFileName.Get(), "r"); FILE * out = fopen(strOutput.Get(), "w+"); // Enable binary mode SET_BINARY_MODE(in); SET_BINARY_MODE(out); // Deflate the file int iReturn = Inflate(in, out); // Close the files fclose(in); fclose(out); return iReturn; }
//TODO: Multi-thread this void FZipPackage::LoadAsset( FStringConst& Path ) { guard; //Check that the asset exists FZipAsset* Asset = (FZipAsset*)FindAsset( Path ); if(!Asset) { FString Err = FString( L"Asset '" ) + Path.Data + FString( L"' could not be read." ); Throw( (wchar_t*)Err.Data, false ); } Seek( Asset->Location, Begin ); Asset->Ptr = new uint8[Asset->Size]; switch (Asset->CompressType) { case 0: { //No compression Read( Asset->Ptr, Asset->Size ); break; } case 8: { //Deflate uint8* CompressData = new uint8[Asset->CompressSize]; Read( CompressData, Asset->CompressSize ); Inflate( CompressData, Asset->Ptr, Asset->CompressSize, Asset->Size ); if(Asset->Type == AT_Text || Asset->Type == AT_Script) { //Null terminate the data if it has formatted text Asset->Ptr[Asset->Size] = 0; } break; } default: { Logf( LOG_ERR, L"Asset '%s' is compressed with an unknown method.", Asset->Name ); } } unguard; }
// implements ZeroCopyInputStream ---------------------------------- bool GzipInputStream::Next(const void** data, int* size) { bool ok = (zerror_ == Z_OK) || (zerror_ == Z_STREAM_END) || (zerror_ == Z_BUF_ERROR); if ((!ok) || (zcontext_.next_out == NULL)) { return false; } if (zcontext_.next_out != output_position_) { DoNextOutput(data, size); return true; } if (zerror_ == Z_STREAM_END) { if (zcontext_.next_out != NULL) { // sub_stream_ may have concatenated streams to follow zerror_ = inflateEnd(&zcontext_); if (zerror_ != Z_OK) { return false; } zerror_ = internalInflateInit2(&zcontext_, format_); if (zerror_ != Z_OK) { return false; } } else { *data = NULL; *size = 0; return false; } } zerror_ = Inflate(Z_NO_FLUSH); if ((zerror_ == Z_STREAM_END) && (zcontext_.next_out == NULL)) { // The underlying stream's Next returned false inside Inflate. return false; } ok = (zerror_ == Z_OK) || (zerror_ == Z_STREAM_END) || (zerror_ == Z_BUF_ERROR); if (!ok) { return false; } DoNextOutput(data, size); return true; }
wchar_t *UnicodeString::GetBuffer(size_t nSize) { Inflate(nSize == (size_t)-1?m_pData->GetSize():nSize); return m_pData->GetData(); }
/*package*/ void WebHistoryItemClassic::Inflate( /* [in] */ Int32 nativeFrame) { mNativeBridge = Inflate(nativeFrame, mFlattenedData); mFlattenedData = NULL; }
void Rectangle::Inflate(const VectorType &size) noexcept { Inflate(size.X(), size.Y()); }
void CFindCallersViewWnd::RefreshLayout() { auto clientRect = GetClientRect(); clientRect.Inflate(-5, -5); m_callersList.SetSizePosition(clientRect); }
/*! \fn StarDict::search( const char *word ) */ const char* StarDict::search( const char *word ) { char line[256]; string headword; struct entry entry; bool found = false; uint a; string idxFile; char buf[m_idxfilesize]; if( isIdxCompressed ) { gzFile gzfile = gzopen( idxFileName.c_str(), "rb" ); if( gzfile == NULL ) { m_isOk = false; return ""; } int read = gzread( gzfile, buf, m_idxfilesize ); if( m_idxfilesize != (uint)read ) { m_isOk = false; return ""; } idxFile.assign( buf, m_idxfilesize ); gzclose( gzfile ); }else{ ifstream file; file.open( idxFileName.c_str() ); file.readsome( buf, m_idxfilesize ); idxFile.assign( buf, m_idxfilesize ); file.close(); } // Find the headword in index file uint pos = 0; for(uint b=0;b<m_wordcount;b++) { a = 0; do { line[a] = idxFile[pos]; a++; pos++; }while( line[a-1] != '\0' ); headword = line; for(a=0;a<8;a++) line[a] = idxFile[pos++]; if( headword.compare( word ) != 0 ) continue; found = true; entry.headword = headword; // Get the position of definition in definition file entry.position = (unsigned char)line[3] | (unsigned char)line[2] << 8 | (unsigned char)line[1] << 16 | (unsigned char)line[0] << 24; // Get the size of definition in definition file entry.size = (unsigned char)line[7] | (unsigned char)line[6] << 8 | (unsigned char)line[5] << 16 | (unsigned char)line[4] << 24; } // If not found, return a null string if( !found ) return ""; // Check if the definition file is compressed if( isCompressed ) { // Calculate how many chunks we have to skip uint startChunk = entry.position / CHLEN ; uint endChunk = (entry.position + entry.size ) / CHLEN; // Calculate the position of definition in chunk uint pos = entry.position % CHLEN; // Size of the chunk we are looking for unsigned long chunkLen = 0; for(uint a = startChunk; a < endChunk + 1; a++ ) chunkLen += offsets[a]; // How many bytes we have to skip unsigned long skip = 0; for(uint a=0;a<startChunk;a++) skip += offsets[a]; // Definition file file.open( dictFileName.c_str() ); // Jump to chunk we are looking for file.seekg( offset + skip ); // Get the compressed data char buf[chunkLen]; file.readsome( buf, chunkLen ); string data( buf, chunkLen ); file.close(); // Decompress the data string result = Inflate( data ); // Returns only the definition return result.substr( pos, entry.size ).c_str(); }else{ // The file is not compressed file.open( dictFileName.c_str() ); // Jump to position of definition file.seekg( entry.position ); // Get the definition char buf[entry.size]; file.readsome( buf, entry.size ); string result( buf, entry.size ); file.close(); // Return the result return result.c_str(); } return ""; }
int IDATParse(struct XPng* xpng, struct XInflate* inflate, struct XBitmap* xbitmap, const unsigned char* stream, int dataLength) { const unsigned char* idatBuffer; // IDAT 정보 unsigned char* imageCurBuffer; int imageCurWidthByte; int ColorMapTablePos; unsigned char filter; unsigned char filter_a[RGBA]; unsigned char* filter_b ; unsigned char filter_c[RGBA]; const unsigned char* outBuf; unsigned int outBufLen; int ColorMapTableLen; int imageWidthByte; int imagePaddingByte; const int* ColorMapTableCur; imageCurBuffer = xpng->m_imageCurBuffer; imageCurWidthByte = xpng->m_imageCurWidthByte; ColorMapTablePos = xpng->m_ColorMapTablePos; filter = xpng->m_filter; filter_b = xpng->m_filter_b; *(int*)filter_a = *(int*)xpng->m_filter_a; *(int*)filter_c = *(int*)xpng->m_filter_c; ColorMapTableLen = xpng->m_ColorMapTableLen; imageWidthByte = xpng->m_imageWidthByte; imagePaddingByte = xpng->m_imagePaddingByte; ColorMapTableCur = xpng->m_ColorMapTableCur; if(xpng->m_pInflate->m_outBuffer == NULL) { xpng->m_pInflate->m_outBuffer = (unsigned char*)malloc(DEFAULT_ALLOC_SIZE); // jmlee 초기화 xpng->m_pInflate->m_outBufferAlloc = DEFAULT_ALLOC_SIZE; } idatBuffer = (unsigned char *)malloc(dataLength); // 스트림에서 IDAT Data만 가져옴 memcpy(idatBuffer, stream, dataLength); // 압축해제 시작 if(Inflate(inflate, idatBuffer, dataLength)!=XINFLATE_ERR_OK){ printf("error!!!!"); } //디코딩 결과 저장 outBuf = inflate->m_outBuffer; outBufLen = inflate->m_outBufferPos; // 출력 버퍼에 쓰기. while(outBufLen) { // 매 스캔라인 첫번째 바이트는 filter 정보이다. if(imageCurWidthByte == imageWidthByte) { filter = *outBuf; // 필터에 사용할 변수 초기화 *((unsigned int*)filter_a) = 0; *((unsigned int*)filter_c) = 0; filter_b = xpng->m_scanline_current; // 최초 실행시 더미값 set if(xpng->m_bEnd == false) { filter_b = xpng->m_filter_b_dummy; xpng->m_bEnd = true; } // 기본 초기화 ColorMapTablePos = 0; // 이전 스캔라인 기억 처리 xpng->m_scanline_before = xpng->m_scanline_current; xpng->m_scanline_current = imageCurBuffer; // filter 읽었으니 1증가 outBuf++; outBufLen--; } // 영상 데이타 복사 switch(filter) { case FILTER_NONE : if(xpng->m_bPaletted) { unsigned char palPixel; while(outBufLen) { palPixel = *outBuf; // 빨레트를 참고해서 RGBA 값 세팅하기 *(imageCurBuffer + 2) = xpng->m_palette[palPixel * 3 + 0]; // R *(imageCurBuffer + 1) = xpng->m_palette[palPixel * 3 + 1]; // G *(imageCurBuffer + 0) = xpng->m_palette[palPixel * 3 + 2]; // B // RGBA 사용안함 *(imageCurBuffer + 3) = 255; // A //WriteOnePixel(xbitmap, &xpng->m_palette[palPixel * 3 + 2]); //WriteOnePixel(xbitmap, &xpng->m_palette[palPixel * 3 + 1]); //WriteOnePixel(xbitmap, &xpng->m_palette[palPixel * 3 + 0]); // a값 버리려면 3으로 변경하고 A부분 주석 MOVETONEXTBUFFER_4_PAL } } else { if(ColorMapTablePos==0) { if(ColorMapTableCur == colorMapTable_RGB_2_BGR) { while(outBufLen>3 && imageCurWidthByte>3) { *(imageCurBuffer + 2) = *(outBuf+0); // R *(imageCurBuffer + 1) = *(outBuf+1); // G *(imageCurBuffer + 0) = *(outBuf+2); // B MOVETONEXTBUFFER_FAST(3); } } else if(ColorMapTableCur == colorMapTable_RGBA_2_BGRA) { while(outBufLen>4 && imageCurWidthByte>4) { *(imageCurBuffer + 2) = *(outBuf+0); // R *(imageCurBuffer + 1) = *(outBuf+1); // G *(imageCurBuffer + 0) = *(outBuf+2); // B *(imageCurBuffer + 3) = *(outBuf+3); // A MOVETONEXTBUFFER_FAST(4); } } } while(outBufLen) { // RGB 를 BGR 로 혹은 RGBA 를 BGRA 로 바꾸기 위해서 테이블 참조 *(imageCurBuffer + ColorMapTableCur[ColorMapTablePos]) = *outBuf; MOVETONEXTBUFFER } } break; case FILTER_SUB : if(xpng->m_bPaletted){ } else { // 한번에 3,4 바이트씩 복사한다. if(ColorMapTablePos==0) { if(ColorMapTableCur == colorMapTable_RGB_2_BGR) { while(outBufLen>3 && imageCurWidthByte>3) { filter_a[0] = *(imageCurBuffer + 2) = *(outBuf+0) + filter_a[0]; // R filter_a[1] = *(imageCurBuffer + 1) = *(outBuf+1) + filter_a[1]; // G filter_a[2] = *(imageCurBuffer + 0) = *(outBuf+2) + filter_a[2]; // B MOVETONEXTBUFFER_FAST(3); } } else if(ColorMapTableCur == colorMapTable_RGBA_2_BGRA) { while(outBufLen>4 && imageCurWidthByte>4) { filter_a[0] = *(imageCurBuffer + 2) = *(outBuf+0) + filter_a[0]; // R filter_a[1] = *(imageCurBuffer + 1) = *(outBuf+1) + filter_a[1]; // G filter_a[2] = *(imageCurBuffer + 0) = *(outBuf+2) + filter_a[2]; // B filter_a[3] = *(imageCurBuffer + 3) = *(outBuf+3) + filter_a[3]; // A MOVETONEXTBUFFER_FAST(4); } } } while(outBufLen) { // RGB 를 BGR 로 혹은 RGBA 를 BGRA 로 바꾸기 위해서 테이블 참조 // + 왼쪽 픽셀 참조 // + 필터값 저장(좀전 픽셀) filter_a[ColorMapTablePos] = *(imageCurBuffer + ColorMapTableCur[ColorMapTablePos]) = *outBuf + filter_a[ColorMapTablePos]; MOVETONEXTBUFFER } } break; case FILTER_UP : if(xpng->m_bPaletted){ } else { if(filter_b==NULL) { //DOERR(XPNG_ERR_INVALID_DATA); // 에러 상황이다. } // 한번에 3, 4바이트씩 복사한다. if(ColorMapTablePos==0) { if(ColorMapTableCur == colorMapTable_RGB_2_BGR) { while(outBufLen>3 && imageCurWidthByte>3) { *(imageCurBuffer + 2) = *(outBuf+0) + *(filter_b + 2); // R *(imageCurBuffer + 1) = *(outBuf+1) + *(filter_b + 1); // G *(imageCurBuffer + 0) = *(outBuf+2) + *(filter_b + 0); // B MOVETONEXTBUFFER_FAST(3); filter_b+= 3; } } else if(ColorMapTableCur == colorMapTable_RGBA_2_BGRA) { while(outBufLen>4 && imageCurWidthByte>4) { *(imageCurBuffer + 2) = *(outBuf+0) + *(filter_b + 2); // R *(imageCurBuffer + 1) = *(outBuf+1) + *(filter_b + 1); // G *(imageCurBuffer + 0) = *(outBuf+2) + *(filter_b + 0); // B *(imageCurBuffer + 3) = *(outBuf+3) + *(filter_b + 3); // A //WriteOnePixel(xbitmap, *outBuf+0 + *(filter_b + 2)); //WriteOnePixel(xbitmap, *outBuf+1 + *(filter_b + 1)); //WriteOnePixel(xbitmap, *outBuf+2 + *(filter_b + 0)); //WriteOnePixel(xbitmap, *outBuf+3 + *(filter_b + 3)); MOVETONEXTBUFFER_FAST(4); filter_b+= 4; } } } while(outBufLen) { // RGB 를 BGR 로 혹은 RGBA 를 BGRA 로 바꾸기 위해서 테이블 참조 // + 이전 라인 참조 *(imageCurBuffer + ColorMapTableCur[ColorMapTablePos]) = *outBuf + *(filter_b + ColorMapTableCur[ColorMapTablePos]); // 이전 스캔 라인 filter_b++; MOVETONEXTBUFFER } } break; case FILTER_AVERAGE : if(xpng->m_bPaletted){ } else { if(filter_b==NULL) { //DOERR(XPNG_ERR_INVALID_DATA); // 에러 상황이다. } // 한번에 3,4 픽셀 처리하기 if(ColorMapTablePos==0) { // todo // 이거 테스트 해봐야 하는데.. 적당한 샘플이 없음.. average 는 별로 안쓰이는듯? } while(outBufLen) { int a, b; unsigned char* dest; // 참조할 데이타 a = filter_a[ColorMapTablePos]; // 왼쪽 b = *(filter_b + ColorMapTableCur[ColorMapTablePos]); // 위 // 현재 출력 지점 dest = imageCurBuffer + ColorMapTableCur[ColorMapTablePos]; *dest = *outBuf + (a+b)/2; // 좌측 업데이트 filter_a[ColorMapTablePos] = *dest; // 상단 업데이트 filter_b++; MOVETONEXTBUFFER } } break; case FILTER_PAETH : if(xpng->m_bPaletted){ } else { int a, b,c,pa,pb,pc; int p; unsigned char* dest; int cur; if(filter_b==NULL) { //DOERR(XPNG_ERR_INVALID_DATA); // 에러 상황이다. } ///////////////////////////////////////////////////////////////////////////// // // PAETH 처리를 매크로화 // #define DO_PAETH(src, dst) \ a = filter_a[src]; b = *(filter_b +dst); c = filter_c[src]; \ p = a + b - c; \ pa = XPNG_ABS(p-a); \ pb = XPNG_ABS(p-b); \ pc = XPNG_ABS(p-c); \ \ /* 현재 출력 지점 */ \ dest = imageCurBuffer + dst; \ \ /* 디코딩된 값 */ \ cur = *(outBuf+src); \ \ /* 합치기 */ \ if(pa<=pb && pa<=pc) *dest = cur + a; \ else if(pb<=pc) *dest = cur + b; \ else *dest = cur + c; \ \ /* 필터 업데이트 */ \ filter_a[src] = *dest; \ filter_c[src] = b; // 한번에 3,4 픽셀 처리하기 if(ColorMapTablePos==0) { if(ColorMapTableCur == colorMapTable_RGB_2_BGR) { while(outBufLen>3 && imageCurWidthByte>3) { DO_PAETH(0, 2); // R DO_PAETH(1, 1); // G DO_PAETH(2, 0); // B // 다음 픽셀로 MOVETONEXTBUFFER_FAST(3); filter_b+= 3; } } else if(ColorMapTableCur == colorMapTable_RGBA_2_BGRA) { while(outBufLen>4 && imageCurWidthByte>4) { DO_PAETH(0, 2); // R DO_PAETH(1, 1); // G DO_PAETH(2, 0); // B DO_PAETH(3, 3); // A // 다음 픽셀로 MOVETONEXTBUFFER_FAST(4); filter_b+= 4; } } } while(outBufLen) { // 참조할 데이타 a = filter_a[ColorMapTablePos]; // 왼쪽 b = *(filter_b + ColorMapTableCur[ColorMapTablePos]); // 위 c = filter_c[ColorMapTablePos]; // 왼쪽 위 p = a + b - c; pa = XPNG_ABS(p-a); pb = XPNG_ABS(p-b); pc = XPNG_ABS(p-c); // 현재 출력 지점 dest = imageCurBuffer + ColorMapTableCur[ColorMapTablePos]; // 디코딩된 값 cur = *outBuf; // 합치기 if(pa<=pb && pa<=pc) *dest = cur + a; else if(pb<=pc) *dest = cur + b; else *dest = cur + c; // 좌측 업데이트 filter_a[ColorMapTablePos] = *dest; // 좌상단 업데이트 filter_c[ColorMapTablePos] = b; // 상단 업데이트 filter_b++; MOVETONEXTBUFFER } } break; default : return false; }
/* =================== idSWF::LoadSWF =================== */ bool idSWF::LoadSWF( const char* fullpath ) { idFile* rawfile = fileSystem->OpenFileRead( fullpath ); if( rawfile == NULL ) { idLib::Printf( "SWF File not found %s\n", fullpath ); return false; } swfHeader_t header; rawfile->Read( &header, sizeof( header ) ); if( header.W != 'W' || header.S != 'S' ) { idLib::Warning( "Wrong signature bytes" ); delete rawfile; return false; } if( header.version > 9 ) { idLib::Warning( "Unsupported version %d", header.version ); delete rawfile; return false; } bool compressed; if( header.compression == 'F' ) { compressed = false; } else if( header.compression == 'C' ) { compressed = true; } else { idLib::Warning( "Unsupported compression type %c", header.compression ); delete rawfile; return false; } idSwap::Little( header.fileLength ); // header.fileLength somewhat annoyingly includes the size of the header uint32 fileLength2 = header.fileLength - ( uint32 )sizeof( swfHeader_t ); // slurp the raw file into a giant array, which is somewhat atrocious when loading from the preload since it's already an idFile_Memory byte* fileData = ( byte* )Mem_Alloc( fileLength2, TAG_SWF ); size_t fileSize = rawfile->Read( fileData, fileLength2 ); delete rawfile; if( compressed ) { byte* uncompressed = ( byte* )Mem_Alloc( fileLength2, TAG_SWF ); if( !Inflate( fileData, ( int )fileSize, uncompressed, fileLength2 ) ) { idLib::Warning( "Inflate error" ); Mem_Free( uncompressed ); return false; } Mem_Free( fileData ); fileData = uncompressed; } idSWFBitStream bitstream( fileData, fileLength2, false ); swfRect_t frameSize; bitstream.ReadRect( frameSize ); if( !frameSize.tl.Compare( vec2_zero ) ) { idLib::Warning( "Invalid frameSize top left" ); Mem_Free( fileData ); return false; } frameWidth = frameSize.br.x; frameHeight = frameSize.br.y; frameRate = bitstream.ReadU16(); // parse everything mainsprite->Load( bitstream, true ); // now that all images have been loaded, write out the combined image idStr atlasFileName = "generated/"; atlasFileName += fullpath; atlasFileName.SetFileExtension( ".tga" ); WriteSwfImageAtlas( atlasFileName ); Mem_Free( fileData ); return true; }
void CSG_Rect::Inflate(double d, bool bPercent) { Inflate(d, d, bPercent); }
void CUIRect::Deflate(int cx, int cy) { Inflate(-cx, -cy); }
UnicodeString& UnicodeString::Upper(size_t nStartPos, size_t nLength) { Inflate(m_pData->GetSize()); CharUpperBuffW(m_pData->GetData()+nStartPos, nLength==(size_t)-1?(DWORD)(m_pData->GetLength()-nStartPos):(DWORD)nLength); return *this; }
void ZONE_FILLER::buildUnconnectedThermalStubsPolygonList( SHAPE_POLY_SET& aCornerBuffer, const ZONE_CONTAINER* aZone, const SHAPE_POLY_SET& aRawFilledArea, double aArcCorrection, double aRoundPadThermalRotation ) const { SHAPE_LINE_CHAIN spokes; BOX2I itemBB; VECTOR2I ptTest[4]; auto zoneBB = aRawFilledArea.BBox(); int zone_clearance = aZone->GetZoneClearance(); int biggest_clearance = m_board->GetDesignSettings().GetBiggestClearanceValue(); biggest_clearance = std::max( biggest_clearance, zone_clearance ); zoneBB.Inflate( biggest_clearance ); // half size of the pen used to draw/plot zones outlines int pen_radius = aZone->GetMinThickness() / 2; for( auto module : m_board->Modules() ) { for( auto pad : module->Pads() ) { // Rejects non-standard pads with tht-only thermal reliefs if( aZone->GetPadConnection( pad ) == PAD_ZONE_CONN_THT_THERMAL && pad->GetAttribute() != PAD_ATTRIB_STANDARD ) continue; if( aZone->GetPadConnection( pad ) != PAD_ZONE_CONN_THERMAL && aZone->GetPadConnection( pad ) != PAD_ZONE_CONN_THT_THERMAL ) continue; if( !pad->IsOnLayer( aZone->GetLayer() ) ) continue; if( pad->GetNetCode() != aZone->GetNetCode() ) continue; // Calculate thermal bridge half width int thermalBridgeWidth = aZone->GetThermalReliefCopperBridge( pad ) - aZone->GetMinThickness(); if( thermalBridgeWidth <= 0 ) continue; // we need the thermal bridge half width // with a small extra size to be sure we create a stub // slightly larger than the actual stub thermalBridgeWidth = ( thermalBridgeWidth + 4 ) / 2; int thermalReliefGap = aZone->GetThermalReliefGap( pad ); itemBB = pad->GetBoundingBox(); itemBB.Inflate( thermalReliefGap ); if( !( itemBB.Intersects( zoneBB ) ) ) continue; // Thermal bridges are like a segment from a starting point inside the pad // to an ending point outside the pad // calculate the ending point of the thermal pad, outside the pad VECTOR2I endpoint; endpoint.x = ( pad->GetSize().x / 2 ) + thermalReliefGap; endpoint.y = ( pad->GetSize().y / 2 ) + thermalReliefGap; // Calculate the starting point of the thermal stub // inside the pad VECTOR2I startpoint; int copperThickness = aZone->GetThermalReliefCopperBridge( pad ) - aZone->GetMinThickness(); if( copperThickness < 0 ) copperThickness = 0; // Leave a small extra size to the copper area inside to pad copperThickness += KiROUND( IU_PER_MM * 0.04 ); startpoint.x = std::min( pad->GetSize().x, copperThickness ); startpoint.y = std::min( pad->GetSize().y, copperThickness ); startpoint.x /= 2; startpoint.y /= 2; // This is a CIRCLE pad tweak // for circle pads, the thermal stubs orientation is 45 deg double fAngle = pad->GetOrientation(); if( pad->GetShape() == PAD_SHAPE_CIRCLE ) { endpoint.x = KiROUND( endpoint.x * aArcCorrection ); endpoint.y = endpoint.x; fAngle = aRoundPadThermalRotation; } // contour line width has to be taken into calculation to avoid "thermal stub bleed" endpoint.x += pen_radius; endpoint.y += pen_radius; // compute north, south, west and east points for zone connection. ptTest[0] = VECTOR2I( 0, endpoint.y ); // lower point ptTest[1] = VECTOR2I( 0, -endpoint.y ); // upper point ptTest[2] = VECTOR2I( endpoint.x, 0 ); // right point ptTest[3] = VECTOR2I( -endpoint.x, 0 ); // left point // Test all sides for( int i = 0; i < 4; i++ ) { // rotate point RotatePoint( ptTest[i], fAngle ); // translate point ptTest[i] += pad->ShapePos(); if( aRawFilledArea.Contains( ptTest[i] ) ) continue; spokes.Clear(); // polygons are rectangles with width of copper bridge value switch( i ) { case 0: // lower stub spokes.Append( -thermalBridgeWidth, endpoint.y ); spokes.Append( +thermalBridgeWidth, endpoint.y ); spokes.Append( +thermalBridgeWidth, startpoint.y ); spokes.Append( -thermalBridgeWidth, startpoint.y ); break; case 1: // upper stub spokes.Append( -thermalBridgeWidth, -endpoint.y ); spokes.Append( +thermalBridgeWidth, -endpoint.y ); spokes.Append( +thermalBridgeWidth, -startpoint.y ); spokes.Append( -thermalBridgeWidth, -startpoint.y ); break; case 2: // right stub spokes.Append( endpoint.x, -thermalBridgeWidth ); spokes.Append( endpoint.x, thermalBridgeWidth ); spokes.Append( +startpoint.x, thermalBridgeWidth ); spokes.Append( +startpoint.x, -thermalBridgeWidth ); break; case 3: // left stub spokes.Append( -endpoint.x, -thermalBridgeWidth ); spokes.Append( -endpoint.x, thermalBridgeWidth ); spokes.Append( -startpoint.x, thermalBridgeWidth ); spokes.Append( -startpoint.x, -thermalBridgeWidth ); break; } aCornerBuffer.NewOutline(); // add computed polygon to list for( int ic = 0; ic < spokes.PointCount(); ic++ ) { auto cpos = spokes.CPoint( ic ); RotatePoint( cpos, fAngle ); // Rotate according to module orientation cpos += pad->ShapePos(); // Shift origin to position aCornerBuffer.Append( cpos ); } } } } }
EDA_RECT& EDA_RECT::Inflate( int aDelta ) { Inflate( aDelta, aDelta ); return *this; }
void CSG_Rect::Deflate(double dx, double dy, bool bPercent) { Inflate(-dx, -dy, bPercent); }
UnicodeString& Unlink() {Inflate(m_pData->GetLength()+1); return *this;}