STATIC_INLINE VC_CONTAINER_STATUS_T ps_find_start_code( VC_CONTAINER_T *ctx, uint8_t *buffer ) { unsigned int i; /* Scan for a pack or PES packet start code prefix */ for (i = 0; i < PS_SYNC_FAIL_MAX; ++i) { if(PEEK_BYTES(ctx, buffer, 4) < 4) return VC_CONTAINER_ERROR_EOS; if(buffer[0] == 0x0 && buffer[1] == 0x0 && buffer[2] == 0x1 && buffer[3] >= 0xB9) break; if (SKIP_BYTES(ctx, 1) != 1) return VC_CONTAINER_ERROR_EOS; } if(i == PS_SYNC_FAIL_MAX) /* We didn't find a valid pack or PES packet */ return VC_CONTAINER_ERROR_FORMAT_NOT_SUPPORTED; if (buffer[3] == 0xB9) /* MPEG_program_end_code */ return VC_CONTAINER_ERROR_EOS; return VC_CONTAINER_SUCCESS; }
static VC_CONTAINER_STATUS_T avi_finish_data_chunk( VC_CONTAINER_T *p_ctx, uint32_t chunk_size ) { VC_CONTAINER_STATUS_T status = VC_CONTAINER_SUCCESS; if (chunk_size) { /* Rewrite the chunk size, this won't be efficient if it happens often */ if (STREAM_SEEKABLE(p_ctx)) { SEEK(p_ctx, STREAM_POSITION(p_ctx) - chunk_size - 4); WRITE_U32(p_ctx, chunk_size, "Chunk Size"); SKIP_BYTES(p_ctx, chunk_size); } else { LOG_DEBUG(p_ctx, "warning, can't rewrite chunk size, data will be malformed"); status = VC_CONTAINER_ERROR_FAILED; } } AVI_END_CHUNK(p_ctx); if (status != VC_CONTAINER_SUCCESS) status = STREAM_STATUS(p_ctx); return status; }
static VC_CONTAINER_STATUS_T ps_read_system_header( VC_CONTAINER_T *ctx ) { uint8_t header[8]; uint32_t length; VC_CONTAINER_BITS_T bits; if(_READ_U32(ctx) != 0x1BB) return VC_CONTAINER_ERROR_CORRUPTED; LOG_FORMAT(ctx, "system_header"); ctx->priv->module->level++; length = READ_U16(ctx, "header_length"); if(length < 6) return VC_CONTAINER_ERROR_CORRUPTED; if(READ_BYTES(ctx, header, 6) != 6) return VC_CONTAINER_ERROR_EOS; BITS_INIT(ctx, &bits, header, 6); if(BITS_READ_U32(ctx, &bits, 1, "marker_bit") != 0x1) return VC_CONTAINER_ERROR_CORRUPTED; BITS_SKIP(ctx, &bits, 22, "rate_bound"); if(BITS_READ_U32(ctx, &bits, 1, "marker_bit") != 0x1) return VC_CONTAINER_ERROR_CORRUPTED; BITS_SKIP(ctx, &bits, 6, "audio_bound"); BITS_SKIP(ctx, &bits, 1, "fixed_flag"); BITS_SKIP(ctx, &bits, 1, "CSPS_flag"); BITS_SKIP(ctx, &bits, 1, "system_audio_lock_flag"); BITS_SKIP(ctx, &bits, 1, "system_video_lock_flag"); if(BITS_READ_U32(ctx, &bits, 1, "marker_bit") != 0x1) return VC_CONTAINER_ERROR_CORRUPTED; BITS_SKIP(ctx, &bits, 5, "video_bound"); BITS_SKIP(ctx, &bits, 1, "packet_rate_restriction_flag"); BITS_SKIP(ctx, &bits, 7, "reserved_bits"); length -= 6; while(length >= 3 && (PEEK_U8(ctx) & 0x80)) { SKIP_U8(ctx, "stream_id"); SKIP_BYTES(ctx, 2); length -= 3; } SKIP_BYTES(ctx, length); ctx->priv->module->level--; return STREAM_STATUS(ctx); }
/***************************************************************************** Functions exported as part of the Container Module API *****************************************************************************/ static VC_CONTAINER_STATUS_T binary_reader_read( VC_CONTAINER_T *p_ctx, VC_CONTAINER_PACKET_T *packet, uint32_t flags ) { VC_CONTAINER_MODULE_T *module = p_ctx->priv->module; unsigned int size; if(module->status != VC_CONTAINER_SUCCESS) return module->status; if(!module->block_size) { module->block_size = module->default_block_size; module->init = 0; } packet->size = module->block_size; packet->dts = packet->pts = VC_CONTAINER_TIME_UNKNOWN; if(module->init) packet->dts = packet->pts = 0; packet->track = 0; packet->flags = 0; if(flags & VC_CONTAINER_READ_FLAG_SKIP) { size = SKIP_BYTES(p_ctx, module->block_size); module->block_size -= size; module->status = STREAM_STATUS(p_ctx); return module->status; } if(flags & VC_CONTAINER_READ_FLAG_INFO) return VC_CONTAINER_SUCCESS; size = MIN(module->block_size, packet->buffer_size); size = READ_BYTES(p_ctx, packet->data, size); module->block_size -= size; packet->size = size; module->status = size ? VC_CONTAINER_SUCCESS : STREAM_STATUS(p_ctx); return module->status; }
const TUSBDescriptor *CUSBConfigurationParser::GetDescriptor (u8 ucType) { assert (m_bValid); const TUSBDescriptor *pResult = 0; while (m_pNextPosition < m_pEndPosition) { u8 ucDescLen = m_pNextPosition->Header.bLength; u8 ucDescType = m_pNextPosition->Header.bDescriptorType; TUSBDescriptor *pDescEnd = SKIP_BYTES (m_pNextPosition, ucDescLen); assert (pDescEnd <= m_pEndPosition); if ( ucType == DESCRIPTOR_ENDPOINT && ucDescType == DESCRIPTOR_INTERFACE) { break; } if (ucDescType == ucType) { pResult = m_pNextPosition; m_pNextPosition = pDescEnd; break; } m_pNextPosition = pDescEnd; } if (pResult != 0) { m_pErrorPosition = pResult; } m_pCurrentDescriptor = pResult; return pResult; }
const TUSBDescriptor *USBConfigurationParserGetDescriptor (TUSBConfigurationParser *pThis, u8 ucType) { assert (pThis != 0); assert (pThis->m_bValid); const TUSBDescriptor *pResult = 0; while (pThis->m_pCurrentPosition < pThis->m_pEndPosition) { u8 ucDescLen = pThis->m_pCurrentPosition->Header.bLength; u8 ucDescType = pThis->m_pCurrentPosition->Header.bDescriptorType; TUSBDescriptor *pDescEnd = SKIP_BYTES (pThis->m_pCurrentPosition, ucDescLen); assert (pDescEnd <= pThis->m_pEndPosition); if ( ucType == DESCRIPTOR_ENDPOINT && ucDescType == DESCRIPTOR_INTERFACE) { break; } if (ucDescType == ucType) { pResult = pThis->m_pCurrentPosition; pThis->m_pCurrentPosition = pDescEnd; break; } pThis->m_pCurrentPosition = pDescEnd; } if (pResult != 0) { pThis->m_pErrorPosition = pResult; } return pResult; }
patmanInstrument::LoadErrors patmanInstrument::loadPatch( const QString & _filename ) { unloadCurrentPatch(); FILE * fd = fopen( _filename.toUtf8().constData() , "rb" ); if( !fd ) { perror( "fopen" ); return LoadOpen; } unsigned char header[239]; if( fread( header, 1, 239, fd ) != 239 || ( memcmp( header, "GF1PATCH110\0ID#000002", 22 ) && memcmp( header, "GF1PATCH100\0ID#000002", 22 ) ) ) { fclose( fd ); return LoadNotGUS; } if( header[82] != 1 && header[82] != 0 ) { fclose( fd ); return LoadInstruments; } if( header[151] != 1 && header[151] != 0 ) { fclose( fd ); return LoadLayers; } int sample_count = header[198]; for( int i = 0; i < sample_count; ++i ) { unsigned short tmpshort; #define SKIP_BYTES( x ) \ if ( fseek( fd, x, SEEK_CUR ) == -1 ) \ { \ fclose( fd ); \ return LoadIO; \ } #define READ_SHORT( x ) \ if ( fread( &tmpshort, 2, 1, fd ) != 1 ) \ { \ fclose( fd ); \ return LoadIO; \ } \ x = (unsigned short)swap16IfBE( tmpshort ); #define READ_LONG( x ) \ if ( fread( &x, 4, 1, fd ) != 1 ) \ { \ fclose( fd ); \ return LoadIO; \ } \ x = (unsigned)swap32IfBE( x ); // skip wave name, fractions SKIP_BYTES( 7 + 1 ); unsigned data_length; READ_LONG( data_length ); unsigned loop_start; READ_LONG( loop_start ); unsigned loop_end; READ_LONG( loop_end ); unsigned sample_rate; READ_SHORT( sample_rate ); // skip low_freq, high_freq SKIP_BYTES( 4 + 4 ); unsigned root_freq; READ_LONG( root_freq ); // skip tuning, panning, envelope, tremolo, vibrato SKIP_BYTES( 2 + 1 + 12 + 3 + 3 ); unsigned char modes; if ( fread( &modes, 1, 1, fd ) != 1 ) { fclose( fd ); return LoadIO; } // skip scale frequency, scale factor, reserved space SKIP_BYTES( 2 + 2 + 36 ); f_cnt_t frames; sample_t * wave_samples; if( modes & MODES_16BIT ) { frames = data_length >> 1; wave_samples = new sample_t[frames]; for( f_cnt_t frame = 0; frame < frames; ++frame ) { short sample; if ( fread( &sample, 2, 1, fd ) != 1 ) { delete[] wave_samples; fclose( fd ); return LoadIO; } sample = swap16IfBE( sample ); if( modes & MODES_UNSIGNED ) { sample ^= 0x8000; } wave_samples[frame] = sample / 32767.0f; } loop_start >>= 1; loop_end >>= 1; } else {
CUSBConfigurationParser::CUSBConfigurationParser (const void *pBuffer, unsigned nBufLen) : m_pBuffer ((TUSBDescriptor *) pBuffer), m_nBufLen (nBufLen), m_bValid (FALSE), m_pEndPosition (SKIP_BYTES (m_pBuffer, nBufLen)), m_pNextPosition (m_pBuffer), m_pCurrentDescriptor (0), m_pErrorPosition (m_pBuffer) { assert (m_pBuffer != 0); if ( m_nBufLen < 4 // wTotalLength must exist || m_nBufLen > 512) // best guess { return; } if ( m_pBuffer->Configuration.bLength != sizeof (TUSBConfigurationDescriptor) || m_pBuffer->Configuration.bDescriptorType != DESCRIPTOR_CONFIGURATION || m_pBuffer->Configuration.wTotalLength > nBufLen) { return; } if (m_pBuffer->Configuration.wTotalLength < nBufLen) { m_pEndPosition = SKIP_BYTES (m_pBuffer, m_pBuffer->Configuration.wTotalLength); } const TUSBDescriptor *pCurrentPosition = m_pBuffer; u8 ucLastDescType = 0; while (SKIP_BYTES (pCurrentPosition, 2) < m_pEndPosition) { u8 ucDescLen = pCurrentPosition->Header.bLength; u8 ucDescType = pCurrentPosition->Header.bDescriptorType; TUSBDescriptor *pDescEnd = SKIP_BYTES (pCurrentPosition, ucDescLen); if (pDescEnd > m_pEndPosition) { m_pErrorPosition = pCurrentPosition; return; } u8 ucExpectedLen = 0; switch (ucDescType) { case DESCRIPTOR_CONFIGURATION: if (ucLastDescType != 0) { m_pErrorPosition = pCurrentPosition; return; } ucExpectedLen = sizeof (TUSBConfigurationDescriptor); break; case DESCRIPTOR_INTERFACE: if (ucLastDescType == 0) { m_pErrorPosition = pCurrentPosition; return; } ucExpectedLen = sizeof (TUSBInterfaceDescriptor); break; case DESCRIPTOR_ENDPOINT: if ( ucLastDescType == 0 || ucLastDescType == DESCRIPTOR_CONFIGURATION) { m_pErrorPosition = pCurrentPosition; return; } ucExpectedLen = sizeof (TUSBEndpointDescriptor); break; default: break; } if ( ucExpectedLen != 0 && ucDescLen != ucExpectedLen) { m_pErrorPosition = pCurrentPosition; return; } ucLastDescType = ucDescType; pCurrentPosition = pDescEnd; } if (pCurrentPosition != m_pEndPosition) { m_pErrorPosition = pCurrentPosition; return; } m_bValid = TRUE; }
JNIEXPORT void JNICALL Java_sun_java2d_opengl_OGLRenderQueue_flushBuffer (JNIEnv *env, jobject oglrq, jlong buf, jint limit) { jboolean sync = JNI_FALSE; unsigned char *b, *end; J2dTraceLn1(J2D_TRACE_INFO, "OGLRenderQueue_flushBuffer: limit=%d", limit); b = (unsigned char *)jlong_to_ptr(buf); if (b == NULL) { J2dRlsTraceLn(J2D_TRACE_ERROR, "OGLRenderQueue_flushBuffer: cannot get direct buffer address"); return; } INIT_PREVIOUS_OP(); end = b + limit; while (b < end) { jint opcode = NEXT_INT(b); J2dTraceLn2(J2D_TRACE_VERBOSE, "OGLRenderQueue_flushBuffer: opcode=%d, rem=%d", opcode, (end-b)); switch (opcode) { // draw ops case sun_java2d_pipe_BufferedOpCodes_DRAW_LINE: { jint x1 = NEXT_INT(b); jint y1 = NEXT_INT(b); jint x2 = NEXT_INT(b); jint y2 = NEXT_INT(b); OGLRenderer_DrawLine(oglc, x1, y1, x2, y2); } break; case sun_java2d_pipe_BufferedOpCodes_DRAW_RECT: { jint x = NEXT_INT(b); jint y = NEXT_INT(b); jint w = NEXT_INT(b); jint h = NEXT_INT(b); OGLRenderer_DrawRect(oglc, x, y, w, h); } break; case sun_java2d_pipe_BufferedOpCodes_DRAW_POLY: { jint nPoints = NEXT_INT(b); jboolean isClosed = NEXT_BOOLEAN(b); jint transX = NEXT_INT(b); jint transY = NEXT_INT(b); jint *xPoints = (jint *)b; jint *yPoints = ((jint *)b) + nPoints; OGLRenderer_DrawPoly(oglc, nPoints, isClosed, transX, transY, xPoints, yPoints); SKIP_BYTES(b, nPoints * BYTES_PER_POLY_POINT); } break; case sun_java2d_pipe_BufferedOpCodes_DRAW_PIXEL: { jint x = NEXT_INT(b); jint y = NEXT_INT(b); // Note that we could use GL_POINTS here, but the common // use case for DRAW_PIXEL is when rendering a Path2D, // which will consist of a mix of DRAW_PIXEL and DRAW_LINE // calls. So to improve batching we use GL_LINES here, // even though it requires an extra vertex per pixel. CONTINUE_IF_NULL(oglc); CHECK_PREVIOUS_OP(GL_LINES); j2d_glVertex2i(x, y); j2d_glVertex2i(x+1, y+1); } break; case sun_java2d_pipe_BufferedOpCodes_DRAW_SCANLINES: { jint count = NEXT_INT(b); OGLRenderer_DrawScanlines(oglc, count, (jint *)b); SKIP_BYTES(b, count * BYTES_PER_SCANLINE); } break; case sun_java2d_pipe_BufferedOpCodes_DRAW_PARALLELOGRAM: { jfloat x11 = NEXT_FLOAT(b); jfloat y11 = NEXT_FLOAT(b); jfloat dx21 = NEXT_FLOAT(b); jfloat dy21 = NEXT_FLOAT(b); jfloat dx12 = NEXT_FLOAT(b); jfloat dy12 = NEXT_FLOAT(b); jfloat lwr21 = NEXT_FLOAT(b); jfloat lwr12 = NEXT_FLOAT(b); OGLRenderer_DrawParallelogram(oglc, x11, y11, dx21, dy21, dx12, dy12, lwr21, lwr12); } break; case sun_java2d_pipe_BufferedOpCodes_DRAW_AAPARALLELOGRAM: { jfloat x11 = NEXT_FLOAT(b); jfloat y11 = NEXT_FLOAT(b); jfloat dx21 = NEXT_FLOAT(b); jfloat dy21 = NEXT_FLOAT(b); jfloat dx12 = NEXT_FLOAT(b); jfloat dy12 = NEXT_FLOAT(b); jfloat lwr21 = NEXT_FLOAT(b); jfloat lwr12 = NEXT_FLOAT(b); OGLRenderer_DrawAAParallelogram(oglc, dstOps, x11, y11, dx21, dy21, dx12, dy12, lwr21, lwr12); } break; // fill ops case sun_java2d_pipe_BufferedOpCodes_FILL_RECT: { jint x = NEXT_INT(b); jint y = NEXT_INT(b); jint w = NEXT_INT(b); jint h = NEXT_INT(b); OGLRenderer_FillRect(oglc, x, y, w, h); } break; case sun_java2d_pipe_BufferedOpCodes_FILL_SPANS: { jint count = NEXT_INT(b); OGLRenderer_FillSpans(oglc, count, (jint *)b); SKIP_BYTES(b, count * BYTES_PER_SPAN); } break; case sun_java2d_pipe_BufferedOpCodes_FILL_PARALLELOGRAM: { jfloat x11 = NEXT_FLOAT(b); jfloat y11 = NEXT_FLOAT(b); jfloat dx21 = NEXT_FLOAT(b); jfloat dy21 = NEXT_FLOAT(b); jfloat dx12 = NEXT_FLOAT(b); jfloat dy12 = NEXT_FLOAT(b); OGLRenderer_FillParallelogram(oglc, x11, y11, dx21, dy21, dx12, dy12); } break; case sun_java2d_pipe_BufferedOpCodes_FILL_AAPARALLELOGRAM: { jfloat x11 = NEXT_FLOAT(b); jfloat y11 = NEXT_FLOAT(b); jfloat dx21 = NEXT_FLOAT(b); jfloat dy21 = NEXT_FLOAT(b); jfloat dx12 = NEXT_FLOAT(b); jfloat dy12 = NEXT_FLOAT(b); OGLRenderer_FillAAParallelogram(oglc, dstOps, x11, y11, dx21, dy21, dx12, dy12); } break; // text-related ops case sun_java2d_pipe_BufferedOpCodes_DRAW_GLYPH_LIST: { jint numGlyphs = NEXT_INT(b); jint packedParams = NEXT_INT(b); jfloat glyphListOrigX = NEXT_FLOAT(b); jfloat glyphListOrigY = NEXT_FLOAT(b); jboolean usePositions = EXTRACT_BOOLEAN(packedParams, OFFSET_POSITIONS); jboolean subPixPos = EXTRACT_BOOLEAN(packedParams, OFFSET_SUBPIXPOS); jboolean rgbOrder = EXTRACT_BOOLEAN(packedParams, OFFSET_RGBORDER); jint lcdContrast = EXTRACT_BYTE(packedParams, OFFSET_CONTRAST); unsigned char *images = b; unsigned char *positions; jint bytesPerGlyph; if (usePositions) { positions = (b + numGlyphs * BYTES_PER_GLYPH_IMAGE); bytesPerGlyph = BYTES_PER_POSITIONED_GLYPH; } else { positions = NULL; bytesPerGlyph = BYTES_PER_GLYPH_IMAGE; } OGLTR_DrawGlyphList(env, oglc, dstOps, numGlyphs, usePositions, subPixPos, rgbOrder, lcdContrast, glyphListOrigX, glyphListOrigY, images, positions); SKIP_BYTES(b, numGlyphs * bytesPerGlyph); } break; // copy-related ops case sun_java2d_pipe_BufferedOpCodes_COPY_AREA: { jint x = NEXT_INT(b); jint y = NEXT_INT(b); jint w = NEXT_INT(b); jint h = NEXT_INT(b); jint dx = NEXT_INT(b); jint dy = NEXT_INT(b); OGLBlitLoops_CopyArea(env, oglc, dstOps, x, y, w, h, dx, dy); } break; case sun_java2d_pipe_BufferedOpCodes_BLIT: { jint packedParams = NEXT_INT(b); jint sx1 = NEXT_INT(b); jint sy1 = NEXT_INT(b); jint sx2 = NEXT_INT(b); jint sy2 = NEXT_INT(b); jdouble dx1 = NEXT_DOUBLE(b); jdouble dy1 = NEXT_DOUBLE(b); jdouble dx2 = NEXT_DOUBLE(b); jdouble dy2 = NEXT_DOUBLE(b); jlong pSrc = NEXT_LONG(b); jlong pDst = NEXT_LONG(b); jint hint = EXTRACT_BYTE(packedParams, OFFSET_HINT); jboolean texture = EXTRACT_BOOLEAN(packedParams, OFFSET_TEXTURE); jboolean rtt = EXTRACT_BOOLEAN(packedParams, OFFSET_RTT); jboolean xform = EXTRACT_BOOLEAN(packedParams, OFFSET_XFORM); jboolean isoblit = EXTRACT_BOOLEAN(packedParams, OFFSET_ISOBLIT); if (isoblit) { OGLBlitLoops_IsoBlit(env, oglc, pSrc, pDst, xform, hint, texture, rtt, sx1, sy1, sx2, sy2, dx1, dy1, dx2, dy2); } else { jint srctype = EXTRACT_BYTE(packedParams, OFFSET_SRCTYPE); OGLBlitLoops_Blit(env, oglc, pSrc, pDst, xform, hint, srctype, texture, sx1, sy1, sx2, sy2, dx1, dy1, dx2, dy2); } } break; case sun_java2d_pipe_BufferedOpCodes_SURFACE_TO_SW_BLIT: { jint sx = NEXT_INT(b); jint sy = NEXT_INT(b); jint dx = NEXT_INT(b); jint dy = NEXT_INT(b); jint w = NEXT_INT(b); jint h = NEXT_INT(b); jint dsttype = NEXT_INT(b); jlong pSrc = NEXT_LONG(b); jlong pDst = NEXT_LONG(b); OGLBlitLoops_SurfaceToSwBlit(env, oglc, pSrc, pDst, dsttype, sx, sy, dx, dy, w, h); } break; case sun_java2d_pipe_BufferedOpCodes_MASK_FILL: { jint x = NEXT_INT(b); jint y = NEXT_INT(b); jint w = NEXT_INT(b); jint h = NEXT_INT(b); jint maskoff = NEXT_INT(b); jint maskscan = NEXT_INT(b); jint masklen = NEXT_INT(b); unsigned char *pMask = (masklen > 0) ? b : NULL; OGLMaskFill_MaskFill(oglc, x, y, w, h, maskoff, maskscan, masklen, pMask); SKIP_BYTES(b, masklen); } break; case sun_java2d_pipe_BufferedOpCodes_MASK_BLIT: { jint dstx = NEXT_INT(b); jint dsty = NEXT_INT(b); jint width = NEXT_INT(b); jint height = NEXT_INT(b); jint masklen = width * height * sizeof(jint); OGLMaskBlit_MaskBlit(env, oglc, dstx, dsty, width, height, b); SKIP_BYTES(b, masklen); } break; // state-related ops case sun_java2d_pipe_BufferedOpCodes_SET_RECT_CLIP: { jint x1 = NEXT_INT(b); jint y1 = NEXT_INT(b); jint x2 = NEXT_INT(b); jint y2 = NEXT_INT(b); OGLContext_SetRectClip(oglc, dstOps, x1, y1, x2, y2); } break; case sun_java2d_pipe_BufferedOpCodes_BEGIN_SHAPE_CLIP: { OGLContext_BeginShapeClip(oglc); } break; case sun_java2d_pipe_BufferedOpCodes_SET_SHAPE_CLIP_SPANS: { jint count = NEXT_INT(b); OGLRenderer_FillSpans(oglc, count, (jint *)b); SKIP_BYTES(b, count * BYTES_PER_SPAN); } break; case sun_java2d_pipe_BufferedOpCodes_END_SHAPE_CLIP: { OGLContext_EndShapeClip(oglc, dstOps); } break; case sun_java2d_pipe_BufferedOpCodes_RESET_CLIP: { OGLContext_ResetClip(oglc); } break; case sun_java2d_pipe_BufferedOpCodes_SET_ALPHA_COMPOSITE: { jint rule = NEXT_INT(b); jfloat extraAlpha = NEXT_FLOAT(b); jint flags = NEXT_INT(b); OGLContext_SetAlphaComposite(oglc, rule, extraAlpha, flags); } break; case sun_java2d_pipe_BufferedOpCodes_SET_XOR_COMPOSITE: { jint xorPixel = NEXT_INT(b); OGLContext_SetXorComposite(oglc, xorPixel); } break; case sun_java2d_pipe_BufferedOpCodes_RESET_COMPOSITE: { OGLContext_ResetComposite(oglc); } break; case sun_java2d_pipe_BufferedOpCodes_SET_TRANSFORM: { jdouble m00 = NEXT_DOUBLE(b); jdouble m10 = NEXT_DOUBLE(b); jdouble m01 = NEXT_DOUBLE(b); jdouble m11 = NEXT_DOUBLE(b); jdouble m02 = NEXT_DOUBLE(b); jdouble m12 = NEXT_DOUBLE(b); OGLContext_SetTransform(oglc, m00, m10, m01, m11, m02, m12); } break; case sun_java2d_pipe_BufferedOpCodes_RESET_TRANSFORM: { OGLContext_ResetTransform(oglc); } break; // context-related ops case sun_java2d_pipe_BufferedOpCodes_SET_SURFACES: { jlong pSrc = NEXT_LONG(b); jlong pDst = NEXT_LONG(b); if (oglc != NULL) { RESET_PREVIOUS_OP(); } oglc = OGLContext_SetSurfaces(env, pSrc, pDst); dstOps = (OGLSDOps *)jlong_to_ptr(pDst); } break; case sun_java2d_pipe_BufferedOpCodes_SET_SCRATCH_SURFACE: { jlong pConfigInfo = NEXT_LONG(b); if (oglc != NULL) { RESET_PREVIOUS_OP(); } oglc = OGLSD_SetScratchSurface(env, pConfigInfo); dstOps = NULL; } break; case sun_java2d_pipe_BufferedOpCodes_FLUSH_SURFACE: { jlong pData = NEXT_LONG(b); OGLSDOps *oglsdo = (OGLSDOps *)jlong_to_ptr(pData); if (oglsdo != NULL) { CONTINUE_IF_NULL(oglc); RESET_PREVIOUS_OP(); OGLSD_Delete(env, oglsdo); } } break; case sun_java2d_pipe_BufferedOpCodes_DISPOSE_SURFACE: { jlong pData = NEXT_LONG(b); OGLSDOps *oglsdo = (OGLSDOps *)jlong_to_ptr(pData); if (oglsdo != NULL) { CONTINUE_IF_NULL(oglc); RESET_PREVIOUS_OP(); OGLSD_Delete(env, oglsdo); if (oglsdo->privOps != NULL) { free(oglsdo->privOps); } } } break; case sun_java2d_pipe_BufferedOpCodes_DISPOSE_CONFIG: { jlong pConfigInfo = NEXT_LONG(b); CONTINUE_IF_NULL(oglc); RESET_PREVIOUS_OP(); OGLGC_DestroyOGLGraphicsConfig(pConfigInfo); // the previous method will call glX/wglMakeCurrent(None), // so we should nullify the current oglc and dstOps to avoid // calling glFlush() (or similar) while no context is current oglc = NULL; dstOps = NULL; } break; case sun_java2d_pipe_BufferedOpCodes_INVALIDATE_CONTEXT: { // flush just in case there are any pending operations in // the hardware pipe if (oglc != NULL) { RESET_PREVIOUS_OP(); j2d_glFlush(); } // invalidate the references to the current context and // destination surface that are maintained at the native level oglc = NULL; dstOps = NULL; } break; case sun_java2d_pipe_BufferedOpCodes_SAVE_STATE: { j2d_glPushAttrib(GL_ALL_ATTRIB_BITS); j2d_glPushClientAttrib(GL_CLIENT_ALL_ATTRIB_BITS); j2d_glMatrixMode(GL_MODELVIEW); j2d_glPushMatrix(); j2d_glMatrixMode(GL_PROJECTION); j2d_glPushMatrix(); j2d_glMatrixMode(GL_TEXTURE); j2d_glPushMatrix(); } break; case sun_java2d_pipe_BufferedOpCodes_RESTORE_STATE: { j2d_glPopAttrib(); j2d_glPopClientAttrib(); j2d_glMatrixMode(GL_MODELVIEW); j2d_glPopMatrix(); j2d_glMatrixMode(GL_PROJECTION); j2d_glPopMatrix(); j2d_glMatrixMode(GL_TEXTURE); j2d_glPopMatrix(); } break; case sun_java2d_pipe_BufferedOpCodes_SYNC: { sync = JNI_TRUE; } break; // multibuffering ops case sun_java2d_pipe_BufferedOpCodes_SWAP_BUFFERS: { jlong window = NEXT_LONG(b); if (oglc != NULL) { RESET_PREVIOUS_OP(); } OGLSD_SwapBuffers(env, window); } break; // special no-op (mainly used for achieving 8-byte alignment) case sun_java2d_pipe_BufferedOpCodes_NOOP: break; // paint-related ops case sun_java2d_pipe_BufferedOpCodes_RESET_PAINT: { OGLPaints_ResetPaint(oglc); } break; case sun_java2d_pipe_BufferedOpCodes_SET_COLOR: { jint pixel = NEXT_INT(b); OGLPaints_SetColor(oglc, pixel); } break; case sun_java2d_pipe_BufferedOpCodes_SET_GRADIENT_PAINT: { jboolean useMask= NEXT_BOOLEAN(b); jboolean cyclic = NEXT_BOOLEAN(b); jdouble p0 = NEXT_DOUBLE(b); jdouble p1 = NEXT_DOUBLE(b); jdouble p3 = NEXT_DOUBLE(b); jint pixel1 = NEXT_INT(b); jint pixel2 = NEXT_INT(b); OGLPaints_SetGradientPaint(oglc, useMask, cyclic, p0, p1, p3, pixel1, pixel2); } break; case sun_java2d_pipe_BufferedOpCodes_SET_LINEAR_GRADIENT_PAINT: { jboolean useMask = NEXT_BOOLEAN(b); jboolean linear = NEXT_BOOLEAN(b); jint cycleMethod = NEXT_INT(b); jint numStops = NEXT_INT(b); jfloat p0 = NEXT_FLOAT(b); jfloat p1 = NEXT_FLOAT(b); jfloat p3 = NEXT_FLOAT(b); void *fractions, *pixels; fractions = b; SKIP_BYTES(b, numStops * sizeof(jfloat)); pixels = b; SKIP_BYTES(b, numStops * sizeof(jint)); OGLPaints_SetLinearGradientPaint(oglc, dstOps, useMask, linear, cycleMethod, numStops, p0, p1, p3, fractions, pixels); } break; case sun_java2d_pipe_BufferedOpCodes_SET_RADIAL_GRADIENT_PAINT: { jboolean useMask = NEXT_BOOLEAN(b); jboolean linear = NEXT_BOOLEAN(b); jint numStops = NEXT_INT(b); jint cycleMethod = NEXT_INT(b); jfloat m00 = NEXT_FLOAT(b); jfloat m01 = NEXT_FLOAT(b); jfloat m02 = NEXT_FLOAT(b); jfloat m10 = NEXT_FLOAT(b); jfloat m11 = NEXT_FLOAT(b); jfloat m12 = NEXT_FLOAT(b); jfloat focusX = NEXT_FLOAT(b); void *fractions, *pixels; fractions = b; SKIP_BYTES(b, numStops * sizeof(jfloat)); pixels = b; SKIP_BYTES(b, numStops * sizeof(jint)); OGLPaints_SetRadialGradientPaint(oglc, dstOps, useMask, linear, cycleMethod, numStops, m00, m01, m02, m10, m11, m12, focusX, fractions, pixels); } break; case sun_java2d_pipe_BufferedOpCodes_SET_TEXTURE_PAINT: { jboolean useMask= NEXT_BOOLEAN(b); jboolean filter = NEXT_BOOLEAN(b); jlong pSrc = NEXT_LONG(b); jdouble xp0 = NEXT_DOUBLE(b); jdouble xp1 = NEXT_DOUBLE(b); jdouble xp3 = NEXT_DOUBLE(b); jdouble yp0 = NEXT_DOUBLE(b); jdouble yp1 = NEXT_DOUBLE(b); jdouble yp3 = NEXT_DOUBLE(b); OGLPaints_SetTexturePaint(oglc, useMask, pSrc, filter, xp0, xp1, xp3, yp0, yp1, yp3); } break; // BufferedImageOp-related ops case sun_java2d_pipe_BufferedOpCodes_ENABLE_CONVOLVE_OP: { jlong pSrc = NEXT_LONG(b); jboolean edgeZero = NEXT_BOOLEAN(b); jint kernelWidth = NEXT_INT(b); jint kernelHeight = NEXT_INT(b); OGLBufImgOps_EnableConvolveOp(oglc, pSrc, edgeZero, kernelWidth, kernelHeight, b); SKIP_BYTES(b, kernelWidth * kernelHeight * sizeof(jfloat)); } break; case sun_java2d_pipe_BufferedOpCodes_DISABLE_CONVOLVE_OP: { OGLBufImgOps_DisableConvolveOp(oglc); } break; case sun_java2d_pipe_BufferedOpCodes_ENABLE_RESCALE_OP: { jlong pSrc = NEXT_LONG(b); jboolean nonPremult = NEXT_BOOLEAN(b); jint numFactors = 4; unsigned char *scaleFactors = b; unsigned char *offsets = (b + numFactors * sizeof(jfloat)); OGLBufImgOps_EnableRescaleOp(oglc, pSrc, nonPremult, scaleFactors, offsets); SKIP_BYTES(b, numFactors * sizeof(jfloat) * 2); } break; case sun_java2d_pipe_BufferedOpCodes_DISABLE_RESCALE_OP: { OGLBufImgOps_DisableRescaleOp(oglc); } break; case sun_java2d_pipe_BufferedOpCodes_ENABLE_LOOKUP_OP: { jlong pSrc = NEXT_LONG(b); jboolean nonPremult = NEXT_BOOLEAN(b); jboolean shortData = NEXT_BOOLEAN(b); jint numBands = NEXT_INT(b); jint bandLength = NEXT_INT(b); jint offset = NEXT_INT(b); jint bytesPerElem = shortData ? sizeof(jshort):sizeof(jbyte); void *tableValues = b; OGLBufImgOps_EnableLookupOp(oglc, pSrc, nonPremult, shortData, numBands, bandLength, offset, tableValues); SKIP_BYTES(b, numBands * bandLength * bytesPerElem); } break; case sun_java2d_pipe_BufferedOpCodes_DISABLE_LOOKUP_OP: { OGLBufImgOps_DisableLookupOp(oglc); } break; default: J2dRlsTraceLn1(J2D_TRACE_ERROR, "OGLRenderQueue_flushBuffer: invalid opcode=%d", opcode); if (oglc != NULL) { RESET_PREVIOUS_OP(); } return; } } if (oglc != NULL) { RESET_PREVIOUS_OP(); if (sync) { j2d_glFinish(); } else { j2d_glFlush(); } OGLSD_Flush(env); } }
static VC_CONTAINER_STATUS_T ps_read_pack_header( VC_CONTAINER_T *ctx ) { VC_CONTAINER_MODULE_T *module = ctx->priv->module; uint8_t header[10]; int64_t scr, scr_base, scr_ext = INT64_C(0); uint64_t pack_offset = STREAM_POSITION(ctx); uint32_t mux_rate, stuffing; VC_CONTAINER_BITS_T bits; VC_CONTAINER_STATUS_T status; if(_READ_U32(ctx) != 0x1BA) return VC_CONTAINER_ERROR_CORRUPTED; LOG_FORMAT(ctx, "pack_header"); module->level++; if (PEEK_U8(ctx) & 0x40) /* program stream */ { if(READ_BYTES(ctx, header, 10) != 10) return VC_CONTAINER_ERROR_EOS; BITS_INIT(ctx, &bits, header, 10); if(BITS_READ_U32(ctx, &bits, 2, "'01' marker bits") != 0x1) return VC_CONTAINER_ERROR_CORRUPTED; scr_base = BITS_READ_U32(ctx, &bits, 3, "system_clock_reference_base [32..30]") << 30; if(BITS_READ_U32(ctx, &bits, 1, "marker_bit") != 0x1) return VC_CONTAINER_ERROR_CORRUPTED; scr_base |= BITS_READ_U32(ctx, &bits, 15, "system_clock_reference_base [29..15]") << 15; if(BITS_READ_U32(ctx, &bits, 1, "marker_bit") != 0x1) return VC_CONTAINER_ERROR_CORRUPTED; scr_base |= BITS_READ_U32(ctx, &bits, 15, "system_clock_reference_base [14..0]"); LOG_FORMAT(ctx, "system_clock_reference_base %"PRId64, scr_base); if(BITS_READ_U32(ctx, &bits, 1, "marker_bit") != 0x1) return VC_CONTAINER_ERROR_CORRUPTED; scr_ext = BITS_READ_U32(ctx, &bits, 9, "system_clock_reference_extension"); if(BITS_READ_U32(ctx, &bits, 1, "marker_bit") != 0x1) return VC_CONTAINER_ERROR_CORRUPTED; mux_rate = BITS_READ_U32(ctx, &bits, 22, "program_mux_rate"); if(BITS_READ_U32(ctx, &bits, 1, "marker_bit") != 0x1) return VC_CONTAINER_ERROR_CORRUPTED; if(BITS_READ_U32(ctx, &bits, 1, "marker_bit") != 0x1) return VC_CONTAINER_ERROR_CORRUPTED; BITS_SKIP(ctx, &bits, 5, "reserved"); stuffing = BITS_READ_U32(ctx, &bits, 3, "pack_stuffing_length"); SKIP_BYTES(ctx, stuffing); } else /* system stream */ { if(READ_BYTES(ctx, header, 8) != 8) return VC_CONTAINER_ERROR_EOS; BITS_INIT(ctx, &bits, header, 8); if(BITS_READ_U32(ctx, &bits, 4, "'0010' marker bits") != 0x2) return VC_CONTAINER_ERROR_CORRUPTED; scr_base = BITS_READ_U32(ctx, &bits, 3, "system_clock_reference_base [32..30]") << 30; if(BITS_READ_U32(ctx, &bits, 1, "marker_bit") != 0x1) return VC_CONTAINER_ERROR_CORRUPTED; scr_base |= BITS_READ_U32(ctx, &bits, 15, "system_clock_reference_base [29..15]") << 15; if(BITS_READ_U32(ctx, &bits, 1, "marker_bit") != 0x1) return VC_CONTAINER_ERROR_CORRUPTED; scr_base |= BITS_READ_U32(ctx, &bits, 15, "system_clock_reference_base [14..0]"); LOG_FORMAT(ctx, "system_clock_reference_base %"PRId64, scr_base); if(BITS_READ_U32(ctx, &bits, 1, "marker_bit") != 0x1) return VC_CONTAINER_ERROR_CORRUPTED; if(BITS_READ_U32(ctx, &bits, 1, "marker_bit") != 0x1) return VC_CONTAINER_ERROR_CORRUPTED; mux_rate = BITS_READ_U32(ctx, &bits, 22, "program_mux_rate"); if(BITS_READ_U32(ctx, &bits, 1, "marker_bit") != 0x1) return VC_CONTAINER_ERROR_CORRUPTED; } if ((status = STREAM_STATUS(ctx)) != VC_CONTAINER_SUCCESS) return status; module->level--; /* Set or update system_clock_reference, adjust bias if necessary */ scr = scr_base * INT64_C(300) + scr_ext; if (module->scr_offset == VC_CONTAINER_TIME_UNKNOWN) module->scr_offset = scr; if (module->scr == VC_CONTAINER_TIME_UNKNOWN) module->scr_bias = -scr; else if (scr < module->scr) module->scr_bias = module->scr - scr; if (module->scr != VC_CONTAINER_TIME_UNKNOWN) { /* system_clock_reference is not necessarily continuous across the entire stream */ if (scr > module->scr) { int64_t data_rate; data_rate = INT64_C(27000000) * (pack_offset - module->pack_offset) / (scr - module->scr); if (module->data_rate) { /* Simple moving average over data rate seen so far */ module->data_rate = (module->data_rate * 31 + data_rate) >> 5; } else {
void USBConfigurationParser (TUSBConfigurationParser *pThis, const void *pBuffer, unsigned nBufLen) { assert (pThis != 0); pThis->m_pBuffer = (TUSBDescriptor *) pBuffer; pThis->m_nBufLen = nBufLen; pThis->m_bValid = FALSE; pThis->m_pEndPosition = SKIP_BYTES (pThis->m_pBuffer, nBufLen); pThis->m_pCurrentPosition = pThis->m_pBuffer; pThis->m_pErrorPosition = pThis->m_pBuffer; assert (pThis->m_pBuffer != 0); if ( pThis->m_nBufLen < 4 // wTotalLength must exist || pThis->m_nBufLen > 512) // best guess { return; } if ( pThis->m_pBuffer->Configuration.bLength != sizeof (TUSBConfigurationDescriptor) || pThis->m_pBuffer->Configuration.bDescriptorType != DESCRIPTOR_CONFIGURATION || pThis->m_pBuffer->Configuration.wTotalLength > nBufLen) { return; } if (pThis->m_pBuffer->Configuration.wTotalLength < nBufLen) { pThis->m_pEndPosition = SKIP_BYTES (pThis->m_pBuffer, pThis->m_pBuffer->Configuration.wTotalLength); } const TUSBDescriptor *pCurrentPosition = pThis->m_pBuffer; u8 ucLastDescType = 0; boolean bInAudioInterface = FALSE; while (SKIP_BYTES (pCurrentPosition, 2) < pThis->m_pEndPosition) { u8 ucDescLen = pCurrentPosition->Header.bLength; u8 ucDescType = pCurrentPosition->Header.bDescriptorType; TUSBDescriptor *pDescEnd = SKIP_BYTES (pCurrentPosition, ucDescLen); if (pDescEnd > pThis->m_pEndPosition) { pThis->m_pErrorPosition = pCurrentPosition; return; } u8 ucExpectedLen = 0; switch (ucDescType) { case DESCRIPTOR_CONFIGURATION: if (ucLastDescType != 0) { pThis->m_pErrorPosition = pCurrentPosition; return; } ucExpectedLen = sizeof (TUSBConfigurationDescriptor); break; case DESCRIPTOR_INTERFACE: if (ucLastDescType == 0) { pThis->m_pErrorPosition = pCurrentPosition; return; } ucExpectedLen = sizeof (TUSBInterfaceDescriptor); bInAudioInterface = pCurrentPosition->Interface.bInterfaceClass == 0x01; // Audio class break; case DESCRIPTOR_ENDPOINT: if ( ucLastDescType == 0 || ucLastDescType == DESCRIPTOR_CONFIGURATION) { pThis->m_pErrorPosition = pCurrentPosition; return; } ucExpectedLen = bInAudioInterface ? sizeof (TUSBAudioEndpointDescriptor) : sizeof (TUSBEndpointDescriptor); break; default: break; } if ( ucExpectedLen != 0 && ucDescLen != ucExpectedLen) { pThis->m_pErrorPosition = pCurrentPosition; return; } ucLastDescType = ucDescType; pCurrentPosition = pDescEnd; } if (pCurrentPosition != pThis->m_pEndPosition) { pThis->m_pErrorPosition = pCurrentPosition; return; } pThis->m_bValid = TRUE; }