AS3_Val initializeSkeletalChannel( void* self, AS3_Val args ) { int channelType; int length; Animation* animation; float* times; float** param; Matrix4x4* matrices; float* interpolations; Vector* inTangent; Vector* outTangent; SkeletalChannel* channel; AS3_ArrayValue(args, "IntType, IntType, PtrType, PtrType, PtrType, PtrType, PtrType, PtrType, PtrType", &channelType, &length, &animation, ×, ¶m, &matrices,&interpolations, &inTangent, &outTangent); channel = newSkeletalChannel(animation, length, channelType, times, param, matrices, interpolations, inTangent, outTangent); return AS3_Ptr(channel); }
AS3_Val getWorldPositionFromSreen( void* self, AS3_Val args ) { Viewport* viewport; double x, y, z; int autoDepth; Vector3D output; AS3_ArrayValue( args, "PtrType, DoubleType, DoubleType, DoubleType, IntType", &viewport, &x, &y, &z, &autoDepth ); if( viewport_getWorldPositionFromView(&output, viewport, (float)x, (float)y, (float)z, autoDepth) ) { x = output.x; y = output.y; z = output.z; return AS3_Array( "DoubleType, DoubleType, DoubleType", x, y, z); } return 0; }
static AS3_Val thunk_InitPeerDownloadInfo(void *gg_clientData, AS3_Val gg_args) { AS3_Val info; AS3_Val bytes; AS3_ArrayValue(gg_args, "AS3ValType, AS3ValType", &info, &bytes); AS3_Val isDownloadingVal = AS3_CallTS("readUnsignedByte", bytes, ""); if (AS3_IntValue(isDownloadingVal) == 1) { AS3_Val true = AS3_True(); AS3_SetS(info, "isDownloading", true); AS3_Release(true); } else { AS3_Val false = AS3_False(); AS3_SetS(info, "isDownloading", false); AS3_Release(false); } AS3_Val onLineTimeVal = AS3_CallTS("readUnsignedInt", bytes, ""); AS3_Val avgDownloadVal = AS3_CallTS("readUnsignedShort", bytes, ""); AS3_Val nowDownloadVal = AS3_CallTS("readUnsignedShort", bytes, ""); AS3_Val avgUploadVal = AS3_CallTS("readUnsignedShort", bytes, ""); AS3_Val nowUploadVal = AS3_CallTS("readUnsignedShort", bytes, ""); AS3_SetS(info, "onLineTime", onLineTimeVal); AS3_SetS(info, "avgDownload", avgDownloadVal); AS3_SetS(info, "nowDownload", nowDownloadVal); AS3_SetS(info, "avgUpload", avgUploadVal); AS3_SetS(info, "nowUpload", nowUploadVal); AS3_ByteArray_seek(bytes, 3, 1); // ignore 3 byte reserved bytes AS3_Release(isDownloadingVal); AS3_Release(onLineTimeVal); AS3_Release(avgDownloadVal); AS3_Release(nowDownloadVal); AS3_Release(avgUploadVal); AS3_Release(nowUploadVal); AS3_Release(bytes); AS3_Release(info); return NULL; }
/* Загрузка состояния из памяти */ AS3_Val QSPOpenSavedGameFromData(void *param, AS3_Val args) { AS3_Val data; int dataSize, dataLen; QSP_BOOL isRefresh; QSP_CHAR *ptr; AS3_ArrayValue(args, "AS3ValType, IntType, IntType", &data, &dataSize, &isRefresh); if (qspIsExitOnError && qspErrorNum) return AS3_False(); qspPrepareExecution(); if (qspIsDisableCodeExec) return AS3_False(); dataLen = dataSize / sizeof(QSP_CHAR); ptr = (QSP_CHAR *)malloc((dataLen + 1) * sizeof(QSP_CHAR)); AS3_ByteArray_seek(data, 0, SEEK_SET); AS3_ByteArray_readBytes(ptr, data, dataSize); ptr[dataLen] = 0; qspOpenGameStatusFromString(ptr); free(ptr); if (qspErrorNum) return AS3_False(); if (isRefresh) qspCallRefreshInt(QSP_FALSE); return AS3_True(); }
/** * Returns a pointer to the memory allocated for this sample. * Every frame value is a float, as Flash's native sound format is a 32bit float * and we don't want to waste time converting back and forth to doubles. * The sample is zeroed. * Stereo samples are interleaved. */ static AS3_Val allocateSampleMemory(void* self, AS3_Val args) { int frames; int channels; int size; int zero; float *buffer; AS3_ArrayValue(args, "IntType, IntType, IntType", &frames, &channels, &zero); size = frames * channels * sizeof(float); buffer = (float *) malloc(size); // If zero is true, then we must zero out this sample // Otherwise, it is more efficient to leave it full of junk, if it's going to be overwritten if (buffer && zero) { memset(buffer, 0, size); } // Return the sample pointer return AS3_Int((int)buffer); }
AS3_Val doDecode(void* data,AS3_Val args) { AS3_Val input = NULL; int in_len; char * ar; AS3_ArrayValue(args,"AS3ValType,IntType",&input,&in_len); ar = (char*)malloc(in_len); AS3_ByteArray_readBytes((void*)ar,input,in_len); char * decryptData; char * key="kael"; decryptData = dofileEx(ar, key, in_len); //make a new as3 byteArray var AS3_Val baNS = AS3_String("flash.utils"); AS3_Val baClass = AS3_NSGetS(baNS, "ByteArray"); AS3_Val emptyParams = AS3_Array(""); AS3_Val byteArray2 = AS3_New(baClass, emptyParams); AS3_ByteArray_writeBytes(byteArray2, decryptData, in_len); return byteArray2; }
/* Показ / скрытие окон */ AS3_Val QSPShowWindow(void *param, AS3_Val args) { int type; QSP_BOOL isShow; AS3_ArrayValue(args, "IntType, IntType", &type, &isShow); switch (type) { case QSP_WIN_ACTS: qspCurIsShowActs = isShow; break; case QSP_WIN_OBJS: qspCurIsShowObjs = isShow; break; case QSP_WIN_VARS: qspCurIsShowVars = isShow; break; case QSP_WIN_INPUT: qspCurIsShowInput = isShow; break; } return AS3_True(); }
/* Загрузка новой игры из памяти */ AS3_Val QSPLoadGameWorldFromData(void *param, AS3_Val args) { char *ptr; AS3_Val data; int dataSize; char *fileName; QSP_CHAR *fileNameWC; AS3_ArrayValue(args, "AS3ValType, IntType, StrType", &data, &dataSize, &fileName); if (qspIsExitOnError && qspErrorNum) return AS3_False(); qspResetError(); if (qspIsDisableCodeExec) return AS3_False(); ptr = (char *)malloc(dataSize + 3); AS3_ByteArray_seek(data, 0, SEEK_SET); AS3_ByteArray_readBytes(ptr, data, dataSize); ptr[dataSize] = ptr[dataSize + 1] = ptr[dataSize + 2] = 0; fileNameWC = qspC2W(fileName); qspOpenQuestFromData(ptr, dataSize + 3, fileNameWC, QSP_FALSE); free(fileNameWC); free(ptr); if (qspErrorNum) return AS3_False(); return AS3_True(); }
static AS3_Val thunk_CreatePacketFromByteArray(void *gg_clientData, AS3_Val gg_args) { AS3_Val bytes; AS3_ArrayValue(gg_args, "AS3ValType", &bytes); AS3_Val actionVal = AS3_CallTS("readUnsignedByte", bytes, ""); AS3_Val transactionIdVal = AS3_CallTS("readUnsignedInt", bytes, ""); AS3_Val protocolVersionVal = AS3_CallTS("readUnsignedShort", bytes, ""); AS3_Val pplive_protocol_namespace = AS3_String("com.pplive.p2p.network.protocol"); AS3_Val PacketClass = AS3_NSGetS(pplive_protocol_namespace, "Packet"); AS3_Val paramArray = AS3_Array("IntType, IntType, IntType", AS3_IntValue(actionVal), AS3_IntValue(transactionIdVal), AS3_IntValue(protocolVersionVal)); AS3_Val packet = AS3_New(PacketClass, paramArray); AS3_Release(paramArray); AS3_Release(PacketClass); AS3_Release(pplive_protocol_namespace); AS3_Release(protocolVersionVal); AS3_Release(transactionIdVal); AS3_Release(actionVal); AS3_Release(bytes); return packet; }
static AS3_Val getPrice(void* self, AS3_Val args) { double N, T, S, K, v, r, price; AS3_ArrayValue( args, "DoubleType, DoubleType, DoubleType, DoubleType, DoubleType, DoubleType", &N, &T, &S, &K, &v, &r); double dt = T/N; //one time step double u = 1 + v*sqrt(dt); //up-tick double d = 1 - v*sqrt(dt); //down-tick double p = 0.5 + r*sqrt(dt)/(2*v); //risk-neutral probability of up-tick double df = 1/(1+r*dt); //discount factor over 1 time step, dt double* optionValues = malloc((N+1) * sizeof(double)); //populate the tree (for N-steps there will be N+1 values) int i, j; double ST; for (i=0; i < N+1; i++) { ST = S * pow(u, i) * pow(d, N-i); optionValues[i] = (ST > K)? ST - K : 0; } //now work backwards to get expected //option value at each previous stage for (i=N; i >= 0; i--) { for(j=0; j<i; j++) { optionValues[j] = (p*optionValues[j+1] + (1-p)*optionValues[j])*df; } } price = optionValues[0]; free(optionValues); return AS3_Number(price); }
/** * Set every sample in the range to a fixed value. * Useful for function generators of different types, or erasing audio. */ static AS3_Val setSamples(void *self, AS3_Val args) { float *buffer; int bufferPosition; int channels; int frames; double valueArg; float value; int count, count16, remainder; AS3_ArrayValue(args, "IntType, IntType, IntType, DoubleType", &bufferPosition, &channels, &frames, &valueArg); buffer = (float *) bufferPosition; value = (float) valueArg; count = frames * channels; count16 = count / 16; remainder = count % 16; while (count16--) { *buffer++ = value; *buffer++ = value; *buffer++ = value; *buffer++ = value; *buffer++ = value; *buffer++ = value; *buffer++ = value; *buffer++ = value; *buffer++ = value; *buffer++ = value; *buffer++ = value; *buffer++ = value; *buffer++ = value; *buffer++ = value; *buffer++ = value; *buffer++ = value; } while (remainder--) { *buffer++ = value; } return 0; }
/** * Writes a sample out to an as3 byte array in wav file format. * Writes as fixed point 16 bit. */ static AS3_Val writeWavBytes(void *self, AS3_Val args) { int bufferPosition; int channels; int frames; float *buffer; AS3_Val dst; int count; short *wavOut; int framesToWrite; int theseFramesToWrite; AS3_ArrayValue(args, "IntType, AS3ValType, IntType, IntType", &bufferPosition, &dst, &channels, &frames); buffer = (float *) bufferPosition; framesToWrite = frames * channels; // Convert and output wav bytes in 16k chunks // Convert each buffer into scratch memory, and then writeBytes while (framesToWrite > 0) { theseFramesToWrite = framesToWrite; if (theseFramesToWrite > 16384) { theseFramesToWrite = 16384; } framesToWrite -= theseFramesToWrite; count = theseFramesToWrite; wavOut = scratch5; // scratch buffer 5 is 16k of shorts while (count--) { *wavOut++ = (short) (*buffer++ * 32768 + 0.5 ); } wavOut = scratch5; AS3_ByteArray_writeBytes(dst, wavOut, theseFramesToWrite * 2 ); // 2 bytes per short } return 0; }
AS3_Val initializeFog( void* self, AS3_Val args ) { Fog * fog; AS3_Val color; double a, r, g, b, density, start, end; int mode; AS3_ArrayValue( args, "AS3ValType, DoubleType, DoubleType, DoubleType, IntType", & color, & start, & end, & density, & mode ); r = AS3_NumberValue( AS3_GetS( color, "redMultiplier" ) ); g = AS3_NumberValue( AS3_GetS( color, "greenMultiplier" ) ); b = AS3_NumberValue( AS3_GetS( color, "blueMultiplier" ) ); a = AS3_NumberValue( AS3_GetS( color, "alphaMultiplier" ) ); fog = newFog( newColorValue( (float)r, (float)g, (float)b, (float)a ), (float)start, (float)end, (float)density, mode ); AS3_Release( color ); return AS3_Array( "PtrType, PtrType, PtrType, PtrType, PtrType, PtrType", fog, fog->global, & fog->start, & fog->end, & fog->density, & fog->mode ); }
/** * Hard clipper stage */ static AS3_Val clip(void *self, AS3_Val args) { int bufferPosition, channels, frames; float *buffer; int count; float x; AS3_ArrayValue(args, "IntType, IntType, IntType", &bufferPosition, &channels, &frames); buffer = (float *) bufferPosition; count = frames*channels; while (count--) { x = *buffer; if( x < -1 ) { *buffer++ = -1.0; } else if( x > 1 ) { *buffer++ = 1.0; } else { buffer++; } } return 0; }
static AS3_Val thunk_InitAnnounceResponsePacket(void *gg_clientData, AS3_Val gg_args) { AS3_Val packet; AS3_Val bytes; AS3_ArrayValue(gg_args, "AS3ValType, AS3ValType", &packet, &bytes); AS3_Val paramArray = AS3_Array("AS3ValType", bytes); AS3_Val p2p_struct_namespace = AS3_String("com.pplive.p2p.struct"); AS3_Val PeerDownloadInfoClass = AS3_NSGetS(p2p_struct_namespace, "PeerDownloadInfo"); AS3_Val BlockMapClass = AS3_NSGetS(p2p_struct_namespace, "BlockMap"); AS3_Val peerDownloadInfo = AS3_New(PeerDownloadInfoClass, paramArray); AS3_Val blockMapInfo = AS3_New(BlockMapClass, paramArray); AS3_SetS(packet, "peerDownloadInfo", peerDownloadInfo); AS3_SetS(packet, "blockMap", blockMapInfo); AS3_Release(blockMapInfo); AS3_Release(peerDownloadInfo); AS3_Release(BlockMapClass); AS3_Release(PeerDownloadInfoClass); AS3_Release(p2p_struct_namespace); AS3_Release(paramArray); AS3_Release(bytes); AS3_Release(packet); return NULL; }
AS3_Val cloneMesh( void * self, AS3_Val args ) { Mesh* src, *mesh; Material* material; Texture* texture; int render_mode, i; Vector3D** vp; AS3_ArrayValue( args, "PtrType, PtrType, PtrType, IntType",& src, & material, & texture, & render_mode); mesh = mesh_clone(src, material, texture, render_mode); mesh_updateFaces(mesh); mesh_updateVertices(mesh); if( ( vp = ( Vector3D * * )malloc( sizeof( Vector3D * ) * mesh -> nVertices ) ) == NULL ) { return AS3_Array( "PtrType, PtrType, PtrType, PtrType, PtrType, PtrType, PtrType, PtrType, PtrType, PtrType, PtrType, PtrType, PtrType", mesh, & mesh->lightEnable, & mesh->fogEnable, & mesh->useMipmap, //& mesh->terrainTrace, & mesh->mip_dist, & mesh->v_dirty, & mesh->octree_depth, & mesh->addressMode, & mesh->texTransform->rotation, mesh->texTransform->offset, mesh->texTransform->scale, & mesh->texTransformDirty, & mesh->hit, & mesh->skinMeshController, & mesh->octree->data->aabb); } for( i = 0; i < mesh -> nVertices; i ++ ) { vp[i] = mesh -> vertices[i]->position; } return AS3_Array( "PtrType, PtrType, PtrType, PtrType, PtrType, PtrType, PtrType, PtrType, PtrType, PtrType, PtrType, PtrType, PtrType, PtrType", mesh, & mesh->lightEnable, & mesh->fogEnable, & mesh->useMipmap, //& mesh->terrainTrace, & mesh->mip_dist, & mesh->v_dirty, & mesh->octree_depth, & mesh->addressMode, & mesh->texTransform->rotation, mesh->texTransform->offset, mesh->texTransform->scale, & mesh->texTransformDirty, & mesh->hit, & mesh->skinMeshController, & mesh->octree->data->aabb, & vp ); }
AS3_Val initializeMesh( void * self, AS3_Val args ) { Mesh * mesh; Texture * * tp; Material * * mp; unsigned int vl, fl, i, * fs; int * rmp; float * vs; Vector3D * * vp; Vector * uvp; AS3_ArrayValue( args, "PtrType, PtrType, PtrType, PtrType, PtrType, PtrType, IntType, IntType",& vs, & fs, & uvp, & mp, & tp, & rmp, & vl, & fl ); mesh = newMesh( vl, fl ); for( i = 0; i < vl; i ++ ) { mesh_push_vertex( mesh, vs[i * 3], vs[i * 3 + 1], vs[i * 3 + 2] ); } //free( vs ); for( i = 0; i < fl; i ++ ) { mesh_push_triangle( mesh, (* mesh -> vertices) + fs[i * 3], (* mesh -> vertices) + fs[i * 3 + 1], (* mesh -> vertices) + fs[i * 3 + 2], uvp + i * 3 , uvp + i * 3 + 1, uvp + i * 3 + 2, mp[i], tp[i], rmp[i] ); } mesh_updateFaces(mesh); mesh_updateVertices(mesh); //free( fs ); //free( rmp ); if( ( vp = ( Vector3D * * )malloc( sizeof( Vector3D * ) * mesh -> nVertices ) ) == NULL ) { return AS3_Array( "PtrType, PtrType, PtrType, PtrType, PtrType, PtrType, PtrType, PtrType, PtrType, PtrType, PtrType, PtrType, PtrType", mesh, & mesh->lightEnable, & mesh->fogEnable, & mesh->useMipmap, //& mesh->terrainTrace, & mesh->mip_dist, & mesh->v_dirty, & mesh->octree_depth, & mesh->addressMode, & mesh->texTransform->rotation, mesh->texTransform->offset, mesh->texTransform->scale, & mesh->texTransformDirty, & mesh->hit, & mesh->skinMeshController, mesh->octree->data->aabb); } for( i = 0; i < mesh -> nVertices; i ++ ) { vp[i] = mesh -> vertices[i]->position; } return AS3_Array( "PtrType, PtrType, PtrType, PtrType, PtrType, PtrType, PtrType, PtrType, PtrType, PtrType, PtrType, PtrType, PtrType, PtrType, PtrType", mesh, & mesh->lightEnable, & mesh->fogEnable, & mesh->useMipmap, //& mesh->terrainTrace, & mesh->mip_dist, & mesh->v_dirty, & mesh->octree_depth, & mesh->addressMode, & mesh->texTransform->rotation, mesh->texTransform->offset, mesh->texTransform->scale, & mesh->texTransformDirty, & mesh->hit, & mesh->skinMeshController, mesh->octree->data->aabb, & vp); }
AS3_Val testFunction(void* data, AS3_Val args) { AS3_Val test; AS3_ArrayValue(args, "AS3ValType", &test); return AS3_Ptr(test); }
/** * Converts a Sample at a lower rate (22050 Hz) or lower number of channels (mono) * to the standard Flash sound format (44.1k stereo interleaved). * The descriptor in this case represents the sourceBuffer, not the targetBuffer, which is stereo/44.1 */ static AS3_Val standardize(void *self, AS3_Val args) { int bufferPosition; int rate; int channels; int frames; float *buffer; int sourceBufferPosition; float *sourceBuffer; int count; AS3_ArrayValue(args, "IntType, IntType, IntType, IntType, IntType", &bufferPosition, &sourceBufferPosition, &channels, &frames, &rate); buffer = (float *) bufferPosition; sourceBuffer = (float *) sourceBufferPosition; if (rate == 44100 && channels == 2) { // We're already standardized. Just copy the memory memcpy(buffer, sourceBuffer, frames * channels * sizeof(float)); } else if (rate == 22050 && channels == 1) { // Upsample and stereoize with cubic interpolation // First set hold first sample *buffer++ = *sourceBuffer; *buffer++ = *sourceBuffer; *buffer++ = cubicInterpolate(*(sourceBuffer), *(sourceBuffer), *(sourceBuffer+1), *(sourceBuffer+2), 0.5); *buffer = *(buffer-1); buffer++; sourceBuffer++; // Loop count = (frames/2) - 2; while (--count) { *buffer++ = *sourceBuffer; *buffer++ = *sourceBuffer; *buffer++ = cubicInterpolate(*(sourceBuffer-1), *sourceBuffer, *(sourceBuffer+1), *(sourceBuffer+2), 0.5); *buffer = *(buffer-1); buffer++; sourceBuffer++; } // Last set hold 2 samples *buffer++ = *sourceBuffer; *buffer++ = *sourceBuffer; *buffer++ = cubicInterpolate(*(sourceBuffer-1), *sourceBuffer, *(sourceBuffer+1), *(sourceBuffer+1), 0.5); *buffer = *(buffer-1); buffer++; sourceBuffer++; *buffer++ = *sourceBuffer; *buffer++ = *sourceBuffer; *buffer++ = cubicInterpolate(*(sourceBuffer-1), *sourceBuffer, *sourceBuffer, *sourceBuffer, 0.5); *buffer = *(buffer-1); // Done } else if (rate == 22050 && channels == 2) { // Upsample with cubic interpolation // First set hold sample *buffer++ = *sourceBuffer; *buffer++ = *(sourceBuffer+1); *buffer++ = cubicInterpolate(*sourceBuffer, *sourceBuffer, *(sourceBuffer+2), *(sourceBuffer+4), 0.5); *buffer = cubicInterpolate(*(sourceBuffer+1), *(sourceBuffer+1), *(sourceBuffer+3), *(sourceBuffer+5), 0.5); buffer++; sourceBuffer += 2; count = frames/2 - 2; while (--count) { *buffer++ = *sourceBuffer; // left *buffer++ = *(sourceBuffer+1); // right *buffer++ = cubicInterpolate(*(sourceBuffer-2), *sourceBuffer, *(sourceBuffer+2), *(sourceBuffer+4), 0.5); *buffer++ = cubicInterpolate(*(sourceBuffer-1), *(sourceBuffer+1), *(sourceBuffer+3), *(sourceBuffer+5), 0.5); sourceBuffer += 2; } // second to last set *buffer++ = *sourceBuffer; // left *buffer++ = *(sourceBuffer+1); // right *buffer++ = cubicInterpolate(*(sourceBuffer-2), *sourceBuffer, *(sourceBuffer+2), *(sourceBuffer+2), 0.5); *buffer++ = cubicInterpolate(*(sourceBuffer-1), *(sourceBuffer+1), *(sourceBuffer+3), *(sourceBuffer+3), 0.5); sourceBuffer += 2; // last set *buffer++ = *sourceBuffer; // left *buffer++ = *(sourceBuffer+1); // right *buffer++ = cubicInterpolate(*(sourceBuffer-2), *sourceBuffer, *sourceBuffer, *sourceBuffer, 0.5); *buffer= cubicInterpolate(*(sourceBuffer-1), *(sourceBuffer+1), *(sourceBuffer+1), *(sourceBuffer+1), 0.5); // Done } else if (rate == 44100 && channels == 1) { // Stereoize count = frames; while (--count) { *buffer++ = *sourceBuffer; *buffer++ = *sourceBuffer++; } } return 0; }
// Mix one buffer into another static AS3_Val mixIn(void *self, AS3_Val args) { int bufferPosition; int channels; int frames; float *buffer; int sourceBufferPosition; float *sourceBuffer; double leftGainArg; double rightGainArg; float leftGain; float rightGain; int count, count8, remainder; AS3_ArrayValue(args, "IntType, IntType, IntType, IntType, DoubleType, DoubleType", &bufferPosition, &sourceBufferPosition, &channels, &frames, &leftGainArg, &rightGainArg); buffer = (float *) bufferPosition; sourceBuffer = (float *) sourceBufferPosition; // this can be passed with an offset to easily mix offset slices of samples leftGain = (float) leftGainArg; rightGain = (float) rightGainArg; count = frames; count8 = count / 8; remainder = count % 8; if (channels == 1) { while (count8--) { *buffer++ += *sourceBuffer++ * leftGain; *buffer++ += *sourceBuffer++ * leftGain; *buffer++ += *sourceBuffer++ * leftGain; *buffer++ += *sourceBuffer++ * leftGain; *buffer++ += *sourceBuffer++ * leftGain; *buffer++ += *sourceBuffer++ * leftGain; *buffer++ += *sourceBuffer++ * leftGain; *buffer++ += *sourceBuffer++ * leftGain; } while (remainder--) { *buffer++ += *sourceBuffer++ * leftGain; } } else if (channels == 2) { while (count8--) { *buffer++ += *sourceBuffer++ * leftGain; *buffer++ += *sourceBuffer++ * rightGain; *buffer++ += *sourceBuffer++ * leftGain; *buffer++ += *sourceBuffer++ * rightGain; *buffer++ += *sourceBuffer++ * leftGain; *buffer++ += *sourceBuffer++ * rightGain; *buffer++ += *sourceBuffer++ * leftGain; *buffer++ += *sourceBuffer++ * rightGain; *buffer++ += *sourceBuffer++ * leftGain; *buffer++ += *sourceBuffer++ * rightGain; *buffer++ += *sourceBuffer++ * leftGain; *buffer++ += *sourceBuffer++ * rightGain; *buffer++ += *sourceBuffer++ * leftGain; *buffer++ += *sourceBuffer++ * rightGain; *buffer++ += *sourceBuffer++ * leftGain; *buffer++ += *sourceBuffer++ * rightGain; } while (remainder--) { *buffer++ += *sourceBuffer++ * leftGain; *buffer++ += *sourceBuffer++ * rightGain; } } return 0; }
/** * Mix a mono sample into a stereo sample. * Buffer is stereo, and source buffer is mono. */ static AS3_Val mixInPan(void *self, AS3_Val args) { int bufferPosition; int frames; float *buffer; int sourceBufferPosition; float *sourceBuffer; double leftGainArg; double rightGainArg; float leftGain; float rightGain; int count, count16, remainder; AS3_ArrayValue(args, "IntType, IntType, IntType, DoubleType, DoubleType", &bufferPosition, &sourceBufferPosition, &frames, &leftGainArg, &rightGainArg); buffer = (float *) bufferPosition; sourceBuffer = (float *) sourceBufferPosition; leftGain = (float) leftGainArg; rightGain = (float) rightGainArg; count = frames; count16 = count / 16; remainder = count % 16; while (count16--) { *buffer++ += *sourceBuffer * leftGain; *buffer++ += *sourceBuffer++ * rightGain; *buffer++ += *sourceBuffer * leftGain; *buffer++ += *sourceBuffer++ * rightGain; *buffer++ += *sourceBuffer * leftGain; *buffer++ += *sourceBuffer++ * rightGain; *buffer++ += *sourceBuffer * leftGain; *buffer++ += *sourceBuffer++ * rightGain; *buffer++ += *sourceBuffer * leftGain; *buffer++ += *sourceBuffer++ * rightGain; *buffer++ += *sourceBuffer * leftGain; *buffer++ += *sourceBuffer++ * rightGain; *buffer++ += *sourceBuffer * leftGain; *buffer++ += *sourceBuffer++ * rightGain; *buffer++ += *sourceBuffer * leftGain; *buffer++ += *sourceBuffer++ * rightGain; *buffer++ += *sourceBuffer * leftGain; *buffer++ += *sourceBuffer++ * rightGain; *buffer++ += *sourceBuffer * leftGain; *buffer++ += *sourceBuffer++ * rightGain; *buffer++ += *sourceBuffer * leftGain; *buffer++ += *sourceBuffer++ * rightGain; *buffer++ += *sourceBuffer * leftGain; *buffer++ += *sourceBuffer++ * rightGain; *buffer++ += *sourceBuffer * leftGain; *buffer++ += *sourceBuffer++ * rightGain; *buffer++ += *sourceBuffer * leftGain; *buffer++ += *sourceBuffer++ * rightGain; *buffer++ += *sourceBuffer * leftGain; *buffer++ += *sourceBuffer++ * rightGain; *buffer++ += *sourceBuffer * leftGain; *buffer++ += *sourceBuffer++ * rightGain; } while (remainder--) { *buffer++ += *sourceBuffer * leftGain; *buffer++ += *sourceBuffer++ * rightGain; } return 0; }
/** * Scan in a wavetable. Wavetable should be at least one longer than the table size. */ static AS3_Val wavetableIn(void *self, AS3_Val args) { AS3_Val settings; int bufferPosition; int channels; int frames; float *buffer; int sourceBufferPosition; float *sourceBuffer; double phaseArg; float phase; double phaseAddArg; float phaseAdd; double phaseResetArg; float phaseReset; int tableSize; int count; int intPhase; float *wavetablePosition; float *scratch; double y1Arg, y2Arg; float y1, y2; float fractional, fractionalIncrement, instantBend; AS3_ArrayValue(args, "IntType, IntType, IntType, IntType, AS3ValType", &bufferPosition, &sourceBufferPosition, &channels, &frames, &settings); AS3_ObjectValue(settings, "tableSize:IntType, phase:DoubleType, phaseAdd:DoubleType, phaseReset:DoubleType, y1:DoubleType, y2:DoubleType", &tableSize, &phaseArg, &phaseAddArg, &phaseResetArg, &y1Arg, &y2Arg); buffer = (float *) bufferPosition; sourceBuffer = (float *) sourceBufferPosition; phaseAdd = (float) phaseAddArg * tableSize; // num source frames to add per output frames phase = (float) phaseArg * tableSize; // translate into a frame count into the table phaseReset = (float) phaseResetArg * tableSize; y1 = (float) y1Arg; y2 = (float) y2Arg; // Expand the pitch modulation into scratch // expandLine(scratch1, y1, y2, frames); // draws spline segment into scratch1 // scratch = (float *) scratch1; // Make sure we got everything right //sprintf(trace, "Wavetable size=%d phase=%f phaseAdd=%f y1=%f y2=%f", tableSize, phase, phaseAdd, y1, y2); //sztrace(trace); count=frames; fractional = 0.0; fractionalIncrement = 1 / (float) frames; if (channels == 1) { while (count--) { while (phase >= tableSize) { if (phaseReset == -1) { // no looping! return 0; } else { // wrap phase to the loop point phase -= tableSize; phase += phaseReset; } } intPhase = (int) phase; // int phase wavetablePosition = sourceBuffer + intPhase; *buffer++ = interpolate(*wavetablePosition, *(wavetablePosition+1), phase - intPhase); // Increment phase by adjusting phaseAdd for instantaneous pitch bend instantBend = interpolate(y1, y2, fractional); fractional += fractionalIncrement; phase += phaseAdd * shiftToFreq(instantBend); } } else if (channels == 2 ) { while (count--) { while (phase >= tableSize) { if (phaseReset == -1) { // no looping! return 0; } else { // wrap phase to the loop point phase -= tableSize; phase += phaseReset; } } intPhase = ((int)(phase*0.5))*2; // int phase, round to even frames, for each stereo frame pair wavetablePosition = sourceBuffer + intPhase; *buffer++ = interpolate(*wavetablePosition, *(wavetablePosition+2), phase - intPhase); *buffer++ = interpolate(*(wavetablePosition+1), *(wavetablePosition+3), phase - intPhase); // Increment phase by adjusting phaseAdd for instantaneous pitch bend instantBend = interpolate(y1, y2, fractional); fractional += fractionalIncrement; phase += phaseAdd * shiftToFreq(instantBend); } } // Scale back down to a factor, and write the final phase value back to AS3 phase /= tableSize; AS3_Set(settings, AS3_String("phase"), AS3_Number(phase)); return 0; }
static AS3_Val delay(void *self, AS3_Val args) { int bufferPosition; int channels; int frames; int count; float *buffer; int ringBufferPosition; float *ringBuffer; AS3_Val settings; int length; double feedbackArg; float feedback; double dryMixArg; float dryMix; double wetMixArg; float wetMix; int offset = 0; float echo; float *echoPointer; // Extract args AS3_ArrayValue(args, "IntType, IntType, IntType, IntType, AS3ValType", &bufferPosition, &ringBufferPosition, &channels, &frames, &settings); AS3_ObjectValue(settings, "length:IntType, dryMix:DoubleType, wetMix:DoubleType, feedback:DoubleType", &length, &dryMixArg, &wetMixArg, &feedbackArg); // Cast arguments to the needed types buffer = (float *) bufferPosition; ringBuffer = (float *) ringBufferPosition; dryMix = (float) dryMixArg; wetMix = (float) wetMixArg; feedback = (float) feedbackArg; // Show params // sprintf(trace, "Echo length=%d, dry=%f, wet=%f, fb=%f", length, dryMix, wetMix, feedback); // sztrace(trace); count = frames * channels; while (count--) { if (offset > length) { offset = 0; } echoPointer = ringBuffer + offset; echo = *echoPointer; *echoPointer = *buffer + echo*feedback; *buffer = *buffer * dryMix + echo * wetMix + 1e-15 - 1e-15; buffer++; offset++; } // Shift the memory so that the echo pointer offset is the start of the buffer int ringSize = length * channels * sizeof(float); int firstChunkSize = offset * channels * sizeof(float); int secondChunkSize = ringSize - firstChunkSize; float *temp = (float *) malloc(ringSize); // copy offset-end -> start of temp buffer memcpy(temp, ringBuffer + offset, secondChunkSize); // copy start-offset -> second half of temp buffer memcpy(temp + offset, ringBuffer, firstChunkSize); // copy temp buffer back to ringbuffer memcpy(ringBuffer, temp, ringSize); free(temp); return 0; }
static AS3_Val biquad(void *self, AS3_Val args) { int bufferPosition; int channels; int frames; int count; float *buffer; int stateBufferPosition; float *stateBuffer; AS3_Val coeffs; // coefficients object double a0d, a1d, a2d, b0d, b1d, b2d; // doubles from object float a0, a1, a2, b0, b1, b2; // filter coefficients float lx, ly, lx1, lx2, ly1, ly2; // left delay line float rx, ry, rx1, rx2, ry1, ry2; // right delay line // Extract args AS3_ArrayValue(args, "IntType, IntType, IntType, IntType, AS3ValType", &bufferPosition, &stateBufferPosition, &channels, &frames, &coeffs); buffer = (float *) bufferPosition; stateBuffer = (float *) stateBufferPosition; // Extract filter coefficients from object AS3_ObjectValue(coeffs, "a0:DoubleType, a1:DoubleType, a2:DoubleType, b0:DoubleType, b1:DoubleType, b2:DoubleType", &a0d, &a1d, &a2d, &b0d, &b1d, &b2d); // Cast to floats a0 = (float) a0d; a1 = (float) a1d; a2 = (float) a2d; b0 = (float) b0d; b1 = (float) b1d; b2 = (float) b2d; // Make sure we recieved all the correct coefficients // sprintf(trace, "Biquad a0=%f a1=%f a2=%f b0=%f b1=%f b2=%f", a0, a1, a2, b0, b1, b2); // sztrace(trace); count = frames; if (channels == 1) { lx1 = *stateBuffer; lx2 = *(stateBuffer+1); ly1 = *(stateBuffer+2); ly2 = *(stateBuffer+3); while (count--) { lx = *buffer + 1e-15 - 1e-15; // input with denormals zapped ly = lx*b0 + lx1*b1 + lx2*b2 - ly1*a1 - ly2*a2; lx2 = lx1; lx1 = lx; ly2 = ly1; ly1 = ly; *buffer++ = ly; // output } *stateBuffer = lx1; *(stateBuffer+1) = lx2; *(stateBuffer+2) = ly1; *(stateBuffer+3) = ly2; } else if (channels == 2) { lx1 = *stateBuffer; rx1 = *(stateBuffer+1); lx2 = *(stateBuffer+2); rx2 = *(stateBuffer+3); ly1 = *(stateBuffer+4); ry1 = *(stateBuffer+5); ly2 = *(stateBuffer+6); ry2 = *(stateBuffer+7); while (count--) { lx = *buffer + 1e-15 - 1e-15; // left input ly = lx*b0 + lx1*b1 + lx2*b2 - ly1*a1 - ly2*a2; lx2 = lx1; lx1 = lx; ly2 = ly1; ly1 = ly; *buffer++ = ly; // left output rx = *buffer + 1e-15 - 1e-15; // right input ry = rx*b0 + rx1*b1 + rx2*b2 - ry1*a1 - ry2*a2; rx2 = rx1; rx1 = rx; ry2 = ry1; ry1 = ry; *buffer++ = ry; // right output } *stateBuffer = lx1; *(stateBuffer+1) = rx1; *(stateBuffer+2) = lx2; *(stateBuffer+3) = rx2; *(stateBuffer+4) = ly1; *(stateBuffer+5) = ry1; *(stateBuffer+6) = ly2; *(stateBuffer+7) = ry2; } return 0; }
static AS3_Val setFilterType(void* self, AS3_Val args) { AS3_ArrayValue(args, "StrType", &filterType); return 0; }
//FLASH: Camera parameters setup static AS3_Val setFrameParams(void* self, AS3_Val args) { AS3_ArrayValue(args,"IntType, IntType, IntType",&frameWidth,&frameHeight,&frameChannels); //fprintf(stderr, "[OPENCV] setFrameParams: %d - %d - %d", frameWidth, frameHeight, frameChannels); return 0; }
AS3_Val call(void* thiz, AS3_Val args) { AS3_Val is; AS3_Val os; uint8_t* bufIn; uint8_t* bufOut; int i = 0; int j = 0; uint32_t color; uint32_t* bufDst; int w = 0; int h = 0; int len; int type; struct { uint16_t w; uint16_t h; } size; AS3_ArrayValue(args, "AS3ValType,IntType,IntType,AS3ValType", &is, &len, &type, &os); for(;;) { bufIn = malloc(len); if(!bufIn) break; AS3_ByteArray_readBytes(bufIn, is, len); bufOut = WebPDecodeRGB(bufIn, len, &w, &h); free(bufIn); if(!bufOut || w <= 0 || h <= 0) break; bufDst = (uint32_t*)malloc(w * h * 4); if(!bufDst) break; len = w * h * 3; while(i < len) { color = *(uint32_t*)(bufOut + i); color = (color << 8) | 0x000000FF; bufDst[j++] = color; i += 3; } free(bufOut); size.w = w; size.h = h; AS3_ByteArray_writeBytes(os, &size, sizeof(size)); AS3_ByteArray_writeBytes(os, bufDst, w * h * 4); free(bufDst); break; } return AS3_Undefined(); }
static AS3_Val benchmark(void* self, AS3_Val args) { /* used in the FORTRAN version */ long I; long N1, N2, N3, N4, N6, N7, N8, N9, N10, N11; double X1,X2,X3,X4,X,Y,Z; long LOOP; int II, JJ; /* added for this version */ long loopstart; long startsec, finisec; float KIPS; int continuous; loopstart = 1000; /* see the note about LOOP below */ continuous = 1; printf("[WHETSTONE] benchmark\n"); AS3_ArrayValue( args, "IntType", &loopstart); printf("[WHETSTONE] benchmark : %s\n", loopstart); LCONT: /* C C Start benchmark timing at this point. C */ startsec = time(0); /* C C The actual benchmark starts here. C */ T = .499975; T1 = 0.50025; T2 = 2.0; /* C C With loopcount LOOP=10, one million Whetstone instructions C will be executed in EACH MAJOR LOOP..A MAJOR LOOP IS EXECUTED C 'II' TIMES TO INCREASE WALL-CLOCK TIMING ACCURACY. C LOOP = 1000; */ LOOP = loopstart; II = 1; JJ = 1; IILOOP: N1 = 0; N2 = 12 * LOOP; N3 = 14 * LOOP; N4 = 345 * LOOP; N6 = 210 * LOOP; N7 = 32 * LOOP; N8 = 899 * LOOP; N9 = 616 * LOOP; N10 = 0; N11 = 93 * LOOP; /* C C Module 1: Simple identifiers C */ X1 = 1.0; X2 = -1.0; X3 = -1.0; X4 = -1.0; for (I = 1; I <= N1; I++) { X1 = (X1 + X2 + X3 - X4) * T; X2 = (X1 + X2 - X3 + X4) * T; X3 = (X1 - X2 + X3 + X4) * T; X4 = (-X1+ X2 + X3 + X4) * T; } #ifdef PRINTOUT IF (JJ==II)POUT(N1,N1,N1,X1,X2,X3,X4); #endif /* C C Module 2: Array elements C */ E1[1] = 1.0; E1[2] = -1.0; E1[3] = -1.0; E1[4] = -1.0; for (I = 1; I <= N2; I++) { E1[1] = ( E1[1] + E1[2] + E1[3] - E1[4]) * T; E1[2] = ( E1[1] + E1[2] - E1[3] + E1[4]) * T; E1[3] = ( E1[1] - E1[2] + E1[3] + E1[4]) * T; E1[4] = (-E1[1] + E1[2] + E1[3] + E1[4]) * T; } #ifdef PRINTOUT IF (JJ==II)POUT(N2,N3,N2,E1[1],E1[2],E1[3],E1[4]); #endif /* C C Module 3: Array as parameter C */ for (I = 1; I <= N3; I++) PA(E1); #ifdef PRINTOUT IF (JJ==II)POUT(N3,N2,N2,E1[1],E1[2],E1[3],E1[4]); #endif /* C C Module 4: Conditional jumps C */ J = 1; for (I = 1; I <= N4; I++) { if (J == 1) J = 2; else J = 3; if (J > 2) J = 0; else J = 1; if (J < 1) J = 1; else J = 0; } #ifdef PRINTOUT IF (JJ==II)POUT(N4,J,J,X1,X2,X3,X4); #endif /* C C Module 5: Omitted C Module 6: Integer arithmetic C */ J = 1; K = 2; L = 3; for (I = 1; I <= N6; I++) { J = J * (K-J) * (L-K); K = L * K - (L-J) * K; L = (L-K) * (K+J); E1[L-1] = J + K + L; E1[K-1] = J * K * L; } #ifdef PRINTOUT IF (JJ==II)POUT(N6,J,K,E1[1],E1[2],E1[3],E1[4]); #endif /* C C Module 7: Trigonometric functions C */ X = 0.5; Y = 0.5; for (I = 1; I <= N7; I++) { X = T * DATAN(T2*DSIN(X)*DCOS(X)/(DCOS(X+Y)+DCOS(X-Y)-1.0)); Y = T * DATAN(T2*DSIN(Y)*DCOS(Y)/(DCOS(X+Y)+DCOS(X-Y)-1.0)); } #ifdef PRINTOUT IF (JJ==II)POUT(N7,J,K,X,X,Y,Y); #endif /* C C Module 8: Procedure calls C */ X = 1.0; Y = 1.0; Z = 1.0; for (I = 1; I <= N8; I++) P3(X,Y,&Z); #ifdef PRINTOUT IF (JJ==II)POUT(N8,J,K,X,Y,Z,Z); #endif /* C C Module 9: Array references C */ J = 1; K = 2; L = 3; E1[1] = 1.0; E1[2] = 2.0; E1[3] = 3.0; for (I = 1; I <= N9; I++) P0(); #ifdef PRINTOUT IF (JJ==II)POUT(N9,J,K,E1[1],E1[2],E1[3],E1[4]); #endif /* C C Module 10: Integer arithmetic C */ J = 2; K = 3; for (I = 1; I <= N10; I++) { J = J + K; K = J + K; J = K - J; K = K - J - J; } #ifdef PRINTOUT IF (JJ==II)POUT(N10,J,K,X1,X2,X3,X4); #endif /* C C Module 11: Standard functions C */ X = 0.75; for (I = 1; I <= N11; I++) X = DSQRT(DEXP(DLOG(X)/T1)); #ifdef PRINTOUT IF (JJ==II)POUT(N11,J,K,X,X,X,X); #endif /* C C THIS IS THE END OF THE MAJOR LOOP. C */ if (++JJ <= II) goto IILOOP; /* C C Stop benchmark timing at this point. C */ finisec = time(0); /* C---------------------------------------------------------------- C Performance in Whetstone KIP's per second is given by C C (100*LOOP*II)/TIME C C where TIME is in seconds. C-------------------------------------------------------------------- */ printf("\n"); if (finisec-startsec <= 0) { printf("Insufficient duration- Increase the LOOP count\n"); //return(1); return 0; } printf("Loops: %ld, Iterations: %d, Duration: %ld sec.\n", LOOP, II, finisec-startsec); KIPS = (100.0*LOOP*II)/(float)(finisec-startsec); if (KIPS >= 1000.0) printf("C Converted Double Precision Whetstones: %.1f MIPS\n", KIPS/1000.0); else printf("C Converted Double Precision Whetstones: %.1f KIPS\n", KIPS); if (continuous) goto LCONT; //return(0); return 0; }
static AS3_Val prediction(void* self, AS3_Val args) { AS3_Val in_arr = AS3_Undefined(), out_arr = AS3_Array(0); float *tmp, d, e; int i,j,k,l, n,x,y, newx,newy, il, dx,dy; LAYER *pL; AS3_ArrayValue( args, "AS3ValType", &in_arr ); for(i=0; i < 1024; ++i) data[i] = AS3_IntValue(AS3_Get(in_arr, AS3_Int(4*i+1))) /255.0; n = 1; x = 32; y = 32; #define DATA(l,j,i) data[((l)*y + (j))*x + (i)] #define O(k,dy,dx) o[((k)*newy + (dy))*newx + (dx)] #define W(k,l,j,i) pL->w[(((k)*n + (l))*pL->y + (j))*pL->x + (i)] for (il=0; il < nl; ++il) { flyield(); pL = L+il; newx = x+1-pL->x; newy = y+1-pL->y; for (dx=0; dx < newx; ++dx) for (dy=0; dy < newy; ++dy) for (k=0; k < pL->n; ++k) { d = pL->b[k]; for (l=0; l < n; ++l) for(j=0; j < pL->y; ++j) for(i=0; i < pL->x; ++i) d += DATA(l,j+dy,i+dx)*W(k,l,j,i); O(k,dy,dx) = d; } if(pL->maxpool) { for (k=0; k < pL->n; ++k) for (dx=0; dx < newx; dx+=2) for (dy=0; dy < newy; dy+=2) { d=O(k,dy,dx); e=O(k,dy,dx+1); if(e>d) d=e; e=O(k,dy+1,dx); if(e>d) d=e; e=O(k,dy+1,dx+1); if(e>d) d=e; O(k,dy/2,dx/2)=d; } newx /= 2; newy /= 2; } for (dx=0; dx < newx; ++dx) for (dy=0; dy < newy; ++dy) { e = 0; for (k=0; k < pL->n; ++k) { d = O(k,dy,dx); if(pL->nonlin==1) d=1.0/(1.0 + exp(-d)); else if(pL->nonlin==2) d=tanh(d); else if(pL->nonlin==3) { d=exp(d); e += d; } O(k,dy,dx) = d; } if(pL->nonlin==3 && e) for (k=0; k < pL->n; ++k) O(k,dy,dx) /= e; } tmp = data; data = o; o = tmp; x = newx; y = newy; n = pL->n; } for(i=0; i < n*x*y; ++i) AS3_Set(out_arr, AS3_Int(i), AS3_Number(data[i])); return out_arr; }