void PA_file_mon(char *edname, char *ppname, char *gfname)
{int64_t curpos;
/* check on the edit file */
if (PA_gs.edit_file != NULL)
{if (_PA.edstr == 0L)
_PA.edstr = io_tell(PA_gs.edit_file);
curpos = io_tell(PA_gs.edit_file);
if (curpos+_PA.edstr >= MAXSIZE)
{io_close(PA_gs.edit_file);
PA_advance_name(edname);
PA_gs.edit_file = io_open(edname, "w");
PA_ERR((PA_gs.edit_file == NULL),
"CAN'T OPEN FILE %s - PA_FILE_MON", edname);
PRINT(stdout, "Edit file %s opened\n", edname);
_PA.edstr = 0L;};};
/* check on the post processor */
if (PA_gs.pp_file != NULL)
{FILE *str;
str = PA_gs.pp_file->stream;
if (_PA.ppstr == 0L)
_PA.ppstr = lio_tell(str);
curpos = lio_tell(str);
if (curpos+_PA.ppstr >= MAXSIZE)
{PA_close_pp();
PA_advance_name(ppname);
PA_gs.pp_file = PA_open(ppname, "w", FALSE);
PRINT(stdout, "Post processor file %s opened\n", ppname);
_PA.ppstr = 0L;};};
/* check on the PVA file */
if (PA_gs.pva_file != NULL)
{FILE *str;
str = PA_gs.pva_file->stream;
if (_PA.ppstr == 0L)
_PA.ppstr = lio_tell(str);
curpos = lio_tell(str);
if (curpos+_PA.ppstr >= MAXSIZE)
{PD_close(PA_gs.pva_file);
PA_advance_name(gfname);
PA_gs.pva_file = PA_open(gfname, "w", FALSE);
PA_ERR(((PA_gs.pva_file == NULL) ||
(PD_def_mapping(PA_gs.pva_file) == 0)),
"CAN`T DEFINE MAPPINGS - PA_FILE_MON");
PRINT(stdout, "PVA file %s opened\n", gfname);
_PA.ppstr = 0L;};};
return;}
/*-------------------------------------------------------------------------
* Function: lite_PD_get_file_length
*
* Purpose: Return current file size
*
* Programmer: Adapted from PACT, Mark C. Miller, 26Feb08
*
*-------------------------------------------------------------------------
*/
long lite_PD_get_file_length(PDBfile *file) {
off_t caddr, flen;
caddr = io_tell(file->stream);
io_seek(file->stream, 0, SEEK_END);
flen = io_tell(file->stream);
io_seek(file->stream, caddr, SEEK_SET);
return((long)flen);
}
static int aac_count_time (struct aac_data *data)
{
NeAACDecFrameInfo frame_info;
int samples = 0, bytes = 0, frames = 0;
off_t file_size;
char *sample_buf;
long saved_pos;
file_size = io_file_size (data->stream);
if (file_size == -1)
return -1;
saved_pos = io_tell (data->stream);
/* guess track length by decoding the first 10 frames */
while (frames < 10) {
if (buffer_fill_frame(data) <= 0)
break;
sample_buf = NeAACDecDecode(data->decoder, &frame_info,
buffer_data(data), buffer_length(data));
if (frame_info.error == 0 && frame_info.samples > 0) {
samples += frame_info.samples;
bytes += frame_info.bytesconsumed;
frames++;
}
if (frame_info.bytesconsumed == 0)
break;
buffer_consume (data, frame_info.bytesconsumed);
}
if (io_seek(data->stream, saved_pos, SEEK_SET) == (off_t)-1) {
logit ("Can't seek after couting time");
return -1;
}
if (frames == 0)
return -1;
samples /= frames;
samples /= data->channels;
bytes /= frames;
return ((file_size / bytes) * samples) / data->sample_rate;
}
static syment *
_PD_write (PDBfile *file, char *name, char *intype, char *outtype,
lite_SC_byte *vr, dimdes *dims, int appnd) {
int reset;
syment *ep;
long number, addr;
char bf[MAXLINE], fullpath[MAXLINE], *lname;
_append_flag = FALSE;
ep = NULL;
switch (setjmp(_lite_PD_write_err)) {
case ABORT : return(NULL);
case ERR_FREE : return(ep);
default : memset(lite_PD_err, 0, MAXLINE);
break;
}
if (file->mode == PD_OPEN) {
lite_PD_error("FILE OPENED IN READ-ONLY MODE - _PD_WRITE", PD_WRITE);
}
strcpy(fullpath, _lite_PD_fixname(file, name));
/*
* Append a new block to an existing entry if TRUE.
*/
if (appnd) {
strcpy(bf, fullpath);
/*
* Do this so that things such as a[20:20].b work properly
* NOTE: this also implies that a[20:20].b.c works while
* a.b[20:20].c doesn't
* for now this defines the semantics of append (10/6/93)
*/
lname = lite_SC_firsttok(bf, ".()[]");
ep = lite_PD_inquire_entry(file, lname, FALSE, NULL);
if (ep == NULL) {
lite_PD_error("CAN'T APPEND TO NON-EXISTING ENTRY - _PD_WRITE",
PD_WRITE);
}
_lite_PD_adj_dimensions(file, fullpath, ep);
/*
* Extend the syment.
*/
_lite_PD_add_block(file, ep, dims);
}
addr = file->chrtaddr;
ep = _lite_PD_effective_ep(file, fullpath, FALSE, NULL);
if (ep != NULL) {
/*
* If the variable already exists use the existing file info.
*/
addr = PD_entry_address(ep);
_lite_PD_rl_dimensions(dims);
lname = fullpath;
reset = FALSE;
} else {
/*
* If the variable doesn't exist define it to the file.
*/
number = _lite_PD_comp_num(dims);
ep = _lite_PD_mk_syment(outtype, number, addr, NULL, dims);
strcpy(bf, fullpath);
lname = lite_SC_firsttok(bf, ".([ ");
_lite_PD_e_install(lname, ep, file->symtab);
reset = TRUE;
}
if (file->virtual_internal) {
SC_address ad;
ad.memaddr = vr;
ep->blocks->diskaddr = ad.diskaddr;
lite_SC_mark(vr, 1);
ep = lite_PD_copy_syment(ep);
} else {
if (outtype == NULL) outtype = PD_entry_type(ep);
if (intype == NULL) intype = outtype;
/*
* Go to the correct address.
*/
if (io_seek(file->stream, addr, SEEK_SET)) {
lite_PD_error("FSEEK FAILED TO FIND CURRENT ADDRESS - _PD_WRITE",
PD_WRITE);
}
/*
* Do the low level write.
*/
if (!_lite_PD_hyper_write(file, lname, ep, vr, intype)) {
lite_PD_error("CAN'T WRITE VARIABLE - _PD_WRITE", PD_WRITE);
}
/*
* If the variable didn't previously exist we're at the end
* of the file.
*/
if (reset) {
file->chrtaddr = io_tell(file->stream);
if (file->chrtaddr == -1L) {
lite_PD_error("CAN'T FIND ADDRESS OF NEXT VARIABLE - _PD_WRITE",
PD_WRITE);
}
/*
* Make a releasable copy of the entry
* SX depends on this critically!!
*/
ep = lite_PD_copy_syment(ep);
}
}
return(ep);
}
/*-------------------------------------------------------------------------
* Function: lite_PD_open
*
* Purpose: Open an existing PDB file, extract the symbol table and
* structure chart.
*
* Return: Success: Ptr to the PDB file structure
*
* Failure: NULL
*
* Programmer: Adapted from the PACT PDB library
* Mar 4, 1996 10:26 AM EST
*
* Modifications:
*
* Robb Matzke, 4 Mar 1996
* Fixed indentation. Files can only be opened with mode `r'.
*
* Robb Matzke, 17 Apr 1996
* Added write capability back into the function, but it is protected
* with #ifdef PDB_WRITE.
*
* Mark C. Miller, Fri Apr 13 22:37:56 PDT 2012
* Changed mode string checks to strchr to accomodate wider variety
* of mode characters for new hash table size and open modes.
*
* Mark C. Miller, Thu Jun 14 13:25:02 PDT 2012
* Remove call to io_close in ABORT case. The file pointer may not
* have been properly initialized.
*-------------------------------------------------------------------------
*/
PDBfile *
lite_PD_open (char *name, char *mode) {
char str[MAXLINE], *token;
PDBfile *file=NULL;
static FILE *fp;
syment *ep;
#ifdef PDB_WRITE
/*
* If opened in write mode use PD_CREATE instead.
*/
if (strchr(mode,'w')) return lite_PD_create (name);
#else
assert (!strchr(mode,'r')) ;
#endif
switch (setjmp(_lite_PD_open_err)) {
case ABORT:
if (fp) io_close(fp);
return(NULL);
case ERR_FREE:
return(file);
default:
memset(lite_PD_err, 0, MAXLINE);
break;
}
/*
* Open the file
*/
strcpy(str, name);
#ifdef PDB_WRITE
fp = io_open(str, BINARY_MODE_RPLUS);
if (fp == NULL) {
if (strchr(mode,'r')) {
#endif
fp = io_open(str, BINARY_MODE_R);
if (fp == NULL) {
lite_PD_error("CAN'T OPEN FILE IN READ-ONLY MODE - PD_OPEN",
PD_OPEN);
}
#ifdef PDB_WRITE
} else if (strchr(mode,'a')) {
return lite_PD_create (name);
} else {
lite_PD_error("CAN'T OPEN FILE - PD_OPEN", PD_OPEN);
}
}
#endif
if (lite_PD_buffer_size != -1) {
if (io_setvbuf(fp, NULL, _IOFBF, (size_t) lite_PD_buffer_size)) {
lite_PD_error("CAN'T SET FILE BUFFER - PD_OPEN", PD_OPEN);
}
}
file = _lite_PD_mk_pdb(str, mode);
if (file == NULL) {
lite_PD_error("CAN'T ALLOCATE PDBFILE - PD_OPEN", PD_OPEN);
}
file->stream = fp;
#ifdef PDB_WRITE
if (strchr(mode,'a')) file->mode = PD_APPEND;
else file->mode = PD_OPEN;
#else
file->mode = PD_OPEN ;
#endif
/*
* Attempt to read an ASCII header.
*/
if (io_seek(fp, 0L, SEEK_SET)) {
_lite_PD_rl_pdb(file);
lite_PD_error("FSEEK FAILED TO FIND ORIGIN - PD_OPEN", PD_OPEN);
}
if (_lite_PD_rfgets(str, MAXLINE, fp) == NULL) {
_lite_PD_rl_pdb(file);
lite_PD_error("CAN'T READ THE FILE HEADER - PD_OPEN", PD_OPEN);
}
/*
* The first token should be the identifying header token.
*/
token = strtok(str, " ");
if (token == NULL) {
_lite_PD_rl_pdb(file);
lite_PD_error("FILE HEADER NOT ASCII - PD_OPEN", PD_OPEN);
}
if (strcmp(token, HeadTok) == 0) {
/*
* This is a PDB_SYSTEM_VERSION 2 or later file.
* Read the primitive data type formats which set the standard.
*/
if (!_lite_PD_rd_format(file)) {
_lite_PD_rl_pdb(file);
lite_PD_error("FAILED TO READ FORMATS - PD_OPEN", PD_OPEN);
}
} else if (strcmp(token, OldHeadTok) == 0) {
/*
* This is a pre-PDB_SYSTEM_VERSION 2 style file. The second token
* is the machine type that wrote the file. Set the file->std for
* machine type for PD_open the file->std is always the PDBfile standard.
* Alignment issues are not properly handled before PDB_SYSTEM_VERSION 3
* but do the best that we can.
*/
token = strtok(NULL, " ");
if (token == NULL)
{
_lite_PD_rl_pdb(file);
lite_PD_error("INCOMPLETE HEADER - PD_OPEN", PD_OPEN);
}
switch (atoi(token)) {
case IEEE_32_64:
file->std = _lite_PD_copy_standard(&lite_IEEEA_STD);
file->align = _lite_PD_copy_alignment(&lite_M68000_ALIGNMENT);
break;
case IEEE_32_96:
file->std = _lite_PD_copy_standard(&lite_IEEEB_STD);
file->align = _lite_PD_copy_alignment(&lite_M68000_ALIGNMENT);
break;
case INTEL_X86:
file->std = _lite_PD_copy_standard(&lite_INTELA_STD);
file->align = _lite_PD_copy_alignment(&lite_INTELA_ALIGNMENT);
break;
case CRAY_64:
file->std = _lite_PD_copy_standard(&lite_CRAY_STD);
file->align = _lite_PD_copy_alignment(&lite_UNICOS_ALIGNMENT);
break;
case VAX_11:
file->std = _lite_PD_copy_standard(&lite_VAX_STD);
file->align = _lite_PD_copy_alignment(&lite_DEF_ALIGNMENT);
break;
default:
file->std = _lite_PD_copy_standard(&lite_DEF_STD);
file->align = _lite_PD_copy_alignment(&lite_DEF_ALIGNMENT);
break;
}
/*
* To correctly handle the situation in which many PDBfiles are open
* at the same time always try to latch on to the file->host_std.
* Alignment issues are not properly handled before PDB_SYSTEM_VERSION 3
* but do the best that we can
*/
if (_lite_PD_compare_std(file->host_std, file->std,
file->host_align, file->align)) {
_lite_PD_rl_standard(file->std);
file->std = _lite_PD_copy_standard(file->host_std);
_lite_PD_rl_alignment(file->align);
file->align = _lite_PD_copy_alignment(file->host_align);
}
} else {
_lite_PD_rl_pdb(file);
lite_PD_error("BAD FILE HEADER - PD_OPEN", PD_OPEN);
}
/*
* Record the current file position as the location of the symbol table
* address and sequentially the chart address.
*/
file->headaddr = io_tell(fp);
if (file->headaddr == -1L) {
_lite_PD_rl_pdb(file);
lite_PD_error("CAN'T FIND HEADER ADDRESS - PD_OPEN", PD_OPEN);
}
/*
* Read the address of the symbol table and structure chart.
*/
if (_lite_PD_rfgets(str, MAXLINE, fp) == NULL) {
_lite_PD_rl_pdb(file);
lite_PD_error("CAN'T READ SYMBOL TABLE ADDRESS - PD_OPEN", PD_OPEN);
}
token = strtok(str, "\001");
if (token == NULL) {
_lite_PD_rl_pdb(file);
lite_PD_error("BAD STRUCTURE CHART ADDRESS - PD_OPEN", PD_OPEN);
}
file->chrtaddr = atol(token);
token = strtok(NULL, "\001");
if (token == NULL) {
_lite_PD_rl_pdb(file);
lite_PD_error("BAD SYMBOL TABLE ADDRESS - PD_OPEN", PD_OPEN);
}
file->symtaddr = atol(token);
/*
* Read the symbol table first so that the file pointer is positioned
* to the "extra" information, then read the "extra's" to get the
* alignment data, and finish with the structure chart which needs
* the alignment data
*/
/*
* Read the symbol table.
*/
if (io_seek(fp, file->symtaddr, SEEK_SET)) {
_lite_PD_rl_pdb(file);
lite_PD_error("FSEEK FAILED SYMBOL TABLE - PD_OPEN", PD_OPEN);
}
if (!_lite_PD_rd_symt(file)) {
_lite_PD_rl_pdb(file);
lite_PD_error("CAN'T READ SYMBOL TABLE - PD_OPEN", PD_OPEN);
}
/*
* Read the miscellaneous data.
*/
if (!_lite_PD_rd_extras(file)) {
_lite_PD_rl_pdb(file);
lite_PD_error("CAN'T READ MISCELLANEOUS DATA - PD_OPEN", PD_OPEN);
}
/*
* Initialize the pdb system defs and structure chart.
*/
_lite_PD_init_chrt(file);
/*
* Read the structure chart.
*/
if (io_seek(fp, file->chrtaddr, SEEK_SET)) {
_lite_PD_rl_pdb(file);
lite_PD_error("FSEEK FAILED STRUCTURE CHART - PD_OPEN", PD_OPEN);
}
if (!_lite_PD_rd_chrt(file)) {
_lite_PD_rl_pdb(file);
lite_PD_error("CAN'T READ STRUCTURE CHART - PD_OPEN", PD_OPEN);
}
ep = lite_PD_inquire_entry(file, PDB_ATTRIBUTE_TABLE, TRUE, NULL);
if (ep != NULL) {
if (!lite_PD_read(file, PDB_ATTRIBUTE_TABLE, &file->attrtab)) {
lite_PD_close(file);
lite_PD_error("FAILED TO READ ATTRIBUTE TABLE - PD_OPEN", PD_OPEN);
}
_lite_PD_convert_attrtab(file);
file->chrtaddr = PD_entry_address(ep);
_lite_PD_rl_syment(ep);
lite_SC_hash_rem(_lite_PD_fixname(file, PDB_ATTRIBUTE_TABLE),
file->symtab);
} else {
file->attrtab = NULL;
}
/*
* Position the file pointer to the location of the structure chart.
*/
if (io_seek(fp, file->chrtaddr, SEEK_SET)) {
lite_PD_close(file);
lite_PD_error("FSEEK FAILED CHART - PD_OPEN", PD_OPEN);
}
return(file);
}
int
lite_PD_flush (PDBfile *file) {
FILE *fp;
if (file->flushed) return(TRUE);
if (file->attrtab != NULL) {
lite_PD_cd(file, NULL);
if (!lite_PD_write(file, PDB_ATTRIBUTE_TABLE, "HASHTAB *",
&file->attrtab)) {
return(FALSE);
}
}
switch (setjmp(_lite_PD_write_err)) {
case ABORT:
return(FALSE);
case ERR_FREE:
return(TRUE);
default:
memset(lite_PD_err, 0, MAXLINE);
break;
}
fp = file->stream;
if (io_flush(fp)) {
lite_PD_error("FFLUSH FAILED BEFORE CHART - PD_FLUSH", PD_WRITE);
}
/*
* Seek the place to write the structure chart.
*/
if (io_seek(fp, file->chrtaddr, SEEK_SET)) {
lite_PD_error("FSEEK FAILED TO FIND CHART - PD_FLUSH", PD_WRITE);
}
/*
* Write the structure chart.
*/
file->chrtaddr = _lite_PD_wr_chrt(file);
if (file->chrtaddr == -1L) {
lite_PD_error("CAN'T WRITE STRUCTURE CHART - PD_FLUSH", PD_WRITE);
}
/*
* Write the symbol table.
*/
file->symtaddr = _lite_PD_wr_symt(file);
if (file->symtaddr == -1L) {
lite_PD_error("CAN'T WRITE SYMBOL TABLE - PD_FLUSH", PD_WRITE);
}
/*
* Write the extras table.
*/
if (!_lite_PD_wr_extras(file)) {
lite_PD_error("CAN'T WRITE MISCELLANEOUS DATA - PD_FLUSH", PD_WRITE);
}
if (io_tell(fp) == -1L) {
lite_PD_error("CAN'T FIND HEADER ADDRESS - PD_FLUSH", PD_WRITE);
}
if (io_flush(fp)) {
lite_PD_error("FFLUSH FAILED AFTER CHART - PD_FLUSH", PD_WRITE);
}
/*
* Update the header.
*/
if (io_seek(fp, file->headaddr, SEEK_SET)) {
lite_PD_error("FSEEK FAILED - PD_FLUSH", PD_WRITE);
}
if (file->headaddr != io_tell(fp)) {
lite_PD_error("FSEEK FAILED TO FIND HEADER - PD_FLUSH", PD_WRITE);
}
io_printf(fp, "%ld\001%ld\001\n", file->chrtaddr, file->symtaddr);
if (io_flush(fp)) {
lite_PD_error("FFLUSH FAILED AFTER HEADER - PD_FLUSH", PD_WRITE);
}
file->flushed = TRUE;
return(TRUE);
}
PDBfile *
lite_PD_create (char *name) {
char str[MAXLINE];
PDBfile *file;
static FILE *fp;
file = NULL;
switch (setjmp(_lite_PD_create_err)) {
case ABORT:
if (fp) io_close(fp);
return(NULL);
case ERR_FREE:
return(file);
default:
memset(lite_PD_err, 0, MAXLINE);
break;
}
/*
* Open the file.
*/
strncpy(str, name, sizeof(str));
str[sizeof(str)-1] = '\0';
fp = io_open(str, BINARY_MODE_WPLUS);
if (!fp) lite_PD_error("CAN'T CREATE FILE - PD_CREATE", PD_CREATE);
if (lite_PD_buffer_size != -1) {
if (io_setvbuf(fp, NULL, _IOFBF, (size_t) lite_PD_buffer_size)) {
lite_PD_error("CAN'T SET FILE BUFFER - PD_CREATE", PD_OPEN);
}
}
/*
* Make the PDBfile.
*/
file = _lite_PD_mk_pdb(str, lite_PD_DEF_CREATM);
if (file == NULL) {
lite_PD_error("CAN'T ALLOCATE PDBFILE - PD_CREATE", PD_OPEN);
}
file->stream = fp;
file->mode = PD_CREATE;
/*
* Set the file data conversion standard - and yes someone might pick
* a target standard which is the current standard
*/
file->std = _lite_PD_copy_standard(file->host_std);
file->align = _lite_PD_copy_alignment(file->host_align);
if (lite_REQ_STANDARD != NULL) {
if (!_lite_PD_compare_std(lite_REQ_STANDARD, file->std,
lite_REQ_ALIGNMENT, file->align)) {
_lite_PD_rl_standard(file->std);
file->std = _lite_PD_copy_standard(lite_REQ_STANDARD);
_lite_PD_rl_alignment(file->align);
file->align = _lite_PD_copy_alignment(lite_REQ_ALIGNMENT);
}
lite_REQ_STANDARD = NULL;
}
/*
* Write the ASCII header.
*/
io_printf(fp, "%s\n", HeadTok);
if (io_flush(fp)) {
lite_PD_error("FFLUSH FAILED BEFORE HEADER - PD_CREATE", PD_CREATE);
}
/*
* Write the primitive data type formats.
*/
if (!_lite_PD_wr_format(file)) {
lite_PD_error("FAILED TO WRITE FORMATS - PD_CREATE", PD_CREATE);
}
/*
* Record the current file position as the location of the symbol table
* address and sequentially the chart address
*/
if ((file->headaddr = io_tell(fp)) == -1L) {
lite_PD_error("CAN'T FIND HEADER ADDRESS - PD_CREATE", PD_CREATE);
}
/*
* Initialize the pdb system defs and structure chart.
*/
_lite_PD_init_chrt(file);
if (io_flush(fp)) {
lite_PD_error("FFLUSH FAILED AFTER HEADER - PD_CREATE", PD_CREATE);
}
memset(str, 0, PAD_SIZE);
if (io_write(str, (size_t) 1, PAD_SIZE, fp) != PAD_SIZE) {
lite_PD_error("FAILED TO PAD FILE FOR MPW - PD_CREATE", PD_CREATE);
}
file->chrtaddr = file->headaddr + 128L;
if (io_seek(fp, file->chrtaddr, SEEK_SET)) {
lite_PD_error("FAILED TO FIND START OF DATA - PD_CREATE", PD_CREATE);
}
file->system_version = PDB_SYSTEM_VERSION;
file->date = lite_SC_date();
return(file);
}
void CUpdater::CheckUpdates(CMenus *pMenus)
{
dbg_msg("autoupdate", "Checking for updates...");
if (!CHttpDownloader::GetToFile("http://" UPDATES_HOST UPDATES_BASE_PATH UPDATES_MANIFEST_FILE, UPDATES_MANIFEST_FILE))
{
dbg_msg("autoupdate", "Error downloading updates manifest :/");
return;
}
Reset();
IOHANDLE fileAutoUpdate = io_open(UPDATES_MANIFEST_FILE, IOFLAG_READ);
io_seek(fileAutoUpdate, 0, IOSEEK_END);
std::streamsize size = io_tell(fileAutoUpdate);
io_seek(fileAutoUpdate, 0, IOSEEK_START);
std::vector<char> buffer(size);
if (io_read(fileAutoUpdate, buffer.data(), size))
{
bool needUpdate = false;
json_settings JsonSettings;
mem_zero(&JsonSettings, sizeof(JsonSettings));
char aError[256];
json_value *pJsonNodeMain = json_parse_ex(&JsonSettings, buffer.data(), size, aError);
if (pJsonNodeMain == 0)
{
dbg_msg("autoupdate", "Error: %s", aError);
return;
}
int verCode = -1;
for(int j=pJsonNodeMain->u.object.length-1; j>=0; j--) // Ascendent Search: Manifest has descendant order
{
sscanf((const char *)pJsonNodeMain->u.object.values[j].name, "%d", &verCode);
json_value *pNodeCode = pJsonNodeMain->u.object.values[j].value;
if (verCode <= HCLIENT_VERSION_CODE)
continue;
needUpdate = true;
const json_value &rVersion = (*pNodeCode)["version"];
str_copy(m_NewVersion, (const char *)rVersion, sizeof(m_NewVersion));
// Need update client?
const json_value &rClient = (*pNodeCode)["client"];
m_NeedUpdateClient = (rClient.u.boolean);
// Need update server?
const json_value &rServer = (*pNodeCode)["server"];
m_NeedUpdateServer = (rServer.u.boolean);
// Get files to download
const json_value &rDownload = (*pNodeCode)["download"];
for(unsigned k = 0; k < rDownload.u.array.length; k++)
AddFileToDownload((const char *)rDownload[k]);
// Get files to remove
const json_value &rRemove = (*pNodeCode)["remove"];
for(unsigned k = 0; k < rRemove.u.array.length; k++)
AddFileToRemove((const char *)rRemove[k]);
}
if (needUpdate) pMenus->SetPopup(CMenus::POPUP_UPDATER);
else m_Updated = true;
}
io_close(fileAutoUpdate);
fs_remove(UPDATES_MANIFEST_FILE);
}
static int spx_seek (void *prv_data, int sec)
{
struct spx_data *data = (struct spx_data *)prv_data;
off_t begin = 0, end, old_pos;
assert (sec >= 0);
end = io_file_size (data->stream);
if (end == -1)
return -1;
old_pos = io_tell (data->stream);
debug ("Seek request to %ds", sec);
while (1) {
off_t middle = (end + begin) / 2;
ogg_int64_t granule_pos;
int position_seconds;
debug ("Seek to %"PRId64, middle);
if (io_seek(data->stream, middle, SEEK_SET) == -1) {
io_seek (data->stream, old_pos, SEEK_SET);
ogg_stream_reset (&data->os);
ogg_sync_reset (&data->oy);
return -1;
}
debug ("Syncing...");
/* Sync to page and read it */
ogg_sync_reset (&data->oy);
while (!io_eof(data->stream)) {
if (ogg_sync_pageout(&data->oy, &data->og) == 1) {
debug ("Sync");
break;
}
if (!io_eof(data->stream)) {
debug ("Need more data");
get_more_data (data);
}
}
if (io_eof(data->stream)) {
debug ("EOF when syncing");
return -1;
}
granule_pos = ogg_page_granulepos(&data->og);
position_seconds = granule_pos / data->rate;
debug ("We are at %ds", position_seconds);
if (position_seconds == sec) {
ogg_stream_pagein (&data->os, &data->og);
debug ("We have it at granulepos %"PRId64, granule_pos);
break;
}
else if (sec < position_seconds) {
end = middle;
debug ("going back");
}
else {
begin = middle;
debug ("going forward");
}
debug ("begin - end %"PRId64" - %"PRId64, begin, end);
if (end - begin <= 200) {
/* Can't find the exact position. */
sec = position_seconds;
break;
}
}
ogg_sync_reset (&data->oy);
ogg_stream_reset (&data->os);
return sec;
}