// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
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);
}
