void device::setup(const occa::properties &props) { occa::properties settings_ = settings(); occa::properties defaults; std::string paths[2] = {"", ""}; paths[1] = "mode/"; paths[1] += (std::string) props["mode"]; paths[1] += '/'; for (int i = 0; i < 2; ++i) { const std::string &path = paths[i]; if (settings_.has(path + "device")) { defaults += settings_[path + "device"]; } if (settings_.has(path + "kernel")) { defaults["kernel"] += settings_[path + "kernel"]; } if (settings_.has(path + "memory")) { defaults["memory"] += settings_[path + "memory"]; } } setDHandle(occa::newModeDevice(defaults + props)); stream newStream = createStream(); dHandle->currentStream = newStream.handle; }
// Loads the old save by constructing a new save containing the old save's data bool SaveConverter_Notes::load() { if (_size == 0) return false; Common::InSaveFile *save; // Test if it's an old savd if (!isOldSave(&save) || !save) return false; displayWarning(); SaveWriter writer(1, 0); SavePartVars *vars = readVars(*save, _size, false); if (!vars) return loadFail(0, save); // We don't need the save anymore delete save; // Write all parts if (!writer.writePart(0, vars)) return loadFail(0, 0); // We don't need this anymore delete vars; // Create the final read stream if (!createStream(writer)) return loadFail(0, 0); return true; }
void toggleStream(Generator& generator, XnProductionNodeType type, bool* bIsOn) { XnStatus nRetVal = XN_STATUS_OK; if (!generator.IsValid()) { createStream(generator, type); } if (!generator.IsValid()) { // failed creating the stream return; } if (generator.IsGenerating()) { generator.StopGenerating(); } else { nRetVal = generator.StartGenerating(); if (nRetVal != XN_STATUS_OK) { displayMessage("Failed to turn on %s: %s", generator.GetInfo().GetInstanceName(), xnGetStatusString(nRetVal)); return; } } *bIsOn = (generator.IsGenerating() == TRUE); }
StreamHandle AudioDevice::playStream(const std::string &name) { StreamHandle handle = createStream(name); if(handle) handle->play(); else JL_WARNING_LOG("Attempted to play non-existant stream!"); return handle; }
FormatInfoPage *PalmDocPlugin::createInfoPage(ZLOptionsDialog &dialog, const ZLFile &file) { shared_ptr<ZLInputStream> stream = createStream(file); stream->open(); bool readAsPalmDoc = ((PalmDocStream&)*stream).hasExtraSections(); stream->close(); if (!readAsPalmDoc) { return new PlainTextInfoPage(dialog, file, ZLResourceKey("Text"), !TextFormatDetector().isHtml(*stream)); } else { return 0; } }
void DataHandler::createFileIfNotExisting(const char *dataFilePath) { if(!doesFileExist(dataFilePath)) { cerr << "File " << dataFilePath << " doesn't exist. Creating..." << endl; fstream createStream(dataFilePath, ios_base::out); if(createStream.fail()) { string error = string("File ") + dataFilePath + string(" doesn't exist and unable to create it!"); throw error; } createStream.close(); } }
//******************************************************************** // //******************************************************************** //-------------------------------------------------------------------- // //-------------------------------------------------------------------- bool DSFilterSourceStreamAudio::init(INWStreamReader* _stream) { bool bOK = true; if (!isOk()) { bOK = createStream(_stream); mInit = true; } return bOK; }
// Loads the old save by constructing a new save containing the old save's data bool SaveConverter_v4::load() { clear(); uint32 varSize = SaveHandler::getVarSize(_vm); if (varSize == 0) return false; Common::InSaveFile *save; // Test if it's an old savd if (!isOldSave(&save) || !save) return false; displayWarning(); SaveWriter writer(3, 0); SavePartInfo *info = readInfo(*save, kSlotNameLength, false); if (!info) return loadFail(0, 0, 0, save); SavePartVars *vars = readVars(*save, varSize, true); if (!vars) return loadFail(info, 0, 0, save); SavePartMem *props = readMem(*save, 256000, true); if (!props) return loadFail(info, vars, 0, save); // We don't need the save anymore delete save; // Write all parts if (!writer.writePart(0, info)) return loadFail(info, vars, props, 0); if (!writer.writePart(1, vars)) return loadFail(info, vars, props, 0); if (!writer.writePart(2, props)) return loadFail(info, vars, props, 0); // We don't need those anymore delete info; delete vars; delete props; // Create the final read stream if (!createStream(writer)) return loadFail(0, 0, 0, 0); return true; }
void test_seek() { for (unsigned int i = 0; i < 50; i++) { uint8 buffer[MAX_BUFFER]; uint32 size = (cOSRand::rand() % (MAX_BUFFER - 2)) + 2; for (uint32 i = 0; i < size; i++) { buffer[i] = (uint8)cOSRand::rand(); } int type = cOSRand::rand(); // Create the stream { cSmartPtr<basicIO> stream = createStream(type); stream->pipeWrite(buffer, size); closeStream(type, stream); } // Read from the stream with seeking... { cSmartPtr<basicIO> rstream = createReadStream(type); // From begin unsigned int idx; for (idx = 0; idx < 10; idx++) { int positionFromBegin = cOSRand::rand() % size; rstream->seek(positionFromBegin, basicInput::IO_SEEK_SET); uint8 ch; TESTS_ASSERT_EQUAL(rstream->pipeRead(&ch, 1), 1); TESTS_ASSERT_EQUAL(buffer[positionFromBegin], ch); } // From end for (idx = 0; idx < 10; idx++) { int positionFromEnd = (cOSRand::rand() % (size - 1)) + 1; positionFromEnd = -positionFromEnd; rstream->seek(positionFromEnd, basicInput::IO_SEEK_END); uint8 ch; TESTS_ASSERT_EQUAL(rstream->pipeRead(&ch, 1), 1); TESTS_ASSERT_EQUAL(buffer[size + positionFromEnd], ch); } } cout << '-'; cout.flush(); } }
OSStatus AudioHardwareImpl::start(AudioDeviceIOProcID inProcID, AudioTimeStamp* ioRequestedStartTime, UInt32 inFlags) { AudioHardwareStream* stream; if (m_streams.find(inProcID) != m_streams.end()) return noErr; stream = createStream(inProcID); m_streams[inProcID] = stream; // TODO: time return stream; }
status_t ProCamera::createStreamCpu(int width, int height, int format, int heapCount, bool synchronousMode, /*out*/ sp<CpuConsumer>* cpuConsumer, int* streamId) { ALOGV("%s: createStreamW %dx%d (fmt=0x%x)", __FUNCTION__, width, height, format); *cpuConsumer = NULL; sp <IProCameraUser> c = mCamera; if (c == 0) return NO_INIT; sp<BufferQueue> bq = new BufferQueue(); sp<CpuConsumer> cc = new CpuConsumer(bq, heapCount/*, synchronousMode*/); cc->setName(String8("ProCamera::mCpuConsumer")); sp<Surface> stc = new Surface(bq); status_t s = createStream(width, height, format, stc->getIGraphicBufferProducer(), streamId); if (s != OK) { ALOGE("%s: Failure to create stream %dx%d (fmt=0x%x)", __FUNCTION__, width, height, format); return s; } sp<ProFrameListener> frameAvailableListener = new ProFrameListener(this, *streamId); getStreamInfo(*streamId).cpuStream = true; getStreamInfo(*streamId).cpuConsumer = cc; getStreamInfo(*streamId).synchronousMode = synchronousMode; getStreamInfo(*streamId).stc = stc; // for lifetime management getStreamInfo(*streamId).frameAvailableListener = frameAvailableListener; cc->setFrameAvailableListener(frameAvailableListener); *cpuConsumer = cc; return s; }
aalError Sample::load() { if(length != 0) { return AAL_ERROR_INIT; } Stream * stream = createStream(name); if(!stream) { return AAL_ERROR_FILEIO; } stream->getFormat(format); length = stream->getLength(); deleteStream(stream); return AAL_OK; }
status_t ProCamera::createStream(int width, int height, int format, const sp<Surface>& surface, /*out*/ int* streamId) { *streamId = -1; ALOGV("%s: createStreamW %dx%d (fmt=0x%x)", __FUNCTION__, width, height, format); if (surface == 0) { return BAD_VALUE; } return createStream(width, height, format, surface->getIGraphicBufferProducer(), streamId); }
void test_remote_address() { // Create memory-stream BasicIOPtr stream = createStream(0); // Start by normally encode a series of default memory stream #define NUMBER_OF_ADDRESSES (100) cSArray<remoteAddressNumericValue> m_address(NUMBER_OF_ADDRESSES); // Serialize for (uint i = 0; i < 100; i++) { // Randomize m_address[i] = remoteAddressNumericValue((addressNumericValue)(cOSRand::rand())); // And encode stream->streamWriteRemoteAddress(m_address[i]); } stream->seek(0, basicIO::IO_SEEK_SET); // Deserialize for (uint i = 0; i < 100; i++) { remoteAddressNumericValue temp = stream->streamReadRemoteAddress(); TESTS_ASSERT_EQUAL(temp, m_address[i]); } // Now test for clipping! stream->seek(0, basicIO::IO_SEEK_SET); stream->changeEncodedAddressType(false, REMOTE_ADDRESS_64BIT); stream->changeDecodedAddressType(false, REMOTE_ADDRESS_64BIT); // Serialize for (uint i = 0; i < 100; i++) stream->streamWriteRemoteAddress(m_address[i]); stream->seek(0, basicIO::IO_SEEK_SET); // Deserialize for (uint i = 0; i < 100; i++) { remoteAddressNumericValue temp = stream->streamReadRemoteAddress(); TESTS_ASSERT_EQUAL(temp, m_address[i]); } }
void test_read_write() { for (unsigned int i = 0; i < 50; i++) { uint8 buffer[MAX_BUFFER]; uint8 read[MAX_BUFFER]; uint32 size = (cOSRand::rand() % (MAX_BUFFER - 1)) + 1; for (uint32 i = 0; i < size; i++) { buffer[i] = (uint8)cOSRand::rand(); read[i] = 0; } int type = cOSRand::rand(); // Write out to the stream { cSmartPtr<basicIO> stream = createStream(type); stream->pipeWrite(buffer, size); closeStream(type, stream); } // Read from the stream { cSmartPtr<basicIO> rstream = createReadStream(type); rstream->pipeRead(read, size); // Test the reading for (uint32 j = 0; j < size; j++) { TESTS_ASSERT_EQUAL(read[j], buffer[j]); } TESTS_ASSERT(rstream->isEOS()); } cout << ','; cout.flush(); } }
// Creates the stream, registers the data and end events and starts the stream void readFile( void * loop ){ gEventLoop = loop; void * stream = createStream( "prod", "stahp", chunk, initRead, loop ); if (stream == NULL){ fprintf(stderr, "cannot create stream\n"); exit(-1); } // remember the stream for use in terminate function gStream = stream; registerEvent( loop, "prod", addToSum ); registerEvent( loop, "stahp", terminate ); // start the stream startStream( stream, fileName ); }
void LasReader::initialize() { if (m_initialized) return; m_istream = createStream(); m_istream->seekg(0); ILeStream in(m_istream); in >> m_lasHeader; if (!m_lasHeader.pointFormatSupported()) { std::ostringstream oss; oss << "Unsupported LAS input point format: " << (int)m_lasHeader.pointFormat() << "."; throw pdal_error(oss.str()); } // We need to read the VLRs in initialize() because they may contain an // extra-bytes VLR that is needed to determine dimensions. m_istream->seekg(m_lasHeader.vlrOffset()); for (size_t i = 0; i < m_lasHeader.vlrCount(); ++i) { VariableLengthRecord r; in >> r; m_vlrs.push_back(std::move(r)); } if (m_lasHeader.versionAtLeast(1, 4)) { m_istream->seekg(m_lasHeader.eVlrOffset()); for (size_t i = 0; i < m_lasHeader.eVlrCount(); ++i) { ExtVariableLengthRecord r; in >> r; m_vlrs.push_back(std::move(r)); } readExtraBytesVlr(); }
/*============================================================================ Description: (API Call) Writes an entire stream in one pass. Arguments: io_pStorage - pointer to parent storage in which to create the new stream in_wszStreamName - name of new stream in_pvBuf - data to write into stream in_pcbBufSize - number of bytes in in_pvBuf Return: Status code ==========================================================================*/ int flushStream(Storage* io_pStorage, const wchar_t* in_wszStreamName, const void* in_pvBuf, unsigned long* in_pcbBufSize) { int iRet = SSTG_OK; Stream* pNewStream = NULL; ASSERT ((io_pStorage != NULL) && (in_wszStreamName != NULL) && (*in_wszStreamName != 0) && (in_pvBuf != NULL)); if ((io_pStorage == NULL) || (in_wszStreamName == NULL) || (*in_wszStreamName == 0) || (in_pvBuf == NULL)) { return SSTG_ERROR_ILLEGAL_CALL; } _KABOOM1; iRet = createStream(io_pStorage, in_wszStreamName, &pNewStream); if (iRet != SSTG_OK) { return iRet; } iRet = streamWrite(pNewStream, in_pvBuf, in_pcbBufSize); if (iRet != SSTG_OK) { return iRet; } iRet = closeStream(&pNewStream); return iRet; }
bool SimplePdbPlugin::readMetainfo(Book &book) const { const ZLFile &file = book.file(); shared_ptr<ZLInputStream> stream = createStream(file); detectEncodingAndLanguage(book, *stream); if (book.encoding().empty()) { return false; } int readType = HtmlMetainfoReader::NONE; if (book.title().empty()) { readType |= HtmlMetainfoReader::TITLE; } if (book.authors().empty()) { readType |= HtmlMetainfoReader::AUTHOR; } if (readType != HtmlMetainfoReader::NONE) { //if ((readType != HtmlMetainfoReader::NONE) && TextFormatDetector().isHtml(*stream)) { readType |= HtmlMetainfoReader::TAGS; HtmlMetainfoReader metainfoReader(book, (HtmlMetainfoReader::ReadType)readType); metainfoReader.readDocument(*stream); } return true; }
FormatInfoPage *ZTXTPlugin::createInfoPage(ZLOptionsDialog &dialog, const std::string &fileName) { ZLFile file(fileName); fb::shared_ptr<ZLInputStream> stream = createStream(file); return new PlainTextInfoPage(dialog, fileName, ZLResourceKey("Text"), !TextFormatDetector().isHtml(*stream)); }
Common::SeekableReadStream *BlbArchive::createStream(uint index) { return createStream(&_entries[index]); }
/* * Class: EnumAccel_Unit * Method: creatStream * Signature: (I)V */ JNIEXPORT void JNICALL Java_EnumAccel_00024Unit_createStream (JNIEnv *env, jobject jobj, jint rank){ int h = createStream(rank); }
// Loads the old save by constructing a new save containing the old save's data bool SaveConverter_v3::load() { clear(); uint32 varSize = SaveHandler::getVarSize(_vm); if (varSize == 0) return false; Common::InSaveFile *save; int type = isOldSave(&save); // Test if it's an old savd if ((type == 0) || !save) return false; displayWarning(); bool screenShot; uint32 screenShotWidth; uint32 screenShotHeight; getScreenShotProps(type, screenShot, screenShotWidth, screenShotHeight); SaveWriter writer(screenShot ? 3 : 2, 0); SavePartInfo *info = readInfo(*save, kSlotNameLength, false); if (!info) return loadFail(0, 0, 0, save); SavePartVars *vars = readVars(*save, varSize, true); if (!vars) return loadFail(info, 0, 0, save); if (screenShot) { SavePartSprite *sprite = readSprite(*save, screenShotWidth, screenShotHeight, true); if (!sprite) return loadFail(info, vars, 0, save); if (!writer.writePart(2, sprite)) return loadFail(info, vars, sprite, save); delete sprite; } // We don't need the save anymore delete save; // Write all parts if (!writer.writePart(0, info)) return loadFail(info, vars, 0, 0); if (!writer.writePart(1, vars)) return loadFail(info, vars, 0, 0); // We don't need those anymore delete info; delete vars; // Create the final read stream if (!createStream(writer)) return loadFail(0, 0, 0, 0); return true; }
void useStream( std::string const& streamName ) { Stream stream = createStream( streamName ); setStreamBuf( stream.streamBuf ); m_stream.release(); m_stream = stream; }
int createParticle(pScene sc,pMesh mesh) { pParticle pp; pStream st; pMaterial pm; pTetra pt1; pTriangle pt; pPoint ppt; double v[4],cx,cy,cz; int i,j,k,l,nmat,nbp,base; if ( ddebug ) printf("create particles\n"); if ( egal(sc->iso.val[0],sc->iso.val[MAXISO-1]) ) return(0); if ( sc->stream ) { st = sc->stream; if ( st->listp ) free(st->listp); free(sc->stream); } sc->stream = createStream(sc,mesh); sc->par.cumtim = 0.0; sc->par.advtim = 0; assert(sc->stream); st = sc->stream; fprintf(stdout," Creating particles :"); fflush(stdout); st->nbstl = 0; base = ++mesh->mark; pt = &mesh->tria[refitem]; nmat = matRef(sc,pt->ref); pm = &sc->material[nmat]; k = pm->depmat[LTria]; if ( !k || pm->flag ) return(0); /* point positions */ for (i=1; i<=mesh->np; i++) { ppt = &mesh->point[i]; ppt->mark = base; } if ( sc->par.nbpart >= MAX_PRT ) sc->par.nbpart = MAX_PRT; ++base; l = 1; nbp = 0; while ( k != 0 && st->nbstl < MAX_LST-1 ) { pt = &mesh->tria[k]; if ( pt->v[0] ) { cx = cy = cz = 0.0; for (i=0; i<3; i++) { ppt = &mesh->point[pt->v[i]]; cx += 0.33 * ppt->c[0]; cy += 0.33 * ppt->c[1]; cz += 0.33 * ppt->c[2]; ppt->flag = 1; } st->listp[l++] = cx; st->listp[l++] = cy; st->listp[l++] = cz; ++st->nbstl; if ( st->nbstl > MAX_LST-1 ) break; k = pt->nxt; } } fprintf(stdout,"%d\n",st->nbstl); if ( !st->nbstl ) return(0); /* init positions */ tp = calloc((st->nbstl+1),sizeof(Particle)); assert(tp); for (k=1; k<=st->nbstl; k++) tp[k].nsdep = mesh->ntet / 2; for (k=1; k<=mesh->ntet; k++) mesh->tetra[k].cpt = 0; l = 1; for (k=1; k<=st->nbstl; k++) { pp = &tp[k]; pp->pos[1][0] = st->listp[l++]; pp->pos[1][1] = st->listp[l++]; pp->pos[1][2] = st->listp[l++]; tp[k].nsdep = locateTetra(mesh,pp->nsdep,++mesh->mark,pp->pos[1],pp->cb); if ( !pp->nsdep ) { for (j=1; j<=mesh->ntet; j++) { pt1 = &mesh->tetra[j]; if ( pt1->mark != mesh->mark && inTetra(mesh,j,pp->pos[1],pp->cb) ) break; } if ( j > mesh->ntet ) return(0); else pp->nsdep = j; } pp->norm = field3DInterp(mesh,tp[k].nsdep,tp[k].cb,v); pp->size = sizeTetra(mesh,tp[k].nsdep); if ( pp->size == 0.0 ) pp->step = EPS*sc->dmax; else pp->step = HSIZ * min(pp->size,pp->norm); pp->step = min(0.05*sc->par.dt,pp->step); pp->flag = 1; pp->cur = 1; colorParticle(sc,pp); for (i=2; i<=sc->par.nbpart; i++) { pp->pos[i][0] = pp->pos[1][0]; pp->pos[i][1] = pp->pos[1][1]; pp->pos[i][2] = pp->pos[1][2]; } } return(1); }
/* * For server: create the shared memory. Create incoming and * outgoing streams. */ static jint createConnection(SharedMemoryTransport *transport, jlong otherPID, SharedMemoryConnection **connectionPtr) { jint error; char streamPrefix[MAX_IPC_NAME]; SharedMemoryConnection *connection = allocConnection(); if (connection == NULL) { return SYS_NOMEM; } sprintf(connection->name, "%s.%ld", transport->name, otherPID); error = sysSharedMemCreate(connection->name, sizeof(SharedMemory), &connection->sharedMemory, &connection->shared); if (error != SYS_OK) { closeConnection(connection); return error; } memset(connection->shared, 0, sizeof(SharedMemory)); /* This process is the server */ connection->incoming.shared = &connection->shared->toServer; connection->outgoing.shared = &connection->shared->toClient; strcpy(streamPrefix, connection->name); strcat(streamPrefix, ".ctos"); error = createStream(streamPrefix, &connection->incoming); if (error != SYS_OK) { closeConnection(connection); return error; } strcpy(streamPrefix, connection->name); strcat(streamPrefix, ".stoc"); error = createStream(streamPrefix, &connection->outgoing); if (error != SYS_OK) { closeConnection(connection); return error; } error = sysProcessOpen(otherPID, &connection->otherProcess); if (error != SYS_OK) { fprintf(stderr,"Error accessing process, rc = %d\n", error); closeConnection(connection); return error; } /* * Create an event that signals that the connection is shutting * down. The event is unnamed as it's process local, and is * manually reset (so that a signalling the event will signal * all threads waiting on it). */ error = sysEventCreate(NULL, &connection->shutdown, JNI_TRUE); if (error != SYS_OK) { fprintf(stderr,"Error creating unnamed event, rc = %d\n", error); closeConnection(connection); return error; } *connectionPtr = connection; return SYS_OK; }
status_t BnCameraDeviceUser::onTransact( uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags) { switch(code) { case DISCONNECT: { ALOGV("DISCONNECT"); CHECK_INTERFACE(ICameraDeviceUser, data, reply); disconnect(); reply->writeNoException(); return NO_ERROR; } break; case SUBMIT_REQUEST: { CHECK_INTERFACE(ICameraDeviceUser, data, reply); // arg0 = request sp<CaptureRequest> request; if (data.readInt32() != 0) { request = new CaptureRequest(); request->readFromParcel(const_cast<Parcel*>(&data)); } // arg1 = streaming (bool) bool repeating = data.readInt32(); // return code: requestId (int32) reply->writeNoException(); int64_t lastFrameNumber = -1; reply->writeInt32(submitRequest(request, repeating, &lastFrameNumber)); reply->writeInt32(1); reply->writeInt64(lastFrameNumber); return NO_ERROR; } break; case SUBMIT_REQUEST_LIST: { CHECK_INTERFACE(ICameraDeviceUser, data, reply); List<sp<CaptureRequest> > requestList; int requestListSize = data.readInt32(); for (int i = 0; i < requestListSize; i++) { if (data.readInt32() != 0) { sp<CaptureRequest> request = new CaptureRequest(); if (request->readFromParcel(const_cast<Parcel*>(&data)) != OK) { return BAD_VALUE; } requestList.push_back(request); } else { sp<CaptureRequest> request = 0; requestList.push_back(request); ALOGE("A request is missing. Sending in null request."); } } bool repeating = data.readInt32(); reply->writeNoException(); int64_t lastFrameNumber = -1; reply->writeInt32(submitRequestList(requestList, repeating, &lastFrameNumber)); reply->writeInt32(1); reply->writeInt64(lastFrameNumber); return NO_ERROR; } break; case CANCEL_REQUEST: { CHECK_INTERFACE(ICameraDeviceUser, data, reply); int requestId = data.readInt32(); reply->writeNoException(); int64_t lastFrameNumber = -1; reply->writeInt32(cancelRequest(requestId, &lastFrameNumber)); reply->writeInt32(1); reply->writeInt64(lastFrameNumber); return NO_ERROR; } break; case DELETE_STREAM: { CHECK_INTERFACE(ICameraDeviceUser, data, reply); int streamId = data.readInt32(); reply->writeNoException(); reply->writeInt32(deleteStream(streamId)); return NO_ERROR; } break; case CREATE_STREAM: { CHECK_INTERFACE(ICameraDeviceUser, data, reply); status_t ret = BAD_VALUE; if (data.readInt32() != 0) { OutputConfiguration outputConfiguration(data); ret = createStream(outputConfiguration); } else { ALOGE("%s: cannot take an empty OutputConfiguration", __FUNCTION__); } reply->writeNoException(); ALOGV("%s: CREATE_STREAM: write noException", __FUNCTION__); reply->writeInt32(ret); ALOGV("%s: CREATE_STREAM: write ret = %d", __FUNCTION__, ret); return NO_ERROR; } break; case CREATE_INPUT_STREAM: { CHECK_INTERFACE(ICameraDeviceUser, data, reply); int width, height, format; width = data.readInt32(); height = data.readInt32(); format = data.readInt32(); status_t ret = createInputStream(width, height, format); reply->writeNoException(); reply->writeInt32(ret); return NO_ERROR; } break; case GET_INPUT_SURFACE: { CHECK_INTERFACE(ICameraDeviceUser, data, reply); sp<IGraphicBufferProducer> bp; status_t ret = getInputBufferProducer(&bp); sp<IBinder> b(IInterface::asBinder(ret == OK ? bp : NULL)); reply->writeNoException(); reply->writeInt32(ret); reply->writeInt32(1); reply->writeString16(String16("camera input")); // name of surface reply->writeStrongBinder(b); return NO_ERROR; } break; case CREATE_DEFAULT_REQUEST: { CHECK_INTERFACE(ICameraDeviceUser, data, reply); int templateId = data.readInt32(); CameraMetadata request; status_t ret; ret = createDefaultRequest(templateId, &request); reply->writeNoException(); reply->writeInt32(ret); // out-variables are after exception and return value reply->writeInt32(1); // to mark presence of metadata object request.writeToParcel(const_cast<Parcel*>(reply)); return NO_ERROR; } break; case GET_CAMERA_INFO: { CHECK_INTERFACE(ICameraDeviceUser, data, reply); CameraMetadata info; status_t ret; ret = getCameraInfo(&info); reply->writeNoException(); reply->writeInt32(ret); // out-variables are after exception and return value reply->writeInt32(1); // to mark presence of metadata object info.writeToParcel(reply); return NO_ERROR; } break; case WAIT_UNTIL_IDLE: { CHECK_INTERFACE(ICameraDeviceUser, data, reply); reply->writeNoException(); reply->writeInt32(waitUntilIdle()); return NO_ERROR; } break; case FLUSH: { CHECK_INTERFACE(ICameraDeviceUser, data, reply); reply->writeNoException(); int64_t lastFrameNumber = -1; reply->writeInt32(flush(&lastFrameNumber)); reply->writeInt32(1); reply->writeInt64(lastFrameNumber); return NO_ERROR; } case BEGIN_CONFIGURE: { CHECK_INTERFACE(ICameraDeviceUser, data, reply); reply->writeNoException(); reply->writeInt32(beginConfigure()); return NO_ERROR; } break; case END_CONFIGURE: { CHECK_INTERFACE(ICameraDeviceUser, data, reply); bool isConstrainedHighSpeed = data.readInt32(); reply->writeNoException(); reply->writeInt32(endConfigure(isConstrainedHighSpeed)); return NO_ERROR; } break; case PREPARE: { CHECK_INTERFACE(ICameraDeviceUser, data, reply); int streamId = data.readInt32(); reply->writeNoException(); reply->writeInt32(prepare(streamId)); return NO_ERROR; } break; case TEAR_DOWN: { CHECK_INTERFACE(ICameraDeviceUser, data, reply); int streamId = data.readInt32(); reply->writeNoException(); reply->writeInt32(tearDown(streamId)); return NO_ERROR; } break; default: return BBinder::onTransact(code, data, reply, flags); } }
aalError DSoundSource::init(SourceId _id, const Channel & _channel) { id = _id; DSBUFFERDESC _desc; WAVEFORMATEX _format; bool streaming(false); clean(); channel = _channel; memset(&_desc, 0, sizeof(DSBUFFERDESC)); _desc.dwSize = sizeof(DSBUFFERDESC); _desc.dwFlags = DSBCAPS_GETCURRENTPOSITION2; if(channel.flags & FLAG_VOLUME) { _desc.dwFlags |= DSBCAPS_CTRLVOLUME; } if(channel.flags & FLAG_PITCH) { _desc.dwFlags |= DSBCAPS_CTRLFREQUENCY; } if(channel.flags & FLAG_PAN) { _desc.dwFlags |= DSBCAPS_CTRLPAN; } if(channel.flags & FLAG_ANY_3D_FX) { _desc.dwFlags |= DSBCAPS_CTRL3D; _desc.dwFlags &= ~DSBCAPS_CTRLPAN; channel.flags &= ~FLAG_PAN; } _desc.lpwfxFormat = &_format; _format.nSamplesPerSec = sample->getFormat().frequency; _format.wBitsPerSample = (WORD)sample->getFormat().quality; _format.nChannels = (WORD)sample->getFormat().channels; _format.wFormatTag = WAVE_FORMAT_PCM; _format.nBlockAlign = (WORD)(sample->getFormat().channels * (sample->getFormat().quality >> 3)); _format.nAvgBytesPerSec = _format.nBlockAlign * sample->getFormat().frequency; _format.cbSize = 0; // Get buffer size and determine if streaming must be enable if(sample->getLength() > stream_limit_bytes) { size = stream_limit_bytes, streaming = true; } else { size = sample->getLength(); } _desc.dwBufferBytes = size; if(backend->device->CreateSoundBuffer(&_desc, &lpdsb, NULL)) { return AAL_ERROR_SYSTEM; } if(aalError error = init()) { return error; } stream = createStream(sample->getName()); if(!stream) { return AAL_ERROR_FILEIO; } // Load sample data if not streamed if(!streaming) { if(stream->setPosition(0)) { return AAL_ERROR_SYSTEM; } DWORD cur0, cur1; void * ptr0, *ptr1; if(lpdsb->Lock(0, 0, &ptr0, &cur0, &ptr1, &cur1, DSBLOCK_ENTIREBUFFER)) { return AAL_ERROR_SYSTEM; } stream->read(ptr0, size, write); if(lpdsb->Unlock(ptr0, cur0, ptr1, cur1)) { return AAL_ERROR_SYSTEM; } if(write != size) { return AAL_ERROR_SYSTEM; } deleteStream(stream); } return AAL_OK; }
SINT4 storageSelfTest1(StgMode in_stgModeOpen, StgMode in_stgModeCreate) { SINT4 iRet = SSTG_OK; RootStorage* pRoot = NULL; Storage* pStorage1 = NULL; Storage* pStorage2 = NULL; Storage* pStorage3 = NULL; Stream* pStream1 = NULL; Stream* pStream2 = NULL; Stream* pStream3 = NULL; Stream* pStream4 = NULL; int cch = 0; unsigned long cchL = 0; wchar_t pwchBuf[] = L"Stuff to write into streams"; wchar_t pwchBuf2[60]; /* The main thing being tested here is the open list. If the calling * application fails to close some streams and storages before closing * the structured storage file, the structured storage library is supposed * to clean everything up automatically. */ /* Create a bunch of streams and storages */ iRet = createStructuredStorageEx (WSZ_TEST_FILENAME, in_stgModeCreate, &pRoot, 0); ASSERT (iRet == SSTG_OK && pRoot != NULL); iRet = getStorageFromRoot (pRoot, &pStorage1); ASSERT (iRet == SSTG_OK && pStorage1 != NULL); iRet = createStream (pStorage1, WSZ_TEST_STREAM_1, &pStream1); ASSERT (iRet == SSTG_OK && pStream1 != NULL); cch = 0; ASSERT (writeLEwstring(pStream1, pwchBuf, &cch) == SSTG_OK && cch == 28); iRet = createStorage (pStorage1, WSZ_TEST_STORAGE_2, &pStorage2); ASSERT (iRet == SSTG_OK && pStorage2 != NULL); iRet = createStorage (pStorage2, WSZ_TEST_STORAGE_3, &pStorage3); ASSERT (iRet == SSTG_OK && pStorage3 != NULL); iRet = createStream (pStorage2, WSZ_TEST_STREAM_2, &pStream2); ASSERT (iRet == SSTG_OK && pStream2 != NULL); cch = 0; ASSERT (writeLEwstring(pStream2, pwchBuf, &cch) == SSTG_OK && cch == 28); cchL = 28 * sizeof(wchar_t); iRet = flushStream(pStorage2, WSZ_TEST_STREAM_3, pwchBuf, &cchL); ASSERT(iRet == SSTG_OK && cchL == (28 * sizeof(wchar_t))); /* Test to ensure that destroying a mini stream works */ cchL = 28 * sizeof(wchar_t); iRet = flushStream(pStorage2, WSZ_TEST_STREAM_4, pwchBuf, &cchL); ASSERT(iRet == SSTG_OK && cchL == (28 * sizeof(wchar_t))); iRet = destroy(pStorage2, WSZ_TEST_STREAM_4); ASSERT(iRet == SSTG_OK); /* Test to make sure duplicates are not allowed */ iRet = createStream(pStorage2, WSZ_TEST_STREAM_3, &pStream4); ASSERT (iRet != SSTG_OK && pStream4 == NULL); /* Now close the entire compound file without closing any of the open * children */ iRet = closeStructuredStorage(&pRoot); ASSERT (iRet == SSTG_OK && pRoot == NULL); pStorage1 = NULL; pStorage2 = NULL; pStorage3 = NULL; pStream1 = NULL; pStream2 = NULL; pStream3 = NULL; /* Now do the same thing for reading. */ /* Open a bunch of streams and storages for reading. */ iRet = openStructuredStorageEx (WSZ_TEST_FILENAME, in_stgModeOpen, &pRoot); ASSERT (iRet == SSTG_OK); iRet = getStorageFromRoot (pRoot, &pStorage1); ASSERT (iRet == SSTG_OK && pStorage1 != NULL); iRet = openStream (pStorage1, WSZ_TEST_STREAM_1, &pStream1); ASSERT (iRet == SSTG_OK && pStream1 != NULL); cch = 28; iRet = readLEwstring(pStream1, &cch, pwchBuf2); ASSERT (iRet == SSTG_OK && cch == 28); ASSERT (memcmp(pwchBuf, pwchBuf2, wcslen(pwchBuf) + 1) == 0); memset(pwchBuf2, 0, sizeof(pwchBuf2)); iRet = openStorage (pStorage1, WSZ_TEST_STORAGE_2, &pStorage2); ASSERT (iRet == SSTG_OK && pStorage2 != NULL); iRet = openStorage (pStorage2, WSZ_TEST_STORAGE_3, &pStorage3); ASSERT (iRet == SSTG_OK && pStorage3 != NULL); iRet = openStream (pStorage2, WSZ_TEST_STREAM_2, &pStream2); ASSERT (iRet == SSTG_OK && pStream2 != NULL); cch = 28; ASSERT (readLEwstring(pStream2, &cch, pwchBuf2) == SSTG_OK && cch == 28); ASSERT (memcmp(pwchBuf, pwchBuf2, wcslen(pwchBuf) + 1) == 0); memset(pwchBuf2, 0, sizeof(pwchBuf2)); iRet = openStream (pStorage2, WSZ_TEST_STREAM_3, &pStream3); ASSERT (iRet == SSTG_OK && pStream3 != NULL); cch = 28 * sizeof(wchar_t); iRet = streamRead(pStream3, pwchBuf2, &cchL); ASSERT (iRet == SSTG_OK && cchL == (28 * sizeof(wchar_t))); ASSERT (memcmp(pwchBuf, pwchBuf2, wcslen(pwchBuf) + 1) == 0); memset(pwchBuf2, 0, sizeof(pwchBuf2)); /* Close the entire compound file without closing any of the open * children */ iRet = closeStructuredStorage(&pRoot); ASSERT (iRet == SSTG_OK && pRoot == NULL); /* Remove test file */ SSRW_WREMOVE (WSZ_TEST_FILENAME); return iRet; }
status_t BnCameraDeviceUser::onTransact( uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags) { switch(code) { case DISCONNECT: { ALOGV("DISCONNECT"); CHECK_INTERFACE(ICameraDeviceUser, data, reply); disconnect(); reply->writeNoException(); return NO_ERROR; } break; case SUBMIT_REQUEST: { CHECK_INTERFACE(ICameraDeviceUser, data, reply); // arg0 = request sp<CaptureRequest> request; if (data.readInt32() != 0) { request = new CaptureRequest(); request->readFromParcel(const_cast<Parcel*>(&data)); } // arg1 = streaming (bool) bool repeating = data.readInt32(); // return code: requestId (int32) reply->writeNoException(); int64_t lastFrameNumber = -1; reply->writeInt32(submitRequest(request, repeating, &lastFrameNumber)); reply->writeInt32(1); reply->writeInt64(lastFrameNumber); return NO_ERROR; } break; case SUBMIT_REQUEST_LIST: { CHECK_INTERFACE(ICameraDeviceUser, data, reply); List<sp<CaptureRequest> > requestList; int requestListSize = data.readInt32(); for (int i = 0; i < requestListSize; i++) { if (data.readInt32() != 0) { sp<CaptureRequest> request = new CaptureRequest(); if (request->readFromParcel(const_cast<Parcel*>(&data)) != OK) { return BAD_VALUE; } requestList.push_back(request); } else { sp<CaptureRequest> request = 0; requestList.push_back(request); ALOGE("A request is missing. Sending in null request."); } } bool repeating = data.readInt32(); reply->writeNoException(); int64_t lastFrameNumber = -1; reply->writeInt32(submitRequestList(requestList, repeating, &lastFrameNumber)); reply->writeInt32(1); reply->writeInt64(lastFrameNumber); return NO_ERROR; } break; case CANCEL_REQUEST: { CHECK_INTERFACE(ICameraDeviceUser, data, reply); int requestId = data.readInt32(); reply->writeNoException(); int64_t lastFrameNumber = -1; reply->writeInt32(cancelRequest(requestId, &lastFrameNumber)); reply->writeInt32(1); reply->writeInt64(lastFrameNumber); return NO_ERROR; } break; case DELETE_STREAM: { CHECK_INTERFACE(ICameraDeviceUser, data, reply); int streamId = data.readInt32(); reply->writeNoException(); reply->writeInt32(deleteStream(streamId)); return NO_ERROR; } break; case CREATE_STREAM: { CHECK_INTERFACE(ICameraDeviceUser, data, reply); int width, height, format; width = data.readInt32(); ALOGV("%s: CREATE_STREAM: width = %d", __FUNCTION__, width); height = data.readInt32(); ALOGV("%s: CREATE_STREAM: height = %d", __FUNCTION__, height); format = data.readInt32(); ALOGV("%s: CREATE_STREAM: format = %d", __FUNCTION__, format); sp<IGraphicBufferProducer> bp; if (data.readInt32() != 0) { String16 name = readMaybeEmptyString16(data); bp = interface_cast<IGraphicBufferProducer>( data.readStrongBinder()); ALOGV("%s: CREATE_STREAM: bp = %p, name = %s", __FUNCTION__, bp.get(), String8(name).string()); } else { ALOGV("%s: CREATE_STREAM: bp = unset, name = unset", __FUNCTION__); } status_t ret; ret = createStream(width, height, format, bp); reply->writeNoException(); ALOGV("%s: CREATE_STREAM: write noException", __FUNCTION__); reply->writeInt32(ret); ALOGV("%s: CREATE_STREAM: write ret = %d", __FUNCTION__, ret); return NO_ERROR; } break; case CREATE_DEFAULT_REQUEST: { CHECK_INTERFACE(ICameraDeviceUser, data, reply); int templateId = data.readInt32(); CameraMetadata request; status_t ret; ret = createDefaultRequest(templateId, &request); reply->writeNoException(); reply->writeInt32(ret); // out-variables are after exception and return value reply->writeInt32(1); // to mark presence of metadata object request.writeToParcel(const_cast<Parcel*>(reply)); return NO_ERROR; } break; case GET_CAMERA_INFO: { CHECK_INTERFACE(ICameraDeviceUser, data, reply); CameraMetadata info; status_t ret; ret = getCameraInfo(&info); reply->writeNoException(); reply->writeInt32(ret); // out-variables are after exception and return value reply->writeInt32(1); // to mark presence of metadata object info.writeToParcel(reply); return NO_ERROR; } break; case WAIT_UNTIL_IDLE: { CHECK_INTERFACE(ICameraDeviceUser, data, reply); reply->writeNoException(); reply->writeInt32(waitUntilIdle()); return NO_ERROR; } break; case FLUSH: { CHECK_INTERFACE(ICameraDeviceUser, data, reply); reply->writeNoException(); int64_t lastFrameNumber = -1; reply->writeInt32(flush(&lastFrameNumber)); reply->writeInt32(1); reply->writeInt64(lastFrameNumber); return NO_ERROR; } case BEGIN_CONFIGURE: { CHECK_INTERFACE(ICameraDeviceUser, data, reply); reply->writeNoException(); reply->writeInt32(beginConfigure()); return NO_ERROR; } break; case END_CONFIGURE: { CHECK_INTERFACE(ICameraDeviceUser, data, reply); reply->writeNoException(); reply->writeInt32(endConfigure()); return NO_ERROR; } break; default: return BBinder::onTransact(code, data, reply, flags); } }