static int mp3_get_info(struct music_info *info)
{
if (info->type & MD_GET_CURTIME) {
info->cur_time = g_play_time;
}
if (info->type & MD_GET_CPUFREQ) {
if (use_me) {
if (mp3_data.use_buffer)
info->psp_freq[0] = 49;
else
info->psp_freq[0] = 33;
info->psp_freq[1] = 16;
} else {
info->psp_freq[0] = 66 + (133 - 66) * g_info.avg_bps / 1000 / 320;
info->psp_freq[1] = 111;
}
}
if (info->type & MD_GET_DECODERNAME) {
if (use_me) {
STRCPY_S(info->decoder_name, "mp3");
} else {
STRCPY_S(info->decoder_name, "madmp3");
}
}
if (info->type & MD_GET_ENCODEMSG) {
if (config.show_encoder_msg && mp3info.lame_encoded) {
char lame_method[80];
switch (mp3info.lame_mode) {
case ABR:
STRCPY_S(lame_method, "ABR");
break;
case CBR:
STRCPY_S(lame_method, "CBR");
break;
case VBR:
SPRINTF_S(lame_method, "VBR V%1d",
mp3info.lame_vbr_quality);
break;
default:
break;
}
if (mp3info.lame_str[strlen(mp3info.lame_str) - 1] == ' ')
SPRINTF_S(info->encode_msg,
"%s%s", mp3info.lame_str, lame_method);
else
SPRINTF_S(info->encode_msg,
"%s %s", mp3info.lame_str, lame_method);
} else {
info->encode_msg[0] = '\0';
}
}
if (info->type & MD_GET_INSKBPS) {
info->ins_kbps = get_inst_bitrate(&g_inst_br) / 1000;
}
return generic_get_info(info);
}
extern dword copy_dir(const char *src, const char *dest, t_copy_cb cb,
t_copy_overwritecb ocb, void *data)
{
int dl = xrIoDopen(src);
dword result = 0;
SceIoDirent sid;
if (dl < 0) {
if (cb != NULL)
cb(src, dest, false, data);
return 0;
}
xrIoMkdir(dest, 0777);
memset(&sid, 0, sizeof(SceIoDirent));
while (xrIoDread(dl, &sid)) {
char copysrc[260], copydest[260];
if (sid.d_name[0] == '.')
continue;
SPRINTF_S(copysrc, "%s/%s", src, sid.d_name);
SPRINTF_S(copydest, "%s/%s", dest, sid.d_name);
if (FIO_S_ISDIR(sid.d_stat.st_mode)) {
result += copy_dir(copysrc, copydest, cb, ocb, data);
continue;
}
if (copy_file(copysrc, copydest, cb, ocb, data))
++result;
memset(&sid, 0, sizeof(SceIoDirent));
}
xrIoDclose(dl);
return result;
}
extern u32 utils_del_dir(const char *dir)
{
u32 count = 0;
int dl = sceIoDopen(dir);
SceIoDirent sid;
if (dl < 0)
return count;
memset(&sid, 0, sizeof(SceIoDirent));
while (sceIoDread(dl, &sid)) {
char compPath[260];
if (sid.d_name[0] == '.')
continue;
SPRINTF_S(compPath, "%s/%s", dir, sid.d_name);
if (FIO_S_ISDIR(sid.d_stat.st_mode)) {
if (utils_del_dir(compPath)) {
count++;
}
continue;
}
if (utils_del_file(compPath)) {
count++;
}
memset(&sid, 0, sizeof(SceIoDirent));
}
sceIoDclose(dl);
sceIoRmdir(dir);
return count;
}
static void report_image_error(int status)
{
char infomsg[80];
const char *errstr;
switch (status) {
case 1:
case 2:
case 3:
errstr = _("格式错误");
break;
case 4:
case 5:
errstr = _("内存不足");
break;
case 6:
errstr = _("压缩档案损坏或密码错误");
break;
default:
errstr = _("不明");
break;
}
SPRINTF_S(infomsg, _("图像无法装载, 原因: %s"), errstr);
win_msg(infomsg, COLOR_WHITE, COLOR_WHITE, config.msgbcolor);
ctrl_waitrelease();
dbg_printf(d,
_
("图像无法装载，原因: %s where = %d config.path %s filename %s"),
errstr, where, config.path, filename);
imgreading = false;
reset_image_ptr();
}
/**
* 得到TTA音乐文件相关信息
*
* @param pinfo 信息结构体指针
*
* @return
*/
static int tta_get_info(struct music_info *pinfo)
{
generic_get_info(pinfo);
if (pinfo->type & MD_GET_TITLE) {
if (g_info.tag.title[0] == '\0') {
pinfo->encode = conf_encode_gbk;
STRCPY_S(pinfo->title, (const char *) ttainfo.ID3.title);
}
}
if (pinfo->type & MD_GET_ARTIST) {
if (g_info.tag.artist[0] == '\0') {
pinfo->encode = conf_encode_gbk;
STRCPY_S(pinfo->artist, (const char *) ttainfo.ID3.artist);
}
}
if (pinfo->type & MD_GET_ALBUM) {
if (g_info.tag.album[0] == '\0') {
pinfo->encode = conf_encode_gbk;
STRCPY_S(pinfo->album, (const char *) ttainfo.ID3.album);
}
}
if (pinfo->type & MD_GET_CURTIME) {
pinfo->cur_time = g_play_time;
}
if (pinfo->type & MD_GET_CPUFREQ) {
#ifdef _DEBUG
pinfo->psp_freq[0] = 222;
#else
pinfo->psp_freq[0] = 111;
#endif
pinfo->psp_freq[1] = pinfo->psp_freq[0] / 2;
}
if (pinfo->type & MD_GET_FREQ) {
pinfo->freq = ttainfo.SAMPLERATE;
}
if (pinfo->type & MD_GET_CHANNELS) {
pinfo->channels = ttainfo.NCH;
}
if (pinfo->type & MD_GET_AVGKBPS) {
pinfo->avg_kbps = ttainfo.BITRATE;
}
if (pinfo->type & MD_GET_DECODERNAME) {
STRCPY_S(pinfo->decoder_name, "tta");
}
if (pinfo->type & MD_GET_ENCODEMSG) {
if (config.show_encoder_msg && g_status != ST_UNKNOWN) {
SPRINTF_S(pinfo->encode_msg, "%s: %.2f", _("压缩率"),
ttainfo.COMPRESS);
} else {
pinfo->encode_msg[0] = '\0';
}
}
return 0;
}
int music_add_dir(const char *spath, const char *lpath)
{
p_fat_info info;
dword i, count;
if (spath == NULL || lpath == NULL)
return -EINVAL;
count = fat_readdir(lpath, (char *) spath, &info);
if (count == INVALID)
return -EBADF;
for (i = 0; i < count; i++) {
char sfn[PATH_MAX];
char lfn[PATH_MAX];
if ((info[i].attr & FAT_FILEATTR_DIRECTORY) > 0) {
char lpath2[PATH_MAX], spath2[PATH_MAX];
if (info[i].filename[0] == '.')
continue;
SPRINTF_S(lpath2, "%s%s/", lpath, info[i].longname);
SPRINTF_S(spath2, "%s%s/", spath, info[i].filename);
music_add_dir(spath2, lpath2);
continue;
}
if (fs_is_music(info[i].filename, info[i].longname) == false)
continue;
SPRINTF_S(sfn, "%s%s", spath, info[i].filename);
SPRINTF_S(lfn, "%s%s", lpath, info[i].longname);
music_add(sfn, lfn);
}
free((void *) info);
return 0;
}
static void cache_invalidate_hack(void)
{
int fd;
int t[20];
char conffile[PATH_MAX];
SPRINTF_S(conffile, "%s%s%d%s", scene_appdir(), "config", 0, ".ini");
fd = xrIoOpen(conffile, PSP_O_RDONLY, 0777);
if (fd >= 0) {
xrIoRead(fd, t, sizeof(t));
xrIoClose(fd);
}
}
void AudioCaptureThread::ON_WIMDATA(WPARAM wParam, LPARAM lParam)
{
if(IsWorking())
{
#ifdef ENABLE_AUDIO_DENOISE
Denoise((BYTE*)((PWAVEHDR)lParam)->lpData, ((PWAVEHDR)lParam)->dwBytesRecorded);
#endif//ENABLE_AUDIO_DENOISE
static ULONG ulPkgNo = 0;
MMRESULT mmResult = MMSYSERR_NOERROR;
PWAVEHDR waveHdr = (PWAVEHDR) lParam;
#ifdef ENABLE_AUDIO_AEC
VERIFY(::GetMicQueue());
{
double dCurTime = jrtplib::RTPTime::CurrentTime().GetDouble();
RecPkgQueue::element_type bufAEC(new AudioBuffer((BYTE*)waveHdr->lpData, waveHdr->dwBytesRecorded, dCurTime));
if (IsWorking())
{
::GetMicQueue()->push_back(bufAEC);
#ifdef PRINT_AEC_INFO
SPRINTF_S(dbg_str,
"Audio data: mic recv= %d"
"\ttime: %f"
, ulPkgNo
, dCurTime);
DEBUG_INFO(dbg_str);
#endif//PRINT_AEC_INFO
}
}
#else //ENABLE_AUDIO_AEC
RecPkgQueue::element_type buf2Send(new AudioBuffer((BYTE*)((PWAVEHDR)lParam)->lpData, ((PWAVEHDR)lParam)->dwBytesRecorded, 0));
((AudioSendSession*)m_pSession)->getPackageQueue()->push_back(buf2Send);
#endif//ENABLE_AUDIO_AEC
//mmResult = ::waveInPrepareHeader (hWaveIn, waveHdr, sizeof(WAVEHDR));
//checkMMError(mmResult, true);
waveHdr->dwFlags = WHDR_PREPARED;
mmResult = ::waveInAddBuffer (m_hWaveIn, waveHdr, sizeof(WAVEHDR));
checkMMError(mmResult, true);
++ulPkgNo;
}
}
int dbg_printf(DBG * d, const char *fmt, ...)
{
char *buf;
va_list ap;
int l, size;
size_t i;
pspTime tm;
char timestr[80];
int timelen;
if (!d)
return -1;
if (!d->on)
return 0;
va_start(ap, fmt);
sceRtcGetCurrentClockLocalTime(&tm);
SPRINTF_S(timestr, "%u-%u-%u %02u:%02u:%02u", tm.year, tm.month, tm.day, tm.hour, tm.minutes, tm.seconds);
timelen = strlen(timestr);
size = DBG_BUFSIZE;
buf = malloc(size + timelen + 2);
strcpy_s(buf, size + timelen + 2, timestr);
strcat_s(buf, size + timelen + 2, ": ");
l = vsnprintf(buf + timelen + 2, size, fmt, ap);
buf[size + timelen + 2 - 1] = '\0';
while (strlen(buf) == size - 1) {
size *= 2 + 16;
buf = safe_realloc(buf, size + timelen + 2);
if (!buf)
return 0;
strcpy_s(buf, size + timelen + 2, timestr);
strcat_s(buf, size + timelen + 2, ": ");
l = vsnprintf(buf + timelen + 2, size, fmt, ap);
buf[size + timelen + 2 - 1] = '\0';
}
strcat_s(buf, size + timelen + 2, "\n");
va_end(ap);
for (i = 0; i < d->otsize; ++i) {
if (d->ot[i].write)
(*d->ot[i].write) (d->ot[i].arg, buf);
}
free(buf);
return l;
}
static int chmEnum(struct chmFile *h, struct chmUnitInfo *ui, void *context)
{
t_win_menuitem item;
t_fs_filetype ft;
char fname[PATH_MAX] = "";
char t[20];
int size = strlen(ui->path);
if (size == 0 || ui->path[size - 1] == '/')
return CHM_ENUMERATOR_CONTINUE;
ft = fs_file_get_type(ui->path);
if (ft == fs_filetype_chm || ft == fs_filetype_zip || ft == fs_filetype_rar || ft == fs_filetype_umd || ft == fs_filetype_pdb)
return CHM_ENUMERATOR_CONTINUE;
win_menuitem_new(&item);
buffer_copy_string(item.compname, ui->path);
SPRINTF_S(t, "%u", (unsigned int) ui->length);
buffer_copy_string(item.shortname, t);
if (ui->path[0] == '/') {
strncpy_s(fname, NELEMS(fname), ui->path + 1, 256);
} else {
strncpy_s(fname, NELEMS(fname), ui->path, 256);
}
charsets_utf8_conv((unsigned char *) fname, sizeof(fname), (unsigned char *) fname, sizeof(fname));
item.data = (void *) ft;
filename_to_itemname(&item, fname);
item.selected = false;
item.icolor = ((p_fs_chm_enum) context)->icolor;
item.selicolor = ((p_fs_chm_enum) context)->selicolor;
item.selrcolor = ((p_fs_chm_enum) context)->selrcolor;
item.selbcolor = ((p_fs_chm_enum) context)->selbcolor;
item.data3 = ui->length;
win_menu_add(g_menu, &item);
return CHM_ENUMERATOR_CONTINUE;
}
extern bool ini_conf_load(const char *inifilename, p_conf conf)
{
dictionary *dict;
char buf[80];
int i;
extern void get_language(void);
if (conf == NULL || inifilename == NULL) {
return false;
}
dict = iniparser_load(inifilename);
if (dict == NULL)
return false;
conf_default(conf);
STRCPY_S(conf->path, iniparser_getstring(dict, "Global:path", conf->path));
conf->forecolor =
iniparser_getunsigned(dict, "UI:forecolor", conf->forecolor);
conf->giftranscolor =
iniparser_getunsigned(dict, "Image:giftranscolor", conf->giftranscolor);
conf->bgcolor = iniparser_getunsigned(dict, "UI:bgcolor", conf->bgcolor);
conf->have_bg = iniparser_getboolean(dict, "UI:have_bg", conf->have_bg);
conf->titlecolor =
iniparser_getunsigned(dict, "UI:titlecolor", conf->titlecolor);
conf->menutextcolor =
iniparser_getunsigned(dict, "UI:menutextcolor", conf->menutextcolor);
conf->menubcolor =
iniparser_getunsigned(dict, "UI:menubcolor", conf->menubcolor);
conf->selicolor =
iniparser_getunsigned(dict, "UI:selicolor", conf->selicolor);
conf->selbcolor =
iniparser_getunsigned(dict, "UI:selbcolor", conf->selbcolor);
conf->msgbcolor =
iniparser_getunsigned(dict, "UI:msgbcolor", conf->msgbcolor);
conf->usedyncolor =
iniparser_getboolean(dict, "UI:usedyncolor", conf->usedyncolor);
conf->rowspace = iniparser_getint(dict, "Text:rowspace", conf->rowspace);
conf->infobar =
stringToInfobar(iniparser_getstring
(dict, "Text:infobar",
infobarToString(buf, sizeof(buf), conf->infobar)));
conf->infobar_style =
iniparser_getint(dict, "Text:infobar_style", conf->infobar_style);
conf->infobar_fontsize =
iniparser_getunsigned(dict, "Text:infobar_fontsize",
conf->infobar_fontsize);
conf->rlastrow =
iniparser_getboolean(dict, "Text:rlastrow", conf->rlastrow);
conf->autobm = iniparser_getboolean(dict, "Text:autobm", conf->autobm);
conf->vertread =
stringToVertread(iniparser_getstring
(dict, "Text:vertread",
vertreadToString(buf, sizeof(buf), conf->vertread)));
conf->encode =
stringToEncode(iniparser_getstring
(dict, "Text:encode",
encodeToString(buf, sizeof(buf), conf->encode)));
conf->fit =
stringToFit(iniparser_getstring
(dict, "Image:fit",
fitToString(buf, sizeof(buf), conf->fit)));
conf->imginfobar =
iniparser_getboolean(dict, "Image:imginfobar", conf->imginfobar);
conf->scrollbar =
iniparser_getboolean(dict, "Text:scrollbar", conf->scrollbar);
conf->scale = iniparser_getint(dict, "Image:scale", conf->scale);
conf->rotate =
stringToRotate(iniparser_getstring
(dict, "Image:rotate",
rotateToString(buf, sizeof(buf), conf->rotate)));
for (i = 0; i < 20; ++i) {
char key[20];
SPRINTF_S(key, "Text:txtkey1_%02d", i);
conf->txtkey[i] = iniparser_getint(dict, key, conf->txtkey[i]);
SPRINTF_S(key, "Image:imgkey1_%02d", i);
conf->imgkey[i] = iniparser_getint(dict, key, conf->imgkey[i]);
}
check_empty_imgkey(conf);
STRCPY_S(conf->shortpath,
iniparser_getstring(dict, "Global:shortpath", conf->shortpath));
conf->confver = iniparser_getint(dict, "Global:confver", conf->confver);
conf->bicubic = iniparser_getboolean(dict, "Image:bicubic", conf->bicubic);
conf->wordspace = iniparser_getint(dict, "Text:wordspace", conf->wordspace);
conf->borderspace =
iniparser_getunsigned(dict, "Text:borderspace", conf->borderspace);
STRCPY_S(conf->lastfile,
iniparser_getstring(dict, "Global:lastfile", conf->lastfile));
conf->mp3encode =
stringToEncode(iniparser_getstring
(dict, "Music:mp3encode",
encodeToString(buf, sizeof(buf), conf->mp3encode)));
conf->lyricencode =
stringToEncode(iniparser_getstring
(dict, "Music:lyricencode",
encodeToString(buf, sizeof(buf), conf->lyricencode)));
conf->mp3cycle =
stringToCycle(iniparser_getstring
(dict, "Music:mp3cycle",
cycleToString(buf, sizeof(buf), conf->mp3cycle)));
conf->isreading =
iniparser_getboolean(dict, "Global:isreading", conf->isreading);
STRCPY_S(conf->bgarch,
iniparser_getstring(dict, "UI:bgarch", conf->bgarch));
STRCPY_S(conf->bgfile,
iniparser_getstring(dict, "UI:bgfile", conf->bgfile));
conf->bgwhere = iniparser_getint(dict, "UI:bgwhere", conf->bgwhere);
conf->slideinterval =
iniparser_getint(dict, "Image:slideinterval", conf->slideinterval);
conf->hprmctrl =
iniparser_getboolean(dict, "Music:hprmctrl", conf->hprmctrl);
conf->grayscale = iniparser_getint(dict, "UI:grayscale", conf->grayscale);
conf->showhidden =
iniparser_getboolean(dict, "Global:showhidden", conf->showhidden);
conf->showunknown =
iniparser_getboolean(dict, "Global:showunknown", conf->showunknown);
conf->showfinfo =
iniparser_getboolean(dict, "Global:showfinfo", conf->showfinfo);
conf->allowdelete =
iniparser_getboolean(dict, "Global:allowdelete", conf->allowdelete);
conf->arrange =
stringToArrange(iniparser_getstring
(dict, "Global:arrange",
arrangeToString(buf, sizeof(buf), conf->arrange)));
conf->enableusb =
iniparser_getboolean(dict, "Global:enableusb", conf->enableusb);
conf->viewpos =
stringToViewpos(iniparser_getstring
(dict, "Image:viewpos",
viewposToString(buf, sizeof(buf), conf->viewpos)));
conf->imgmvspd = iniparser_getint(dict, "Image:imgmvspd", conf->imgmvspd);
conf->imgpaging =
stringToImgpaging(iniparser_getstring
(dict, "Image:imgpaging",
imgpagingToString(buf, sizeof(buf),
conf->imgpaging)));
conf->imgpaging_spd =
iniparser_getint(dict, "Image:imgpaging_spd", conf->imgpaging_spd);
conf->imgpaging_interval =
iniparser_getint(dict, "Image:imgpaging_interval",
conf->imgpaging_interval);
conf->imgpaging_duration =
iniparser_getint(dict, "Image:imgpaging_duration",
conf->imgpaging_duration);
for (i = 0; i < 20; ++i) {
char key[20];
SPRINTF_S(key, "Global:flkey1_%02d", i);
conf->flkey[i] = iniparser_getint(dict, key, conf->flkey[i]);
}
conf->fontsize = iniparser_getint(dict, "UI:fontsize", conf->fontsize);
conf->reordertxt =
iniparser_getboolean(dict, "Text:reordertxt", conf->reordertxt);
conf->pagetonext =
iniparser_getboolean(dict, "Text:pagetonext", conf->pagetonext);
conf->autopage = iniparser_getint(dict, "Text:autopage", conf->autopage);
conf->prev_autopage =
iniparser_getint(dict, "Text:prev_autopage", conf->prev_autopage);
conf->autopagetype =
iniparser_getint(dict, "Text:autopagetype", conf->autopagetype);
conf->autolinedelay =
iniparser_getint(dict, "Text:autolinedelay", conf->autolinedelay);
conf->thumb =
stringToThumb(iniparser_getstring
(dict, "Image:thumb",
thumbToString(buf, sizeof(buf), conf->thumb)));
conf->bookfontsize =
iniparser_getint(dict, "Text:bookfontsize", conf->bookfontsize);
conf->enable_analog =
iniparser_getboolean(dict, "Text:enable_analog", conf->enable_analog);
conf->img_enable_analog =
iniparser_getboolean(dict, "Image:img_enable_analog",
conf->img_enable_analog);
for (i = 0; i < 20; ++i) {
char key[20];
SPRINTF_S(key, "Text:txtkey2_%02d", i);
conf->txtkey2[i] = iniparser_getint(dict, key, conf->txtkey2[i]);
SPRINTF_S(key, "Image:imgkey2_%02d", i);
conf->imgkey2[i] = iniparser_getint(dict, key, conf->imgkey2[i]);
SPRINTF_S(key, "Global:flkey2_%02d", i);
conf->flkey2[i] = iniparser_getint(dict, key, conf->flkey2[i]);
}
conf->imgpagereserve =
iniparser_getint(dict, "Image:imgpagereserve", conf->imgpagereserve);
conf->lyricex = iniparser_getint(dict, "Music:lyricex", conf->lyricex);
conf->autoplay =
iniparser_getboolean(dict, "Music:autoplay", conf->autoplay);
conf->usettf = iniparser_getboolean(dict, "Text:usettf", conf->usettf);
STRCPY_S(conf->cttfarch,
iniparser_getstring(dict, "Text:cttfarch", conf->cttfarch));
STRCPY_S(conf->cttfpath,
iniparser_getstring(dict, "Text:cttfpath", conf->cttfpath));
STRCPY_S(conf->ettfarch,
iniparser_getstring(dict, "Text:ettfarch", conf->ettfarch));
STRCPY_S(conf->ettfpath,
iniparser_getstring(dict, "Text:ettfpath", conf->ettfpath));
for (i = 0; i < 3; ++i) {
char key[20];
SPRINTF_S(key, "Global:freqs_%d", i);
conf->freqs[i] = iniparser_getint(dict, key, conf->freqs[i]);
}
conf->imgbrightness =
iniparser_getint(dict, "Image:imgbrightness", conf->imgbrightness);
conf->dis_scrsave =
iniparser_getboolean(dict, "Global:dis_scrsave", conf->dis_scrsave);
conf->autosleep =
iniparser_getint(dict, "Global:autosleep", conf->autosleep);
conf->load_exif =
iniparser_getboolean(dict, "Image:load_exif", conf->load_exif);
conf->launchtype =
iniparser_getint(dict, "Global:launchtype", conf->launchtype);
conf->infobar_use_ttf_mode =
iniparser_getboolean(dict, "Text:infobar_use_ttf_mode",
conf->infobar_use_ttf_mode);
conf->img_no_repeat =
iniparser_getboolean(dict, "Image:no_repeat", conf->img_no_repeat);
conf->hide_flash =
iniparser_getboolean(dict, "Global:hide_flash", conf->hide_flash);
conf->tabstop = iniparser_getunsigned(dict, "Text:tabstop", conf->tabstop);
conf->apetagorder =
iniparser_getboolean(dict, "Music:apetagorder", conf->apetagorder);
STRCPY_S(conf->language,
iniparser_getstring(dict, "UI:language", conf->language));
get_language();
conf->filelistwidth =
iniparser_getint(dict, "UI:filelistwidth", conf->filelistwidth);
if (conf->filelistwidth < 0 || conf->filelistwidth > 240)
conf->filelistwidth = 160;
conf->ttf_load_to_memory =
iniparser_getboolean(dict, "Text:ttf_load_to_memory",
conf->ttf_load_to_memory);
conf->save_password =
iniparser_getboolean(dict, "Global:save_password", conf->save_password);
conf->scrollbar_width =
iniparser_getint(dict, "Text:scrollbar_width", conf->scrollbar_width);
conf->hide_last_row =
iniparser_getboolean(dict, "Text:hide_last_row", conf->hide_last_row);
conf->infobar_show_timer =
iniparser_getboolean(dict, "Text:infobar_show_timer",
conf->infobar_show_timer);
conf->englishtruncate =
iniparser_getboolean(dict, "Text:englishtruncate",
conf->englishtruncate);
conf->image_scroll_chgn_speed =
iniparser_getboolean(dict, "Image:image_scroll_chgn_speed",
conf->image_scroll_chgn_speed);
conf->ttf_haste_up =
iniparser_getboolean(dict, "Text:ttf_haste_up", conf->ttf_haste_up);
conf->linenum_style =
iniparser_getboolean(dict, "Text:linenum_style", conf->linenum_style);
conf->infobar_align =
stringToAlign(iniparser_getstring(dict, "Text:infobar_align", ""));
STRCPY_S(conf->musicdrv_opts,
iniparser_getstring(dict, "Music:musicdrv_opts",
conf->musicdrv_opts));
conf->magnetic_scrolling =
iniparser_getboolean(dict, "Image:magnetic_scrolling",
conf->magnetic_scrolling);
conf->use_image_queue =
iniparser_getboolean(dict, "Image:use_image_queue",
conf->use_image_queue);
conf->max_cache_img =
iniparser_getunsigned(dict, "Image:max_cache_img", conf->max_cache_img);
conf->show_encoder_msg =
iniparser_getboolean(dict, "Music:show_encoder_msg",
conf->show_encoder_msg);
if (conf->max_cache_img == 0) {
conf->use_image_queue = false;
}
dictionary_del(dict);
return true;
}
static void conf_default(p_conf conf)
{
memset(conf, 0, sizeof(t_conf));
STRCPY_S(conf->path, "ms0:/");
STRCPY_S(conf->shortpath, "ms0:/");
STRCPY_S(conf->lastfile, "");
STRCPY_S(conf->bgarch, "");
STRCPY_S(conf->bgfile, scene_appdir());
STRCAT_S(conf->bgfile, "bg.png");
conf->bgwhere = scene_in_zip;
conf->confver = XREADER_VERSION_NUM;
conf->forecolor = 0xFFFFFFFF;
conf->giftranscolor = 0xFFFFFFFF;
conf->bgcolor = 0;
conf->have_bg = true;
conf->rowspace = 2;
conf->wordspace = 0;
conf->borderspace = 0;
conf->vertread = 0;
conf->infobar = conf_infobar_info;
conf->infobar_style = 0;
conf->rlastrow = false;
conf->autobm = true;
conf->encode = conf_encode_gbk;
conf->fit = conf_fit_none;
conf->imginfobar = false;
conf->scrollbar = false;
conf->scale = 0;
conf->rotate = conf_rotate_0;
conf->enable_analog = true;
conf->img_enable_analog = true;
conf->txtkey[0] = PSP_CTRL_SQUARE;
conf->txtkey[1] = PSP_CTRL_LTRIGGER;
conf->txtkey[2] = PSP_CTRL_RTRIGGER;
conf->txtkey[3] = PSP_CTRL_UP | PSP_CTRL_CIRCLE;
conf->txtkey[4] = PSP_CTRL_DOWN | PSP_CTRL_CIRCLE;
conf->txtkey[5] = PSP_CTRL_LEFT | PSP_CTRL_CIRCLE;
conf->txtkey[6] = PSP_CTRL_RIGHT | PSP_CTRL_CIRCLE;
conf->txtkey[7] = PSP_CTRL_LTRIGGER | PSP_CTRL_CIRCLE;
conf->txtkey[8] = PSP_CTRL_RTRIGGER | PSP_CTRL_CIRCLE;
conf->txtkey[9] = 0;
conf->txtkey[10] = 0;
conf->txtkey[11] = PSP_CTRL_CROSS;
conf->txtkey[12] = PSP_CTRL_TRIANGLE;
conf->imgkey[0] = PSP_CTRL_LTRIGGER;
conf->imgkey[1] = PSP_CTRL_RTRIGGER;
conf->imgkey[2] = PSP_CTRL_TRIANGLE;
conf->imgkey[3] = PSP_CTRL_UP | PSP_CTRL_CIRCLE;
conf->imgkey[4] = PSP_CTRL_DOWN | PSP_CTRL_CIRCLE;
conf->imgkey[5] = PSP_CTRL_LEFT | PSP_CTRL_CIRCLE;
conf->imgkey[6] = PSP_CTRL_RIGHT | PSP_CTRL_CIRCLE;
conf->imgkey[7] = PSP_CTRL_SQUARE;
conf->imgkey[8] = PSP_CTRL_CIRCLE;
conf->imgkey[9] = PSP_CTRL_CROSS;
conf->imgkey[10] = PSP_CTRL_LTRIGGER | PSP_CTRL_CIRCLE;
conf->imgkey[11] = 0;
conf->imgkey[12] = PSP_CTRL_UP;
conf->imgkey[13] = PSP_CTRL_DOWN;
conf->imgkey[14] = PSP_CTRL_LEFT;
conf->imgkey[15] = PSP_CTRL_RIGHT;
conf->flkey[0] = PSP_CTRL_CIRCLE;
conf->flkey[1] = PSP_CTRL_LTRIGGER;
conf->flkey[2] = PSP_CTRL_RTRIGGER;
conf->flkey[3] = PSP_CTRL_CROSS;
conf->flkey[4] = 0;
conf->flkey[5] = PSP_CTRL_TRIANGLE;
conf->flkey[6] = PSP_CTRL_SQUARE;
conf->flkey[7] = PSP_CTRL_LTRIGGER | PSP_CTRL_RTRIGGER;
conf->bicubic = false;
conf->mp3encode = conf_encode_gbk;
conf->lyricencode = conf_encode_gbk;
conf->mp3cycle = conf_cycle_repeat;
conf->isreading = false;
conf->slideinterval = 5;
conf->hprmctrl = false;
conf->grayscale = 30;
conf->showhidden = true;
conf->showunknown = true;
conf->showfinfo = true;
conf->allowdelete = true;
conf->arrange = conf_arrange_name;
conf->enableusb = false;
conf->viewpos = conf_viewpos_leftup;
conf->imgmvspd = 8;
conf->imgpaging = conf_imgpaging_direct;
conf->imgpaging_spd = 8;
conf->imgpaging_interval = 10;
conf->imgpaging_duration = 10;
conf->fontsize = 12;
conf->bookfontsize = 12;
conf->reordertxt = false;
conf->pagetonext = false;
conf->autopage = 0;
conf->autopagetype = 2;
conf->autolinedelay = 0;
conf->thumb = conf_thumb_scroll;
conf->imgpagereserve = 0;
#if defined(ENABLE_MUSIC) && defined(ENABLE_LYRIC)
conf->lyricex = 1;
#else
conf->lyricex = 0;
#endif
conf->autoplay = false;
conf->usettf = 0;
conf->freqs[0] = 1;
conf->freqs[1] = 5;
conf->freqs[2] = 8;
conf->imgbrightness = 100;
conf->dis_scrsave = false;
conf->autosleep = 0;
conf->load_exif = true;
conf->prev_autopage = 2;
conf->launchtype = 2;
/*
conf->titlecolor = RGB(0x80, 0x10, 0x10);
conf->menutextcolor = RGB(0xDF, 0xDF, 0xDF);
conf->menubcolor = RGB(0x40, 0x10, 0x10);
conf->selicolor = RGB(0xFF, 0xFF, 0x40);
conf->selbcolor = RGB(0x20, 0x20, 0xDF);
conf->msgbcolor = RGB(0x18, 0x28, 0x50);
*/
conf->titlecolor = RGB(0x30, 0x60, 0x30);
conf->menutextcolor = RGB(0xDF, 0xDF, 0xDF);
conf->menubcolor = RGB(0x10, 0x30, 0x20);
conf->selicolor = RGB(0xFF, 0xFF, 0x40);
conf->selbcolor = RGB(0x20, 0x20, 0xDF);
conf->msgbcolor = RGB(0x18, 0x28, 0x50);
conf->usedyncolor = false;
STRCPY_S(conf->cttfpath, scene_appdir());
STRCAT_S(conf->cttfpath, "fonts/gbk.ttf");
STRCPY_S(conf->ettfpath, scene_appdir());
STRCAT_S(conf->ettfpath, "fonts/asc.ttf");
conf->infobar_use_ttf_mode = true;
conf->img_no_repeat = false;
conf->hide_flash = true;
conf->tabstop = 4;
conf->apetagorder = true;
STRCPY_S(conf->language, "zh_CN");
conf->filelistwidth = 160;
if (kuKernelGetModel() == PSP_MODEL_STANDARD) {
conf->ttf_load_to_memory = false;
} else {
conf->ttf_load_to_memory = true;
}
conf->save_password = true;
conf->scrollbar_width = 5;
conf->hide_last_row = false;
conf->infobar_show_timer = true;
conf->infobar_fontsize = 12;
conf->englishtruncate = true;
conf->image_scroll_chgn_speed = true;
conf->ttf_haste_up = true;
conf->linenum_style = false;
conf->infobar_align = conf_align_left;
conf->show_encoder_msg = false;
SPRINTF_S(conf->musicdrv_opts,
"mp3_brute_mode=off mp3_use_me=on mp3_check_crc=off mp3_buffer_size=%d "
"wma_buffer_size=%d aac_buffer_size=%d wav_buffer_size=%d wv_buffer_size=%d "
"aa3_buffer_size=%d at3_buffer_size=%d m4a_buffer_size=%d "
"flac_buffer_size=%d",
BUFFERED_READER_BUFFER_SIZE, BUFFERED_READER_BUFFER_SIZE,
BUFFERED_READER_BUFFER_SIZE, BUFFERED_READER_BUFFER_SIZE,
WVPACK_BUFFERED_READER_BUFFER_SIZE, BUFFERED_READER_BUFFER_SIZE,
BUFFERED_READER_BUFFER_SIZE, BUFFERED_READER_BUFFER_SIZE,
BUFFERED_READER_BUFFER_SIZE);
conf->magnetic_scrolling = true;
conf->use_image_queue = true;
conf->max_cache_img = 10;
}
extern bool ini_conf_save(p_conf conf)
{
dictionary *dict;
FILE *fp;
char buf[PATH_MAX];
int i;
if (conf == NULL) {
return false;
}
conf->confver = XREADER_VERSION_NUM;
dict = dictionary_new(0);
if (dict == NULL)
return false;
fp = fopen(conf_filename, "w");
if (fp == NULL) {
return false;
}
if (iniparser_setstring(dict, "Global", NULL) != 0)
goto error;
if (iniparser_setstring(dict, "UI", NULL) != 0)
goto error;
if (iniparser_setstring(dict, "Text", NULL) != 0)
goto error;
if (iniparser_setstring(dict, "Image", NULL) != 0)
goto error;
if (iniparser_setstring(dict, "Music", NULL) != 0)
goto error;
iniparser_setstring(dict, "Global:path", conf->path);
iniparser_setstring(dict, "UI:forecolor",
hexToString(buf, sizeof(buf), conf->forecolor));
iniparser_setstring(dict, "Image:giftranscolor",
hexToString(buf, sizeof(buf), conf->giftranscolor));
iniparser_setstring(dict, "UI:bgcolor",
hexToString(buf, sizeof(buf), conf->bgcolor));
iniparser_setstring(dict, "UI:have_bg",
booleanToString(buf, sizeof(buf), conf->have_bg));
iniparser_setstring(dict, "UI:titlecolor",
hexToString(buf, sizeof(buf), conf->titlecolor));
iniparser_setstring(dict, "UI:menutextcolor",
hexToString(buf, sizeof(buf), conf->menutextcolor));
iniparser_setstring(dict, "UI:menubcolor",
hexToString(buf, sizeof(buf), conf->menubcolor));
iniparser_setstring(dict, "UI:selicolor",
hexToString(buf, sizeof(buf), conf->selicolor));
iniparser_setstring(dict, "UI:selbcolor",
hexToString(buf, sizeof(buf), conf->selbcolor));
iniparser_setstring(dict, "UI:msgbcolor",
hexToString(buf, sizeof(buf), conf->msgbcolor));
iniparser_setstring(dict, "UI:usedyncolor",
booleanToString(buf, sizeof(buf), conf->usedyncolor));
iniparser_setstring(dict, "Text:rowspace",
dwordToString(buf, sizeof(buf), conf->rowspace));
iniparser_setstring(dict, "Text:infobar",
infobarToString(buf, sizeof(buf), conf->infobar));
iniparser_setstring(dict, "Text:infobar_style",
intToString(buf, sizeof(buf), conf->infobar_style));
iniparser_setstring(dict, "Text:rlastrow",
booleanToString(buf, sizeof(buf), conf->rlastrow));
iniparser_setstring(dict, "Text:autobm",
booleanToString(buf, sizeof(buf), conf->autobm));
iniparser_setstring(dict, "Text:vertread",
vertreadToString(buf, sizeof(buf), conf->vertread));
iniparser_setstring(dict, "Text:encode",
encodeToString(buf, sizeof(buf), conf->encode));
iniparser_setstring(dict, "Image:fit",
fitToString(buf, sizeof(buf), conf->fit));
iniparser_setstring(dict, "Image:imginfobar",
booleanToString(buf, sizeof(buf), conf->imginfobar));
iniparser_setstring(dict, "Text:scrollbar",
booleanToString(buf, sizeof(buf), conf->scrollbar));
iniparser_setstring(dict, "Image:scale",
dwordToString(buf, sizeof(buf), conf->scale));
iniparser_setstring(dict, "Image:rotate",
rotateToString(buf, sizeof(buf), conf->rotate));
for (i = 0; i < 20; ++i) {
char key[20];
SPRINTF_S(key, "Text:txtkey1_%02d", i);
iniparser_setstring(dict, key,
hexToString(buf, sizeof(buf), conf->txtkey[i]));
SPRINTF_S(key, "Image:imgkey1_%02d", i);
iniparser_setstring(dict, key,
hexToString(buf, sizeof(buf), conf->imgkey[i]));
}
iniparser_setstring(dict, "Global:shortpath", conf->shortpath);
iniparser_setstring(dict, "Global:confver",
hexToString(buf, sizeof(buf), conf->confver));
iniparser_setstring(dict, "Image:bicubic",
booleanToString(buf, sizeof(buf), conf->bicubic));
iniparser_setstring(dict, "Text:wordspace",
dwordToString(buf, sizeof(buf), conf->wordspace));
iniparser_setstring(dict, "Text:borderspace",
dwordToString(buf, sizeof(buf), conf->borderspace));
iniparser_setstring(dict, "Global:lastfile", conf->lastfile);
iniparser_setstring(dict, "Music:mp3encode",
encodeToString(buf, sizeof(buf), conf->mp3encode));
iniparser_setstring(dict, "Music:lyricencode",
encodeToString(buf, sizeof(buf), conf->lyricencode));
iniparser_setstring(dict, "Music:mp3cycle",
cycleToString(buf, sizeof(buf), conf->mp3cycle));
iniparser_setstring(dict, "Global:isreading",
booleanToString(buf, sizeof(buf), conf->isreading));
iniparser_setstring(dict, "UI:bgarch", conf->bgarch);
iniparser_setstring(dict, "UI:bgfile", conf->bgfile);
iniparser_setstring(dict, "UI:bgwhere",
intToString(buf, sizeof(buf), conf->bgwhere));
iniparser_setstring(dict, "Image:slideinterval",
dwordToString(buf, sizeof(buf), conf->slideinterval));
iniparser_setstring(dict, "Music:hprmctrl",
booleanToString(buf, sizeof(buf), conf->hprmctrl));
iniparser_setstring(dict, "UI:grayscale",
intToString(buf, sizeof(buf), conf->grayscale));
iniparser_setstring(dict, "Global:showhidden",
booleanToString(buf, sizeof(buf), conf->showhidden));
iniparser_setstring(dict, "Global:showunknown",
booleanToString(buf, sizeof(buf), conf->showunknown));
iniparser_setstring(dict, "Global:showfinfo",
booleanToString(buf, sizeof(buf), conf->showfinfo));
iniparser_setstring(dict, "Global:allowdelete",
booleanToString(buf, sizeof(buf), conf->allowdelete));
iniparser_setstring(dict, "Global:arrange",
arrangeToString(buf, sizeof(buf), conf->arrange));
iniparser_setstring(dict, "Global:enableusb",
booleanToString(buf, sizeof(buf), conf->enableusb));
iniparser_setstring(dict, "Image:viewpos",
viewposToString(buf, sizeof(buf), conf->viewpos));
iniparser_setstring(dict, "Image:imgmvspd",
dwordToString(buf, sizeof(buf), conf->imgmvspd));
iniparser_setstring(dict, "Image:imgpaging",
imgpagingToString(buf, sizeof(buf), conf->imgpaging));
iniparser_setstring(dict, "Image:imgpaging_spd",
dwordToString(buf, sizeof(buf), conf->imgpaging_spd));
iniparser_setstring(dict, "Image:imgpaging_interval",
dwordToString(buf, sizeof(buf),
conf->imgpaging_interval));
iniparser_setstring(dict, "Image:imgpaging_duration",
dwordToString(buf, sizeof(buf),
conf->imgpaging_duration));
for (i = 0; i < 20; ++i) {
char key[20];
SPRINTF_S(key, "Global:flkey1_%02d", i);
iniparser_setstring(dict, key,
hexToString(buf, sizeof(buf), conf->flkey[i]));
}
iniparser_setstring(dict, "UI:fontsize",
intToString(buf, sizeof(buf), conf->fontsize));
iniparser_setstring(dict, "Text:reordertxt",
booleanToString(buf, sizeof(buf), conf->reordertxt));
iniparser_setstring(dict, "Text:pagetonext",
booleanToString(buf, sizeof(buf), conf->pagetonext));
iniparser_setstring(dict, "Text:autopage",
intToString(buf, sizeof(buf), conf->autopage));
iniparser_setstring(dict, "Text:prev_autopage",
intToString(buf, sizeof(buf), conf->prev_autopage));
iniparser_setstring(dict, "Text:autopagetype",
intToString(buf, sizeof(buf), conf->autopagetype));
iniparser_setstring(dict, "Text:autolinedelay",
intToString(buf, sizeof(buf), conf->autolinedelay));
iniparser_setstring(dict, "Image:thumb",
thumbToString(buf, sizeof(buf), conf->thumb));
iniparser_setstring(dict, "Text:bookfontsize",
intToString(buf, sizeof(buf), conf->bookfontsize));
iniparser_setstring(dict, "Text:enable_analog",
booleanToString(buf, sizeof(buf), conf->enable_analog));
iniparser_setstring(dict, "Image:img_enable_analog",
booleanToString(buf, sizeof(buf),
conf->img_enable_analog));
for (i = 0; i < 20; ++i) {
char key[20];
SPRINTF_S(key, "Text:txtkey2_%02d", i);
iniparser_setstring(dict, key,
hexToString(buf, sizeof(buf), conf->txtkey2[i]));
SPRINTF_S(key, "Image:imgkey2_%02d", i);
iniparser_setstring(dict, key,
hexToString(buf, sizeof(buf), conf->imgkey2[i]));
SPRINTF_S(key, "Global:flkey2_%02d", i);
iniparser_setstring(dict, key,
hexToString(buf, sizeof(buf), conf->flkey2[i]));
}
iniparser_setstring(dict, "Image:imgpagereserve",
dwordToString(buf, sizeof(buf), conf->imgpagereserve));
iniparser_setstring(dict, "Music:lyricex",
dwordToString(buf, sizeof(buf), conf->lyricex));
iniparser_setstring(dict, "Music:autoplay",
booleanToString(buf, sizeof(buf), conf->autoplay));
iniparser_setstring(dict, "Text:usettf",
booleanToString(buf, sizeof(buf), conf->usettf));
iniparser_setstring(dict, "Text:cttfarch", conf->cttfarch);
iniparser_setstring(dict, "Text:cttfpath", conf->cttfpath);
iniparser_setstring(dict, "Text:ettfarch", conf->ettfarch);
iniparser_setstring(dict, "Text:ettfpath", conf->ettfpath);
for (i = 0; i < 3; ++i) {
char key[20];
SPRINTF_S(key, "Global:freqs_%d", i);
iniparser_setstring(dict, key,
intToString(buf, sizeof(buf), conf->freqs[i]));
}
iniparser_setstring(dict, "Image:imgbrightness",
intToString(buf, sizeof(buf), conf->imgbrightness));
iniparser_setstring(dict, "Global:dis_scrsave",
booleanToString(buf, sizeof(buf), conf->dis_scrsave));
iniparser_setstring(dict, "Global:autosleep",
intToString(buf, sizeof(buf), conf->autosleep));
iniparser_setstring(dict, "Image:load_exif",
booleanToString(buf, sizeof(buf), conf->load_exif));
iniparser_setstring(dict, "Global:launchtype",
intToString(buf, sizeof(buf), conf->launchtype));
iniparser_setstring(dict, "Text:infobar_use_ttf_mode",
booleanToString(buf, sizeof(buf),
conf->infobar_use_ttf_mode));
iniparser_setstring(dict, "Text:infobar_fontsize",
dwordToString(buf, sizeof(buf),
conf->infobar_fontsize));
iniparser_setstring(dict, "Image:no_repeat",
booleanToString(buf, sizeof(buf), conf->img_no_repeat));
iniparser_setstring(dict, "Global:hide_flash",
booleanToString(buf, sizeof(buf), conf->hide_flash));
iniparser_setstring(dict, "Text:tabstop",
dwordToString(buf, sizeof(buf), conf->tabstop));
iniparser_setstring(dict, "Music:apetagorder",
booleanToString(buf, sizeof(buf), conf->apetagorder));
iniparser_setstring(dict, "UI:language", conf->language);
iniparser_setstring(dict, "UI:filelistwidth",
intToString(buf, sizeof(buf), conf->filelistwidth));
iniparser_setstring(dict, "Text:ttf_load_to_memory",
booleanToString(buf, sizeof(buf),
conf->ttf_load_to_memory));
iniparser_setstring(dict, "Global:save_password",
booleanToString(buf, sizeof(buf), conf->save_password));
iniparser_setstring(dict, "Text:scrollbar_width",
intToString(buf, sizeof(buf), conf->scrollbar_width));
iniparser_setstring(dict, "Text:hide_last_row",
booleanToString(buf, sizeof(buf), conf->hide_last_row));
iniparser_setstring(dict, "Text:infobar_show_timer",
booleanToString(buf, sizeof(buf),
conf->infobar_show_timer));
iniparser_setstring(dict, "Text:englishtruncate",
booleanToString(buf, sizeof(buf),
conf->englishtruncate));
iniparser_setstring(dict, "Image:image_scroll_chgn_speed",
booleanToString(buf, sizeof(buf),
conf->image_scroll_chgn_speed));
iniparser_setstring(dict, "Text:ttf_haste_up",
booleanToString(buf, sizeof(buf), conf->ttf_haste_up));
iniparser_setstring(dict, "Text:linenum_style",
booleanToString(buf, sizeof(buf), conf->linenum_style));
iniparser_setstring(dict, "Text:infobar_align",
alignToString(buf, sizeof(buf), conf->infobar_align));
iniparser_setstring(dict, "Music:musicdrv_opts", conf->musicdrv_opts);
iniparser_setstring(dict, "Image:magnetic_scrolling",
booleanToString(buf, sizeof(buf),
conf->magnetic_scrolling));
iniparser_setstring(dict, "Image:use_image_queue",
booleanToString(buf, sizeof(buf),
conf->use_image_queue));
iniparser_setstring(dict, "Image:max_cache_img",
dwordToString(buf, sizeof(buf), conf->max_cache_img));
iniparser_setstring(dict, "Music:show_encoder_msg",
booleanToString(buf, sizeof(buf),
conf->show_encoder_msg));
iniparser_dump_ini(dict, fp);
fclose(fp);
dictionary_del(dict);
return true;
error:
if (fp != NULL)
fclose(fp);
return false;
}
void AudioAECThread::DoJob()
{
DEBUG_INFO("AudioAECThread::DoJob()......");
#ifdef ENABLE_AUDIO_AEC
RecPkgQueue* pQueueMic = ::GetMicQueue();
RecPkgQueue* pQueueRef = ::GetRefQueue();
RecPkgQueue* pQueueOut = ::GetOutQueue();
AECQueue aecQueue(pQueueMic, pQueueRef);
EchoCanceller aec;
bool bUseAEC = ::GetUseAEC();// enable AEC on recorded data ?
BYTE* pAecOut = NULL;
if (bUseAEC)
{
aec.Init();
pAecOut = new BYTE[RECORD_SEND_BUFFER_SIZE]; //TODO: customization needed
DEBUG_INFO(L"AEC EN-ABLED for audio data");
}
else
DEBUG_INFO(L"AEC DIS-ABLED for audio data");
int nSentMiced = 0;
double dLastMatchedMic = 0,
dLastMatchedRef = 0;
bool bMatchedBefore = false;
for(; IsWorking(); )
{
while (IsWorking() && pQueueMic->size())
{
if (bUseAEC)
{
if ( pQueueRef->size() == 0 )
{
//TODO: no play data, if never did AEC, record data is ok to send out
// otherwise, reserve for sync & AEC
if (!bMatchedBefore)
{
#ifdef PRINT_AEC_INFO
SPRINTF_S(dbg_str,
"Audio data: mic sent= %d"
, nSentMiced);
DEBUG_INFO(dbg_str);
#endif//PRINT_AEC_INFO
++nSentMiced;
RecPkgQueue::const_reference& pBufMic = pQueueMic->front();
pQueueOut->push_back(pBufMic);
pQueueMic->pop_front();
}
}
else
{
int idxMic = 0, idxRef = 0;
bool bMatch = aecQueue.FindMatch(AEC_TIME_OFFSET, MAX_AEC_TIME_INTERVAL, idxMic, idxRef);
if (bMatch)
{
bMatchedBefore = true;
while (idxMic > 0)
{
pQueueMic->pop_front();
--idxMic;
}
while (idxRef > 1) // TODO: reserve 1 play for later match
{
pQueueRef->pop_front();
--idxRef;
}
RecPkgQueue::const_reference& pBufMic = pQueueMic->front();
RecPkgQueue::reference& pBufRef = pQueueRef->front();
if (idxRef == 1)
pBufRef = pQueueRef->at(1);
const int nSizeMic = pBufMic->getSize();
const int nSizeRef = pBufRef->getSize();
ASSERT(nSizeMic == nSizeRef);
aec.DoAEC(pBufMic->getBuffer(), pBufRef->getBuffer(), pAecOut);
RecPkgQueue::element_type buf2Send(new AudioBuffer(pAecOut, RECORD_SEND_BUFFER_SIZE, 0));//TODO: customization needed
pQueueOut->push_back(buf2Send);
pQueueMic->pop_front();
}
else
{
// if can't found matched audio data, reserve it for later use
#ifdef PRINT_AEC_INFO
SPRINTF_S(dbg_str,
"Audio data match failed, ref queue = %d"
, pQueueRef->size());
DEBUG_INFO(dbg_str);
#endif//PRINT_AEC_INFO
}
jrtplib::RTPTime::Wait(jrtplib::RTPTime(0, 1));
}
}
else // bUseAEC == false
{
RecPkgQueue::const_reference& pBufMic = pQueueMic->front();
pQueueOut->push_back(pBufMic);
pQueueMic->pop_front();
}
jrtplib::RTPTime::Wait(jrtplib::RTPTime(0, 1));
}
jrtplib::RTPTime::Wait(jrtplib::RTPTime(0, 1));
}
if (bUseAEC)
{
aec.Uninit();
delete[] pAecOut;
}
#else//ENABLE_AUDIO_AEC
ASSERT(0); // use this thread while ENABLE_AUDIO_AEC disabled?
#endif//ENABLE_AUDIO_AEC
DEBUG_INFO("AudioAECThread::DoJob() DONE");
}
bool AECQueue::FindMatch(double offset, double maxTimeInterval, int& idxMic, int& idxRef)
{
//const double dMaxInterval = 10000;
//double minInterval = dMaxInterval;
double dMic = 0;
double dRef = 0;
#ifdef PRINT_AEC_INFO
SPRINTF_S(dbg_str,
"Audio data match: mic queue=%d\tref queue=%d"
" offset: %.4f interval: %.4f"
, m_pQueueMic->size(), m_pQueueRef->size()
, offset, maxTimeInterval);
DEBUG_INFO(dbg_str);
#endif//PRINT_AEC_INFO
bool bMatch = false;
bool bMicBehindOfPlay = false;
m_cs.Lock();
for (size_t i=0; !bMatch && i < m_pQueueMic->size(); ++i)
{
//#ifdef PRINT_AEC_INFO
// SPRINTF_S(dbg_str,
// "Audio data match: mic index=%d"
// , i);
// DEBUG_INFO(dbg_str);
//#endif//PRINT_AEC_INFO
bMicBehindOfPlay = false;
RecPkgQueue::const_reference& pBufMic = m_pQueueMic->at(i);
dMic = pBufMic->GetRecordedOrPlayedTime();
for (size_t j=0; !bMatch && j < m_pQueueRef->size(); ++j)
//size_t j=0;
{
//#ifdef PRINT_AEC_INFO
// SPRINTF_S(dbg_str,
// "Audio data match: ref index=%d"
// , j);
// DEBUG_INFO(dbg_str);
//#endif//PRINT_AEC_INFO
RecPkgQueue::const_reference& pBufRef = m_pQueueRef->at(j);
dRef = pBufRef->GetRecordedOrPlayedTime();
#ifdef PRINT_AEC_INFO
SPRINTF_S(dbg_str,
"Audio data time of mic[%d]: %f\tref[%d]: %f"
, i, dMic
, j, dRef);
DEBUG_INFO(dbg_str);
#endif//PRINT_AEC_INFO
//double interval = dMic - dRef/* - maxTimeInterval*/;
double interval = (dMic - offset) - dRef/* - maxTimeInterval*/;
if (interval < 0)
{ // mic now ahead of this play
if (bMicBehindOfPlay) // last play ahead of this mic
{
idxMic = i;
idxRef = j - 1;
bMatch = true;
break;
}
//else
//{
// if (interval * (-1) < maxTimeInterval / 4)
// {
// idxMic = i;
// idxRef = j;
// bMatch = true;
// break;
// }
// else
// {// mic too much ahead of rec, try another mic
// break;
// }
//}
}
else if (interval > 0)
{ // mic now behind of this play
bMicBehindOfPlay = true;
if (interval < maxTimeInterval * 1.5)
{
idxMic = i;
idxRef = j;
bMatch = true;
break;
}
}
}
}
if (bMatch)
{
#ifdef PRINT_AEC_INFO
SPRINTF_S(dbg_str,
"Audio data matched: "
"\tat mic: %d"
"\tat ref: %d"
, idxMic
, idxRef);
DEBUG_INFO(dbg_str);
#endif//PRINT_AEC_INFO
}
else
{
#ifdef PRINT_AEC_INFO
//DEBUG_INFO("Audio data NO MATCH found!");
#endif//PRINT_AEC_INFO
}
m_cs.Unlock();
return bMatch;
}
extern u32 fs_rar_to_menu(const char *rarfile, u32 icolor, u32 selicolor, u32 selrcolor, u32 selbcolor)
{
int fid;
struct RAROpenArchiveData arcdata;
struct RARHeaderDataEx header;
int ret;
HANDLE hrar;
t_fs_filetype ft;
t_win_menuitem item;
if (menu_renew(&g_menu) == NULL) {
return 0;
}
fid = freq_enter_hotzone();
arcdata.ArcName = (char *) rarfile;
arcdata.OpenMode = RAR_OM_LIST;
arcdata.CmtBuf = NULL;
arcdata.CmtBufSize = 0;
hrar = RAROpenArchive(&arcdata);
if (hrar == 0) {
freq_leave(fid);
return 0;
}
add_parent_to_menu(g_menu, icolor, selicolor, selrcolor, selbcolor);
do {
char t[20];
if ((ret = RARReadHeaderEx(hrar, &header)) != 0) {
if (ret != ERAR_UNKNOWN)
break;
RARCloseArchive(hrar);
if ((hrar = reopen_rar_with_passwords(&arcdata)) == 0)
break;
if (RARReadHeaderEx(hrar, &header) != 0)
break;
}
if (header.UnpSize == 0)
continue;
ft = fs_file_get_type(header.FileName);
if (ft == fs_filetype_chm || ft == fs_filetype_zip || ft == fs_filetype_rar)
continue;
win_menuitem_new(&item);
item.data = (void *) ft;
if (header.Flags & 0x200) {
char str[1024];
const u8 *uni;
memset(str, 0, 1024);
uni = (u8 *) header.FileNameW;
charsets_utf32_conv(uni, sizeof(header.FileNameW), (u8 *) str, sizeof(str));
buffer_copy_string_len(item.compname, header.FileName, 256);
filename_to_itemname(&item, str);
} else {
buffer_copy_string_len(item.compname, header.FileName, 256);
filename_to_itemname(&item, header.FileName);
}
SPRINTF_S(t, "%u", (unsigned int) header.UnpSize);
buffer_copy_string(item.shortname, t);
item.selected = false;
item.icolor = icolor;
item.selicolor = selicolor;
item.selrcolor = selrcolor;
item.selbcolor = selbcolor;
item.data3 = header.UnpSize;
win_menu_add(g_menu, &item);
} while (RARProcessFile(hrar, RAR_SKIP, NULL, NULL) == 0);
RARCloseArchive(hrar);
freq_leave(fid);
return g_menu->size;
}
extern u32 fs_umd_to_menu(const char *umdfile, u32 icolor, u32 selicolor, u32 selrcolor, u32 selbcolor)
{
buffer *pbuf = NULL;
u32 cur_count = 1;
int fid;
t_win_menuitem item;
if (menu_renew(&g_menu) == NULL) {
return 0;
}
fid = freq_enter_hotzone();
add_parent_to_menu(g_menu, icolor, selicolor, selrcolor, selbcolor);
do {
size_t stlen = 0;
u_int i = 1;
struct t_chapter *p;
char pos[20] = { 0 };
if (!p_umdchapter || (p_umdchapter->umdfile->ptr && strcmp(p_umdchapter->umdfile->ptr, umdfile))) {
if (p_umdchapter)
umd_chapter_reset(p_umdchapter);
p_umdchapter = umd_chapter_init();
if (!p_umdchapter)
break;
buffer_copy_string(p_umdchapter->umdfile, umdfile);
cur_count = parse_umd_chapters(umdfile, &p_umdchapter);
} else
cur_count = p_umdchapter->chapter_count + 1;
if (cur_count > 1) {
p = p_umdchapter->pchapters;
pbuf = buffer_init();
if (!pbuf || buffer_prepare_copy(pbuf, 256) < 0)
break;
for (i = 1; i < cur_count; i++) {
stlen = p[i - 1].name->used - 1;
stlen = charsets_ucs_conv((const u8 *) p[i - 1].name->ptr, stlen, (u8 *) pbuf->ptr, pbuf->size);
SPRINTF_S(pos, "%d", p[i - 1].length);
win_menuitem_new(&item);
buffer_copy_string_len(item.shortname, pos, 20);
buffer_copy_string_len(item.compname, pbuf->ptr, (stlen > 256) ? 256 : stlen);
filename_to_itemname(&item, item.compname->ptr);
if (1 != p_umdchapter->umd_type) {
if (0 == p_umdchapter->umd_mode)
item.data = (void *) fs_filetype_bmp;
else if (1 == p_umdchapter->umd_mode)
item.data = (void *) fs_filetype_jpg;
else
item.data = (void *) fs_filetype_gif;
} else
item.data = (void *) fs_filetype_txt;
item.data2[0] = p[i - 1].chunk_pos & 0xFFFF;
item.data2[1] = (p[i - 1].chunk_pos >> 16) & 0xFFFF;
item.data2[2] = p[i - 1].chunk_offset & 0xFFFF;
item.data2[3] = (p[i - 1].chunk_offset >> 16) & 0xFFFF;
item.data3 = p[i - 1].length;
#if 0
printf("%d pos:%d,%d,%d-%d,%d\n", i, p[i - 1].chunk_pos, item.data2[0], item.data2[1], item.data2[2], item.data2[3]);
#endif
item.selected = false;
item.icolor = icolor;
item.selicolor = selicolor;
item.selrcolor = selrcolor;
item.selbcolor = selbcolor;
//buffer_free(p[i - 1].name);
win_menu_add(g_menu, &item);
}
#if 0
printf("%s umd file:%s type:%d,mode:%d,chapter count:%ld\n", __func__, umdfile, p_umdchapter->umd_type, p_umdchapter->umd_mode, cur_count);
#endif
}
} while (false);
if (pbuf)
buffer_free(pbuf);
freq_leave(fid);
return g_menu->size;
}
static void scene_show_info(int selidx)
{
char infostr[64];
int ilen;
if (config.fit == conf_fit_custom)
SPRINTF_S(infostr, _("%dx%d %d%% 旋转角度 %d %s"),
(int) width_rotated, (int) height_rotated,
(int) config.scale, (int) oldangle,
config.bicubic ? _("三次立方") : _("两次线性"));
else
SPRINTF_S(infostr, _("%dx%d %s 旋转角度 %d %s"),
(int) width_rotated, (int) height_rotated,
conf_get_fitname(config.fit), (int) oldangle,
config.bicubic ? _("三次立方") : _("两次线性"));
ilen = strlen(infostr);
if (config.imginfobar) {
if (config.load_exif && exif_array && exif_array->used > 0) {
int width = exif_max_width();
int height, line_num, top, left, right;
int i;
width =
width > PSP_SCREEN_WIDTH - 10 ? PSP_SCREEN_WIDTH - 10 : width;
height = PSP_SCREEN_HEIGHT / DISP_FONTSIZE - 1;
line_num =
exif_array->used <= height ? exif_array->used : height;
top =
(PSP_SCREEN_HEIGHT -
(1 + height) * DISP_FONTSIZE) / 2 >
1 ? (PSP_SCREEN_HEIGHT - (1 + height) * DISP_FONTSIZE) / 2 : 1;
left =
(PSP_SCREEN_WIDTH - width) / 4 - 10 <
1 ? 1 : (PSP_SCREEN_WIDTH - width) / 4 - 10;
right =
(PSP_SCREEN_WIDTH + 3 * width) / 4 >=
PSP_SCREEN_WIDTH - 1 ? PSP_SCREEN_WIDTH -
2 : (PSP_SCREEN_WIDTH + 3 * width) / 4;
disp_fillrect(left, top, right, top + DISP_FONTSIZE * line_num, 0);
disp_rectangle(left - 1, top - 1, right + 1,
top + DISP_FONTSIZE * line_num + 1, COLOR_WHITE);
for (i = 0; i < line_num; ++i) {
const char *teststr = exif_array->ptr[i]->ptr;
disp_putnstring((PSP_SCREEN_WIDTH -
width) / 4,
top + i * DISP_FONTSIZE,
COLOR_WHITE,
(const byte *) teststr,
strlen(teststr), 0, 0, DISP_FONTSIZE, 0);
}
}
disp_fillrect(0, PSP_SCREEN_HEIGHT - DISP_FONTSIZE, 479, 271, 0);
disp_putnstring(0, PSP_SCREEN_HEIGHT - DISP_FONTSIZE,
COLOR_WHITE,
(const byte *) filelist[selidx].name,
960 / DISP_FONTSIZE - ilen - 1, 0, 0, DISP_FONTSIZE, 0);
disp_putnstring(PSP_SCREEN_WIDTH -
DISP_FONTSIZE / 2 * ilen,
PSP_SCREEN_HEIGHT - DISP_FONTSIZE,
COLOR_WHITE, (const byte *) infostr,
ilen, 0, 0, DISP_FONTSIZE, 0);
} else {
disp_fillrect(11, 11, 10 + DISP_FONTSIZE / 2 * ilen,
10 + DISP_FONTSIZE, 0);
disp_putnstring(11, 11, COLOR_WHITE,
(const byte *) infostr, ilen, 0, 0, DISP_FONTSIZE, 0);
}
}
static int mp3_load(const char *spath, const char *lpath)
{
int ret;
__init();
dbg_printf(d, "%s: loading %s", __func__, spath);
g_status = ST_UNKNOWN;
mp3_data.use_buffer = true;
mp3_data.fd = xrIoOpen(spath, PSP_O_RDONLY, 0777);
if (mp3_data.fd < 0)
return -1;
g_info.filesize = xrIoLseek(mp3_data.fd, 0, PSP_SEEK_END);
xrIoLseek(mp3_data.fd, 0, PSP_SEEK_SET);
mp3_data.size = g_info.filesize;
if (g_info.filesize < 0)
return g_info.filesize;
xrIoLseek(mp3_data.fd, 0, PSP_SEEK_SET);
mad_stream_init(&stream);
mad_frame_init(&frame);
mad_synth_init(&synth);
if (use_me) {
if ((ret = me_init()) < 0) {
dbg_printf(d, "me_init failed: %d", ret);
use_me = false;
}
}
mp3info.check_crc = check_crc;
mp3info.have_crc = false;
if (use_brute_method) {
if (read_mp3_info_brute(&mp3info, &mp3_data) < 0) {
__end();
return -1;
}
} else {
if (read_mp3_info(&mp3info, &mp3_data) < 0) {
__end();
return -1;
}
}
g_info.channels = mp3info.channels;
g_info.sample_freq = mp3info.sample_freq;
g_info.avg_bps = mp3info.average_bitrate;
g_info.samples = mp3info.frames;
g_info.duration = mp3info.duration;
generic_readtag(&g_info, spath);
if (mp3_data.use_buffer) {
SceOff cur = xrIoLseek(mp3_data.fd, 0, PSP_SEEK_CUR);
xrIoClose(mp3_data.fd);
mp3_data.fd = -1;
mp3_data.r = buffered_reader_open(spath, g_io_buffer_size, 1);
if (mp3_data.r == NULL) {
__end();
return -1;
}
buffered_reader_seek(mp3_data.r, cur);
}
dbg_printf(d, "[%d channel(s), %d Hz, %.2f kbps, %02d:%02d%sframes %d%s]",
g_info.channels, g_info.sample_freq,
g_info.avg_bps / 1000,
(int) (g_info.duration / 60), (int) g_info.duration % 60,
mp3info.frameoff != NULL ? ", frame table, " : ", ",
g_info.samples, mp3info.have_crc ? ", crc passed" : "");
#ifdef _DEBUG
if (mp3info.lame_encoded) {
char lame_method[80];
char encode_msg[80];
switch (mp3info.lame_mode) {
case ABR:
STRCPY_S(lame_method, "ABR");
break;
case CBR:
STRCPY_S(lame_method, "CBR");
break;
case VBR:
SPRINTF_S(lame_method, "VBR V%1d", mp3info.lame_vbr_quality);
break;
default:
break;
}
if (mp3info.lame_str[strlen(mp3info.lame_str) - 1] == ' ')
SPRINTF_S(encode_msg, "%s%s", mp3info.lame_str, lame_method);
else
SPRINTF_S(encode_msg, "%s %s", mp3info.lame_str, lame_method);
dbg_printf(d, "[ %s ]", encode_msg);
}
#endif
ret = xAudioInit();
if (ret < 0) {
__end();
return -1;
}
ret = xAudioSetFrequency(g_info.sample_freq);
if (ret < 0) {
__end();
return -1;
}
g_buff = xAudioAlloc(0, BUFF_SIZE);
if (g_buff == NULL) {
__end();
return -1;
}
if (use_me)
xAudioSetChannelCallback(0, memp3_audiocallback, NULL);
else
xAudioSetChannelCallback(0, mp3_audiocallback, NULL);
generic_lock();
g_status = ST_LOADED;
generic_unlock();
return 0;
}
extern u32 fs_zip_to_menu(const char *zipfile, u32 icolor, u32 selicolor, u32 selrcolor, u32 selbcolor)
{
int fid;
unzFile unzf;
t_win_menuitem item;
if (menu_renew(&g_menu) == NULL) {
return 0;
}
fid = freq_enter_hotzone();
unzf = unzOpen(zipfile);
if (unzf == NULL) {
freq_leave(fid);
return 0;
}
add_parent_to_menu(g_menu, icolor, selicolor, selrcolor, selbcolor);
if (unzGoToFirstFile(unzf) != UNZ_OK) {
unzClose(unzf);
freq_leave(fid);
return g_menu->size;
}
do {
char fname[PATH_MAX];
unz_file_info file_info;
t_fs_filetype ft;
char t[20];
if (unzGetCurrentFileInfo(unzf, &file_info, fname, PATH_MAX, NULL, 0, NULL, 0) != UNZ_OK)
break;
if (file_info.uncompressed_size == 0)
continue;
ft = fs_file_get_type(fname);
if (ft == fs_filetype_chm || ft == fs_filetype_zip || ft == fs_filetype_rar)
continue;
win_menuitem_new(&item);
item.data = (void *) ft;
buffer_copy_string(item.compname, fname);
SPRINTF_S(t, "%u", (unsigned int) file_info.uncompressed_size);
buffer_copy_string(item.shortname, t);
filename_to_itemname(&item, fname);
item.selected = false;
item.icolor = icolor;
item.selicolor = selicolor;
item.selrcolor = selrcolor;
item.selbcolor = selbcolor;
item.data3 = file_info.uncompressed_size;
win_menu_add(g_menu, &item);
} while (unzGoToNextFile(unzf) == UNZ_OK);
unzClose(unzf);
freq_leave(fid);
return g_menu->size;
}
