void SplashInitPlatform(Splash * splash) { HDC hdc; int paletteMode; InitializeCriticalSection(&splash->lock); splash->isLayered = FALSE; hdc = GetDC(NULL); paletteMode = (GetDeviceCaps(hdc, RASTERCAPS) & RC_PALETTE) != 0; if (UpdateLayeredWindow && !paletteMode) { splash->isLayered = TRUE; } splash->byteAlignment = 4; if (splash->isLayered) { initFormat(&splash->screenFormat, 0x00ff0000, 0x0000ff00, 0x000000ff, 0xff000000); splash->screenFormat.premultiplied = 1; splash->maskRequired = 0; } else { splash->maskRequired = 1; if (paletteMode) { int numColors = GetDeviceCaps(hdc, SIZEPALETTE) - GetDeviceCaps(hdc, NUMRESERVED); int i; int numComponents[3]; initFormat(&splash->screenFormat, 0, 0, 0, 0); /* FIXME: maybe remapping to non-reserved colors would improve performance */ for (i = 0; i < numColors; i++) { splash->colorIndex[i] = i; } numColors = quantizeColors(numColors, numComponents); initColorCube(numComponents, splash->colorMap, splash->dithers, splash->colorIndex); splash->screenFormat.colorIndex = splash->colorIndex; splash->screenFormat.depthBytes = 1; splash->screenFormat.colorMap = splash->colorMap; splash->screenFormat.dithers = splash->dithers; splash->screenFormat.numColors = numColors; splash->hPalette = NULL; } else { initFormat(&splash->screenFormat, 0x00ff0000, 0x0000ff00, 0x000000ff, 0xff000000); } } ReleaseDC(NULL, hdc); }
/* * Class: java_awt_SplashScreen * Method: _update * Signature: (J[IIIIII)V */ JNIEXPORT void JNICALL Java_java_awt_SplashScreen__1update(JNIEnv * env, jclass thisClass, jlong jsplash, jintArray data, jint x, jint y, jint width, jint height, jint stride) { Splash *splash = (Splash *) jlong_to_ptr(jsplash); int dataSize; if (!splash) { return; } SplashLock(splash); dataSize = (*env)->GetArrayLength(env, data); if (splash->overlayData) { free(splash->overlayData); } splash->overlayData = malloc(dataSize * sizeof(rgbquad_t)); if (splash->overlayData) { /* we need a copy anyway, so we'll be using GetIntArrayRegion */ (*env)->GetIntArrayRegion(env, data, 0, dataSize, (jint *) splash->overlayData); initFormat(&splash->overlayFormat, 0xFF0000, 0xFF00, 0xFF, 0xFF000000); initRect(&splash->overlayRect, x, y, width, height, 1, stride * sizeof(rgbquad_t), splash->overlayData, &splash->overlayFormat); SplashUpdate(splash); } SplashUnlock(splash); }
SPLASHEXPORT void SplashInit() { Splash *splash = SplashGetInstance(); memset(splash, 0, sizeof(Splash)); splash->currentFrame = -1; initFormat(&splash->imageFormat, QUAD_RED_MASK, QUAD_GREEN_MASK, QUAD_BLUE_MASK, QUAD_ALPHA_MASK); SplashInitPlatform(splash); }
int SplashDecodeJpeg(Splash * splash, struct jpeg_decompress_struct *cinfo) { int rowStride, stride; JSAMPARRAY buffer; ImageFormat srcFormat; jpeg_read_header(cinfo, TRUE); jpeg_start_decompress(cinfo); SplashCleanup(splash); splash->width = cinfo->output_width; splash->height = cinfo->output_height; stride = splash->width * splash->imageFormat.depthBytes; splash->frameCount = 1; splash->frames = (SplashImage *) malloc(sizeof(SplashImage) * splash->frameCount); memset(splash->frames, 0, sizeof(SplashImage) * splash->frameCount); splash->loopCount = 1; splash->frames[0].bitmapBits = malloc(stride * splash->height); splash->frames[0].delay = 0; rowStride = cinfo->output_width * cinfo->output_components; buffer = (*cinfo->mem->alloc_sarray) ((j_common_ptr) cinfo, JPOOL_IMAGE, rowStride, 1); initFormat(&srcFormat, 0x00FF0000, 0x0000FF00, 0x000000FF, 0x00000000); srcFormat.byteOrder = BYTE_ORDER_LSBFIRST; srcFormat.depthBytes = 3; srcFormat.fixedBits = 0xFF000000; splash->maskRequired = 0; // reset maskRequired as JPEG can't be transparent while (cinfo->output_scanline < cinfo->output_height) { rgbquad_t *out = (rgbquad_t *) ((byte_t *) splash->frames[0].bitmapBits + cinfo->output_scanline * stride); jpeg_read_scanlines(cinfo, buffer, 1); convertLine(buffer[0], sizeof(JSAMPLE) * 3, out, splash->imageFormat.depthBytes, cinfo->output_width, &srcFormat, &splash->imageFormat, CVT_COPY, NULL, 0, NULL, cinfo->output_scanline, 0); } jpeg_finish_decompress(cinfo); return 1; }
FuncInstr::FuncInstr( uint32 bytes, uint32 PC) : instr(bytes), PC(PC) { src1 = src2 = dst = REG_NUM_ZERO; complete = false; initFormat(); switch ( format) { case FORMAT_R: initR(); break; case FORMAT_I: initI(); break; case FORMAT_J: initJ(); break; case FORMAT_UNKNOWN: initUnknown(); break; } new_PC = PC + 4; }
/// (Internal) Prepare to play. Stop the currently playing buffers, and set the correct voice settings. bool CSourceXAudio2::preparePlay(IBuffer::TBufferFormat bufferFormat, uint8 channels, uint8 bitsPerSample, uint32 frequency) { if (_IsPlaying) { // nlwarning(NLSOUND_XAUDIO2_PREFIX "Called play() while _IsPlaying == true!"); // stop the currently playing voice if it's of the same type as we need if (bufferFormat == _Format && channels == _Channels && bitsPerSample == _BitsPerSample) // cannot call stop directly before destroy voice, ms bug in xaudio2, see msdn docs stop(); // sets _IsPlaying = false; } if (_SourceVoice && (bufferFormat != _Format || channels != _Channels || bitsPerSample != _BitsPerSample)) { nlwarning(NLSOUND_XAUDIO2_PREFIX "Switching format %u to %u!", (uint32)_Format, (uint32)bufferFormat); // destroy existing voice _SoundDriver->getXAudio2()->CommitChanges(_OperationSet); _SoundDriver->destroySourceVoice(_SourceVoice); _SourceVoice = NULL; // destroy adpcm utility (if it exists) delete _AdpcmUtility; _AdpcmUtility = NULL; // reset current stuff _Format = IBuffer::FormatNotSet; _Channels = 0; _BitsPerSample = 0; } if (frequency != _Frequency) { if (_SourceVoice) { setupDirectFilter(); setupEffectFilter(); _SourceVoice->SetSourceSampleRate(frequency); } _Frequency = frequency; } if (!_SourceVoice) { // initialize a source voice with this format if (!initFormat(bufferFormat, channels, bitsPerSample)) { nlwarning(NLSOUND_XAUDIO2_PREFIX "Fail to init voice!"); return false; } _SourceVoice->SetSourceSampleRate(frequency); if (!_BufferStreaming) { // notify other sources about this format, so they can make a voice in advance // we know that there is a very high chance that all sources use same format // so this gives better results at runtime (avoids sound clicks etc) _SoundDriver->initSourcesFormat(_Format, _Channels, _BitsPerSample); } } commit3DChanges(); // sets pitch etc // test //XAUDIO2_VOICE_DETAILS voice_details; //_SourceVoice->GetVoiceDetails(&voice_details); //nlinfo("voice_details.InputSampleRate: '%u'", voice_details.InputSampleRate); // test return true; }
int SplashDecodePng(Splash * splash, png_rw_ptr read_func, void *io_ptr) { int stride; ImageFormat srcFormat; png_uint_32 i, rowbytes; png_bytepp row_pointers = NULL; png_bytep image_data = NULL; int success = 0; double gamma; png_structp png_ptr = NULL; png_infop info_ptr = NULL; png_uint_32 width, height; int bit_depth, color_type; ImageRect srcRect, dstRect; png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL); if (!png_ptr) { goto done; } info_ptr = png_create_info_struct(png_ptr); if (!info_ptr) { goto done; } if (setjmp(png_ptr->jmpbuf)) { goto done; } png_ptr->io_ptr = io_ptr; png_ptr->read_data_fn = read_func; png_set_sig_bytes(png_ptr, SIG_BYTES); /* we already read the 8 signature bytes */ png_read_info(png_ptr, info_ptr); /* read all PNG info up to image data */ png_get_IHDR(png_ptr, info_ptr, &width, &height, &bit_depth, &color_type, NULL, NULL, NULL); /* expand palette images to RGB, low-bit-depth grayscale images to 8 bits, * transparency chunks to full alpha channel; strip 16-bit-per-sample * images to 8 bits per sample; and convert grayscale to RGB[A] * this may be sub-optimal but this simplifies implementation */ png_set_expand(png_ptr); png_set_tRNS_to_alpha(png_ptr); png_set_filler(png_ptr, 0xff, PNG_FILLER_AFTER); png_set_strip_16(png_ptr); png_set_gray_to_rgb(png_ptr); if (png_get_gAMA(png_ptr, info_ptr, &gamma)) png_set_gamma(png_ptr, 2.2, gamma); png_read_update_info(png_ptr, info_ptr); rowbytes = png_get_rowbytes(png_ptr, info_ptr); if (!SAFE_TO_ALLOC(rowbytes, height)) { goto done; } if ((image_data = (unsigned char *) malloc(rowbytes * height)) == NULL) { goto done; } if (!SAFE_TO_ALLOC(height, sizeof(png_bytep))) { goto done; } if ((row_pointers = (png_bytepp) malloc(height * sizeof(png_bytep))) == NULL) { goto done; } for (i = 0; i < height; ++i) row_pointers[i] = image_data + i * rowbytes; png_read_image(png_ptr, row_pointers); SplashCleanup(splash); splash->width = width; splash->height = height; if (!SAFE_TO_ALLOC(splash->width, splash->imageFormat.depthBytes)) { goto done; } stride = splash->width * splash->imageFormat.depthBytes; if (!SAFE_TO_ALLOC(splash->height, stride)) { goto done; } splash->frameCount = 1; splash->frames = (SplashImage *) malloc(sizeof(SplashImage) * splash->frameCount); if (splash->frames == NULL) { goto done; } splash->loopCount = 1; splash->frames[0].bitmapBits = malloc(stride * splash->height); if (splash->frames[0].bitmapBits == NULL) { free(splash->frames); goto done; } splash->frames[0].delay = 0; /* FIXME: sort out the real format */ initFormat(&srcFormat, 0xFF000000, 0x00FF0000, 0x0000FF00, 0x000000FF); srcFormat.byteOrder = BYTE_ORDER_MSBFIRST; initRect(&srcRect, 0, 0, width, height, 1, rowbytes, image_data, &srcFormat); initRect(&dstRect, 0, 0, width, height, 1, stride, splash->frames[0].bitmapBits, &splash->imageFormat); convertRect(&srcRect, &dstRect, CVT_COPY); SplashInitFrameShape(splash, 0); png_read_end(png_ptr, NULL); success = 1; done: free(row_pointers); free(image_data); png_destroy_read_struct(&png_ptr, &info_ptr, NULL); return success; }
void SplashInitPlatform(Splash * splash) { int shapeVersionMajor, shapeVersionMinor; // This setting enables the synchronous Xlib mode! // Don't use it == 1 in production builds! #if (defined DEBUG) _Xdebug = 1; #endif pthread_mutex_init(&splash->lock, NULL); // We should not ignore any errors. //XSetErrorHandler(HandleError); // XSetIOErrorHandler(HandleIOError); XSetIOErrorHandler(NULL); splash->display = XOpenDisplay(NULL); if (!splash->display) { splash->isVisible = -1; return; } shapeSupported = XShapeQueryExtension(splash->display, &shapeEventBase, &shapeErrorBase); if (shapeSupported) { XShapeQueryVersion(splash->display, &shapeVersionMajor, &shapeVersionMinor); } splash->screen = XDefaultScreenOfDisplay(splash->display); splash->visual = XDefaultVisualOfScreen(splash->screen); switch (splash->visual->class) { case TrueColor: { int depth = XDefaultDepthOfScreen(splash->screen); splash->byteAlignment = 1; splash->maskRequired = shapeSupported; initFormat(&splash->screenFormat, splash->visual->red_mask, splash->visual->green_mask, splash->visual->blue_mask, 0); splash->screenFormat.byteOrder = (XImageByteOrder(splash->display) == LSBFirst ? BYTE_ORDER_LSBFIRST : BYTE_ORDER_MSBFIRST); splash->screenFormat.depthBytes = (depth + 7) / 8; // TrueColor depth probably can't be less // than 8 bits, and it's always byte padded break; } case PseudoColor: { int availableColors; int numColors; int numComponents[3]; unsigned long colorIndex[SPLASH_COLOR_MAP_SIZE]; XColor xColors[SPLASH_COLOR_MAP_SIZE]; int i; int depth = XDefaultDepthOfScreen(splash->screen); int scale = 65535 / MAX_COLOR_VALUE; availableColors = GetNumAvailableColors(splash->display, splash->screen, splash->visual->map_entries); numColors = quantizeColors(availableColors, numComponents); if (numColors > availableColors) { // Could not allocate the color cells. Most probably // the pool got exhausted. Disable the splash screen. XCloseDisplay(splash->display); splash->isVisible = -1; splash->display = NULL; splash->screen = NULL; splash->visual = NULL; fprintf(stderr, "Warning: unable to initialize the splashscreen. Not enough available color cells.\n"); return; } splash->cmap = AllocColors(splash->display, splash->screen, numColors, colorIndex); for (i = 0; i < numColors; i++) { splash->colorIndex[i] = colorIndex[i]; } initColorCube(numComponents, splash->colorMap, splash->dithers, splash->colorIndex); for (i = 0; i < numColors; i++) { xColors[i].pixel = colorIndex[i]; xColors[i].red = (unsigned short) QUAD_RED(splash->colorMap[colorIndex[i]]) * scale; xColors[i].green = (unsigned short) QUAD_GREEN(splash->colorMap[colorIndex[i]]) * scale; xColors[i].blue = (unsigned short) QUAD_BLUE(splash->colorMap[colorIndex[i]]) * scale; xColors[i].flags = DoRed | DoGreen | DoBlue; } XStoreColors(splash->display, splash->cmap, xColors, numColors); initFormat(&splash->screenFormat, 0, 0, 0, 0); splash->screenFormat.colorIndex = splash->colorIndex; splash->screenFormat.depthBytes = (depth + 7) / 8; // or always 8? splash->screenFormat.colorMap = splash->colorMap; splash->screenFormat.dithers = splash->dithers; splash->screenFormat.numColors = numColors; splash->screenFormat.byteOrder = BYTE_ORDER_NATIVE; break; } default: ; /* FIXME: should probably be fixed, but javaws splash screen doesn't support other visuals either */ } }