/** * Oeffnet eine Datei * \param filename Dateiname * \param *file Zeiger auf Datei-Deskriptor * \param mode Modus, in dem die Datei geoeffnet wird * \param *buffer Puffer fuer mindestens BOTFS_BLOCK_SIZE Byte * \return 0, falls kein Fehler */ int8_t botfs_open(const char * filename, botfs_file_descr_t * file, uint8_t mode, void * buffer) { botfs_acquire_lock_low(&botfs_mutex); /* Datei suchen */ botfs_file_t * ptr = search_file(filename, buffer); if (ptr == NULL) { botfs_release_lock_low(&botfs_mutex); PRINT_MSG("botfs_open(): file not found"); return -1; } /* Datei-Deskriptor laden und updaten */ *file = ptr->descr; file->mode = mode; file->pos = file->start + BOTFS_HEADER_SIZE; /* Datei-Header laden */ if (botfs_read_low(file->start, buffer) != 0) { botfs_release_lock_low(&botfs_mutex); PRINT_MSG("botfs_open(): read_low()-error"); return -2; } /* benutzte Bloecke lt. Header in den Datei-Deskriptor uebernehmen */ botfs_file_header_t * ptr_head = buffer; file->used = ptr_head->used_blocks; // PRINT_MSG("botfs_open(): start=0x%x end=0x%x", file->used.start, file->used.end); int8_t tmp = 0; if (mode == BOTFS_MODE_W) { PRINT_MSG("botfs_open(): Datei wird geleert..."); tmp = clear_file(file, buffer); } botfs_release_lock_low(&botfs_mutex); return tmp; }
/** * Entfernt eine Datei * \param *filename Dateiname * \param *buffer Puffer fuer mindestens BOTFS_BLOCK_SIZE Byte * \return 0, falls kein Fehler */ int8_t botfs_unlink(const char * filename, void * buffer) { botfs_acquire_lock_low(&botfs_mutex); /* Datei suchen */ botfs_file_t * ptr = search_file(filename, buffer); if (ptr == NULL) { botfs_release_lock_low(&botfs_mutex); PRINT_MSG("botfs_unlink(): Datei nicht vorhanden"); return -1; } /* Root-Dir Eintrag loeschen */ ptr->name[0] = 0; ptr->name[1] = 0; botfs_seek(&botfs_vol_data.rootdir, -1, SEEK_CUR); // Dateizeiger stand auf naechstem Dir-Block => -1 if (botfs_write(&botfs_vol_data.rootdir, buffer) != 0) { botfs_release_lock_low(&botfs_mutex); PRINT_MSG("botfs_unlink(): Fehler beim Schreiben des Root-Blocks"); return -2; } const uint16_t start = ptr->descr.start; const uint16_t end = ptr->descr.end; /* Freelist aktualisieren */ int8_t res = add_to_freelist(start, end, buffer); botfs_release_lock_low(&botfs_mutex); PRINT_MSG("botfs_unlink(): Datei \"%s\" wurde geloescht", filename); return res; }
/** * Initialisiert ein Volume * \param *image Dateiname des Images * \param *buffer Puffer fuer mindestens BOTFS_BLOCK_SIZE Byte * \param create Soll das Volume erzeugt werden, falls es nicht existiert? * \return 0, falls kein Fehler */ int8_t botfs_init(char * image, void * buffer, uint8_t create) { init_state = 0; /* Volume laden */ PRINT_MSG("botfs_init_low(\"%s\")...", image); if (botfs_init_low(image, buffer, create) != 0) { PRINT_MSG("botfs_init(): botfs_init_low() schlug fehl"); return -1; } /* Header einlesen */ if (botfs_read_low(BOTFS_HEADER_POS, buffer) != 0) { PRINT_MSG("botfs_init(): botfs_read_low(BOTFS_HEADER_POS) schlug fehl"); return -2; } /* Root-Dir- und Freelist-Adresse speichern */ botfs_volume_t * volume = buffer; botfs_vol_data = volume->data.ctrldata; init_state = 1; if (botfs_check_volume_low(image, buffer) != 0) { PRINT_MSG("botfs_init(): Volume fehlerhaft"); init_state = 0; return -3; } PRINT_MSG("botfs_init() erfolgreich"); return 0; }
/****************************************************************************** * 函 数 名: is_burn * 功能描述: 检查efuse是否已经烧写了flash info * 输入参数: @burn_flag: 烧写标志。1 - 已烧写;0 - 未烧写 * @buffer: efuse中nandc info所在group的值 * 输出参数: 无 * 返 回 值: 0 - 成功; 非0 - 失败 * 函数说明: 检查 *******************************************************************************/ static s32 is_burn(u32 *burn_flag) { s32 ret; u32 efuse_nand_info_addr = EFUSE_NANDC_GROUP_OFFSET; u32 buffer = 0; ret = bsp_efuse_read(&buffer, efuse_nand_info_addr, EFUSE_NANDC_GROUP_LENGTH); if(ret) { PRINT_MSG("Efuse read info error\n"); goto erro; } PRINT_MSG("After read: 0x%x\n", buffer); ret = check_flag(buffer); if(EFUSE_NANDC_NOT_BURN == ret) { *burn_flag = EFUSE_NANDC_NOT_BURN; } else { *burn_flag = EFUSE_NANDC_HAD_BURN; } return OK; erro: return ret; }
int main (int argc, char **argv) { uint_t err = 0; if (argc < 2) { err = 2; PRINT_ERR("not enough arguments\n"); PRINT_MSG("read a wave file as a mono vector\n"); PRINT_MSG("usage: %s <source_path> [samplerate] [win_size] [hop_size]\n", argv[0]); return err; } uint_t samplerate = 0; if ( argc >= 3 ) samplerate = atoi(argv[2]); uint_t win_size = 1024; // window size if ( argc >= 4 ) win_size = atoi(argv[3]); uint_t hop_size = win_size / 4; if ( argc >= 5 ) hop_size = atoi(argv[4]); uint_t n_frames = 0, read = 0; char_t *source_path = argv[1]; aubio_source_t * source = new_aubio_source(source_path, samplerate, hop_size); if (!source) { err = 1; goto beach; } if (samplerate == 0 ) samplerate = aubio_source_get_samplerate(source); // create some vectors fvec_t * in = new_fvec (hop_size); // input audio buffer fvec_t * out = new_fvec (1); // output position // create tempo object aubio_tempo_t * o = new_aubio_tempo("default", win_size, hop_size, samplerate); do { // put some fresh data in input vector aubio_source_do(source, in, &read); // execute tempo aubio_tempo_do(o,in,out); // do something with the beats if (out->data[0] != 0) { PRINT_MSG("beat at %.3fms, %.3fs, frame %d, %.2fbpm with confidence %.2f\n", aubio_tempo_get_last_ms(o), aubio_tempo_get_last_s(o), aubio_tempo_get_last(o), aubio_tempo_get_bpm(o), aubio_tempo_get_confidence(o)); } n_frames += read; } while ( read == hop_size ); PRINT_MSG("read %.2fs, %d frames at %dHz (%d blocks) from %s\n", n_frames * 1. / samplerate, n_frames, samplerate, n_frames / hop_size, source_path); // clean up memory del_aubio_tempo(o); del_fvec(in); del_fvec(out); del_aubio_source(source); beach: aubio_cleanup(); return err; }
static ret_t remove_old_socket (const char *path) { int re; struct stat info; /* It might not exist */ re = cherokee_stat (path, &info); if (re != 0) { return ret_ok; } /* If exist, it must be a socket */ if (! S_ISSOCK(info.st_mode)) { PRINT_MSG ("ERROR: Something happens; '%s' isn't a socket.\n", path); return ret_error; } /* Remove it */ re = unlink (path); if (re != 0) { PRINT_MSG ("ERROR: Couldn't remove unix socket '%s'.\n", path); return ret_error; } return ret_ok; }
// -------------------------------------------------------------------------- // From class CMMFCodec. // The function sets codec configuration. // value used for aConfigType must be KUidMmfCodecAudioSettings // (defined in include\mmf\plugins\mmfCodecImplementationUIDs.hrh) // // -------------------------------------------------------------------------- // void CAriAmrNbEncMmfCodec::ConfigureL( TUid /* aConfigType */, const TDesC8& aParam ) { PRINT_ENTRY; if ( !iConfigured ) { TInt encMode = 0; TInt dtx = 0; TInt offset = 0; Mem::Copy( &encMode, aParam.Ptr() + offset, sizeof( TInt ) ); offset += sizeof(TInt); Mem::Copy( &dtx, aParam.Ptr() + offset, sizeof( TInt ) ); offset += sizeof(TInt); iParam.iMode = ( TInt16 )encMode; iParam.iDtx = ( TInt16 )dtx; PRINT_MSG( LEVEL_HIGH, ( "Mode: %d", iParam.iMode ) ); PRINT_MSG( LEVEL_HIGH, ( "DTX: %d", iParam.iDtx ) ); User::LeaveIfError( iCodec->Reset( &iParam ) ); iConfigured = ETrue; } PRINT_EXIT; }
// -------------------------------------------------------------------------- // Second phase of the two-phased constructor. // Creates an instance of encoder // -------------------------------------------------------------------------- // void CAriAacLCEncMmfCodec::ConstructL() { PRINT_ENTRY; iCodec = CAriAacLCEncWrapper::NewL(); iInternalInputBuffer = ( TUint8* ) User::AllocZL( KMinBytesInput ); iInternalOutputBuffer = ( TUint8* ) User::AllocZL( KMinDstLen ); PRINT_MSG( LEVEL_HIGH, ( "Default NumberOfChannels: %d", iParam.iNumberOfChannels ) ); PRINT_MSG( LEVEL_HIGH, ( "Default OutputBitRate: %d", iParam.iOutputBitRate ) ); PRINT_MSG( LEVEL_HIGH, ( "Default OutputFormat: %d", iParam.iOutputFormat ) ); PRINT_MSG( LEVEL_HIGH, ( "Default SamplingFrequency: %d", iParam.iSamplingFrequency ) ); //Reset encoder with default parameters User::LeaveIfError( iCodec->Reset( &iParam ) ); iSrclenToProcess = sizeof( TInt16 ) * KNoOfSamples * iParam.iNumberOfChannels; PRINT_EXIT; }
/** * Laedt das Volume * \param *image Dateiname des Images * \param *buffer Puffer fuer mindestens BOTFS_BLOCK_SIZE Byte * \param create Soll das Volume erzeugt werden, falls es nicht existiert? * \return 0, falls kein Fehler */ int8_t botfs_init_low(char * image, void * buffer, uint8_t create) { (void) buffer; // kein warning #ifdef DEBUG_BOTFS_LOGFILE botfs_acquire_lock_low(&log_mutex); botfs_log_fd = fopen(BOTFS_DEBUG_LOGFILE, "wb"); botfs_release_lock_low(&log_mutex); #endif // DEBUG_BOTFS_LOGFILE botfs_acquire_lock_low(&file_mutex); image_file = fopen(image, "r+b"); botfs_release_lock_low(&file_mutex); if (image_file == NULL) { PRINT_MSG("botfs_init_low(): Image-Datei \"%s\" konnte nicht geoeffnet werden", image); if (create != 1) { return -1; } PRINT_MSG("botfs_init_low(): Lege neues Images \"%s\" an...", image); if (botfs_create_volume(image, BOTFS_DEFAULT_VOL_NAME, BOTFS_DEFAULT_VOL_SIZE) != 0) { PRINT_MSG("botfs_init_low(): botfs_create_volume(\"%s\") schlug fehl", image); return -2; } botfs_acquire_lock_low(&file_mutex); image_file = fopen(image, "r+b"); botfs_release_lock_low(&file_mutex); if (image_file == NULL) { PRINT_MSG("botfs_init_low(): angelegte Image-Datei \"%s\" konnte nicht geoeffnet werden", image); return -3; } } PRINT_MSG("botfs_init_low() erfolgreich"); return 0; }
static ret_t check_worker_version (const char *this_exec) { FILE *f; char tmp[256]; char *line, *p; int re; snprintf (tmp, sizeof(tmp), "%s -i", cherokee_worker); f = popen (tmp, "r"); if (f == NULL) { PRINT_MSG ("(critical) Cannot execute '%s'\n", tmp); goto error; } while (! feof(f)) { /* Skip line until it found the version entry */ line = fgets (tmp, sizeof(tmp), f); if (line == NULL) continue; line = strstr (line, "Version: "); if (line == NULL) continue; /* Compare both version strings */ line += 9; re = strncmp (line, PACKAGE_VERSION, strlen(PACKAGE_VERSION)); if (re == 0) { pclose(f); return ret_ok; } /* Remove the new line character and report the error */ p = line; while (*p++ != '\n'); *p = '\0'; PRINT_MSG_S ("ERROR: Broken installation detected\n"); PRINT_MSG (" Cherokee (%s) %s\n", this_exec, PACKAGE_VERSION); PRINT_MSG (" Cherokee-worker (%s) %s\n", cherokee_worker, line); PRINT_MSG_S ("\n"); PRINT_MSG_S ("This issue is usually caused by a secondary Cherokee installation in your $PATH.\n"); PRINT_MSG_S ("The following command might help to find where the installations were performed:\n\n"); PRINT_MSG_S ("find `echo $PATH | sed 's/:/ /g'` -name 'cherokee*' -exec dirname \"{}\" \\; | uniq\n"); PRINT_MSG_S ("\n"); goto error; } PRINT_MSG ("(critical) Couldn't find the version string: '%s -i'\n", cherokee_worker); error: if (f != NULL) { pclose(f); } return ret_error; }
static int sem_new (void) { int i; int re; int sem; union semun ctrl; /* Create */ sem = semget (getpid(), SEM_LAUNCH_TOTAL, IPC_CREAT | SEM_R | SEM_A); if (sem < 0) { PRINT_MSG ("Could not create semaphore: %s\n", strerror(errno)); return -1; } /* Initialize */ for (i=0; i < SEM_LAUNCH_TOTAL; i++) { ctrl.val = 0; re = semctl (sem, i, SETVAL, ctrl); if (re < 0) { goto error; } } return sem; error: PRINT_MSG ("Could not initialize semaphore: %s\n", strerror(errno)); return -1; }
int main (int argc, char **argv) { sint_t err = 0; if (argc < 3) { err = 2; PRINT_ERR("not enough arguments\n"); PRINT_MSG("usage: %s <input_path> <output_path> [samplerate] [hop_size]\n", argv[0]); return err; } char_t *source_path = argv[1]; char_t *sink_path = argv[2]; uint_t samplerate = 0; uint_t hop_size = 256; if ( argc >= 4 ) samplerate = atoi(argv[3]); if ( argc >= 5 ) hop_size = atoi(argv[4]); if ( argc >= 6 ) { err = 2; PRINT_ERR("too many arguments\n"); return err; } fvec_t *vec = new_fvec(hop_size); if (!vec) { err = 1; goto beach_fvec; } aubio_source_t *i = new_aubio_source(source_path, samplerate, hop_size); if (!i) { err = 1; goto beach_source; } if (samplerate == 0 ) samplerate = aubio_source_get_samplerate(i); aubio_sink_t *o = new_aubio_sink(sink_path, samplerate); if (!o) { err = 1; goto beach_sink; } uint_t n_frames = 0, read = 0; do { aubio_source_do(i, vec, &read); aubio_sink_do(o, vec, read); n_frames += read; } while ( read == hop_size ); PRINT_MSG("read %d frames at %dHz (%d blocks) from %s written to %s\n", n_frames, samplerate, n_frames / hop_size, source_path, sink_path); del_aubio_sink(o); beach_sink: del_aubio_source(i); beach_source: del_fvec(vec); beach_fvec: return err; }
/****************************************************************************** * 函 数 名: burn_efuse_nandc * 功能描述: 将flash spec info烧写进efuse * 输入参数: 无 * 输出参数: 无 * 返 回 值: 0 - 成功; 非0 - 失败 * 函数说明: *******************************************************************************/ s32 burn_efuse_nandc(void) { s32 ret = ERROR; u32 burn_flag = 0; /* 1 - already burn; 0 - not burn */ struct nand_spec *spec; /* check whether nand info already burn */ /* coverity[no_effect_test] */ ret = is_burn(&burn_flag); if(ret) { PRINT_MSG("Check efuse info error\n"); goto erro; } if(burn_flag) { PRINT_MSG("Efuse nandc info already burn\n"); return OK; } /* get flash info */ spec = (struct nand_spec *)alloc(sizeof(struct nand_spec)); if(!spec) { PRINT_MSG("Malloc memory failed\n"); goto erro; } ret = bsp_get_nand_info(spec); if(OK != ret) { PRINT_MSG("Get flash info failed\n"); goto erro; } PRINT_MSG("After get spec\n"); PRINT_MSG("spec->pagesize : 0x%x\n", spec->pagesize); PRINT_MSG("spec->pagenumperblock : 0x%x\n", spec->pagenumperblock); PRINT_MSG("spec->addrnum : 0x%x\n", spec->addrnum); PRINT_MSG("spec->ecctype : 0x%x\n", spec->ecctype); /* burn flash info into efuse */ ret = do_burn(spec); if(OK != ret) { PRINT_MSG("Burn flash info failed\n"); goto erro; } return OK; erro: return ret; }
int main (int argc, char **argv) { uint_t err = 0; if (argc < 2) { err = 2; PRINT_ERR("not enough arguments\n"); PRINT_MSG("read a wave file as a mono vector\n"); PRINT_MSG("usage: %s <source_path> [samplerate] [hop_size]\n", argv[0]); PRINT_MSG("examples:\n"); PRINT_MSG(" - read file.wav at original samplerate\n"); PRINT_MSG(" %s file.wav\n", argv[0]); PRINT_MSG(" - read file.wav at 32000Hz\n"); PRINT_MSG(" %s file.aif 32000\n", argv[0]); PRINT_MSG(" - read file.wav at original samplerate with 4096 blocks\n"); PRINT_MSG(" %s file.wav 0 4096 \n", argv[0]); return err; } #if __APPLE__ uint_t samplerate = 0; uint_t hop_size = 256; uint_t n_frames = 0, read = 0; if ( argc == 3 ) samplerate = atoi(argv[2]); if ( argc == 4 ) hop_size = atoi(argv[3]); char_t *source_path = argv[1]; aubio_source_apple_audio_t * s = new_aubio_source_apple_audio(source_path, samplerate, hop_size); if (!s) { err = 1; goto beach; } fvec_t *vec = new_fvec(hop_size); if (samplerate == 0 ) samplerate = aubio_source_apple_audio_get_samplerate(s); do { aubio_source_apple_audio_do(s, vec, &read); fvec_print (vec); n_frames += read; } while ( read == hop_size ); PRINT_MSG("read %d frames at %dHz (%d blocks) from %s\n", n_frames, samplerate, n_frames / hop_size, source_path); del_fvec (vec); del_aubio_source_apple_audio (s); beach: #else err = 3; PRINT_ERR("aubio was not compiled with aubio_source_apple_audio\n"); #endif /* __APPLE__ */ return 0; }
static int sem_chmod (int sem, char *worker_uid) { int i; int re; struct semid_ds buf; union semun semopts; struct passwd *passwd; int uid = 0; /* Read the UID */ uid = (int)strtol (worker_uid, (char **)NULL, 10); if (uid == 0) { passwd = getpwnam (worker_uid); if (passwd != NULL) { uid = passwd->pw_uid; } } if (uid == 0) { PRINT_MSG ("(warning) Couldn't get UID for user '%s'\n", worker_uid); return -1; } /* Initialize the memory */ memset (&buf, 0, sizeof(struct semid_ds)); memset (&semopts, 0, sizeof(union semun)); semopts.buf = &buf; /* Set the permissions */ for (i=0; i<SEM_LAUNCH_TOTAL; i++) { re = semctl (sem, i, IPC_STAT, semopts); if (re != -0) { PRINT_MSG ("(warning) Couldn't IPC_STAT: errno=%d\n", errno); return -1; } buf.sem_perm.uid = uid; re = semctl (spawn_shared_sems, i, IPC_SET, semopts); if (re != 0) { PRINT_MSG ("(warning) Couldn't IPC_SET: uid=%d errno=%d\n", uid, errno); return -1; } } return 0; }
// -------------------------------------------------------------------------- // Second phase of the two-phased constructor. // Creates an instance of encoder // -------------------------------------------------------------------------- // void CAriAmrNbEncMmfCodec::ConstructL() { PRINT_ENTRY; iCodec = CAriAmrNbEncWrapper::NewL(); iInternalInputBuffer = ( TUint8* ) User::AllocZL( KMinBytesInput ); iInternalOutputBuffer = ( TUint8* ) User::AllocZL( KMinDstLen ); PRINT_MSG( LEVEL_HIGH, ( "Default mode: %d", iParam.iMode ) ); PRINT_MSG( LEVEL_HIGH, ( "Default DTX: %d", iParam.iDtx ) ); //Reset encoder with default parameters User::LeaveIfError( iCodec->Reset( &iParam ) ); PRINT_EXIT; }
int zarlinkCaculateDevObj(RTKDevType dev_type) { int fxs_dev; int fxo_dev; int fxsfxo_dev; int fxsfxs_dev=0; int total_dev; if (DEV_FXS==dev_type) //display once PRINT_MSG("Total %d lines. %d fxs and %d fxo from Global configuration\n", ZARLINK_SLIC_CH_NUM, ZARLINK_FXS_LINE_NUM, ZARLINK_FXO_LINE_NUM); /* Use minimum number of device to caculate possible combination */ fxsfxo_dev = MIN(ZARLINK_FXS_LINE_NUM, ZARLINK_FXO_LINE_NUM);/* FXS+FXO dev */ #if defined (CONFIG_RTK_VOIP_SLIC_ZARLINK_880_SERIES) fxsfxs_dev = (ZARLINK_FXS_LINE_NUM - fxsfxo_dev) >> 1; /* FXS+FXS dev */ #endif fxs_dev = ZARLINK_FXS_LINE_NUM - fxsfxo_dev - 2*fxsfxs_dev; /* FXS device */ fxo_dev = ZARLINK_FXO_LINE_NUM - fxsfxo_dev; /* FXO device */ total_dev = fxs_dev+fxsfxs_dev+fxo_dev+fxsfxo_dev; if (DEV_FXS==dev_type) //display once PRINT_MSG("Total %d devices\tFXS:%d, FXS+FXS:%d, FXS+FXO:%d, FXO:%d\n", total_dev, fxs_dev, fxsfxs_dev, fxsfxo_dev, fxo_dev ); if (ZARLINK_SLIC_DEV_NUM < total_dev) { PRINT_R("error : %s() Not enough space for chObj\n",__FUNCTION__); return FAILED; } switch (dev_type) { case DEV_FXS: return fxs_dev; break; case DEV_FXO: return fxo_dev; break; case DEV_FXSFXS: return fxsfxs_dev; break; case DEV_FXSFXO: return fxsfxo_dev; break; default: return 0; break; } return 0; }
static bool mesh_validate_customdata( CustomData *data, CustomDataMask mask, const bool do_verbose, const bool do_fixes, bool *r_change) { bool is_valid = true; bool has_fixes = false; int i = 0; PRINT_MSG("%s: Checking %d CD layers...\n", __func__, data->totlayer); while (i < data->totlayer) { CustomDataLayer *layer = &data->layers[i]; bool ok = true; if (CustomData_layertype_is_singleton(layer->type)) { const int layer_tot = CustomData_number_of_layers(data, layer->type); if (layer_tot > 1) { PRINT_ERR("\tCustomDataLayer type %d is a singleton, found %d in Mesh structure\n", layer->type, layer_tot); ok = false; } } if (mask != 0) { CustomDataMask layer_typemask = CD_TYPE_AS_MASK(layer->type); if ((layer_typemask & mask) == 0) { PRINT_ERR("\tCustomDataLayer type %d which isn't in the mask\n", layer->type); ok = false; } } if (ok == false) { if (do_fixes) { CustomData_free_layer(data, layer->type, 0, i); has_fixes = true; } } if (ok) i++; } PRINT_MSG("%s: Finished (is_valid=%d)\n\n", __func__, (int)!has_fixes); *r_change = has_fixes; return is_valid; }
/* * free_blocks_status () only shows the status * of the free blocks */ void free_blocks_status (char *block_ptr){ int i, j; block_header_t *b; TLSF_t *ptr_TLSF; ptr_TLSF = (TLSF_t *) block_ptr; if (!ptr_TLSF || ptr_TLSF -> magic_number != MAGIC_NUMBER) { PRINT_MSG ("free_blocks_status() error: TLSF structure is not initialized\n"); PRINT_MSG ("Hint: Execute init_memory_pool() before calling free_blocks_status()"); return; } PRINT_DBG_C ("\nTLSF structure address 0x"); PRINT_DBG_H (ptr_TLSF); PRINT_DBG_C ("\nFREE BLOCKS\n\n"); for (i = ptr_TLSF -> max_fl_index - 1 - MIN_LOG2_SIZE; i >= 0; i--) { if (ptr_TLSF -> fl_array [i].bitmapSL > 0) for (j = ptr_TLSF -> max_sl_index - 1; j >= 0; j--) { if (ptr_TLSF -> fl_array [i].sl_array[j]) { b = ptr_TLSF -> fl_array [i].sl_array [j]; PRINT_DBG_C ("["); PRINT_DBG_D (i + MIN_LOG2_SIZE); PRINT_DBG_C ("] "); PRINT_DBG_D (TLSF_WORDS2BYTES(1 << (i + MIN_LOG2_SIZE))); PRINT_DBG_C (" bytes -> Free blocks: 0x"); PRINT_DBG_H (ptr_TLSF -> fl_array [i].bitmapSL); PRINT_DBG_C ("\n"); while (b) { PRINT_DBG_C (">>>> First_Level ["); PRINT_DBG_D (i + MIN_LOG2_SIZE); PRINT_DBG_C ("] Second Level ["); PRINT_DBG_D (j); PRINT_DBG_C ("] -> "); PRINT_DBG_D (TLSF_WORDS2BYTES((1 << (i + MIN_LOG2_SIZE)) + ( ((1 << (i + MIN_LOG2_SIZE)) / ptr_TLSF -> max_sl_index) * j))); PRINT_DBG_C (" bytes\n"); print_block (b); b = b -> ptr.free_ptr.next; } } } } }
static gboolean sort_queue (gpointer user_data) { static gint sorts = 0; static gpointer last_p = NULL; gpointer p; gboolean can_quit = FALSE; gint sort_multiplier; gint len; gint i; sort_multiplier = GPOINTER_TO_INT (user_data); if (SORT_QUEUE_AFTER) { PRINT_MSG (("sorting async queue...")); g_async_queue_sort (async_queue, sort_compare, NULL); sorts++; if (sorts >= sort_multiplier) { can_quit = TRUE; } g_async_queue_sort (async_queue, sort_compare, NULL); len = g_async_queue_length (async_queue); PRINT_MSG (("sorted queue (for %d/%d times, size:%d)...", sorts, MAX_SORTS, len)); } else { can_quit = TRUE; len = g_async_queue_length (async_queue); DEBUG_MSG (("printing queue (size:%d)...", len)); } for (i = 0, last_p = NULL; i < len; i++) { p = g_async_queue_pop (async_queue); DEBUG_MSG (("item %d ---> %d", i, GPOINTER_TO_INT (p))); if (last_p) { g_assert (GPOINTER_TO_INT (last_p) <= GPOINTER_TO_INT (p)); } last_p = p; } if (can_quit && QUIT_WHEN_DONE) { g_main_loop_quit (main_loop); } return !can_quit; }
static ret_t process_wait (pid_t wpid) { pid_t re; int exitcode = 0; while (true) { re = waitpid (wpid, &exitcode, 0); if (re > 0) break; else if (errno == EINTR) if (graceful_restart) break; else continue; else if (errno == ECHILD) { return ret_ok; } else { return ret_error; } } if (WIFEXITED(exitcode)) { int re = WEXITSTATUS(exitcode); if (wpid == pid && re == EXIT_OK_ONCE) { clean_up(); exit (EXIT_OK); } else if (wpid == pid && re == EXIT_ERROR_FATAL) { clean_up(); exit (EXIT_ERROR); } /* Child terminated normally */ PRINT_MSG ("PID %d: exited re=%d\n", wpid, re); if (re != 0 && wpid == pid) { worker_retcode = re; return ret_error; } } else if (WIFSIGNALED(exitcode)) { /* Child process terminated by a signal */ PRINT_MSG ("PID %d: received a signal=%d\n", wpid, WTERMSIG(exitcode)); } worker_retcode = 0; return ret_ok; }
/** * Prueft eine Dateiposition auf Gueltigkeit * \param *file Zeiger auf Datei-Deskriptor * \param pos Zu ueberpruefende Position (in Bloecken) */ static int8_t check_pos(botfs_file_descr_t * file, uint16_t pos) { if (pos > file->start && pos <= file->end) { return 0; } PRINT_MSG("check_pos(): start=0x%x, end=0x%x, pos=0x%x", file->start, file->end, pos); return -1; }
static void test_slist_insert_sorted_with_data (void) { GSList *slist = NULL; gint i; PRINT_MSG (("testing g_slist_insert_sorted_with_data()")); for (i = 0; i < SIZE; i++) { slist = g_slist_insert_sorted_with_data (slist, GINT_TO_POINTER (array[i]), (GCompareDataFunc)sort, NULL); } for (i = 0; i < SIZE - 1; i++) { gpointer p1, p2; p1 = g_slist_nth_data (slist, i); p2 = g_slist_nth_data (slist, i+1); g_assert (GPOINTER_TO_INT (p1) <= GPOINTER_TO_INT (p2)); DEBUG_MSG (("slist_insert_sorted_with_data #%3.3d ---> %d", i, GPOINTER_TO_INT (p1))); } }
int main (int argc, char *argv[]) { gint i; DEBUG_MSG (("debugging messages turned on")); DEBUG_MSG (("creating %d random numbers", SIZE)); /* Create an array of random numbers. */ for (i = 0; i < SIZE; i++) { array[i] = g_random_int_range (NUMBER_MIN, NUMBER_MAX); DEBUG_MSG (("number #%3.3d ---> %d", i, array[i])); } /* Start tests. */ test_slist_sort (); test_slist_sort_with_data (); test_slist_insert_sorted (); test_slist_insert_sorted_with_data (); test_slist_reverse (); test_slist_nth (); PRINT_MSG (("testing finished")); return 0; }
int pcm_set_LoopMode(unsigned char group, unsigned int mode, unsigned char main_chid, unsigned char mate_chid) { int i, j = 0; if (mode==0) { PRINT_MSG("Set Loop Mode=0 for group%d\n", group); pcm_LoopMode[group].mode = mode; //0: Not loop mode, 1: loop mode, 2: loop mode with VoIP return 1; } if ((mode != 0) && (pcm_LoopMode[group].mode != 0)) { PRINT_R("Wrong Setting for PCM Loop Mode. Group%d has been set to mode%d\n", group, pcm_LoopMode[group].mode); return 0; } if (main_chid == mate_chid) { PRINT_R("Wrong Setting for PCM Loop Mode. main_chid= %d, mate_chid= %d\n", main_chid, mate_chid); return 0; } //if (pcm_LoopMode[group].mode != mode) { PRINT_MSG("Enter Loop Mode=%d, ch= %d, %d for group%d\n", mode, main_chid, mate_chid, group); pcm_LoopMode[group].mode = mode; pcm_LoopMode[group].main_ch = main_chid; pcm_LoopMode[group].mate_ch = mate_chid; for(i=0; i<2; i++) { if (i ==0) j = main_chid; else if (i ==1) j = mate_chid; rx_loop_r[j]=0; rx_loop_w[j]=0; tx_loop_r[j]=0; tx_loop_w[j]=0; } } return 1; }
Timer::Timer(Type type, const char *name /* = NULL */, ReportType r) : m_type(type), m_report(r) { if (name) { m_name = name; PRINT_MSG("%s...", name); } m_start = measure(); }
int main (int argc, char **argv) { sint_t err = 0; if (argc < 3) { err = 2; PRINT_ERR("not enough arguments\n"); PRINT_MSG("usage: %s <input_path> <output_path> [samplerate]\n", argv[0]); return err; } #ifdef __APPLE__ uint_t samplerate = 44100; uint_t hop_size = 512; uint_t n_frames = 0, read = 0; char_t *source_path = argv[1]; char_t *sink_path = argv[2]; if ( argc == 4 ) samplerate = atoi(argv[3]); fvec_t *vec = new_fvec(hop_size); aubio_source_apple_audio_t *i = new_aubio_source_apple_audio(source_path, samplerate, hop_size); if (samplerate == 0 ) samplerate = aubio_source_apple_audio_get_samplerate(i); aubio_sink_apple_audio_t *o = new_aubio_sink_apple_audio(sink_path, samplerate); if (!i || !o) { err = 1; goto beach; } do { aubio_source_apple_audio_do(i, vec, &read); aubio_sink_apple_audio_do(o, vec, read); n_frames += read; } while ( read == hop_size ); PRINT_MSG("%d frames read from %s\n written to %s at %dHz\n", n_frames, source_path, sink_path, samplerate); beach: del_aubio_source_apple_audio(i); del_aubio_sink_apple_audio(o); del_fvec(vec); #else err = 3; PRINT_ERR("aubio was not compiled with aubio_source_apple_audio\n"); #endif /* __APPLE__ */ return err; }
//------------------------------------------------------------------------------------- void Messagelog::writeLog(Mercury::Channel* pChannel, KBEngine::MemoryStream& s) { uint32 logtype; COMPONENT_TYPE componentType = UNKNOWN_COMPONENT_TYPE; COMPONENT_ID componentID = 0; COMPONENT_ORDER componentOrder = 0; int64 t; GAME_TIME kbetime = 0; std::string str; std::stringstream logstream; s >> logtype; s >> componentType; s >> componentID; s >> componentOrder; s >> t >> kbetime; s >> str; time_t tt = static_cast<time_t>(t); tm* aTm = localtime(&tt); // YYYY year // MM month (2 digits 01-12) // DD day (2 digits 01-31) // HH hour (2 digits 00-23) // MM minutes (2 digits 00-59) // SS seconds (2 digits 00-59) if(aTm == NULL) { ERROR_MSG("Messagelog::writeLog: log is error!\n"); return; } char timebuf[MAX_BUF]; kbe_snprintf(timebuf, MAX_BUF, " [%-4d-%02d-%02d %02d:%02d:%02d %02d] ", aTm->tm_year+1900, aTm->tm_mon+1, aTm->tm_mday, aTm->tm_hour, aTm->tm_min, aTm->tm_sec, kbetime); logstream << KBELOG_TYPE_NAME_EX(logtype); logstream << " "; logstream << COMPONENT_NAME_EX_1(componentType); logstream << " "; logstream << componentID; logstream << " "; logstream << (int)componentOrder; logstream << timebuf; logstream << "- "; logstream << str; DebugHelper::getSingleton().changeLogger(COMPONENT_NAME_EX(componentType)); PRINT_MSG(logstream.str()); DebugHelper::getSingleton().changeLogger("default"); LOG_WATCHERS::iterator iter = logWatchers_.begin(); for(; iter != logWatchers_.end(); iter++) { iter->second.onMessage(logtype, componentType, componentID, componentOrder, t, kbetime, str, logstream); } }
/** * Liest BOTFS_BLOCK_SIZE Bytes aus einer Datei in einen Puffer * \param *file Zeiger auf Datei-Deskriptor * \param *buffer Puffer fuer mindestens BOTFS_BLOCK_SIZE Byte, in die Daten geschrieben werden * \return 0, falls kein Fehler */ int8_t botfs_read(botfs_file_descr_t * file, void * buffer) { if (init_state != 1) { return -99; } /* Positions-Check */ if (check_pos(file, file->pos) != 0) { PRINT_MSG("botfs_read(): Position 0x%x ungueltig!", file->pos); return -1; } /* Daten lesen und Dateizeiger anpassen */ if (botfs_read_low(file->pos++, buffer) != 0) { PRINT_MSG("botfs_read(): botfs_read_low() meldet Fehler"); return -2; } return 0; }
int main (int argc, char **argv) { ret_t ret; struct sigaction act; ret = check_for_python(); if (ret != ret_ok) { PRINT_MSG ("ERROR: Couldn't find python.\n"); exit (EXIT_ERROR); } /* Signal handling */ act.sa_handler = SIG_IGN; sigaction (SIGPIPE, &act, NULL); memset(&act, 0, sizeof(act)); act.sa_sigaction = signals_handler; act.sa_flags = SA_SIGINFO; sigaction (SIGCHLD, &act, NULL); sigaction (SIGINT, &act, NULL); sigaction (SIGTERM, &act, NULL); /* Initialize the embedded server */ cherokee_init(); cherokee_spawner_set_active (false); process_parameters (argc, argv); ret = cherokee_server_new (&srv); if (ret != ret_ok) exit (EXIT_ERROR); ret = config_server (srv); if (ret != ret_ok) exit (EXIT_ERROR); ret = cherokee_server_initialize (srv); if (ret != ret_ok) exit (EXIT_ERROR); print_connection_info(); ret = cherokee_server_unlock_threads (srv); if (ret != ret_ok) exit (EXIT_ERROR); do { ret = cherokee_server_step (srv); } while (ret == ret_eagain); cherokee_server_stop (srv); cherokee_server_free (srv); cherokee_mrproper(); return EXIT_OK; }