uint8_t DS18B20::hasAlarm() {
    uint8_t oldResolution = selectedResolution;
    setResolution(9);
    float temp = getTempC();
    setResolution(oldResolution);
    return ((temp <= selectedScratchpad[ALARM_LOW]) || (temp >= selectedScratchpad[ALARM_HIGH]));
}

GlAndroidContext::GlAndroidContext(const XCHAR *title, int width, int height) {
	_render = new GlRender(width, height);
	printGraphicInformation();
	setResolution(width, height);
	setFullscreen(true);
	_Context = this;
}

static int l_RenderWindow_setResolution(lua_State *L) {
    auto renderWindow = lua_torenderwindow(L, 1);
    integerType width = luaL_checkint(L, 2);
    integerType height = luaL_checkint(L, 3);
    renderWindow->setResolution(width, height);
    return 0;
}

void ExternalDisplay::processUEventOnline(const char *str) {
    const char *s1 = str + (strlen(str)-strlen(DEVICE_NODE_FB1));
    // check if it is for FB1
    if(strncmp(s1,DEVICE_NODE_FB1, strlen(DEVICE_NODE_FB1))== 0) {
        if(isHDMIConfigured()) {
            // HDMI connect event.
            // Tear-down WFD if it is active.
            if(mExternalDisplay == EXTERN_DISPLAY_FB2) {
                closeFrameBuffer();
                setExternalDisplay(EXTERN_DISPLAY_NONE);
                triggerRefresh();
            }
        }
        readResolution();
        //Get the best mode and set
        setResolution(getBestMode());
        enableHDMIVsync(EXTERN_DISPLAY_FB1);
        setExternalDisplay(EXTERN_DISPLAY_FB1);
        triggerRefresh();
    }
    else if(strncmp(s1, DEVICE_NODE_FB2, strlen(DEVICE_NODE_FB2)) == 0) {
        // WFD connect event
        if(mExternalDisplay  == EXTERN_DISPLAY_FB1) {
            // HDMI has higher priority.
            // Do Not Override.
        }else {
            // WFD is connected
            openFrameBuffer(EXTERN_DISPLAY_FB2);
            setExternalDisplay(EXTERN_DISPLAY_FB2);
            triggerRefresh();
        }
    }
}

void ExtDisplayObserver::handleUEvent(char* str){
    int connected = 0;
    // TODO: check for fb2(WFD) driver also
    if(!strcasestr(str, DEVICE_NODE))
    {
        ALOGD_IF(EXT_OBSERVER_DEBUG, "%s: Not Ext Disp Event ", __FUNCTION__);
        return;
    }
    // Event will be of the form:
    // [email protected]/devices/virtual/graphics/fb1 ACTION=change
    // DEVPATH=/devices/virtual/graphics/fb1
    // SUBSYSTEM=graphics HDCP_STATE=FAIL MAJOR=29
    // for now just parse the online or offline are important for us.
    if(!(strncmp(str,"[email protected]",strlen("[email protected]")))) {
        ALOGD_IF(EXT_OBSERVER_DEBUG, "%s: external disp online", __FUNCTION__);
        connected = 1;
        readResolution();
        //Get the best mode and set
        // TODO: DO NOT call this for WFD
        setResolution(getBestMode());
    } else if(!(strncmp(str,"[email protected]",strlen("[email protected]")))) {
        ALOGD_IF(EXT_OBSERVER_DEBUG, "%s: external disp online", __FUNCTION__);
        connected = 0;
        close(fd);
    }
    setExternalDisplayStatus(connected);
}

gFBDC::gFBDC()
{
	fb=new fbClass;

	if (!fb->Available())
		eFatal("[gFBDC] no framebuffer available");

	int xres;
	int yres;
	int bpp;
	fb->getMode(xres, yres, bpp);

	/* we can only use one of these three modes: */
	if (!((xres == 720 && yres == 576)
		|| (xres == 1280 && yres == 720)
		|| (xres == 1920 && yres == 1080)))
	{
		/* fallback to a decent default */
		xres = 720;
		yres = 576;
	}

	surface.clut.data = 0;
	setResolution(xres, yres); // default res

	reloadSettings();
}

bool			BzfDisplay::doSetDefaultResolution()
{
  if (numResolutions >= 2 && defaultResolution < numResolutions)
    return setResolution(defaultResolution);
  else
    return false;
}

void DallasTemperature::begin(void) {
    DeviceAddress deviceAddress;

    _wire->reset_search();

    devices = 0; // Reset the number of devices when we enumerate wire devices

    while (_wire->search(deviceAddress)) {
        if (validAddress(deviceAddress)) {
#if REQUIRESPARASITEPOWERAVAILABLE
            if (!parasite && readPowerSupply(deviceAddress)) parasite = true;
#endif			

            ScratchPad scratchPad;
            readScratchPad(deviceAddress, scratchPad);

#if REQUIRESONLY12BITCONVERSION			
            setResolution(deviceAddress, 12);
#else
            //bitResolution = max(bitResolution, getResolution(deviceAddress));
            uint8_t newResolution = getResolution(deviceAddress);
            if (newResolution > bitResolution) { // the max macro may call getResultion multiple times. 
                bitResolution = newResolution;
            }
#endif
            devices++;
        }
    }
}

JNIEXPORT void JNICALL Java_com_n0n3m4_q3e_Q3EJNI_init(JNIEnv *env, jclass c, jstring LibPath, jint width, jint height, jstring GameDir, jstring Cmdline)
{
    char **argv;
    int argc=0;
    jboolean iscopy;
    const char *dir = (*env)->GetStringUTFChars(
                          env, GameDir, &iscopy);
    const char *arg = (*env)->GetStringUTFChars(
                          env, Cmdline, &iscopy);
    chdir(strdup(dir));
    (*env)->ReleaseStringUTFChars(env, GameDir, dir);
    argv = malloc(sizeof(char*) * 255);
    argc = ParseCommandLine(strdup(arg), argv);
    (*env)->ReleaseStringUTFChars(env, Cmdline, arg);

    const char *libpath = (*env)->GetStringUTFChars(
                              env, LibPath, &iscopy);
    loadLib(strdup(libpath));
    (*env)->ReleaseStringUTFChars(env, LibPath, libpath);

    setCallbacks(&initAudio,&writeAudio,&setState);
    setResolution(width, height);

    qmain(argc, argv);
    free(argv);
}

ImageReceiver::ImageReceiver ()
  : src (new cv::Mat)
{
  cv::namedWindow ("Live Image", 1);
  setStreaming (true);
  setResolution (640, 480);
}

void ExternalDisplay::setExternalDisplay(int connected)
{

    hwc_context_t* ctx = mHwcContext;
    if(ctx) {
        ALOGD_IF(DEBUG, "%s: status = %d", __FUNCTION__,
                 connected);
        if(connected) {
            readResolution();
            //Get the best mode and set
            // TODO: Move this to activate
            setResolution(getBestMode());
            setDpyAttr();
            //enable hdmi vsync
        } else {
            // Disable the hdmi vsync
            closeFrameBuffer();
            resetInfo();
        }
        // Store the external display
        mExternalDisplay = connected;
        const char* prop = (connected) ? "1" : "0";
        // set system property
        property_set("hw.hdmiON", prop);
    }
    return;
}

const bool RawivImporter::import( const std::string& filename )
{
    FILE* ifs = fopen( filename.c_str(), "rb" );
    if ( !ifs )
    {
        kvsMessageError( "Cannot open file <%s>.", filename.c_str() );
        return( false );
    }

    fseek( ifs, 8 * sizeof(int), SEEK_SET );

    unsigned int dim[3];
    fread( dim, sizeof(unsigned int), 3, ifs );
    kvs::Endian::Swap( dim, 3 );
    m_resolution = kvs::Vector3ui( dim );

    fseek( ifs, 6 * sizeof(float), SEEK_CUR );
    const size_t nnodes = m_resolution.x() * m_resolution.y() * m_resolution.z();

    kvs::File file( filename );
    const size_t byte_size = file.byteSize();
    if ( ( byte_size - 68 ) == nnodes )
    {
        unsigned char* values = new unsigned char[ nnodes ];
        fread( values, sizeof(unsigned char), nnodes, ifs );
        kvs::Endian::Swap( values, nnodes );
        m_values = kvs::AnyValueArray( kvs::ValueArray<unsigned char>( values, nnodes ) );
        delete [] values;
    }
    else if ( ( byte_size - 68 ) == 2 * nnodes )
    {
        unsigned short* values = new unsigned short[ nnodes ];
        fread( values, sizeof(unsigned short), nnodes, ifs );
        kvs::Endian::Swap( values, nnodes );
        m_values = kvs::AnyValueArray( kvs::ValueArray<unsigned short>( values, nnodes ) );
        delete [] values;
    }
    else
    {
        float* values = new float[ nnodes ];
        fread( values, sizeof(float), nnodes, ifs );
        kvs::Endian::Swap( values, nnodes );
        m_values = kvs::AnyValueArray( kvs::ValueArray<float>( values, nnodes ) );
        delete [] values;
    }

    fclose( ifs );
    
    const kvs::StructuredVolumeObject::GridType grid_type = kvs::StructuredVolumeObject::Uniform;
    
    setGridType( grid_type );
    setResolution( m_resolution );
    setVeclen( 1 );
    setValues( m_values );
    updateMinMaxCoords();
    updateMinMaxValues();
    
    return( true );
}

void QSFMLCanvas::resizeGL(int width, int height)
{
  Vector3 resolution(width,height,32);
  
  setResolution(resolution);
  
  glViewport(0,0,width,height);
}

/******************************************************************************
Description.: process commands, allows to set v4l2 controls
Input Value.: * control specifies the selected v4l2 control's id
                see struct v4l2_queryctr in the videodev2.h
              * value is used for control that make use of a parameter.
Return Value: depends in the command, for most cases 0 means no errors and
              -1 signals an error. This is just rule of thumb, not more!
******************************************************************************/
int input_cmd(int plugin_number, unsigned int control_id, unsigned int group, int value)
{
    int ret = -1;
    int i = 0;
    DBG("Requested cmd (id: %d) for the %d plugin. Group: %d value: %d\n", control_id, plugin_number, group, value);
    switch(group) {
    case IN_CMD_GENERIC: {
            int i;
            for (i = 0; i<pglobal->in[plugin_number].parametercount; i++) {
                if ((pglobal->in[plugin_number].in_parameters[i].ctrl.id == control_id) &&
                    (pglobal->in[plugin_number].in_parameters[i].group == IN_CMD_GENERIC)){
                    DBG("Generic control found (id: %d): %s\n", control_id, pglobal->in[plugin_number].in_parameters[i].ctrl.name);
                    DBG("New %s value: %d\n", pglobal->in[plugin_number].in_parameters[i].ctrl.name, value);
                    return 0;
                }
            }
            DBG("Requested generic control (%d) did not found\n", control_id);
            return -1;
        } break;
    case IN_CMD_V4L2: {
            ret = v4l2SetControl(cams[plugin_number].videoIn, control_id, value, plugin_number, pglobal);
            if(ret == 0) {
                pglobal->in[plugin_number].in_parameters[i].value = value;
            } else {
                DBG("v4l2SetControl failed: %d\n", ret);
            }
            return ret;
        } break;
    case IN_CMD_RESOLUTION: {
        // the value points to the current formats nth resolution
        if(value > (pglobal->in[plugin_number].in_formats[pglobal->in[plugin_number].currentFormat].resolutionCount - 1)) {
            DBG("The value is out of range");
            return -1;
        }
        int height = pglobal->in[plugin_number].in_formats[pglobal->in[plugin_number].currentFormat].supportedResolutions[value].height;
        int width = pglobal->in[plugin_number].in_formats[pglobal->in[plugin_number].currentFormat].supportedResolutions[value].width;
        ret = setResolution(cams[plugin_number].videoIn, width, height);
        if(ret == 0) {
            pglobal->in[plugin_number].in_formats[pglobal->in[plugin_number].currentFormat].currentResolution = value;
        }
        return ret;
    } break;
    case IN_CMD_JPEG_QUALITY:
        if((value >= 0) && (value < 101)) {
            pglobal->in[plugin_number].jpegcomp.quality = value;
            if(IOCTL_VIDEO(cams[plugin_number].videoIn->fd, VIDIOC_S_JPEGCOMP, &pglobal->in[plugin_number].jpegcomp) != EINVAL) {
                DBG("JPEG quality is set to %d\n", value);
                ret = 0;
            } else {
                DBG("Setting the JPEG quality is not supported\n");
            }
        } else {
            DBG("Quality is out of range\n");
        }
        break;
    }
    return ret;
}

// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void ImportR3DStack::readFilterParameters(AbstractFilterParametersReader* reader, int index)
{
  reader->openFilterGroup(this, index);
  setZStartIndex( reader->readValue("ZStartIndex", getZStartIndex()) );
  setZEndIndex( reader->readValue("ZEndIndex", getZEndIndex()) );
  setOrigin( reader->readValue("Origin", getOrigin()) );
  setResolution( reader->readValue("Resolution", getResolution()) );
  reader->closeFilterGroup();
}

bool DecodeInputAvFormat::initInput(const char* fileName)
{
    uint16_t width = 0, height = 0;
    int ret = avformat_open_input(&m_format, fileName, NULL, NULL);
    if (ret)
        goto error;
    uint32_t i;
    for (i = 0; i < m_format->nb_streams; ++i) {
#if LIBAVCODEC_VERSION_INT >= AV_VERSION_INT(57, 33, 100)
        AVCodecParameters* codec = m_format->streams[i]->codecpar;
#else
        AVCodecContext* codec = m_format->streams[i]->codec;
#endif
        //VP9: width and height of the IVF header,VP8: width and height is zero
        if (AVMEDIA_TYPE_VIDEO == codec->codec_type) {
            width = codec->width;
            height = codec->height;
            break;
        }
    }

    ret = avformat_find_stream_info(m_format, NULL);
    if (ret < 0)
        goto error;
    for (i = 0; i < m_format->nb_streams; i++)
    {
#if LIBAVCODEC_VERSION_INT >= AV_VERSION_INT(57, 33, 100)
        AVCodecParameters* codec = m_format->streams[i]->codecpar;
#else
        AVCodecContext* codec = m_format->streams[i]->codec;
#endif
        if (AVMEDIA_TYPE_VIDEO == codec->codec_type) {
            m_codecId = codec->codec_id;
            if (codec->extradata && codec->extradata_size)
                m_codecData.append((char*)codec->extradata, codec->extradata_size);
            m_videoId = i;
            //VP9: display_width and display_height of the first frame
            if (codec->width > width)
                width = codec->width;
            if (codec->height > height)
                height = codec->height;
            setResolution(width, height);
            break;
        }
    }
    if (i == m_format->nb_streams) {
        ERROR("no video stream");
        goto error;
    }
    m_isEos = false;
    return true;
error:
    if (m_format)
        avformat_close_input(&m_format);
    return false;

}

void ofApp::endRenderMode(){
    cout<<"realtime mode"<<endl;

    setResolution(realtime_width, realtime_height);

    vwt->setAudioDelay(audio_delay);

    closeAudioFile();
}

bool DirectShowCamera::setupDevice() {

	setResolution(_width, _height);
	setFrameRate(_frameRate);
	_videoInput->setAutoReconnectOnFreeze(_id, true, 3);

	return true;

}

// set resolution of all devices to 9, 10, 11, or 12 bits
// if new resolution is out of range, it is constrained.
void DallasTemperature::setResolution(uint8_t newResolution)
{
  bitResolution = constrain(newResolution, 9, 12);
  DeviceAddress deviceAddress;
  for (int i=0; i<devices; i++)
  {
    getAddress(deviceAddress, i);
	setResolution(deviceAddress, bitResolution);
  }
}

void ExternalDisplay::setEDIDMode(int resMode) {
    ALOGD_IF(DEBUG,"resMode=%d ", resMode);
    {
        Mutex::Autolock lock(mExtDispLock);
        setExternalDisplay(false);
        openFrameBuffer(mHdmiFbNum);
        setResolution(resMode);
    }
    setExternalDisplay(true, mHdmiFbNum);
}