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 */
}
}
