コード例 #1
0
ファイル: mail.c プロジェクト: sdgdsffdsfff/mail-jobs-monitor
int httpGet(char* hostname,char *url)
{
	LOGI("httpGet");
	LOGI(hostname);
	//char myurl[BUFFSIZE] = {0};
	//char host[BUFFSIZE] = {0};
	//char GET[BUFFSIZE] = {0};
	struct sockaddr_in sin;
	int sockfd;
	if ((sockfd = socket (AF_INET, SOCK_STREAM, 0)) == -1) {
		LOGE(strerror(errno));
		return -100;
	}

	struct hostent * host_addr = gethostbyname(hostname);
	if(host_addr==NULL) {
		LOGE(strerror(errno));
		return -103;
	}
	sin.sin_family = AF_INET;
	sin.sin_port = htons( (unsigned short)80);
	sin.sin_addr.s_addr = *((unsigned long*)host_addr->h_addr_list[0]);
	if( connect (sockfd,(const struct sockaddr *)&sin, sizeof(struct sockaddr_in) ) == -1 ) {
		LOGE(strerror(errno));
		return -101;
	}
	LOGI("httpGet send");
	// 向WEB服务器发送URL信息
	memset(request, 0, BUFFSIZE);
	strcat(request, url); //请求内容与http版本
	//strcat(request, "GET /index.html HTTP/1.1\r\n"); //请求内容与http版本
	strcat(request, "HOST:"); //主机名,,格式:"HOST:主机"
	strcat(request, hostname);
	strcat(request, "\r\n");
	strcat(request, "Accept:*/*\r\n"); //接受类型,所有类型
	// strcat(request, "User-Agent:Mozilla/4.0 (compatible; MSIE 5.00; Windows 98)");//指定浏览器类型?
	// strcat(request, "Connection: Keep-Alive\r\n");//设置连接,保持连接
	// strcat(request, "Set Cookie:0\r\n");//设置Cookie
	// strcat(request, "Range: bytes=0 - 500\r\n");//设置请求字符串起止位置,断点续传关键"Range: bytes=999 -"
	strcat(request, "\r\n");//空行表示结束
	LOGI(request);
	if( send (sockfd, request, strlen(request), 0) == -1){
		LOGE(strerror(errno));
		return -99;
	}
	LOGI("httpGet recv");

	struct timeval tv_out;
	tv_out.tv_sec = 5;
	tv_out.tv_usec = 0;

	setsockopt(sockfd, SOL_SOCKET, SO_RCVTIMEO, &tv_out, sizeof(tv_out));
	memset(text,0,BUFFSIZE);
	int recv_size = 0,all_size = 0;
	while((recv_size = recv (sockfd, text + all_size, 1024*1024*1024, 0)) != 0){
		all_size += recv_size;
		if(all_size > 5*1024*1024)
			break;
	}
	//LOGI(text);
	LOGI("httpGet end");
	close(sockfd);
	return 0;
}
JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM *jvm, void *reserved)
{
	LOGI("Loading native library compiled at " __TIME__ " " __DATE__);
	sVm = jvm;
	return JNI_VERSION_1_2;
}
コード例 #3
0
ファイル: godot_android.cpp プロジェクト: lonesurvivor/godot
/**
 * Initialize an EGL context for the current display.
 */
static int engine_init_display(struct engine* engine,bool p_gl2) {
    // initialize OpenGL ES and EGL

    /*
     * Here specify the attributes of the desired configuration.
     * Below, we select an EGLConfig with at least 8 bits per color
     * component compatible with on-screen windows
     */
    const EGLint gl2_attribs[] = {
	  //  EGL_SURFACE_TYPE, EGL_WINDOW_BIT,
	    EGL_BLUE_SIZE, 4,
	    EGL_GREEN_SIZE, 4,
	    EGL_RED_SIZE, 4,
	    EGL_ALPHA_SIZE, 0,
	    EGL_DEPTH_SIZE,     16,
	    EGL_STENCIL_SIZE,   EGL_DONT_CARE,
	    EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT,
	    EGL_NONE
    };

    const EGLint gl1_attribs[] = {
	  //  EGL_SURFACE_TYPE, EGL_WINDOW_BIT,
	    EGL_BLUE_SIZE, 4,
	    EGL_GREEN_SIZE, 4,
	    EGL_RED_SIZE, 4,
	    EGL_ALPHA_SIZE, 0,
	    EGL_DEPTH_SIZE,     16,
	    EGL_STENCIL_SIZE,   EGL_DONT_CARE,
	    EGL_NONE
    };

    const EGLint *attribs=p_gl2?gl2_attribs:gl1_attribs;


    EGLint w, h, dummy, format;
    EGLint numConfigs;
    EGLConfig config;
    EGLSurface surface;
    EGLContext context;

    EGLDisplay display = eglGetDisplay(EGL_DEFAULT_DISPLAY);

    eglInitialize(display, 0, 0);


    /* Here, the application chooses the configuration it desires. In this
     * sample, we have a very simplified selection process, where we pick
     * the first EGLConfig that matches our criteria */

    eglChooseConfig(display, attribs, &config, 1, &numConfigs);

    LOGI("Num configs: %i\n",numConfigs);

    /* EGL_NATIVE_VISUAL_ID is an attribute of the EGLConfig that is
     * guaranteed to be accepted by ANativeWindow_setBuffersGeometry().
     * As soon as we picked a EGLConfig, we can safely reconfigure the
     * ANativeWindow buffers to match, using EGL_NATIVE_VISUAL_ID. */
    eglGetConfigAttrib(display, config, EGL_NATIVE_VISUAL_ID, &format);

    ANativeWindow_setBuffersGeometry(engine->app->window, 0, 0, format);
    //ANativeWindow_setFlags(engine->app->window, 0, 0, format|);

    surface = eglCreateWindowSurface(display, config, engine->app->window, NULL);

    const EGLint context_attribs[] = {
	    EGL_CONTEXT_CLIENT_VERSION,2,
	    EGL_NONE
    };
    context = eglCreateContext(display, config, EGL_NO_CONTEXT, p_gl2?context_attribs:NULL);

    if (eglMakeCurrent(display, surface, surface, context) == EGL_FALSE) {
	LOGW("Unable to eglMakeCurrent");
	return -1;
    }

    eglQuerySurface(display, surface, EGL_WIDTH, &w);
    eglQuerySurface(display, surface, EGL_HEIGHT, &h);
    print_line("INIT VIDEO MODE: "+itos(w)+","+itos(h));

    //engine->os->set_egl_extensions(eglQueryString(display,EGL_EXTENSIONS));
    engine->os->init_video_mode(w,h);


    engine->display = display;
    engine->context = context;
    engine->surface = surface;
    engine->width = w;
    engine->height = h;
    engine->display_active=true;

    //engine->state.angle = 0;

    // Initialize GL state.
    //glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_FASTEST);
    glEnable(GL_CULL_FACE);
  //  glShadeModel(GL_SMOOTH);
    glDisable(GL_DEPTH_TEST);
    LOGI("GL Version: %s - %s %s\n", glGetString(GL_VERSION),glGetString(GL_VENDOR), glGetString(GL_RENDERER));

    return 0;
}
コード例 #4
0
ファイル: WarpTV.cpp プロジェクト: Johnta/EffecTV_for_Android
// Destructor
WarpTV::~WarpTV(void)
{
	LOGI("%s(L=%d)", __func__, __LINE__);
	stop();
}
コード例 #5
0
ファイル: termExec.cpp プロジェクト: abscasey/vimtouch
static jobject DEF_JNI(createSubprocess,
                       jstring cmd, jstring arg0, jstring arg1,
                       jobjectArray envVars, jintArray processIdArray)
{
    char const* cmd_str = cmd ? env->GetStringUTFChars(cmd, NULL) : NULL;
    char const* arg0_str = arg0 ? env->GetStringUTFChars(arg0, NULL) : NULL;
    char const* arg1_str = arg1 ? env->GetStringUTFChars(arg1, NULL) : NULL;
    LOGI("cmd_str = '%s'", cmd_str);
    LOGI("arg0_str = '%s'", arg0_str);
    LOGI("arg1_str = '%s'", arg1_str);

    int num_env_vars = envVars ? env->GetArrayLength(envVars) : 0;
    char **envp = NULL;
    char const* tmp = NULL;

    if (num_env_vars > 0)
    {
        envp = (char **)malloc((num_env_vars + 1) * sizeof(char*));

        if (!envp)
        {
            throwOutOfMemoryError(env, "Couldn't allocate envp array");
            return NULL;
        }

        for (int i = 0; i < num_env_vars; ++i)
        {
            jobject obj = env->GetObjectArrayElement(envVars, i);
            jstring env_var = reinterpret_cast<jstring>(obj);
            tmp = env->GetStringUTFChars(env_var, 0);

            if (tmp == NULL)
            {
                throwOutOfMemoryError(env, "Couldn't get env var from array");
                return NULL;
            }

            envp[i] = strdup(tmp);

            if (envp[i] == NULL)
            {
                throwOutOfMemoryError(env, "Couldn't strdup() env var");
                return NULL;
            }

            env->ReleaseStringUTFChars(env_var, tmp);
        }

        envp[num_env_vars] = NULL;
    }

    int procId;
    int ptm = create_subprocess(cmd_str, arg0_str, arg1_str, envp, &procId);

    env->ReleaseStringUTFChars(cmd, cmd_str);
    if(arg0 != NULL) env->ReleaseStringUTFChars(arg0, arg0_str);
    if(arg1 != NULL) env->ReleaseStringUTFChars(arg1, arg1_str);

    for (int i = 0; i < num_env_vars; ++i)
        free(envp[i]);

    free(envp);

    if (processIdArray) {
        int procIdLen = env->GetArrayLength(processIdArray);
        if (procIdLen > 0) {
            jboolean isCopy;
    
            int* pProcId = (int*) env->GetPrimitiveArrayCritical(processIdArray, &isCopy);
            if (pProcId) {
                *pProcId = procId;
                env->ReleasePrimitiveArrayCritical(processIdArray, pProcId, 0);
            }
        }
    }
    
    jobject result = env->NewObject(class_fileDescriptor, method_fileDescriptor_init);
    
    if (!result) {
        LOGE("Couldn't create a FileDescriptor.");
    }
    else {
        env->SetIntField(result, field_fileDescriptor_descriptor, ptm);
    }
    
    return result;
}
コード例 #6
0
bool TeapotRenderer::loadShaders(SHADER_PARAMS* params, const char* strVsh, const char* strFsh)
{
    GLuint program;
    GLuint vertShader, fragShader;
    char *vertShaderPathname, *fragShaderPathname;

    // Create shader program
    program = glCreateProgram();
    LOGI("Created Shader %d", program);

    // Create and compile vertex shader
    if (!shader::compileShader(&vertShader, GL_VERTEX_SHADER, strVsh)) {
        LOGI("Failed to compile vertex shader");
        glDeleteProgram(program);
        return false;
    }

    // Create and compile fragment shader
    if (!shader::compileShader(&fragShader, GL_FRAGMENT_SHADER, strFsh)) {
        LOGI("Failed to compile fragment shader");
        glDeleteProgram(program);
        return false;
    }

    // Attach vertex shader to program
    glAttachShader(program, vertShader);

    // Attach fragment shader to program
    glAttachShader(program, fragShader);

    // Bind attribute locations
    // this needs to be done prior to linking
    glBindAttribLocation(program, ATTRIB_VERTEX, "myVertex");
    glBindAttribLocation(program, ATTRIB_NORMAL, "myNormal");
    glBindAttribLocation(program, ATTRIB_UV, "myUV");

    // Link program
    if (!shader::linkProgram(program)) {
        LOGI("Failed to link program: %d", program);

        if (vertShader) {
            glDeleteShader(vertShader);
            vertShader = 0;
        }
        if (fragShader) {
            glDeleteShader(fragShader);
            fragShader = 0;
        }
        if (program) {
            glDeleteProgram(program);
        }

        return false;
    }

    // Get uniform locations
    params->_uiMatrixP = glGetUniformLocation(program, "uPMatrix");
    params->_uiMatrixView = glGetUniformLocation(program, "uMVMatrix");

    params->_uiLight0 = glGetUniformLocation(program, "vLight0");
    params->_uiMaterialDiffuse = glGetUniformLocation(program,
            "vMaterialDiffuse");
    params->_uiMaterialAmbient = glGetUniformLocation(program,
            "vMaterialAmbient");
    params->_uiMaterialSpecular = glGetUniformLocation(program,
            "vMaterialSpecular");

    // Release vertex and fragment shaders
    if (vertShader)
        glDeleteShader(vertShader);
    if (fragShader)
        glDeleteShader(fragShader);

    params->_program = program;
    return true;
}
コード例 #7
0
ファイル: WarpTV.cpp プロジェクト: Johnta/EffecTV_for_Android
// Key functions
const char* WarpTV::event(int key_code)
{
	LOGI("%s(L=%d): k=%d", __func__, __LINE__, key_code);
	return NULL;
}
コード例 #8
0
void GPGSManager::SignOut() {
  if (gameServices->IsAuthorized()) {
    LOGI("SignOut");
    gameServices->SignOut();
  }
}
コード例 #9
0
void GPGSManager::UnlockAchievement(const char *achievementId) {
  if (gameServices->IsAuthorized()) {
    LOGI("Achievement unlocked");
    gameServices->Achievements().Unlock(achievementId);
  }
}
コード例 #10
0
void GPGSManager::setPlayer2Name()
{
    gpg::PlayerManager::FetchSelfResponse localPlayer = gameServices->Players().FetchSelfBlocking();
    g_gameConfig.player2Name = localPlayer.data.Name();
    LOGI("player2 name:%s", localPlayer.data.Name().c_str());
}
コード例 #11
0
void GPGSManager::BeginUserInitiatedSignIn() {
  if (!gameServices->IsAuthorized()) {
    LOGI("StartAuthorizationUI");
    gameServices->StartAuthorizationUI();
  }
}
コード例 #12
0
void GPGSManager::TakeTurn(const bool winning, const bool losing)
{
    cocos2d::Director::getInstance()->getEventDispatcher()->dispatchCustomEvent("gameshowpopwindowlistener");
    cocos2d::Director::getInstance()->getEventDispatcher()->dispatchCustomEvent("wagonselectshowpopwindowlistener");
    
    LOGI("StarTakeTurn...0");
    gpg::TurnBasedMultiplayerManager& manager = gameServices->TurnBasedMultiplayer();
    gpg::PlayerManager::FetchSelfResponse localPlayer = gameServices->Players().FetchSelfBlocking();
    LOGI("Taking my turnxxxxxxx. local participant name:%s", localPlayer.data.Name().c_str());
    
    
    LOGI("StarTakeTurn...1");
    //Find the participant for the local player.
    gpg::MultiplayerParticipant localParticipant;
    for (auto &participant : current_match_.Participants()) {
        if (participant.Player().Valid() && participant.Player().Id() ==
            localPlayer.data.Id()) {
            localParticipant = participant;
        }
    }
    
    LOGI("Taking my turn. local participant id:%s", localParticipant.Id().c_str());
    LOGI("Taking my turn. local participant name:%s", localParticipant.DisplayName().c_str());
    
    
    std::vector<gpg::MultiplayerParticipant> participants = current_match_.Participants();
    int32_t nextPlayerIndex = GetNextParticipant();
    
    LOGI("StarTakeTurn...2...%d",nextPlayerIndex);
    
    //std::string to std::vector
    g_gameConfig.match_data.clear();
    g_gameConfig.match_data.resize(g_gameConfig.match_string.size());
    g_gameConfig.match_data.assign(g_gameConfig.match_string.begin(), g_gameConfig.match_string.end());

    
    //By default, passing through existing participatntResults
    gpg::ParticipantResults results = current_match_.ParticipantResults();
    
    if(winning || losing)
    {
        if (winning) {
            //Create winning participants result
            results = current_match_.ParticipantResults()
            .WithResult(localParticipant.Id(),  // local player ID
                        0,                      // placing
                        gpg::MatchResult::WIN   // status
                        );
        } else if (losing) {
            //Create losing participants result
            results = current_match_.ParticipantResults()
            .WithResult(localParticipant.Id(),  // local player ID
                        0,                      // placing
                        gpg::MatchResult::LOSS  // status
                        );
        }
        
        manager.FinishMatchDuringMyTurn(
                           current_match_, g_gameConfig.match_data, results,
                           [](
                              gpg::TurnBasedMultiplayerManager::TurnBasedMatchResponse const &
                              response) {
                               LOGI("Took turn");
//                               NoTouchLayer* notouchLayer =((NoTouchLayer*)(cocos2d::Director::getInstance()->getRunningScene()->getChildByTag(NOTOUCHTAG)));
//                               if(notouchLayer)
//                                   notouchLayer->setError("Success!");
                               cocos2d::Director::getInstance()->getEventDispatcher()->dispatchCustomEvent("TakeTurnSuccess");
                               //cocos2d::Director::getInstance()->getEventDispatcher()->dispatchCustomEvent("returntoMenu");
                           });
        return ;
    }

    
    LOGI("StarTakeTurn...3");
    LOGI("current_match_ is %d",current_match_.Valid());
    LOGI("results is %d",results.Valid());
    LOGI("global string is --\n%s\n--\n", g_gameConfig.match_string.c_str());

    //Take normal turn
    switch (nextPlayerIndex) {
        default:
            manager.TakeMyTurn(
                               current_match_, g_gameConfig.match_data, results, participants[nextPlayerIndex],
                               [](
                                      gpg::TurnBasedMultiplayerManager::TurnBasedMatchResponse const &
                                      response) {
                                   LOGI("Took turn");
//                                   NoTouchLayer* notouchLayer =((NoTouchLayer*)(cocos2d::Director::getInstance()->getRunningScene()->getChildByTag(NOTOUCHTAG)));
//                                   if(notouchLayer)
//                                       notouchLayer->setError("Success!");
                                   cocos2d::Director::getInstance()->getEventDispatcher()->dispatchCustomEvent("TakeTurnSuccess");
//                                   cocos2d::Director::getInstance()->getEventDispatcher()->dispatchCustomEvent("returntoMenu");
                               });
            break;
        case NEXT_PARTICIPANT_AUTOMATCH:
            manager.TakeMyTurnAndAutomatch(
                                           current_match_, g_gameConfig.match_data, results,
                                           [](
                                                  gpg::TurnBasedMultiplayerManager::TurnBasedMatchResponse const &
                                                  response) {
                                               LOGI("Took turn");
//                                               NoTouchLayer* notouchLayer =((NoTouchLayer*)(cocos2d::Director::getInstance()->getRunningScene()->getChildByTag(NOTOUCHTAG)));
//                                               if(notouchLayer)
//                                                   notouchLayer->setError("Success!");
                                               cocos2d::Director::getInstance()->getEventDispatcher()->dispatchCustomEvent("TakeTurnSuccess");
//                                               cocos2d::Director::getInstance()->getEventDispatcher()->dispatchCustomEvent("returntoMenu");
                                           });
            break;
        case NEXT_PARTICIPANT_NONE:
            //Error case
            manager.DismissMatch(current_match_);
            cocos2d::Director::getInstance()->replaceScene(MainScreenScene::createScene(false));
            break;
    }
    
    LOGI("StarTakeTurn...4");
}
コード例 #13
0
void GPGSManager::ShowMatchInbox()
{
    gameServices->TurnBasedMultiplayer().ShowMatchInboxUI([](gpg::TurnBasedMultiplayerManager::MatchInboxUIResponse const & response)
    {
        if (response.status == gpg::UIStatus::VALID) {
            //Show game based on the user's selection
            
            cocos2d::Director::getInstance()->getEventDispatcher()->dispatchCustomEvent("showConnectingPopWindow");
            
            current_match_ = response.match;
            switch (response.match.Status()) {
                case gpg::MatchStatus::THEIR_TURN:
                {//Manage match with dismiss, leave and cancel options
                    LOGI("Their turn...By Jacky");
//                    auto notouchlayer = NoTouchLayer::create();
//                    notouchlayer->setTag(NOTOUCHTAG);
//                    cocos2d::Director::getInstance()->getRunningScene()->addChild(notouchlayer,100);
//                    notouchlayer->setError("It's not your turn.");
                    cocos2d::Director::getInstance()->getEventDispatcher()->dispatchCustomEvent("showNotYourTurnPopWindow");
                }
                    break;
                case gpg::MatchStatus::MY_TURN:
                {//Play selected game
                    LOGI("My turn...By Jacky...");
                    
                    //add notouch layer.
//                    auto notouchlayer = NoTouchLayer::create();
//                    notouchlayer->setTag(NOTOUCHTAG);
//                    cocos2d::Director::getInstance()->getRunningScene()->addChild(notouchlayer,100);
                    
                    //PlayGame(response.match);
                    current_match_ = response.match;
                    ParseMatchData();
                    //todo:is second turn?
                    int cur_match_turn = GetMatchTurn();//no found, must return 0;
                    cur_match_turn++;
                    if(cur_match_turn == 1){
                        setPlayer1Name();
                        cocos2d::Director::getInstance()->getEventDispatcher()->dispatchCustomEvent("enterWagonSelect_1");
                    }
                    else if(cur_match_turn ==2){
                        setPlayer2Name();
                        cocos2d::Director::getInstance()->getEventDispatcher()->dispatchCustomEvent("enterWagonSelect_2");
                    }
                    else if(cur_match_turn >=3){
                        LOGI("curmatchturn is %d",cur_match_turn);
                        cocos2d::Director::getInstance()->getEventDispatcher()->dispatchCustomEvent("enterGame");
                    }
                    else
                    {
                        LOGI("Current_match_turn is a invalid number ====>>>%d", cur_match_turn);
//                        std::string err = "Current_match_turn is a invalid number : %d" + cocos2d::Value((int)cur_match_turn).asString();
//                        NoTouchLayer* notouchlayer = ((NoTouchLayer*)(cocos2d::Director::getInstance()->getRunningScene()->getChildByTag(NOTOUCHTAG)));
//                        if(notouchlayer)
//                            notouchlayer->setError(err);
                    }
                }
                    break;
                case gpg::MatchStatus::COMPLETED:
                    //Manage match with dismiss, rematch options
                    LOGI("Completed...By Jacky");
                   cocos2d::Director::getInstance()->getEventDispatcher()->dispatchCustomEvent("showItsCompletedPopWindow");
                     //cocos2d::Director::getInstance()->getEventDispatcher()->dispatchCustomEvent("TakeTurnSuccess");
                    break;
                case gpg::MatchStatus::EXPIRED:
                default:
                    //Manage match with dismiss option
                    LOGI("Expired & default...By Jacky");
                    
                    //add notouch layer.
//                    auto notouchlayer = NoTouchLayer::create();
//                    notouchlayer->setTag(NOTOUCHTAG);
//                    cocos2d::Director::getInstance()->getRunningScene()->addChild(notouchlayer,100);
                    //enter game
                    current_match_ = response.match;
                    ParseMatchData();
                    cocos2d::Director::getInstance()->getEventDispatcher()->dispatchCustomEvent("enterGame");
                    
                    break;
            }
        } else {
            LOGI("Invalid MatchInboxUIResponse response status...%d...By Jacky", response.status);
        }
    });
}
コード例 #14
0
ファイル: main.cpp プロジェクト: h-godai/ssa
/**
 * アプリケーション開始
 */
void android_main(struct android_app* state) {
    struct engine engine;

    // glueが削除されないように
    app_dummy();

    memset(&engine, 0, sizeof(engine));
    state->userData = &engine;
    state->onAppCmd = engine_handle_cmd;
    state->onInputEvent = engine_handle_input;
    engine.app = state;

    // センサーからのデータ取得に必要な初期化
    engine.sensorManager = ASensorManager_getInstance();
    engine.accelerometerSensor = ASensorManager_getDefaultSensor(
            engine.sensorManager, ASENSOR_TYPE_ACCELEROMETER);
    engine.sensorEventQueue = ASensorManager_createEventQueue(
            engine.sensorManager, state->looper, LOOPER_ID_USER, NULL,
            NULL);

    if (state->savedState != NULL) {
        // 以前の状態に戻す
        engine.state = *(struct saved_state*) state->savedState;
    }

    while (1) {

        int ident;
        int events;
        struct android_poll_source* source;

        // アプリケーションが動作することになれば、これらセンサーの制御を行う
        while ((ident = ALooper_pollAll(engine.animating ? 0 : -1, NULL,
                &events, (void**) &source)) >= 0) {

            // イベントを処理する
            if (source != NULL) {
                source->process(state, source);
            }

            // センサーに何かしらのデータが存在したら処理する
            if (ident == LOOPER_ID_USER) {
                if (engine.accelerometerSensor != NULL) {
                    ASensorEvent event;
                    while (ASensorEventQueue_getEvents(
                            engine.sensorEventQueue, &event, 1) > 0) {
                        LOGI("accelerometer: x=%f y=%f z=%f",
                                event.acceleration.x, event.acceleration.y,
                                event.acceleration.z);
                    }
                }
            }

            // 破棄要求があったか
            if (state->destroyRequested != 0) {
                engine_term_display(&engine);
                return;
            }
        }

        if (engine.animating) {
            // 次のフレームを描画するのに必要な処理を行う
            engine.state.angle += .01f;
            if (engine.state.angle > 1) {
                engine.state.angle = 0;
            }

            // 画面描画
            engine_draw_frame(&engine);
        }
    }
}
コード例 #15
0
ファイル: jdapimin.c プロジェクト: siwenhu/gitStudy
jpeg_CreateDecompress (j_decompress_ptr cinfo, int version, size_t structsize)
{
  int i;

  /* Guard against version mismatches between library and caller. */
  cinfo->mem = NULL;            /* so jpeg_destroy knows mem mgr not called */
  if (version != JPEG_LIB_VERSION)
    ERREXIT2(cinfo, JERR_BAD_LIB_VERSION, JPEG_LIB_VERSION, version);
  if (structsize != sizeof(struct jpeg_decompress_struct))
    ERREXIT2(cinfo, JERR_BAD_STRUCT_SIZE,
             (int) sizeof(struct jpeg_decompress_struct), (int) structsize);

  /* For debugging purposes, we zero the whole master structure.
   * But the application has already set the err pointer, and may have set
   * client_data, so we have to save and restore those fields.
   * Note: if application hasn't set client_data, tools like Purify may
   * complain here.
   */
  {
    struct jpeg_error_mgr * err = cinfo->err;
    void * client_data = cinfo->client_data; /* ignore Purify complaint here */
    MEMZERO(cinfo, sizeof(struct jpeg_decompress_struct));
    cinfo->err = err;
    cinfo->client_data = client_data;
  }
  cinfo->is_decompressor = TRUE;

  /* Initialize a memory manager instance for this object */
  jinit_memory_mgr((j_common_ptr) cinfo);

  /* Zero out pointers to permanent structures. */
  cinfo->progress = NULL;
  cinfo->src = NULL;

  for (i = 0; i < NUM_QUANT_TBLS; i++)
    cinfo->quant_tbl_ptrs[i] = NULL;

  for (i = 0; i < NUM_HUFF_TBLS; i++) {
    cinfo->dc_huff_tbl_ptrs[i] = NULL;
    cinfo->ac_huff_tbl_ptrs[i] = NULL;
  }

  /* Initialize marker processor so application can override methods
   * for COM, APPn markers before calling jpeg_read_header.
   */
  cinfo->marker_list = NULL;
  jinit_marker_reader(cinfo);

  /* And initialize the overall input controller. */
  jinit_input_controller(cinfo);

  /* OK, I'm ready */
  cinfo->global_state = DSTATE_START;

  /* The master struct is used to store extension parameters, so we allocate it
   * here.
   */
  LOGI("=========%s:%d", __func__,  __LINE__);
  cinfo->master = (struct jpeg_decomp_master *)
      (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_PERMANENT,
                                  sizeof(my_decomp_master));
  LOGI("=========%s:%d", __func__, __LINE__);
  MEMZERO(cinfo->master, sizeof(my_decomp_master));
}
コード例 #16
0
void GPGSManager::SubmitHighScore(const char *leaderboardId, uint64_t score) {
  if (gameServices->IsAuthorized()) {
    LOGI("High score submitted");
    gameServices->Leaderboards().SubmitScore(leaderboardId, score);
  }
}
コード例 #17
0
ファイル: OMXVideoDecoderVP9HWR.cpp プロジェクト: knone1/boot
OMX_ERRORTYPE OMXVideoDecoderVP9HWR::ProcessorProcess(
        OMX_BUFFERHEADERTYPE ***pBuffers,
        buffer_retain_t *retains,
        OMX_U32)
{
    OMX_ERRORTYPE ret;
    OMX_BUFFERHEADERTYPE *inBuffer = *pBuffers[INPORT_INDEX];
    OMX_BUFFERHEADERTYPE *outBuffer = *pBuffers[OUTPORT_INDEX];
    OMX_BOOL isResolutionChange = OMX_FALSE;

    if (inBuffer->pBuffer == NULL) {
        LOGE("Buffer to decode is empty.");
        return OMX_ErrorBadParameter;
    }

    if (inBuffer->nFlags & OMX_BUFFERFLAG_CODECCONFIG) {
        LOGI("Buffer has OMX_BUFFERFLAG_CODECCONFIG flag.");
    }

    if (inBuffer->nFlags & OMX_BUFFERFLAG_DECODEONLY) {
        LOGW("Buffer has OMX_BUFFERFLAG_DECODEONLY flag.");
    }

    if (inBuffer->nFlags & OMX_BUFFERFLAG_EOS) {
        if (inBuffer->nFilledLen == 0) {
            (*pBuffers[OUTPORT_INDEX])->nFilledLen = 0;
            (*pBuffers[OUTPORT_INDEX])->nFlags = OMX_BUFFERFLAG_EOS;
            return OMX_ErrorNone;
        }
    }

    if (vpx_codec_decode((vpx_codec_ctx_t *)mCtx,
                         inBuffer->pBuffer + inBuffer->nOffset,
                         inBuffer->nFilledLen,
                         NULL,
                         0)) {
        LOGE("on2 decoder failed to decode frame.");
        return OMX_ErrorBadParameter;
    }

    ret = FillRenderBuffer(pBuffers[OUTPORT_INDEX],
                           &retains[OUTPORT_INDEX],
                           ((*pBuffers[INPORT_INDEX]))->nFlags,
                           &isResolutionChange);

    if (ret == OMX_ErrorNone) {
        (*pBuffers[OUTPORT_INDEX])->nTimeStamp = inBuffer->nTimeStamp;
    }

    if (isResolutionChange) {
        HandleFormatChange();
    }

    bool inputEoS = ((*pBuffers[INPORT_INDEX])->nFlags & OMX_BUFFERFLAG_EOS);
    bool outputEoS = ((*pBuffers[OUTPORT_INDEX])->nFlags & OMX_BUFFERFLAG_EOS);
    // if output port is not eos, retain the input buffer
    // until all the output buffers are drained.
    if (inputEoS && !outputEoS) {
        retains[INPORT_INDEX] = BUFFER_RETAIN_GETAGAIN;
        // the input buffer is retained for draining purpose.
        // Set nFilledLen to 0 so buffer will not be decoded again.
        (*pBuffers[INPORT_INDEX])->nFilledLen = 0;
    }

    if (ret == OMX_ErrorNotReady) {
        retains[OUTPORT_INDEX] = BUFFER_RETAIN_GETAGAIN;
        ret = OMX_ErrorNone;
    }

    return ret;
}
コード例 #18
0
ファイル: cHal_init.cpp プロジェクト: klaus-liebler/sensact
void cHAL::Init(void) {

	__HAL_RCC_GPIOA_CLK_ENABLE();
	__HAL_RCC_GPIOB_CLK_ENABLE();
	__HAL_RCC_GPIOC_CLK_ENABLE();
	__HAL_RCC_CAN2_CLK_ENABLE();
	__HAL_RCC_CAN1_CLK_ENABLE();
	__HAL_RCC_USART3_CLK_ENABLE();
	__HAL_RCC_UART4_CLK_ENABLE();

	GPIO_InitTypeDef gi;
	HAL_StatusTypeDef status;

	//Enable UART
	gi.Pin = GPIO_PIN_10 | GPIO_PIN_11; //C10=TX, C11=RX
	gi.Mode = GPIO_MODE_AF_PP;
	gi.Pull = GPIO_PULLUP;
	gi.Speed = GPIO_SPEED_LOW;
	gi.Alternate = GPIO_AF7_USART3;
	HAL_GPIO_Init(GPIOC, &gi);
	InitAndTestUSART();

	//Onboard LEDs
	gi.Mode = GPIO_MODE_OUTPUT_PP;
	gi.Alternate = 0;
	gi.Pull = GPIO_NOPULL;
	gi.Speed = GPIO_SPEED_LOW;
	gi.Pin = GPIO_PIN_7;
	HAL_GPIO_Init(GPIOB, &gi);
	LOGI(BSP::SUCCESSFUL_STRING, "GPIO for LED");

	if(InitDWTCounter())
	{
		LOGI(BSP::SUCCESSFUL_STRING, "DWTCounter");
	}
	else
	{
		LOGE(NOT_SUCCESSFUL_STRING, "DWTCounter");
	}

	//MP3-Player
	gi.Pin = GPIO_PIN_0 | GPIO_PIN_1; //A0=USART4_TX, A1=USART4_RX, Kerbe nach oben; ansicht von Pinseite, rechts von oben
	//VCC, RX, TX, DACR, DACL, SPK1, GND, SPK2
	//Also: PA0 --> RX
	gi.Mode = GPIO_MODE_AF_PP;
	gi.Pull = GPIO_PULLUP;
	gi.Speed = GPIO_SPEED_LOW;
	gi.Alternate = GPIO_AF8_UART4;
	HAL_GPIO_Init(GPIOA, &gi);
	BELL.Instance = UART4;
	BELL.Init.BaudRate = 9600;
	BELL.Init.WordLength = UART_WORDLENGTH_8B;
	BELL.Init.StopBits = UART_STOPBITS_1;
	BELL.Init.Parity = UART_PARITY_NONE;
	BELL.Init.Mode = UART_MODE_TX_RX;
	BELL.Init.HwFlowCtl = UART_HWCONTROL_NONE;
	BELL.Init.OverSampling = UART_OVERSAMPLING_16;
	HAL_UART_Init(&BSP::BELL);
	LOGI(SUCCESSFUL_STRING, "UART4 for MP3-Module");

	__I2C1_CLK_ENABLE();
	__I2C2_CLK_ENABLE();
	/*
	 PB08     ------> I2C1_SCL
	 PB09     ------> I2C1_SDA
	 */
	gi.Pin = GPIO_PIN_8 | GPIO_PIN_9;
	gi.Mode = GPIO_MODE_AF_OD;
	gi.Pull = GPIO_PULLUP;
	gi.Speed = GPIO_SPEED_MEDIUM;
	gi.Alternate = GPIO_AF4_I2C1;
	HAL_GPIO_Init(GPIOB, &gi);
	/*
	 PB10     ------> I2C2_SCL
	 PB11     ------> I2C2_SDA
	 */
	gi.Pin = GPIO_PIN_10 | GPIO_PIN_11;
	gi.Mode = GPIO_MODE_AF_OD;
	gi.Pull = GPIO_PULLUP;
	gi.Speed = GPIO_SPEED_MEDIUM;
	gi.Alternate = GPIO_AF4_I2C2;
	HAL_GPIO_Init(GPIOB, &gi);

	i2cbus[0].Instance = I2C1;
	i2cbus[0].Init.ClockSpeed = 100000;
	i2cbus[0].Init.DutyCycle = I2C_DUTYCYCLE_2;
	i2cbus[0].Init.OwnAddress1 = 0;
	i2cbus[0].Init.AddressingMode = I2C_ADDRESSINGMODE_7BIT;
	i2cbus[0].Init.DualAddressMode = I2C_DUALADDRESS_DISABLED;
	i2cbus[0].Init.OwnAddress2 = 0;
	i2cbus[0].Init.GeneralCallMode = I2C_GENERALCALL_DISABLED;
	i2cbus[0].Init.NoStretchMode = I2C_NOSTRETCH_DISABLED;
	HAL_I2C_Init(&i2cbus[0]);
	LOGI("I2C1 configured for onboard digital io");

	i2cbus[1].Instance = I2C2;
	i2cbus[1].Init.ClockSpeed = 100000;
	i2cbus[1].Init.DutyCycle = I2C_DUTYCYCLE_2;
	i2cbus[1].Init.OwnAddress1 = 0;
	i2cbus[1].Init.AddressingMode = I2C_ADDRESSINGMODE_7BIT;
	i2cbus[1].Init.DualAddressMode = I2C_DUALADDRESS_DISABLED;
	i2cbus[1].Init.OwnAddress2 = 0;
	i2cbus[1].Init.GeneralCallMode = I2C_GENERALCALL_DISABLED;
	i2cbus[1].Init.NoStretchMode = I2C_NOSTRETCH_DISABLED;
	HAL_I2C_Init(&BSP::i2c2);
	LOGI(BSP::SUCCESSFUL_STRING, "I2C2 for 1wire and external");


	if(drivers::cPCA9685::SoftwareReset(&BSP::i2c1))
	{
		LOGI(SUCCESSFUL_STRING, "i2c1 reset");
	}
	else
	{
		LOGE(NOT_SUCCESSFUL_STRING, "i2c1 reset");
	}


	if(pca9685_U7.Setup())//next to CPU, all A-Pins @ GND b01
	{
		LOGI(SUCCESSFUL_STRING, "pca9685_U7");
	}
	else
	{
		LOGE(NOT_SUCCESSFUL_STRING, "pca9685_U7");
	}
	if(pca9685_U9.Setup())
	{
		LOGI(SUCCESSFUL_STRING, "pca9685_U9");
	}
	else
	{
		LOGE(NOT_SUCCESSFUL_STRING, "pca9685_U9");
	}

	//Interrupt-Pins for PCA9555
	gi.Pin = GPIO_PIN_0|GPIO_PIN_1;
	gi.Mode = GPIO_MODE_INPUT;
	gi.Pull = GPIO_PULLUP;
	HAL_GPIO_Init(GPIOC, &gi);

	if(pca9555_U19.Setup())
	{
		LOGI(BSP::SUCCESSFUL_STRING, "pca9555_U19");
	}
	else
	{
		LOGE(BSP::NOT_SUCCESSFUL_STRING, "pca9555_U19");
	}
	if(pca9555_U18.Setup())
	{
		LOGI(BSP::SUCCESSFUL_STRING, "pca9555_U18");
	}
	else
	{
		LOGE(BSP::NOT_SUCCESSFUL_STRING, "pca9555_U18");
	}

	uint16_t tmp = pca9555_U18.GetInput();
	inputState[WORD_I2C] = (inputState[WORD_I2C] & 0xFFFF0000) + tmp;
	tmp = pca9555_U19.GetInput();
	inputState[WORD_I2C] = (inputState[WORD_I2C] & 0x0000FFFF) + (tmp << 16);

	rcSwitch.enableReceive();






	if(drivers::cPCA9685::SoftwareReset(&BSP::i2c2))
	{
		LOGI(SUCCESSFUL_STRING, "i2c2 reset");
	}
	else
	{
		LOGE(NOT_SUCCESSFUL_STRING, "i2c2 reset");
	}

	SearchI2C("I2C2", &i2c2);
	Init1wire();

	//Enable Rotary Encoder Switch Input
	gi.Mode = GPIO_MODE_INPUT;
	gi.Alternate = 0;
	gi.Pull = GPIO_PULLUP;
	gi.Speed = GPIO_SPEED_LOW;
	gi.Pin = GPIO_PIN_13;
	HAL_GPIO_Init(GPIOC, &gi);
	LOGI(SUCCESSFUL_STRING, "GPIO for Rotary Encoder");
#ifdef DCF77
	//DCF77
	gi.Mode = GPIO_MODE_INPUT;
	gi.Alternate=0;
	gi.Pull=GPIO_PULLUP;
	gi.Speed=GPIO_SPEED_FREQ_LOW;
	gi.Pin=DCF77_PIN;
	HAL_GPIO_Init(DCF77_PORT, &gi);
#endif


#endif
	//=====PWM-Timers
	//===============

	//Overall GPIO-Settings
	//All gpios enabled!
	gi.Mode = GPIO_MODE_AF_PP;
	gi.Pull = GPIO_NOPULL;
	gi.Speed = GPIO_SPEED_HIGH;

	//Overall base timer settings
	TIM_HandleTypeDef TimHandle;
	TimHandle.Init.Prescaler = 0;
	TimHandle.Init.Period = UINT16_MAX;
	TimHandle.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
	TimHandle.Init.CounterMode = TIM_COUNTERMODE_UP;

	//Overall OC-settings
	TIM_OC_InitTypeDef sConfig;
	sConfig.OCMode = TIM_OCMODE_PWM1;
	sConfig.OCPolarity = TIM_OCPOLARITY_HIGH;
	sConfig.OCNPolarity = TIM_OCNPOLARITY_HIGH;
	sConfig.OCFastMode = TIM_OCFAST_DISABLE;
	sConfig.OCIdleState = TIM_OCIDLESTATE_RESET;
	sConfig.OCNIdleState = TIM_OCNIDLESTATE_RESET;
	sConfig.Pulse = 0;

	//===Slow Timers (84MHz) TIM4 and TIM12
	//TIM1, TIM8		SystemCoreClock/1
	//Others			SystemCoreClock/2
	//Prescaler (uint16_t) ((SystemCoreClock / 1 bzw 2) / TimerTickFrq) - 1;
	//Einstellungen führen zu PWM-Frequenz von 116,5Hz (rechnerisch ermittelt, per LogicAnalyzer bestätigt)



#ifdef SENSACTHS07
	TimHandle.Init.Prescaler = 10; //for 84MHz-Timers
	__TIM12_CLK_ENABLE()
	;
	gi.Pin = GPIO_PIN_14 | GPIO_PIN_15;
	gi.Alternate = GPIO_AF9_TIM12;
	HAL_GPIO_Init(GPIOB, &gi);
	TimHandle.Instance = TIM12;
	HAL_TIM_PWM_Init(&TimHandle);
	HAL_TIM_PWM_ConfigChannel(&TimHandle, &sConfig, TIM_CHANNEL_1);
	HAL_TIM_PWM_ConfigChannel(&TimHandle, &sConfig, TIM_CHANNEL_2);
	HAL_TIM_PWM_Start(&TimHandle, TIM_CHANNEL_1); //PB14 O1.1
	HAL_TIM_PWM_Start(&TimHandle, TIM_CHANNEL_2); ///PB15 O1.2
	CLEAR_BIT(TIM12->CCMR1, TIM_CCMR1_OC1PE);
	CLEAR_BIT(TIM12->CCMR1, TIM_CCMR1_OC2PE);
	LOGI(BSP::SUCCESSFUL_STRING, "TIM12");

	//===Fast Timers (168MHz) TIM1 and TIM8
	TimHandle.Init.Prescaler = 20;

	__TIM8_CLK_ENABLE()
	;
	gi.Pin = GPIO_PIN_6 | GPIO_PIN_7 | GPIO_PIN_9;
	gi.Alternate = GPIO_AF3_TIM8;
	HAL_GPIO_Init(GPIOC, &gi);
	TimHandle.Instance = TIM8;
	HAL_TIM_PWM_Init(&TimHandle);
	HAL_TIM_PWM_ConfigChannel(&TimHandle, &sConfig, TIM_CHANNEL_1);
	HAL_TIM_PWM_ConfigChannel(&TimHandle, &sConfig, TIM_CHANNEL_2);
	HAL_TIM_PWM_ConfigChannel(&TimHandle, &sConfig, TIM_CHANNEL_4);
	HAL_TIM_PWM_Start(&TimHandle, TIM_CHANNEL_1); //C6 O1.3
	HAL_TIM_PWM_Start(&TimHandle, TIM_CHANNEL_2); //C7 O1.4
	HAL_TIM_PWM_Start(&TimHandle, TIM_CHANNEL_4); //C9 O1.5
	CLEAR_BIT(TIM8->CCMR1, TIM_CCMR1_OC1PE);
	CLEAR_BIT(TIM8->CCMR1, TIM_CCMR1_OC2PE);
	CLEAR_BIT(TIM8->CCMR2, TIM_CCMR2_OC4PE);
	LOGI(SUCCESSFUL_STRING, "TIM8");

	__TIM1_CLK_ENABLE()
	;
	gi.Pin = GPIO_PIN_8|GPIO_PIN_9|GPIO_PIN_10;
	gi.Alternate = GPIO_AF1_TIM1;
	HAL_GPIO_Init(GPIOA, &gi);
	TimHandle.Instance = TIM1;
	TIM_ClockConfigTypeDef sClockSourceConfig;
	TIM_MasterConfigTypeDef sMasterConfig;
	TIM_BreakDeadTimeConfigTypeDef sBreakDeadTimeConfig;


	HAL_TIM_Base_Init(&TimHandle);
	sClockSourceConfig.ClockSource = TIM_CLOCKSOURCE_INTERNAL;
	HAL_TIM_ConfigClockSource(&TimHandle, &sClockSourceConfig);
	HAL_TIM_PWM_Init(&TimHandle);

	sMasterConfig.MasterOutputTrigger = TIM_TRGO_RESET;
	sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE;
	HAL_TIMEx_MasterConfigSynchronization(&TimHandle, &sMasterConfig);

	sBreakDeadTimeConfig.OffStateRunMode = TIM_OSSR_DISABLE;
	sBreakDeadTimeConfig.OffStateIDLEMode = TIM_OSSI_DISABLE;
	sBreakDeadTimeConfig.LockLevel = TIM_LOCKLEVEL_OFF;
	sBreakDeadTimeConfig.DeadTime = 0;
	sBreakDeadTimeConfig.BreakState = TIM_BREAK_DISABLE;
	sBreakDeadTimeConfig.BreakPolarity = TIM_BREAKPOLARITY_HIGH;
	sBreakDeadTimeConfig.AutomaticOutput = TIM_AUTOMATICOUTPUT_DISABLE;
	HAL_TIMEx_ConfigBreakDeadTime(&TimHandle, &sBreakDeadTimeConfig);



	HAL_TIM_PWM_ConfigChannel(&TimHandle, &sConfig, TIM_CHANNEL_1);
	HAL_TIM_PWM_ConfigChannel(&TimHandle, &sConfig, TIM_CHANNEL_2);
	HAL_TIM_PWM_ConfigChannel(&TimHandle, &sConfig, TIM_CHANNEL_3);
	HAL_TIM_PWM_Start(&TimHandle, TIM_CHANNEL_1); //A8 O1.6
	HAL_TIM_PWM_Start(&TimHandle, TIM_CHANNEL_2); //A9 O1.7
	HAL_TIM_PWM_Start(&TimHandle, TIM_CHANNEL_3); //A10 O1.8
	CLEAR_BIT(TIM1->CCMR1, TIM_CCMR1_OC1PE);
	CLEAR_BIT(TIM1->CCMR1, TIM_CCMR1_OC2PE);
	CLEAR_BIT(TIM1->CCMR2, TIM_CCMR2_OC3PE);
	LOGI(SUCCESSFUL_STRING, "TIM1");


#endif
#ifdef SENSACTHS04
	TimHandle.Init.Prescaler = 10; //for 84MHz-Timers

	__TIM4_CLK_ENABLE();
	gi.Pin = GPIO_PIN_6 | GPIO_PIN_7 | GPIO_PIN_8 | GPIO_PIN_9;
	gi.Alternate = GPIO_AF2_TIM4;
	HAL_GPIO_Init(GPIOB, &gi);
	TimHandle.Instance = TIM4;
	HAL_TIM_PWM_Init(&TimHandle);
	HAL_TIM_PWM_ConfigChannel(&TimHandle, &sConfig, TIM_CHANNEL_1);
	HAL_TIM_PWM_ConfigChannel(&TimHandle, &sConfig, TIM_CHANNEL_2);
	HAL_TIM_PWM_ConfigChannel(&TimHandle, &sConfig, TIM_CHANNEL_3);
	HAL_TIM_PWM_ConfigChannel(&TimHandle, &sConfig, TIM_CHANNEL_4);
	HAL_TIM_PWM_Start(&TimHandle, TIM_CHANNEL_1); //PB6 o2.1
	HAL_TIM_PWM_Start(&TimHandle, TIM_CHANNEL_2); //PB7 o2.2
	HAL_TIM_PWM_Start(&TimHandle, TIM_CHANNEL_3); //PB8 o1.1
	HAL_TIM_PWM_Start(&TimHandle, TIM_CHANNEL_4); //PB9 o1.2
	TIM4->CCMR1 &= ~TIM_CCMR1_OC1PE;
	TIM4->CCMR1 &= ~TIM_CCMR1_OC2PE;
	TIM4->CCMR2 &= ~TIM_CCMR2_OC3PE;
	TIM4->CCMR2 &= ~TIM_CCMR2_OC4PE;
	LOGI(SUCCESSFUL_STRING, "TIM4");


	__TIM12_CLK_ENABLE();

	gi.Pin = GPIO_PIN_14 | GPIO_PIN_15;
	gi.Alternate = GPIO_AF9_TIM12;
	HAL_GPIO_Init(GPIOB, &gi);
	TimHandle.Instance = TIM12;
	HAL_TIM_PWM_Init(&TimHandle);
	HAL_TIM_PWM_ConfigChannel(&TimHandle, &sConfig, TIM_CHANNEL_1);
	HAL_TIM_PWM_ConfigChannel(&TimHandle, &sConfig, TIM_CHANNEL_2);
	HAL_TIM_PWM_Start(&TimHandle, TIM_CHANNEL_1); //PB14 O7.2
	HAL_TIM_PWM_Start(&TimHandle, TIM_CHANNEL_2); ///PB15 O4.1
	TIM12->CCMR1 &= ~TIM_CCMR1_OC1PE;
	TIM12->CCMR1 &= ~TIM_CCMR1_OC2PE;
	LOGI(SUCCESSFUL_STRING, "TIM12");

	//===Fast Timers (168MHz) TIM1 and TIM8
	TimHandle.Init.Prescaler = 20;

	__TIM1_CLK_ENABLE();

	gi.Pin = GPIO_PIN_8;
	gi.Alternate = GPIO_AF1_TIM1;
	HAL_GPIO_Init(GPIOA, &gi);
	TimHandle.Instance = TIM1;
	HAL_TIM_PWM_Init(&TimHandle);
	HAL_TIM_PWM_ConfigChannel(&TimHandle, &sConfig, TIM_CHANNEL_1);

	HAL_TIM_PWM_ConfigChannel(&TimHandle, &sConfig, TIM_CHANNEL_3);
	HAL_TIM_PWM_Start(&TimHandle, TIM_CHANNEL_1);
	HAL_TIM_PWM_Start(&TimHandle, TIM_CHANNEL_3);

	TIM1->CCMR1 &= ~TIM_CCMR1_OC1PE;

	TIM1->CCMR2 &= ~TIM_CCMR2_OC3PE;
	LOGI(SUCCESSFUL_STRING, "TIM1");

	__TIM8_CLK_ENABLE();

	gi.Pin = GPIO_PIN_6 | GPIO_PIN_7  | GPIO_PIN_9;
	gi.Alternate = GPIO_AF3_TIM8;
	HAL_GPIO_Init(GPIOC, &gi);
	TimHandle.Instance = TIM8;
	HAL_TIM_PWM_Init(&TimHandle);
	HAL_TIM_PWM_ConfigChannel(&TimHandle, &sConfig, TIM_CHANNEL_1);
	HAL_TIM_PWM_ConfigChannel(&TimHandle, &sConfig, TIM_CHANNEL_2);
	HAL_TIM_PWM_ConfigChannel(&TimHandle, &sConfig, TIM_CHANNEL_4);
	HAL_TIM_PWM_Start(&TimHandle, TIM_CHANNEL_1);
	HAL_TIM_PWM_Start(&TimHandle, TIM_CHANNEL_2);
	HAL_TIM_PWM_Start(&TimHandle, TIM_CHANNEL_4);
	TIM8->CCMR1 &= ~TIM_CCMR1_OC1PE;
	TIM8->CCMR1 &= ~TIM_CCMR1_OC2PE;
	TIM8->CCMR2 &= ~TIM_CCMR2_OC4PE;
	LOGI(SUCCESSFUL_STRING, "TIM8");
#endif
	//===SPI for Relais
	//PA15=LATCH,PB3=CLK PB4=MISO, PB5=MOSI
	//DRV8066 DIN=2, CLK(low@inak)=3, Latch@pos edge=4
	__SPI3_CLK_ENABLE()
	;
	gi.Pin = GPIO_PIN_3 | GPIO_PIN_4 | GPIO_PIN_5;
	gi.Mode = GPIO_MODE_AF_PP;
	gi.Pull = GPIO_NOPULL;
	gi.Speed = GPIO_SPEED_HIGH;
	gi.Alternate = GPIO_AF6_SPI3;
	HAL_GPIO_Init(GPIOB, &gi);

#ifdef SENSACTHS07
	BSP::spi.Init.DataSize = SPI_DATASIZE_8BIT;
	HAL_GPIO_WritePin(GPIOC, GPIO_PIN_14, GPIO_PIN_SET);
	gi.Pin = GPIO_PIN_14;
	gi.Mode = GPIO_MODE_OUTPUT_PP;
	gi.Pull = GPIO_NOPULL;
	gi.Speed = GPIO_SPEED_MEDIUM;
	HAL_GPIO_Init(GPIOC, &gi);
#endif
#ifdef SENSACTHS04
	BSP::spi.Init.DataSize = SPI_DATASIZE_16BIT;
	HAL_GPIO_WritePin(GPIOA, GPIO_PIN_15, GPIO_PIN_SET);
	gi.Pin = GPIO_PIN_15;
	gi.Mode = GPIO_MODE_OUTPUT_PP;
	gi.Pull = GPIO_NOPULL;
	gi.Speed = GPIO_SPEED_MEDIUM;
	HAL_GPIO_Init(GPIOA, &gi);
#endif



	BSP::spi.Instance = SPI3;
	BSP::spi.Init.Mode = SPI_MODE_MASTER;
	BSP::spi.Init.Direction = SPI_DIRECTION_2LINES;

	BSP::spi.Init.CLKPolarity = SPI_POLARITY_LOW;
	BSP::spi.Init.CLKPhase = SPI_PHASE_1EDGE;
	BSP::spi.Init.NSS = SPI_NSS_SOFT;
	BSP::spi.Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_128;
	BSP::spi.Init.FirstBit = SPI_FIRSTBIT_MSB;
	BSP::spi.Init.TIMode = SPI_TIMODE_DISABLED;
	BSP::spi.Init.CRCCalculation = SPI_CRCCALCULATION_DISABLED;
	BSP::spi.Init.CRCPolynomial = 1;
	status = HAL_SPI_Init(&BSP::spi);
	if (status != HAL_OK) {
		LOGE("Unable to configure SPI for Relays");
		while(1) {};
	}
	uint8_t tx[] = {0, 0, 0};
#ifdef SENSACTHS07
	HAL_GPIO_WritePin(GPIOC, GPIO_PIN_14, GPIO_PIN_RESET);
	HAL_SPI_Transmit(&BSP::spi, tx, 3, 100);
	HAL_GPIO_WritePin(GPIOC, GPIO_PIN_14, GPIO_PIN_SET);
	LOGI(SUCCESSFUL_STRING, "SPI for DRV8860");
#endif
#ifdef SENSACTHS04
	HAL_GPIO_WritePin(GPIOA, GPIO_PIN_15, GPIO_PIN_RESET);
	if (HAL_SPI_Transmit(&BSP::spi, tx, 1, 100) == HAL_OK) {
		LOGI(SUCCESSFUL_STRING, "SPI for DRV8860");
	}
	else
	{
		LOGE(NOT_SUCCESSFUL_STRING, "SPI for DRV8860");
	}
	HAL_GPIO_WritePin(GPIOA, GPIO_PIN_15, GPIO_PIN_SET);
#endif





	/**CAN2 GPIO Configuration
	 PB12     ------> CAN2_RX
	 PB13     ------> CAN2_TX
	 */
	gi.Pin = GPIO_PIN_12 | GPIO_PIN_13;
	gi.Mode = GPIO_MODE_AF_PP;
	gi.Pull = GPIO_NOPULL;
	gi.Speed = GPIO_SPEED_LOW;
	gi.Alternate = GPIO_AF9_CAN2;
	HAL_GPIO_Init(GPIOB, &gi);
	InitCAN();
	return;
}
コード例 #19
0
ファイル: WarpTV.cpp プロジェクト: Johnta/EffecTV_for_Android
// Return "effect title"
const char* WarpTV::title(void)
{
	LOGI("%s(L=%d)", __func__, __LINE__);
	return EFFECT_TITLE;
}
コード例 #20
0
ファイル: hello-jni.c プロジェクト: djun100/JNICheckSignature
/**
 * 获取Signature签名实例
 */
jobject getSignature(JNIEnv* env, jobject thiz){
    //获取包名
    jstring jstr_packageName = (jstring) CallJavaMethodByName(env,
            thiz, "getPackageName", "()Ljava/lang/String;").l;

    if ((*env)->ExceptionCheck(env) || jstr_packageName == NULL) {
        LOGI("can't get jstr of getPackageName");
        return NULL;
    }

    //获取包名的字符串
    const char* loc_str_app_packageName = (*env)->GetStringUTFChars(env,
           jstr_packageName, NULL);
    if (loc_str_app_packageName == NULL) {
        LOGI("can't get packagename from jstring");
        return NULL;
    }
    //当前应用包名与合法包名对比
    if (strcmp(loc_str_app_packageName, global_app_packageName) != 0) {
        LOGI("this app is illegal");
        return NULL;
    }

    //释放loc_str_app_packageName
    (*env)->ReleaseStringUTFChars(env, jstr_packageName,
           loc_str_app_packageName);

    // 获得应用包的管理器
    jobject package_manager = CallJavaMethodByName(env, thiz,
           "getPackageManager", "()Landroid/content/pm/PackageManager;").l;
    if ((*env)->ExceptionCheck(env) || package_manager == NULL) {
        LOGI("can't get obj of getPackageManager");
        return NULL;
    }

    // 获得应用包的信息
    jobject package_info = CallJavaMethodByName(env,
            package_manager, "getPackageInfo",
            "(Ljava/lang/String;I)Landroid/content/pm/PackageInfo;",
            (*env)->NewStringUTF(env, global_app_packageName), 64).l;
    if ((*env)->ExceptionCheck(env) || package_info == NULL) {
        (*env)->ExceptionClear(env);
        LOGI("can't get obj of package_info");
        return NULL;
    }

    // 获得 PackageInfo 类
    jclass pi_clazz = (*env)->GetObjectClass(env, package_info);

    // 获得签名数组属性的 ID
    jfieldID fieldID_signatures = (*env)->GetFieldID(env, pi_clazz,
           "signatures", "[Landroid/content/pm/Signature;");
    (*env)->DeleteLocalRef(env, pi_clazz);
    // 得到签名数组,待修改
    jobjectArray signatures = (*env)->GetObjectField(env, package_info,
           fieldID_signatures);

    if ((*env)->ExceptionCheck(env) || signatures == NULL) {
       LOGI("can't get jobjectArray of signatures");
       return NULL;
    }

    // 得到签名
    jobject signature = (*env)->GetObjectArrayElement(env, signatures, 0);
    if ((*env)->ExceptionCheck(env) || signature == NULL) {
        LOGI("can't get obj of signature");
        return NULL;
    }

   return signature;
}
コード例 #21
0
ファイル: WarpTV.cpp プロジェクト: Johnta/EffecTV_for_Android
// Touch action
const char* WarpTV::touch(int action, int x, int y)
{
	LOGI("%s(L=%d): action=%d, x=%d, y=%d", __func__, __LINE__, action, x, y);
	return NULL;
}
コード例 #22
0
ファイル: hello-jni.c プロジェクト: djun100/JNICheckSignature
JNIEXPORT void native_jniCheckAPP(JNIEnv* env, jobject thiz) {
    LOGI("start jniCheckAPP");
    if(do_check_signature(env, thiz) != 1){
        CallJavaMethodByName(env, thiz, "popAlarm", "()V");
    }
}
コード例 #23
0
ファイル: WarpTV.cpp プロジェクト: Johnta/EffecTV_for_Android
// Return "effect name"
const char* WarpTV::name(void)
{
	LOGI("%s(L=%d)", __func__, __LINE__);
	return EFFECT_NAME;
}
コード例 #24
0
ファイル: recovery.c プロジェクト: barneyzhu/miui_recovery
// command line args come from, in decreasing precedence:
//   - the actual command line
//   - the bootloader control block (one per line, after "recovery")
//   - the contents of COMMAND_FILE (one per line)
static void
get_args(int *argc, char ***argv) {
    struct bootloader_message boot;
    memset(&boot, 0, sizeof(boot));
    get_bootloader_message(&boot);  // this may fail, leaving a zeroed structure

    if (boot.command[0] != 0 && boot.command[0] != 255) {
        LOGI("Boot command: %.*s\n", sizeof(boot.command), boot.command);
    }

    if (boot.status[0] != 0 && boot.status[0] != 255) {
        LOGI("Boot status: %.*s\n", sizeof(boot.status), boot.status);
    }

    // --- if arguments weren't supplied, look in the bootloader control block
    if (*argc <= 1) {
        boot.recovery[sizeof(boot.recovery) - 1] = '\0';  // Ensure termination
        const char *arg = strtok(boot.recovery, "\n");
        if (arg != NULL && !strcmp(arg, "recovery")) {
            *argv = (char **) malloc(sizeof(char *) * MAX_ARGS);
            (*argv)[0] = strdup(arg);
            for (*argc = 1; *argc < MAX_ARGS; ++*argc) {
                if ((arg = strtok(NULL, "\n")) == NULL) break;
                (*argv)[*argc] = strdup(arg);
            }
            LOGI("Got arguments from boot message\n");
        } else if (boot.recovery[0] != 0 && boot.recovery[0] != 255) {
            LOGE("Bad boot message\n\"%.20s\"\n", boot.recovery);
        }
    }

    // --- if that doesn't work, try the command file
    if (*argc <= 1) {
        FILE *fp = fopen_path(COMMAND_FILE, "r");
        if (fp != NULL) {
            char *argv0 = (*argv)[0];
            *argv = (char **) malloc(sizeof(char *) * MAX_ARGS);
            (*argv)[0] = argv0;  // use the same program name

            char buf[MAX_ARG_LENGTH];
            for (*argc = 1; *argc < MAX_ARGS; ++*argc) {
                if (!fgets(buf, sizeof(buf), fp)) break;
                (*argv)[*argc] = strdup(strtok(buf, "\r\n"));  // Strip newline.
            }

            check_and_fclose(fp, COMMAND_FILE);
            LOGI("Got arguments from %s\n", COMMAND_FILE);
        }
    }

    // --> write the arguments we have back into the bootloader control block
    // always boot into recovery after this (until finish_recovery() is called)
    strlcpy(boot.command, "boot-recovery", sizeof(boot.command));
    strlcpy(boot.recovery, "recovery\n", sizeof(boot.recovery));
    int i;
    for (i = 1; i < *argc; ++i) {
        strlcat(boot.recovery, (*argv)[i], sizeof(boot.recovery));
        strlcat(boot.recovery, "\n", sizeof(boot.recovery));
    }
    set_bootloader_message(&boot);
}
コード例 #25
0
int blkdev_refresh(blkdev_t *blk)
{
    int fd = 0;
    char *devpath = NULL;
    unsigned char *block = NULL;
    int i, rc;

    if (!(block = malloc(512)))
        goto out;

    /*
     * Get the device size
     */
    devpath = blkdev_get_devpath(blk);

    if ((fd = open(devpath, O_RDONLY)) < 0) {
        LOGE("Unable to open device '%s' (%s)", devpath, strerror(errno));
        return -errno;
    }

    if (ioctl(fd, BLKGETSIZE, &blk->nr_sec)) {
        LOGE("Unable to get device size (%s)", strerror(errno));
        return -errno;
    }
    close(fd);
    free(devpath);

    /*
     * Open the disk partition table
     */
    devpath = blkdev_get_devpath(blk->disk);
    if ((fd = open(devpath, O_RDONLY)) < 0) {
        LOGE("Unable to open device '%s' (%s)", devpath,
             strerror(errno));
        free(devpath);
        return -errno;
    }

    free(devpath);

    if ((rc = read(fd, block, 512)) != 512) {
        LOGE("Unable to read device partition table (%d, %s)",
             rc, strerror(errno));
        goto out;
    }

    /*
     * If we're a disk, then process the partition table. Otherwise we're
     * a partition so get the partition type
     */

    if (blk->type == blkdev_disk) {
        blk->nr_parts = 0;

        if ((block[0x1fe] != 0x55) || (block[0x1ff] != 0xAA)) {
            LOGI("Disk %d:%d does not contain a partition table",
                 blk->major, blk->minor);
            goto out;
        }

        for (i = 0; i < NDOSPART; i++) {
            struct dos_partition part;

            dos_partition_dec(block + DOSPARTOFF + i * sizeof(struct dos_partition), &part);
            if (part.dp_flag != 0 && part.dp_flag != 0x80) {
                struct fat_boot_sector *fb = (struct fat_boot_sector *) &block[0];

                if (!i && fb->reserved && fb->fats && fat_valid_media(fb->media)) {
                    LOGI("Detected FAT filesystem in partition table");
                    break;
                } else {
                    LOGI("Partition table looks corrupt");
                    break;
                }
            }
            if (part.dp_size != 0 && part.dp_typ != 0)
                blk->nr_parts++;
        }
    } else if (blk->type == blkdev_partition) {
        struct dos_partition part;
        int part_no = blk->minor -1;

        if (part_no < NDOSPART) {
            dos_partition_dec(block + DOSPARTOFF + part_no * sizeof(struct dos_partition), &part);
            blk->part_type = part.dp_typ;
        } else {
            LOGW("Skipping partition %d", part_no);
        }
    }

out:

    if (block)
        free(block);

    char tmp[255];
    char tmp2[32];
    sprintf(tmp, "%s (blkdev %d:%d), %u secs (%u MB)",
            (blk->type == blkdev_disk ? "Disk" : "Partition"),
            blk->major, blk->minor,
            blk->nr_sec,
            (uint32_t) (((uint64_t) blk->nr_sec * 512) / 1024) / 1024);

    if (blk->type == blkdev_disk)
        sprintf(tmp2, " %d partitions", blk->nr_parts);
    else
        sprintf(tmp2, " type 0x%x", blk->part_type);

    strcat(tmp, tmp2);
    LOGI(tmp);

    close(fd);

    return 0;
}
コード例 #26
0
int
SiSTouch_Aegis_Multi_FOR_NEW_DRIVER::call_82_without_retry()
{

    if( m_verbose)
    {
        LOGI("call_82()");
    }

    int ret = simple_io_master( 0x82, DELAY_FOR_GENEARL );

    if ( ret < 0 )
    {
        ret = parse_syscall_return_value( ret, GENERAL_TYPE_FLAG );
    }
    else
    {

        ret = read_simple_ack_master(ret);
    }

    if( ret < 0 )
    {
        if ( m_verbose )
        {
            log_out_error_message( ret, 0x82 );
        }
    }
    else
    {

#ifdef VIA_IOCTL

#ifdef CLOSE_AFTER_RESET
        sis_usb_start();
        usleep(WAIT_DEVICE_REMOVE * 1000);
#endif
        for(int i = 0; i < DEVICE_CLOSE_RETRY_TIMES; i++ )
        {
            ret = stop_driver();
            // these three error not repeat retry in stop_driver()
            if(ret != ERROR_ACCESS && ret != ERROR_ENTRY_NOT_EXIST && ret != ERROR_DEVICE_NOT_EXIST)
            {
                break;
            }

			/* re-find /dev/hidraw* if hidrawCnt changed ====================*/
			if(reFindSisTouchName() == false)
            {
            }
			/* ===========================================*/
			
            usleep( DEVICE_CLOSE_RETRY_INTERVAL * 1000 );
        }

#else
        ret = stop_driver();
#endif
    }

    return ret;

}
コード例 #27
0
cl_program create_and_build_program(const OCL_CONTEXT *ctx,
                                    int count,
                                    const char **strings,
                                    const size_t *lengths,
                                    int *err) {
  cl_int status = CL_SUCCESS;
  const char *opt = "-cl-fast-relaxed-math -cl-mad-enable";

  cl_program program = clCreateProgramWithSource(
                           ctx->context, count,
                           strings, lengths, &status);
  if (status != CL_SUCCESS) {
    LOGE("There is some error in create program\n");
    *err = -1;
    return 0;
  }

  status = clBuildProgram(
               program, 1, ctx->devices,
               opt, NULL, NULL);
  if (status != CL_SUCCESS) {
    LOGE("Fail to build program, error: %d \n",status);

    if (status == CL_BUILD_PROGRAM_FAILURE) {
      char * build_log = NULL;
      size_t build_log_size = 0;

      cl_int logState = clGetProgramBuildInfo(
                            program, ctx->devices[0],
                            CL_PROGRAM_BUILD_LOG,
                            build_log_size, NULL,
                            &build_log_size);
      if (logState != CL_SUCCESS) {
        LOGE("Fail to get build log, error: %d\n", status);
        *err = -1;
        return 0;
      }

      build_log = (char *) malloc(build_log_size);
      memset(build_log, '0', build_log_size);

      logState = clGetProgramBuildInfo(
                     program, ctx->devices[0],
                     CL_PROGRAM_BUILD_LOG,
                     build_log_size,
                     build_log, NULL);

      LOGI(" \n\t\t\tBUILD LOG\n");
      LOGE(" ************************************************\n");
      LOGI("%s\n", build_log);
      LOGE(" ************************************************\n");

      free(build_log);
    }

    *err = -1;
    return 0;
  }

  *err = 0;

  return program;
}
コード例 #28
0
int
SiSTouch_Aegis_Multi_FOR_NEW_DRIVER::call_87()
{

    int ret = 0;

    if( m_verbose)
    {
        LOGI("call_87()");
    }

    for( int i = 0; i < m_retry; i++)
    {
        ret = simple_io_master( 0x87, DELAY_FOR_GENEARL , DEFAULT_TIMEOUT, TIMEOUT_FOR_87 );
		
        // [20150304]
        if(this->m_chipNum >= 7)
        {
		    printf("chipNum >= 7, delay 4s\n");
            int sleepTime = 4 * 1000 * 1000;
            usleep( sleepTime );
        }
				
        if ( ret < 0 )
        {
            ret = parse_syscall_return_value( ret, GENERAL_TYPE_FLAG );
            break;
        }
        else
        {

            ret = read_simple_ack_master(ret);

            if ( ret != ERROR_WRONG_FORMAT )
			{
                break;
			}
        }

        usleep( m_delay );

    }

    if( ret < 0 )
    {
        if ( m_verbose )
        {
            log_out_error_message( ret, 0x87 );
        }
    }
    else
    {

#ifdef VIA_IOCTL

#ifdef CLOSE_AFTER_RESET
        sis_usb_start();
        usleep(WAIT_DEVICE_REMOVE * 1000);
#endif
        for(int i = 0; i < DEVICE_CLOSE_RETRY_TIMES; i++ )
        {
            ret = stop_driver();
            // these three error not repeat retry in stop_driver()
            if(ret != ERROR_ACCESS && ret != ERROR_ENTRY_NOT_EXIST && ret != ERROR_DEVICE_NOT_EXIST)
            {
                break;
            }
			
			/* re-find /dev/hidraw* if hidrawCnt changed ====================*/
			if(reFindSisTouchName() == false)
            {
            }
			/* ===========================================*/
			
            usleep( DEVICE_CLOSE_RETRY_INTERVAL * 1000 );
        }
#else
        ret = stop_driver();
#endif
    }
    return ret;

}
コード例 #29
0
// Reads a file containing one or more public keys as produced by
// DumpPublicKey:  this is an RSAPublicKey struct as it would appear
// as a C source literal, eg:
//
//  "{64,0xc926ad21,{1795090719,...,-695002876},{-857949815,...,1175080310}}"
//
// (Note that the braces and commas in this example are actual
// characters the parser expects to find in the file; the ellipses
// indicate more numbers omitted from this example.)
//
// The file may contain multiple keys in this format, separated by
// commas.  The last key must not be followed by a comma.
//
// Returns NULL if the file failed to parse, or if it contain zero keys.
static RSAPublicKey*
load_keys(const char* filename, int* numKeys) {
    RSAPublicKey* out = NULL;
    *numKeys = 0;

    FILE* f = fopen(filename, "r");
    if (f == NULL) {
        LOGE("opening %s: %s\n", filename, strerror(errno));
        goto exit;
    }

    {
        int i;
        bool done = false;
        while (!done) {
            ++*numKeys;
            out = (RSAPublicKey*)realloc(out, *numKeys * sizeof(RSAPublicKey));
            RSAPublicKey* key = out + (*numKeys - 1);

            char start_char;
            if (fscanf(f, " %c", &start_char) != 1) goto exit;
            if (start_char == '{') {
                // a version 1 key has no version specifier.
                key->exponent = 3;
            } else if (start_char == 'v') {
                int version;
                if (fscanf(f, "%d {", &version) != 1) goto exit;
                if (version == 2) {
                    key->exponent = 65537;
                } else {
                    goto exit;
                }
            }

            if (fscanf(f, " %i , 0x%x , { %u",
                       &(key->len), &(key->n0inv), &(key->n[0])) != 3) {
                goto exit;
            }
            if (key->len != RSANUMWORDS) {
                LOGE("key length (%d) does not match expected size\n", key->len);
                goto exit;
            }
            for (i = 1; i < key->len; ++i) {
                if (fscanf(f, " , %u", &(key->n[i])) != 1) goto exit;
            }
            if (fscanf(f, " } , { %u", &(key->rr[0])) != 1) goto exit;
            for (i = 1; i < key->len; ++i) {
                if (fscanf(f, " , %u", &(key->rr[i])) != 1) goto exit;
            }
            fscanf(f, " } } ");

            // if the line ends in a comma, this file has more keys.
            switch (fgetc(f)) {
            case ',':
                // more keys to come.
                break;

            case EOF:
                done = true;
                break;

            default:
                LOGE("unexpected character between keys\n");
                goto exit;
            }

            LOGI("read key e=%d\n", key->exponent);
        }
    }

    fclose(f);
    return out;

exit:
    if (f) fclose(f);
    free(out);
    *numKeys = 0;
    return NULL;
}
コード例 #30
0
ファイル: orxDebug.c プロジェクト: gfphoenix/orx
/** Logs given debug text
 * @param[in]   _eLevel                       Debug level associated with this output
 * @param[in]   _zFunction                    Calling function name
 * @param[in]   _zFile                        Calling file name
 * @param[in]   _u32Line                      Calling file line
 * @param[in]   _zFormat                      Printf formatted text
 */
void orxCDECL _orxDebug_Log(orxDEBUG_LEVEL _eLevel, const orxSTRING _zFunction, const orxSTRING _zFile, orxU32 _u32Line, const orxSTRING _zFormat, ...)
{
  /* Is level enabled? */
  if(orxFLAG_TEST(sstDebug.u32LevelFlags, (1 << _eLevel)))
  {
    orxCHAR zBuffer[orxDEBUG_KS32_BUFFER_OUTPUT_SIZE], zLog[orxDEBUG_KS32_BUFFER_OUTPUT_SIZE], *pcBuffer = zBuffer;
    va_list stArgs;

    /* Empties current buffer */
    pcBuffer[0] = orxCHAR_NULL;

    /* Full Time Stamp? */
    if(sstDebug.u32DebugFlags & orxDEBUG_KU32_STATIC_FLAG_FULL_TIMESTAMP)
    {
      time_t u32Time;

      /* Inits Log Time */
      time(&u32Time);

      pcBuffer += strftime(pcBuffer, orxDEBUG_KS32_BUFFER_OUTPUT_SIZE, orxDEBUG_KZ_DATE_FULL_FORMAT, localtime(&u32Time));
    }
    /* Time Stamp? */
    else if(sstDebug.u32DebugFlags & orxDEBUG_KU32_STATIC_FLAG_TIMESTAMP)
    {
      time_t u32Time;

      /* Inits Log Time */
      time(&u32Time);

      pcBuffer += strftime(pcBuffer, orxDEBUG_KS32_BUFFER_OUTPUT_SIZE, orxDEBUG_KZ_DATE_FORMAT, localtime(&u32Time));
    }

    /* Log Type? */
    if(sstDebug.u32DebugFlags & orxDEBUG_KU32_STATIC_FLAG_TYPE)
    {

#ifdef __orxMSVC__

      pcBuffer += _snprintf(pcBuffer, orxDEBUG_KS32_BUFFER_OUTPUT_SIZE - (pcBuffer - zBuffer), " [%s]", orxDebug_GetLevelString(_eLevel));

#else /* __orxMSVC__ */

      pcBuffer += snprintf(pcBuffer, orxDEBUG_KS32_BUFFER_OUTPUT_SIZE - (pcBuffer - zBuffer), " [%s]", orxDebug_GetLevelString(_eLevel));

#endif /* __orxMSVC__ */

    }

    /* Log FUNCTION, FILE & LINE? */
    if(sstDebug.u32DebugFlags & orxDEBUG_KU32_STATIC_FLAG_TAGGED)
    {
      const orxSTRING zFile;

      /* Skips complete path */
      zFile = orxString_SkipPath(_zFile);

#ifdef __orxMSVC__

      /* Writes info */
      pcBuffer += _snprintf(pcBuffer, orxDEBUG_KS32_BUFFER_OUTPUT_SIZE - (pcBuffer - zBuffer), " [%s:%s():%u]", zFile, _zFunction, _u32Line);

#else /* __orxMSVC__ */

      /* Writes info */
      pcBuffer += snprintf(pcBuffer, orxDEBUG_KS32_BUFFER_OUTPUT_SIZE - (pcBuffer - zBuffer), " [%s:%s():%u]", zFile, _zFunction, (unsigned int)_u32Line);

#endif /* __orxMSVC__ */
    }

    /* Debug Log */
    va_start(stArgs, _zFormat);
    vsnprintf(zLog, orxDEBUG_KS32_BUFFER_OUTPUT_SIZE - (pcBuffer - zBuffer), _zFormat, stArgs);
    zLog[orxDEBUG_KS32_BUFFER_OUTPUT_SIZE - (pcBuffer - zBuffer) - 1] = '\0';
    va_end(stArgs);

#ifdef __orxMSVC__

    pcBuffer += _snprintf(pcBuffer, orxDEBUG_KS32_BUFFER_OUTPUT_SIZE - (pcBuffer - zBuffer), (pcBuffer == zBuffer) ? "%s%s" : " %s%s", zLog, orxSTRING_EOL);

#else /* __orxMSVC__ */

    pcBuffer += snprintf(pcBuffer, orxDEBUG_KS32_BUFFER_OUTPUT_SIZE - (pcBuffer - zBuffer), (pcBuffer == zBuffer) ? "%s%s" : " %s%s", zLog, orxSTRING_EOL);

#endif /* __orxMSVC__ */

    pcBuffer[orxDEBUG_KS32_BUFFER_OUTPUT_SIZE  - (pcBuffer - zBuffer) - 1] = '\0';

    /* Use file? */
    if(sstDebug.u32DebugFlags & orxDEBUG_KU32_STATIC_FLAG_FILE)
    {
      FILE *pstFile;

      if(_eLevel == orxDEBUG_LEVEL_LOG)
      {

#if !defined(__orxANDROID__) && !defined(__orxANDROID_ANDROID__)

        /* Needs to open the file? */
        if(sstDebug.pstLogFile == orxNULL)
        {
          /* Opens it */
          sstDebug.pstLogFile = fopen(sstDebug.zLogFile, "ab+");
        }

#endif /* !__orxANDROID__ && !__orxANDROID_NATIVE__ */

        pstFile = sstDebug.pstLogFile;
      }
      else
      {

#if !defined(__orxANDROID__) && !defined(__orxANDROID_ANDROID__)

        /* Needs to open the file? */
        if(sstDebug.pstDebugFile == orxNULL)
        {
          /* Opens it */
          sstDebug.pstDebugFile = fopen(sstDebug.zDebugFile, "ab+");
        }

#endif /* !__orxANDROID__ && !__orxANDROID_NATIVE__ */

        pstFile = sstDebug.pstDebugFile;
      }

      /* Valid? */
      if(pstFile != orxNULL)
      {
        fprintf(pstFile, "%s", zBuffer);
        fflush(pstFile);
      }
    }

    /* Terminal Display? */
    if(sstDebug.u32DebugFlags & orxDEBUG_KU32_STATIC_FLAG_TERMINAL)
    {
#if defined(__orxANDROID__) || defined(__orxANDROID_NATIVE__)

#define  LOG_TAG    "orxDebug"
#define  LOGI(...)  __android_log_write(ANDROID_LOG_INFO,LOG_TAG,__VA_ARGS__)
#define  LOGD(...)  __android_log_write(ANDROID_LOG_DEBUG,LOG_TAG,__VA_ARGS__)

      if(_eLevel == orxDEBUG_LEVEL_LOG)
      {
        LOGI(zBuffer);
      }
      else
      {
        LOGD(zBuffer);
      }

#else /* __orxANDROID__ || __orxANDROID_NATIVE__ */

      FILE *pstFile;

      if(_eLevel == orxDEBUG_LEVEL_LOG)
      {
        pstFile = stdout;
      }
      else
      {
        pstFile = stderr;
      }

      fprintf(pstFile, "%s", zBuffer);
      fflush(pstFile);

#endif /* __orxANDROID__ || __orxANDROID_NATIVE__ */

    }

    /* Console Display? */
    if(sstDebug.u32DebugFlags & orxDEBUG_KU32_STATIC_FLAG_CONSOLE)
    {
      /* Is console initialized? */
      if(orxModule_IsInitialized(orxMODULE_ID_CONSOLE) != orxFALSE)
      {
        /* Logs it */
        orxConsole_Log(zBuffer);
      }
    }
  }

  /* Done */
  return;
}