// ----------------------------------------------------------------------------- // // ----------------------------------------------------------------------------- void GenericExample::readFilterParameters(AbstractFilterParametersReader* reader, int index) { /* FILTER_WIDGETCODEGEN_AUTO_GENERATED_CODE BEGIN*/ reader->openFilterGroup(this, index); setStlFilePrefix( reader->readValue("StlFilePrefix", getStlFilePrefix()) ); setMaxIterations( reader->readValue("MaxIterations", getMaxIterations()) ); setMisorientationTolerance( reader->readValue("MisorientationTolerance", getMisorientationTolerance()) ); setInputFile( reader->readValue("InputFile", getInputFile()) ); setInputPath( reader->readValue("InputPath", getInputPath()) ); setOutputFile( reader->readValue("OutputFile", getOutputFile()) ); setOutputPath( reader->readValue("OutputPath", getOutputPath()) ); setWriteAlignmentShifts( reader->readValue("WriteAlignmentShifts", getWriteAlignmentShifts()) ); setConversionType( reader->readValue("ConversionType", getConversionType()) ); setDimensions( reader->readValue("Dimensions", getDimensions()) ); setOrigin( reader->readValue("Origin", getOrigin()) ); setCrystalSymmetryRotations( reader->readValue("CrystalSymmetryRotations", getCrystalSymmetryRotations()) ); setSelectedVoxelCellArrayName( reader->readValue("SelectedVoxelCellArrayName", getSelectedVoxelCellArrayName()) ); setSelectedVoxelFieldArrayName( reader->readValue("SelectedVoxelFieldArrayName", getSelectedVoxelFieldArrayName()) ); setSelectedVoxelEnsembleArrayName( reader->readValue("SelectedVoxelEnsembleArrayName", getSelectedVoxelEnsembleArrayName()) ); setSelectedSurfaceMeshPointArrayName( reader->readValue("SelectedSurfaceMeshPointArrayName", getSelectedSurfaceMeshPointArrayName()) ); setSelectedSurfaceMeshFaceArrayName( reader->readValue("SelectedSurfaceMeshFaceArrayName", getSelectedSurfaceMeshFaceArrayName()) ); setSelectedSurfaceMeshEdgeArrayName( reader->readValue("SelectedSurfaceMeshEdgeArrayName", getSelectedSurfaceMeshEdgeArrayName()) ); setSelectedSolidMeshPointArrayName( reader->readValue("SelectedSolidMeshPointArrayName", getSelectedSolidMeshPointArrayName()) ); setSelectedSolidMeshFaceArrayName( reader->readValue("SelectedSolidMeshFaceArrayName", getSelectedSolidMeshFaceArrayName()) ); setSelectedSolidMeshEdgeArrayName( reader->readValue("SelectedSolidMeshEdgeArrayName", getSelectedSolidMeshEdgeArrayName()) ); setStrVector( reader->readValue("StrVector", getStrVector() ) ); reader->closeFilterGroup(); }
// ----------------------------------------------------------------------------- // // ----------------------------------------------------------------------------- void AbaqusSurfaceMeshWriter::readFilterParameters(AbstractFilterParametersReader* reader, int index) { reader->openFilterGroup(this, index); setSurfaceMeshFaceLabelsArrayPath(reader->readDataArrayPath("SurfaceMeshFaceLabelsArrayPath", getSurfaceMeshFaceLabelsArrayPath() ) ); setOutputFile( reader->readString( "OutputFile", getOutputFile() ) ); reader->closeFilterGroup(); }
// ----------------------------------------------------------------------------- // // ----------------------------------------------------------------------------- void SPParksWriter::readFilterParameters(AbstractFilterParametersReader* reader, int index) { reader->openFilterGroup(this, index); setFeatureIdsArrayPath(reader->readDataArrayPath("FeatureIdsArrayPath", getFeatureIdsArrayPath() ) ); setOutputFile( reader->readString( "OutputFile", getOutputFile() ) ); reader->closeFilterGroup(); }
// ----------------------------------------------------------------------------- void AvizoUniformCoordinateWriter::readFilterParameters(AbstractFilterParametersReader* reader, int index) { reader->openFilterGroup(this, index); setFeatureIdsArrayPath(reader->readDataArrayPath("FeatureIdsArrayPath", getFeatureIdsArrayPath() ) ); setOutputFile( reader->readString( "OutputFile", getOutputFile() ) ); setWriteBinaryFile( reader->readValue("WriteBinaryFile", getWriteBinaryFile()) ); reader->closeFilterGroup(); }
// ----------------------------------------------------------------------------- // // ----------------------------------------------------------------------------- void AbaqusSurfaceMeshWriter::readFilterParameters(AbstractFilterParametersReader* reader, int index) { reader->openFilterGroup(this, index); /* Code to read the values goes between these statements */ /* FILTER_WIDGETCODEGEN_AUTO_GENERATED_CODE BEGIN*/ setOutputFile(reader->readValue("OutputFile", getOutputFile())); /* FILTER_WIDGETCODEGEN_AUTO_GENERATED_CODE END*/ reader->closeFilterGroup(); }
// ----------------------------------------------------------------------------- // // ----------------------------------------------------------------------------- void LosAlamosFFTWriter::readFilterParameters(AbstractFilterParametersReader* reader, int index) { reader->openFilterGroup(this, index); setCellEulerAnglesArrayPath(reader->readDataArrayPath("CellEulerAnglesArrayPath", getCellEulerAnglesArrayPath() ) ); setCellPhasesArrayPath(reader->readDataArrayPath("CellPhasesArrayPath", getCellPhasesArrayPath() ) ); setFeatureIdsArrayPath(reader->readDataArrayPath("FeatureIdsArrayPath", getFeatureIdsArrayPath() ) ); setOutputFile( reader->readString( "OutputFile", getOutputFile() ) ); reader->closeFilterGroup(); }
// ----------------------------------------------------------------------------- // // ----------------------------------------------------------------------------- void VisualizeGBCDGMT::readFilterParameters(AbstractFilterParametersReader* reader, int index) { reader->openFilterGroup(this, index); setGBCDArrayPath(reader->readDataArrayPath("GBCDArrayPath", getGBCDArrayPath())); setCrystalStructuresArrayPath(reader->readDataArrayPath("CrystalStructuresArrayPath", getCrystalStructuresArrayPath())); setOutputFile(reader->readString("OutputFile", getOutputFile())); setMisorientationRotation(reader->readAxisAngle("MisorientationRotation", getMisorientationRotation(), -1) ); setPhaseOfInterest(reader->readValue("PhaseOfInterest", getPhaseOfInterest())); reader->closeFilterGroup(); }
// ----------------------------------------------------------------------------- // // ----------------------------------------------------------------------------- void WriteStatsGenOdfAngleFile::readFilterParameters(AbstractFilterParametersReader* reader, int index) { reader->openFilterGroup(this, index); setConvertToDegrees(reader->readValue("ConvertToDegrees", getConvertToDegrees() ) ); setOutputFile( reader->readString("OutputFile", getOutputFile())); setUseGoodVoxels(reader->readValue("UseGoodVoxels", getUseGoodVoxels() ) ); setGoodVoxelsArrayPath(reader->readDataArrayPath("GoodVoxelsArrayPath", getGoodVoxelsArrayPath() ) ); setCellEulerAnglesArrayPath(reader->readDataArrayPath("CellEulerAnglesArrayPath", getCellEulerAnglesArrayPath() ) ); setCellPhasesArrayPath(reader->readDataArrayPath("CellPhasesArrayPath", getCellPhasesArrayPath() ) ); reader->closeFilterGroup(); }
void PrintDialogController::options(QString symbol,int print,QString copy) { setCopyOrOriginal(copy); setSymbol(symbol); if(copy=="ORYGINAĆ"||copy=="DUPLIKAT") initOptions(); setOutputFile(); if(print) //usuniecie deafultowego miejsca zapisania powoduje przekierowanie na drukarke getPrinter()->setOutputFileName(""); }
/* * r e s e t */ returnValue MessageHandling::reset( ) { setErrorVisibilityStatus( VS_VISIBLE ); setWarningVisibilityStatus( VS_VISIBLE ); setInfoVisibilityStatus( VS_VISIBLE ); setOutputFile( myStderr ); setErrorCount( 0 ); return SUCCESSFUL_RETURN; }
// ----------------------------------------------------------------------------- // // ----------------------------------------------------------------------------- void INLWriter::readFilterParameters(AbstractFilterParametersReader* reader, int index) { reader->openFilterGroup(this, index); setCellEulerAnglesArrayPath(reader->readDataArrayPath("CellEulerAnglesArrayPath", getCellEulerAnglesArrayPath() ) ); setCrystalStructuresArrayPath(reader->readDataArrayPath("CrystalStructuresArrayPath", getCrystalStructuresArrayPath() ) ); setCellPhasesArrayPath(reader->readDataArrayPath("CellPhasesArrayPath", getCellPhasesArrayPath() ) ); setFeatureIdsArrayPath(reader->readDataArrayPath("FeatureIdsArrayPath", getFeatureIdsArrayPath() ) ); setNumFeaturesArrayPath(reader->readDataArrayPath("NumFeaturesArrayPath", getNumFeaturesArrayPath() ) ); setMaterialNameArrayPath(reader->readDataArrayPath("MaterialNameArrayPath", getMaterialNameArrayPath())); setOutputFile( reader->readString( "OutputFile", getOutputFile() ) ); reader->closeFilterGroup(); }
void Conjunct::prefix_print(FILE *output_file, int debug) { static char dir_glyphs[] = { '-', '?', '+' }; if (debug) { Formula::print_head(output_file); if(pres_debug>=2) fprintf(output_file, "(@%p)", this); fprintf(output_file, "%s CONJUNCT, ", exact ? "EXACT" : "INEXACT"); if (simplified) fprintf(output_file, "simplified, "); if (verified) fprintf(output_file, "verified, "); if (possible_leading_0s != -1 && guaranteed_leading_0s != -1) assert (guaranteed_leading_0s <= possible_leading_0s); if (guaranteed_leading_0s != -1 && guaranteed_leading_0s == possible_leading_0s) fprintf(output_file,"# leading 0's = %d,", possible_leading_0s); else if (possible_leading_0s != -1 || guaranteed_leading_0s != -1) { if (guaranteed_leading_0s != -1) fprintf(output_file,"%d <= ",guaranteed_leading_0s); fprintf(output_file,"#O's"); if (possible_leading_0s != -1) fprintf(output_file," <= %d",possible_leading_0s); fprintf(output_file,", "); } if (dir_glyphs[leading_dir+1] != '?') fprintf(output_file," first = %c, ", dir_glyphs[leading_dir+1]); fprintf(output_file,"myLocals=["); String s=""; for (Variable_ID_Iterator VI(myLocals); VI; ) { assert( (*VI)->kind() == Wildcard_Var); s += (*VI)->name(); print_var_addrs(s, *VI); VI++; if(VI) s += ","; } s += "] mappedVars=["; for(Variable_ID_Iterator MVI(mappedVars); MVI; ) { s += (*MVI)->name(); print_var_addrs(s, *MVI); MVI++; if(MVI) s += ","; } fprintf(output_file, "%s]\n", (const char *) s); } else level++; setOutputFile(output_file); setPrintLevel(level+1); problem->printProblem(debug); setPrintLevel(0); Formula::prefix_print(output_file, debug); }
// ----------------------------------------------------------------------------- // // ----------------------------------------------------------------------------- void VisualizeGBCDPoleFigure::dataCheck() { setErrorCondition(0); getDataContainerArray()->getPrereqGeometryFromDataContainer<TriangleGeom, AbstractFilter>(this, getGBCDArrayPath().getDataContainerName()); if (getOutputFile().isEmpty() == true) { QString ss = QObject::tr( "The output file must be set"); setErrorCondition(-1000); notifyErrorMessage(getHumanLabel(), ss, getErrorCondition()); } QFileInfo fi(getOutputFile()); QDir parentPath = fi.path(); if (parentPath.exists() == false && getInPreflight()) { QString ss = QObject::tr( "The directory path for the output file does not exist. DREAM.3D will attempt to create this path during execution of the filter"); notifyWarningMessage(getHumanLabel(), ss, -1); } if (fi.suffix().compare("") == 0) { setOutputFile(getOutputFile().append(".vtk")); } QVector<size_t> cDims(1, 1); m_CrystalStructuresPtr = getDataContainerArray()->getPrereqArrayFromPath<DataArray<unsigned int>, AbstractFilter>(this, getCrystalStructuresArrayPath(), cDims); /* Assigns the shared_ptr<> to an instance variable that is a weak_ptr<> */ if (NULL != m_CrystalStructuresPtr.lock().get()) /* Validate the Weak Pointer wraps a non-NULL pointer to a DataArray<T> object */ { m_CrystalStructures = m_CrystalStructuresPtr.lock()->getPointer(0); } /* Now assign the raw pointer to data from the DataArray<T> object */ IDataArray::Pointer tmpGBCDPtr = getDataContainerArray()->getPrereqIDataArrayFromPath<IDataArray, AbstractFilter>(this, getGBCDArrayPath()); if(getErrorCondition() < 0) { return; } if (NULL != tmpGBCDPtr.get()) { QVector<size_t> cDims = tmpGBCDPtr->getComponentDimensions(); m_GBCDPtr = getDataContainerArray()->getPrereqArrayFromPath<DataArray<double>, AbstractFilter>(this, getGBCDArrayPath(), cDims); /* Assigns the shared_ptr<> to an instance variable that is a weak_ptr<> */ if( NULL != m_GBCDPtr.lock().get() ) /* Validate the Weak Pointer wraps a non-NULL pointer to a DataArray<T> object */ { m_GBCD = m_GBCDPtr.lock()->getPointer(0); } /* Now assign the raw pointer to data from the DataArray<T> object */ } if (NULL != m_GBCDPtr.lock().get() && getPhaseOfInterest() >= m_GBCDPtr.lock()->getNumberOfTuples()) { QString ss = QObject::tr("The phase index is larger than the number of Ensembles").arg(ClassName()); setErrorCondition(-1); notifyErrorMessage(getHumanLabel(), ss, getErrorCondition()); } }
MS2ScanVector::MS2ScanVector(const string & sFT2FilenameInput, const string & sOutputDirectory, const string & sConfigFilename, bool bScreenOutput) { unsigned int n; vector<string> vsSingleResidueNames = ProNovoConfig::vsSingleResidueNames; vector<double> vdSingleResidueMasses = ProNovoConfig::vdSingleResidueMasses; sFT2Filename = sFT2FilenameInput; sConfigFile = sConfigFilename; //mass_w = ProNovoConfig::getParentMassWindows(); setOutputFile(sFT2FilenameInput, sOutputDirectory); this->bScreenOutput = bScreenOutput; for (n = 0; n < vsSingleResidueNames.size(); ++n) mapResidueMass[ vsSingleResidueNames[n][0] ] = vdSingleResidueMasses[n]; }
Logger::Logger() : _file(NULL), _nextDebugLevel(Unset) { _logMutex = new Mutex(); #ifdef NDEBUG setLogLevel(Logger::All); _defaultStdOut = false; #else setLogLevel(Logger::All); _defaultStdOut = true; #endif setOutputFile("test.log"); _stdout = _defaultStdOut; }
// ----------------------------------------------------------------------------- // // ----------------------------------------------------------------------------- void EbsdToH5Ebsd::readFilterParameters(AbstractFilterParametersReader* reader, int index) { reader->openFilterGroup(this, index); setOutputFile( reader->readValue("OutputFile", getOutputFile()) ); setZStartIndex( reader->readValue("ZStartIndex", getZStartIndex()) ); setZEndIndex( reader->readValue("ZEndIndex", getZEndIndex()) ); setZResolution( reader->readValue("ZResolution", getZResolution()) ); setSampleTransformationAngle( reader->readValue("SampleTransformationAngle", getSampleTransformationAngle()) ); setSampleTransformationAxis( reader->readValue("SampleTransformationAxis", getSampleTransformationAxis()) ); setEulerTransformationAngle( reader->readValue("EulerTransformationAngle", getEulerTransformationAngle()) ); setEulerTransformationAxis( reader->readValue("EulerTransformationAxis", getEulerTransformationAxis()) ); setRefFrameZDir( static_cast<Ebsd::RefFrameZDir>( reader->readValue("RefFrameZDir", getRefFrameZDir() ) ) ); setEbsdFileList( reader->readValue("EbsdFileList", getEbsdFileList()) ); reader->closeFilterGroup(); }
status_t PVMediaRecorder::setOutputFile(const char *path) { LOGV("setOutputFile(%s)", path); if (mAuthorDriverWrapper == NULL) { LOGE("author driver wrapper is not initialized yet"); return NO_INIT; } // use file descriptor interface int fd = open(path, O_RDWR | O_CREAT ); if (-1 == fd) { LOGE("Ln %d open() error %d", __LINE__, fd); return -errno; } return setOutputFile(fd, 0, 0); }
// Initialize the OsSysLog priority void OsSysLog::initSysLog(const OsSysLogFacility facility, const char* processID, const char* logname, const char* loglevel) { initialize(0, processID) ; setOutputFile(0, logname) ; UtlString logLevel(loglevel); struct tagPrioriotyLookupTable { const char* pIdentity; OsSysLogPriority ePriority; }; struct tagPrioriotyLookupTable lkupTable[] = { { "DEBUG", PRI_DEBUG}, { "INFO", PRI_INFO}, { "NOTICE", PRI_NOTICE}, { "WARNING", PRI_WARNING}, { "ERR", PRI_ERR}, { "CRIT", PRI_CRIT}, { "ALERT", PRI_ALERT}, { "EMERG", PRI_EMERG} }; logLevel.toUpper(); OsSysLogPriority priority = PRI_ERR; int iEntries = sizeof(lkupTable)/sizeof(struct tagPrioriotyLookupTable); for (int i=0; i<iEntries; i++) { if (logLevel == lkupTable[i].pIdentity) { priority = lkupTable[i].ePriority; osPrintf("Setting %s syslog level : %s\n", sFacilityNames[facility], lkupTable[i].pIdentity) ; setLoggingPriority(priority); add(facility, PRI_NOTICE, "Setting %s syslog level : %s", sFacilityNames[facility], lkupTable[i].pIdentity) ; break; } } }
void Writer::startService(){ _cleanUp=getContext()->getEnvironment<bool> ("writer.cleanup"); std::string outfileid=getContext()->getEnvironment<std::string > ("writer.jobid"); LOGDEBUG("looking for output with id:"<<outfileid); litesql::DataSource<db::OutputFile> source = litesql::select<db::OutputFile > (getContext()->database, db::OutputFile::Id==outfileid); if(source.count()>0){ db::OutputFile outputfile=source.one(); setOutputFile(outputfile); outputfile.status=db::OutputFile::Status::Processing; outputfile.update(); run2(); //go(Writer::run, this); //org::esb::lang::CtrlCHitWaiter::wait(); //getc(stdin); }else{ LOGWARN("OutputFile with id "<<outfileid<< " not found"); } }
void JSonIO::reset(){ parserState = 0; setOutputFile("empty"); setTopFace("empty"); setBottomFace("empty"); setLeftFace("empty"); setRightFace("empty"); setFrontFace("empty"); setBackFace("empty"); setFrameStart(0); setFrameStop(0); setOutputWidth(0); setAntialiasing(0); setAaPattern("grid"); frames.clear(); }
void JSonIO::loadJSon(QString filePath){ parserState = 0; QJson::Parser parser; QFile jsonFile(filePath); if (!jsonFile.open(QIODevice::ReadOnly | QIODevice::Text)){ parserState = 1; return; } QTextStream in(&jsonFile); QString json = in.readAll(); jsonFile.close(); bool ok; QVariantMap result = parser.parse(json.toAscii(), &ok).toMap(); if (!ok) { parserState = 2; } setOutputFile(result["outputFile"].toString()); setTopFace(result["topFace"].toString()); setBottomFace(result["bottomFace"].toString()); setLeftFace(result["leftFace"].toString()); setRightFace(result["rightFace"].toString()); setFrontFace(result["frontFace"].toString()); setBackFace(result["backFace"].toString()); setFrameStart(result["frameStart"].toInt()); setFrameStop(result["frameStop"].toInt()); setOutputWidth(result["outputWidth"].toInt()); setAntialiasing(result["antialiasing"].toInt()); setAaPattern(result["aaPattern"].toString()); frames = result["frames"].toList(); }
// ----------------------------------------------------------------------------- // // ----------------------------------------------------------------------------- void TestFilter::readFilterParameters(AbstractFilterParametersReader* reader) { setStlFilePrefix( reader->readValue("StlFilePrefix", StlFilePrefixDefaultValue) ); setMaxIterations( reader->readValue("MaxIterations", MaxIterationsDefaultValue) ); setMisorientationTolerance( reader->readValue("MisorientationTolerance", MisorientationToleranceDefaultValue) ); setInputFile( reader->readValue("InputFile", InputFileDefaultValue) ); setInputPath( reader->readValue("InputPath", InputPathDefaultValue) ); setOutputFile( reader->readValue("OutputFile", OutputFileDefaultValue) ); setOutputPath( reader->readValue("OutputPath", OutputPathDefaultValue) ); setWriteAlignmentShifts( reader->readValue("WriteAlignmentShifts", WriteAlignmentShiftsDefaultValue) ); setConversionType( reader->readValue("ConversionType", ConversionTypeDefaultValue) ); setSelectedCellArrayName( reader->readValue("SelectedCellArrayName", SelectedCellArrayNameDefaultValue) ); setSelectedFieldArrayName( reader->readValue("SelectedFieldArrayName", SelectedFieldArrayNameDefaultValue) ); setSelectedEnsembleArrayName( reader->readValue("SelectedEnsembleArrayName", SelectedEnsembleArrayNameDefaultValue) ); setSurfaceMeshPointArrayName( reader->readValue("SurfaceMeshPointArrayName", SurfaceMeshPointArrayNameDefaultValue) ); setSurfaceMeshFaceArrayName( reader->readValue("SurfaceMeshFaceArrayName", SurfaceMeshFaceArrayNameDefaultValue) ); setSurfaceMeshEdgeArrayName( reader->readValue("SurfaceMeshEdgeArrayName", SurfaceMeshEdgeArrayNameDefaultValue) ); setSolidMeshPointArrayName( reader->readValue("SolidMeshPointArrayName", SolidMeshPointArrayNameDefaultValue) ); setSolidMeshFaceArrayName( reader->readValue("SolidMeshFaceArrayName", SolidMeshFaceArrayNameDefaultValue) ); setSolidMeshEdgeArrayName( reader->readValue("SolidMeshEdgeArrayName", SolidMeshEdgeArrayNameDefaultValue) ); setCellComparisonInputs( reader->readValue("CellComparisonInputs", m_CellComparisonInputs) ); setAxisAngleRotations( reader->readValue("AxisAngleRotations", m_AxisAngleRotations) ); }
ATLog::ATLog( const QString &strFile ) { init(); setOutputFile( strFile ); }
status_t BnMediaRecorder::onTransact( uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags) { switch (code) { case RELEASE: { ALOGV("RELEASE"); CHECK_INTERFACE(IMediaRecorder, data, reply); reply->writeInt32(release()); return NO_ERROR; } break; case INIT: { ALOGV("INIT"); CHECK_INTERFACE(IMediaRecorder, data, reply); reply->writeInt32(init()); return NO_ERROR; } break; case CLOSE: { ALOGV("CLOSE"); CHECK_INTERFACE(IMediaRecorder, data, reply); reply->writeInt32(close()); return NO_ERROR; } break; case RESET: { ALOGV("RESET"); CHECK_INTERFACE(IMediaRecorder, data, reply); reply->writeInt32(reset()); return NO_ERROR; } break; case STOP: { ALOGV("STOP"); CHECK_INTERFACE(IMediaRecorder, data, reply); reply->writeInt32(stop()); return NO_ERROR; } break; case START: { ALOGV("START"); CHECK_INTERFACE(IMediaRecorder, data, reply); reply->writeInt32(start()); return NO_ERROR; } break; case PREPARE: { ALOGV("PREPARE"); CHECK_INTERFACE(IMediaRecorder, data, reply); reply->writeInt32(prepare()); return NO_ERROR; } break; case GET_MAX_AMPLITUDE: { ALOGV("GET_MAX_AMPLITUDE"); CHECK_INTERFACE(IMediaRecorder, data, reply); int max = 0; status_t ret = getMaxAmplitude(&max); reply->writeInt32(max); reply->writeInt32(ret); return NO_ERROR; } break; case SET_VIDEO_SOURCE: { ALOGV("SET_VIDEO_SOURCE"); CHECK_INTERFACE(IMediaRecorder, data, reply); int vs = data.readInt32(); reply->writeInt32(setVideoSource(vs)); return NO_ERROR; } break; case SET_AUDIO_SOURCE: { ALOGV("SET_AUDIO_SOURCE"); CHECK_INTERFACE(IMediaRecorder, data, reply); int as = data.readInt32(); reply->writeInt32(setAudioSource(as)); return NO_ERROR; } break; case SET_OUTPUT_FORMAT: { ALOGV("SET_OUTPUT_FORMAT"); CHECK_INTERFACE(IMediaRecorder, data, reply); int of = data.readInt32(); reply->writeInt32(setOutputFormat(of)); return NO_ERROR; } break; case SET_VIDEO_ENCODER: { ALOGV("SET_VIDEO_ENCODER"); CHECK_INTERFACE(IMediaRecorder, data, reply); int ve = data.readInt32(); reply->writeInt32(setVideoEncoder(ve)); return NO_ERROR; } break; case SET_AUDIO_ENCODER: { ALOGV("SET_AUDIO_ENCODER"); CHECK_INTERFACE(IMediaRecorder, data, reply); int ae = data.readInt32(); reply->writeInt32(setAudioEncoder(ae)); return NO_ERROR; } break; case SET_OUTPUT_FILE_FD: { ALOGV("SET_OUTPUT_FILE_FD"); CHECK_INTERFACE(IMediaRecorder, data, reply); int fd = dup(data.readFileDescriptor()); int64_t offset = data.readInt64(); int64_t length = data.readInt64(); reply->writeInt32(setOutputFile(fd, offset, length)); ::close(fd); return NO_ERROR; } break; case SET_VIDEO_SIZE: { ALOGV("SET_VIDEO_SIZE"); CHECK_INTERFACE(IMediaRecorder, data, reply); int width = data.readInt32(); int height = data.readInt32(); reply->writeInt32(setVideoSize(width, height)); return NO_ERROR; } break; case SET_VIDEO_FRAMERATE: { ALOGV("SET_VIDEO_FRAMERATE"); CHECK_INTERFACE(IMediaRecorder, data, reply); int frames_per_second = data.readInt32(); reply->writeInt32(setVideoFrameRate(frames_per_second)); return NO_ERROR; } break; case SET_PARAMETERS: { ALOGV("SET_PARAMETER"); CHECK_INTERFACE(IMediaRecorder, data, reply); reply->writeInt32(setParameters(data.readString8())); return NO_ERROR; } break; case SET_LISTENER: { ALOGV("SET_LISTENER"); CHECK_INTERFACE(IMediaRecorder, data, reply); sp<IMediaRecorderClient> listener = interface_cast<IMediaRecorderClient>(data.readStrongBinder()); reply->writeInt32(setListener(listener)); return NO_ERROR; } break; case SET_CLIENT_NAME: { ALOGV("SET_CLIENT_NAME"); CHECK_INTERFACE(IMediaRecorder, data, reply); reply->writeInt32(setClientName(data.readString16())); return NO_ERROR; } case SET_PREVIEW_SURFACE: { ALOGV("SET_PREVIEW_SURFACE"); CHECK_INTERFACE(IMediaRecorder, data, reply); sp<IGraphicBufferProducer> surface = interface_cast<IGraphicBufferProducer>( data.readStrongBinder()); reply->writeInt32(setPreviewSurface(surface)); return NO_ERROR; } break; case SET_CAMERA: { ALOGV("SET_CAMERA"); CHECK_INTERFACE(IMediaRecorder, data, reply); sp<ICamera> camera = interface_cast<ICamera>(data.readStrongBinder()); sp<ICameraRecordingProxy> proxy = interface_cast<ICameraRecordingProxy>(data.readStrongBinder()); reply->writeInt32(setCamera(camera, proxy)); return NO_ERROR; } break; case SET_INPUT_SURFACE: { ALOGV("SET_INPUT_SURFACE"); CHECK_INTERFACE(IMediaRecorder, data, reply); sp<IGraphicBufferConsumer> surface = interface_cast<IGraphicBufferConsumer>( data.readStrongBinder()); reply->writeInt32(setInputSurface(surface)); return NO_ERROR; } break; case QUERY_SURFACE_MEDIASOURCE: { ALOGV("QUERY_SURFACE_MEDIASOURCE"); CHECK_INTERFACE(IMediaRecorder, data, reply); // call the mediaserver side to create // a surfacemediasource sp<IGraphicBufferProducer> surfaceMediaSource = querySurfaceMediaSource(); // The mediaserver might have failed to create a source int returnedNull= (surfaceMediaSource == NULL) ? 1 : 0 ; reply->writeInt32(returnedNull); if (!returnedNull) { reply->writeStrongBinder(IInterface::asBinder(surfaceMediaSource)); } return NO_ERROR; } break; default: return BBinder::onTransact(code, data, reply, flags); } }
Debug::Debug() : mDebugEnabled(true) , mDebugLevel(2) , mIndentLevel(0) // Initialy don't indent , mFile(NULL) , mStreamPtr(&std::cout) , mUseThreadLocal(false) { std::string debug_lev; vpr::System::getenv("VPR_DEBUG_NFY_LEVEL", debug_lev); if ( ! debug_lev.empty() ) { mDebugLevel = std::atoi(debug_lev.c_str()); std::cout << "VPR_DEBUG_NFY_LEVEL set to " << mDebugLevel << std::endl; } else { std::cout << "VPR_DEBUG_NFY_LEVEL not found; defaults to " << mDebugLevel << std::endl; } std::cout << "---------------------------------------------------------\n" << "For more or less debug output, change VPR_DEBUG_NFY_LEVEL\n" << "---------------------------------------------------------" << std::endl; std::string debug_enable; vpr::System::getenv("VPR_DEBUG_ENABLE", debug_enable); if ( ! debug_enable.empty() ) { const unsigned int debug_enable_val(std::atoi(debug_enable.c_str())); mDebugEnabled = debug_enable_val != 0; std::cout << "VPR_DEBUG_ENABLE set to " << mDebugEnabled << std::endl; } else { mDebugEnabled = true; std::cout << "VPR_DEBUG_ENABLE not found; defaults to " << mDebugEnabled << std::endl; } // Check to see if there is a default Debug target std::string debug_file; vpr::System::getenv("VPR_DEBUG_FILE", debug_file); if ( ! debug_file.empty() ) { if ( "stderr" == debug_file ) { mStreamPtr = &std::cerr; } else if ( "stdout" != debug_file ) { setOutputFile(debug_file); } else { // Use std::cout by default, which is set via the member // initializer. } } }
status_t BnMediaRecorder::onTransact( uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags) { switch(code) { case RELEASE: { LOGV("RELEASE"); CHECK_INTERFACE(IMediaRecorder, data, reply); reply->writeInt32(release()); return NO_ERROR; } break; case INIT: { LOGV("INIT"); CHECK_INTERFACE(IMediaRecorder, data, reply); reply->writeInt32(init()); return NO_ERROR; } break; case CLOSE: { LOGV("CLOSE"); CHECK_INTERFACE(IMediaRecorder, data, reply); reply->writeInt32(close()); return NO_ERROR; } break; case RESET: { LOGV("RESET"); CHECK_INTERFACE(IMediaRecorder, data, reply); reply->writeInt32(reset()); return NO_ERROR; } break; case STOP: { LOGV("STOP"); CHECK_INTERFACE(IMediaRecorder, data, reply); reply->writeInt32(stop()); return NO_ERROR; } break; case START: { LOGV("START"); CHECK_INTERFACE(IMediaRecorder, data, reply); reply->writeInt32(start()); return NO_ERROR; } break; case PREPARE: { LOGV("PREPARE"); CHECK_INTERFACE(IMediaRecorder, data, reply); reply->writeInt32(prepare()); return NO_ERROR; } break; case GET_MAX_AMPLITUDE: { LOGV("GET_MAX_AMPLITUDE"); CHECK_INTERFACE(IMediaRecorder, data, reply); int max = 0; status_t ret = getMaxAmplitude(&max); reply->writeInt32(max); reply->writeInt32(ret); return NO_ERROR; } break; case SET_VIDEO_SOURCE: { LOGV("SET_VIDEO_SOURCE"); CHECK_INTERFACE(IMediaRecorder, data, reply); int vs = data.readInt32(); reply->writeInt32(setVideoSource(vs)); return NO_ERROR; } break; case SET_AUDIO_SOURCE: { LOGV("SET_AUDIO_SOURCE"); CHECK_INTERFACE(IMediaRecorder, data, reply); int as = data.readInt32(); reply->writeInt32(setAudioSource(as)); return NO_ERROR; } break; case SET_OUTPUT_FORMAT: { LOGV("SET_OUTPUT_FORMAT"); CHECK_INTERFACE(IMediaRecorder, data, reply); int of = data.readInt32(); reply->writeInt32(setOutputFormat(of)); return NO_ERROR; } break; case SET_VIDEO_ENCODER: { LOGV("SET_VIDEO_ENCODER"); CHECK_INTERFACE(IMediaRecorder, data, reply); int ve = data.readInt32(); reply->writeInt32(setVideoEncoder(ve)); return NO_ERROR; } break; case SET_AUDIO_ENCODER: { LOGV("SET_AUDIO_ENCODER"); CHECK_INTERFACE(IMediaRecorder, data, reply); int ae = data.readInt32(); reply->writeInt32(setAudioEncoder(ae)); return NO_ERROR; } break; case SET_OUTPUT_FILE_PATH: { LOGV("SET_OUTPUT_FILE_PATH"); CHECK_INTERFACE(IMediaRecorder, data, reply); const char* path = data.readCString(); reply->writeInt32(setOutputFile(path)); return NO_ERROR; } break; case SET_OUTPUT_FILE_FD: { LOGV("SET_OUTPUT_FILE_FD"); CHECK_INTERFACE(IMediaRecorder, data, reply); int fd = dup(data.readFileDescriptor()); int64_t offset = data.readInt64(); int64_t length = data.readInt64(); reply->writeInt32(setOutputFile(fd, offset, length)); return NO_ERROR; } break; case SET_VIDEO_SIZE: { LOGV("SET_VIDEO_SIZE"); CHECK_INTERFACE(IMediaRecorder, data, reply); int width = data.readInt32(); int height = data.readInt32(); reply->writeInt32(setVideoSize(width, height)); return NO_ERROR; } break; case SET_VIDEO_FRAMERATE: { LOGV("SET_VIDEO_FRAMERATE"); CHECK_INTERFACE(IMediaRecorder, data, reply); int frames_per_second = data.readInt32(); reply->writeInt32(setVideoFrameRate(frames_per_second)); return NO_ERROR; } break; case SET_PARAMETERS: { LOGV("SET_PARAMETER"); CHECK_INTERFACE(IMediaRecorder, data, reply); reply->writeInt32(setParameters(data.readString8())); return NO_ERROR; } break; case SET_LISTENER: { LOGV("SET_LISTENER"); CHECK_INTERFACE(IMediaRecorder, data, reply); sp<IMediaPlayerClient> listener = interface_cast<IMediaPlayerClient>(data.readStrongBinder()); reply->writeInt32(setListener(listener)); return NO_ERROR; } break; case SET_PREVIEW_SURFACE: { LOGV("SET_PREVIEW_SURFACE"); CHECK_INTERFACE(IMediaRecorder, data, reply); sp<ISurface> surface = interface_cast<ISurface>(data.readStrongBinder()); reply->writeInt32(setPreviewSurface(surface)); return NO_ERROR; } break; case SET_CAMERA: { LOGV("SET_CAMERA"); CHECK_INTERFACE(IMediaRecorder, data, reply); sp<ICamera> camera = interface_cast<ICamera>(data.readStrongBinder()); reply->writeInt32(setCamera(camera)); return NO_ERROR; } break; default: return BBinder::onTransact(code, data, reply, flags); } }
Writer::Writer(org::esb::model::OutputFile outputfile){ setOutputFile(outputfile); }