/*----------------------------------------------------------------------------*/
void music_info_init(void)
{
#ifdef USB_SD_DECODE_DEFAULT_REP_OFF
    	play_mode=REPEAT_OFF;
#else
    play_mode = read_info(MEM_PLAY_MODE);
    if (play_mode > REPEAT_RANDOM)
    {
        play_mode = REPEAT_ALL;
    }
#endif
    if (given_device == 0)		  //设备启动时，given_device为0；
    {
        given_device = read_info(MEM_ACTIVE_DEV);
        if ((given_device != 0x01) && (given_device != 0x02))
        {
            given_device = 0x01;
            given_file_number = 1;
        }
    }

    eq_mode = read_info(MEM_EQ_MODE);
    if (eq_mode > CLASSIC)
    {
        eq_mode = NORMAL;
    }
}

int request_usr(simple_person ** arr, int * size, int id,char * conect, tOPC opc)
{

	char opOK=0,qty_people=0;
	int full_size;
	clsvbuff buff;

	initConnection(TYPE_MSG_Q);

	buff.opc=opc;
	buff.id_client=id;
	write_info(&buff);
	read_info(&opOK,sizeof(char),buff.id_client);
	if(opOK==NOTOK)
	{
		return NOTOK;
	}
	read_info((char*)&qty_people,sizeof(char),buff.id_client);
	*size=qty_people;
	full_size=sizeof(simple_person) * (*size);

	if(full_size>0)
	{
		*arr=malloc(full_size);
		if(*arr==NULL)
			return NOTOK;
		read_info((char*) (*arr),full_size,buff.id_client);
	}

	return OK;
}

u16 read_radio_freq(u8 ch)
{
	xd_u16 freq_reg=0;

	freq_reg = read_info(ch+1);
	freq_reg=freq_reg<<8;
	freq_reg |= read_info(ch);

	return freq_reg;	
}

u16 read_radio_freq(u8 ch)
{
	xd_u16 freq_reg=0;
	
	ch=ch<<1;

	freq_reg = read_info(MEM_FM_CHANNL +ch+1);
	freq_reg=freq_reg<<8;
	freq_reg |= read_info(MEM_FM_CHANNL +ch);
	return freq_reg;	
}

/*----------------------------------------------------------------------------*/
void restore_music_point(void)
{
    u8 i;
    for (i = 0;i<10;i++)
    {
        ((u8 *)(&(disk_mus_point[0].id0)))[i] = read_info(MEM_SD_PLAYPOINT_ID0+i);
    }
    for (i = 0;i<10;i++)
    {
        ((u8 *)(&(disk_mus_point[1].id0)))[i] = read_info(MEM_USB_PLAYPOINT_ID0+i);
    }

}

void
print_list_rest (FILE * in)
{
  char stringBuf[1024];

  GList *ac = NULL;
  GList *list = read_info (in);

  list = g_list_sort (list, CompareAccountByUsername);
  printf (" USER             REASON  PERIOD  LEVEL   TIME LEFT(s)\n");
  for (ac = g_list_first (list); ac != NULL; ac = g_list_next (ac))
    {
      Account *_ac = (Account *) ac->data;

      if (_ac->info.field_restrict != NO_PERIOD)
	{
	  //printf( " %-16s %-6s  %-6s   %c     %-4d\n", 
	  printf (" %-16s %-6s  %-6s   %c     %d\n", _ac->id,	//name
		  read_restrict_reason (_ac),	//reason
		  read_restrict_reriod (_ac),	//period
		  get_restrict_level (_ac->restricted),	//level
		  get_time_to_end (_ac)	//time left
	    );
	}
      free (_ac->id);
      free (_ac);
    }
  g_list_free (list);
}

int main()
{
	char service_name[256];

	printf("Input service name you want to connect:\n");
	fgets(service_name, sizeof(service_name), stdin);
	if (service_name[strlen(service_name) - 1] == '\n')
		service_name[strlen(service_name) - 1] = '\0';

	if (!connect_to_service(service_name)) {
		fprintf(stderr, "connect_to_service failed\n");
		exit(EXIT_FAILURE);
	}

	if (!read_info()) {
		fprintf(stderr, "read_info failed\n");
		exit(EXIT_FAILURE);
	}

	if (socketfd != -1) {
		close(socketfd);
	}

	exit(EXIT_SUCCESS);
}

int
main(int argc, char *argv[])
{
	char *p;
	size_t len;
	Subrange *r;
	int (*fn)(Rune **r0, Rune **r1, Rune **r2, Rune **r3);

	p = strrchr(argv[0], '/');
	p = p? p+1 : argv[0];
	switch (*p) {
		case 'c' :	fn = fn_c;	break;
		case 'i' :		fn = fn_i;	break;
		case 'd' :	fn = fn_d;	break;
		case 'a' :	fn = fn_a;	break;
		default:
			fprintf(stderr,"Uknown program name!\n");
			exit(1);
	}
	if (*p != 'd') {
		if (argc < 2) {
			fprintf(stderr,"%c: need text argument\n", *p);
			exit(1);
		}
		argtorune(argv[1]);
	}
	read_info(0);		/* don't reverse ranges */
	do_changes(fn);
	list_changes();
	exit(0);
}

static void get_connections_complete(int sk, void *buf, size_t len)
{
	struct mgmt_rp_get_connections *rp = buf;
	struct controller_info *info;
	uint16_t index;
	int i;

	if (len < sizeof(*rp)) {
		error("Too small get_connections complete event");
		return;
	}

	if (len < (sizeof(*rp) + (rp->conn_count * sizeof(bdaddr_t)))) {
		error("Too small get_connections complete event");
		return;
	}

	index = btohs(bt_get_unaligned(&rp->index));

	if (index > max_index) {
		error("Unexpected index %u in get_connections complete",
								index);
		return;
	}

	info = &controllers[index];

	for (i = 0; i < rp->conn_count; i++) {
		bdaddr_t *bdaddr = g_memdup(&rp->conn[i], sizeof(bdaddr_t));
		info->connections = g_slist_append(info->connections, bdaddr);
	}

	read_info(sk, index);
}

/*----------------------------------------------------------------------------*/
void music_info_init(void)
{
#ifdef NO_REM_LAST_DEV
	given_device = NO_DEVICE;
#else
     given_device = read_info(MEM_ACTIVE_DEV);
#endif

    if (given_device == DEVICE_SDMMC0)
    {
	 Set_Curr_Func(SYS_MP3DECODE_SD);
        given_file_method = PLAY_FIRST_FILE;
        given_device = DEVICE_SDMMC0;
        put_msg_lifo(MSG_MUSIC_SELECT_NEW_DEVICE);
    }
    else if (given_device == DEVICE_UDISK)
    {
    	 Set_Curr_Func(SYS_MP3DECODE_USB);
        given_file_method = PLAY_FIRST_FILE;
        given_device = DEVICE_UDISK;
        put_msg_lifo(MSG_MUSIC_SELECT_NEW_DEVICE);
    }
    else
    {
    	 Set_Curr_Func(SYS_MP3DECODE_USB);
        given_file_method = PLAY_FIRST_FILE;
        given_device = DEVICE_UDISK;
        put_msg_lifo(MSG_MUSIC_SELECT_NEW_DEVICE);
    }
}

int IndexFile::open_index(Asset *asset)
{
// use buffer if being built
	this->asset = asset;
	int result = 0;

	if(asset->index_status == INDEX_BUILDING)
	{
// use buffer
		result = 0;
	}
	else
	if(!(result = open_file()))
	{
// opened existing file
		if(read_info())
		{
			result = 1;
			close_index();
		}
		else
		{
			asset->index_status = INDEX_READY;
		}
	}
	else
	{
		result = 1;
	}

	return result;
}

/**
 * Add a pseudonym to the set of known pseudonyms.
 * For all pseudonym advertisements that we discover
 * FS should automatically call this function.
 *
 * @param cfg overall configuration
 * @param id the pseudonym identifier
 * @param meta metadata for the pseudonym
 */
void
GNUNET_PSEUDONYM_add (const struct GNUNET_CONFIGURATION_Handle *cfg,
                      const struct GNUNET_HashCode * id,
                      const struct GNUNET_CONTAINER_MetaData *meta)
{
  char *name;
  int32_t ranking;
  struct GNUNET_CONTAINER_MetaData *old;
  char *fn;
  struct stat sbuf;

  ranking = 0;
  fn = get_data_filename (cfg, PS_METADATA_DIR, id);
  GNUNET_assert (fn != NULL);

  if ((0 == STAT (fn, &sbuf)) &&
      (GNUNET_OK == read_info (cfg, id, &old, &ranking, &name)))
  {
    GNUNET_CONTAINER_meta_data_merge (old, meta);
    write_pseudonym_info (cfg, id, old, ranking, name);
    GNUNET_CONTAINER_meta_data_destroy (old);
    GNUNET_free_non_null (name);
  }
  else
  {
    write_pseudonym_info (cfg, id, meta, ranking, NULL);
  }
  GNUNET_free (fn);
  internal_notify (id, meta, ranking);
}

int
do_info(const char *const *argv)
{
  const char *thisarg;
  struct partinfo *pi, ps;
  struct dpkg_ar *part;

  if (!*argv)
    badusage(_("--%s requires one or more part file arguments"),
             cipaction->olong);

  while ((thisarg= *argv++)) {
    part = dpkg_ar_open(thisarg);
    if (!part)
      ohshite(_("cannot open archive part file '%.250s'"), thisarg);
    pi = read_info(part, &ps);
    dpkg_ar_close(part);
    if (pi) {
      print_info(pi);
    } else {
      printf(_("file '%s' is not an archive part\n"), thisarg);
    }
    m_output(stdout, _("<standard output>"));
  }

  return 0;
}

bool Channel::read_tile_or_closest_ancestor(TileIndex ti, TileIndex &ret_index, Tile &ret) const {
  Locker lock(*this);  // Lock self and hold lock until exiting this method
  ChannelInfo info;
  bool success = read_info(info);
  if (!success) {
    if (verbosity) log_f("read_tile_or_closest_ancestor: can't read info");
    return false;
  }
  TileIndex root = info.nonnegative_root_tile_index;

  if (ti.is_ancestor_of(root)) {
    ret_index = root;
  } else {
    if (ti != root && !root.is_ancestor_of(ti)) {
      // Tile isn't under root
      return false;
    }
    
    assert(tile_exists(root));
    ret_index = root;
    while (ret_index != ti) {
      TileIndex child = ti.start_time() < ret_index.left_child().end_time() ? ret_index.left_child() : ret_index.right_child();
      if (!tile_exists(child)) break;
      ret_index = child;
    }
  }
  // ret_index now holds closest ancestor to ti (or ti itself if it exists)  
    
  assert(read_tile(ret_index, ret));
  return true;
}

/*----------------------------------------------------------------------------*/
static void sys_info_init(void)
{
    //u8 vol_tmp;

#if 1
    sys_main_vol = read_info(MEM_SYS_VOL);
    if ((sys_main_vol > MAX_MAIN_VOL) || (sys_main_vol == 0))              //每次开机时，不要超过最大音量的一半，以免开机音量过大
    {
        sys_main_vol = 20;
    }
#endif

    dac_init(sys_main_vol);
    delay_10ms(50);										//等待,检测USB,SD在线状态
    //init_rec_name();
    //restore_music_point();
#if 0
#if RTC_ENABLE
    if (work_mode != RTC_MODE)
#endif
    {
    	device_check();
#if USB_DEVICE_ENABLE
        if (pc_connect)
            work_mode = USB_DEVICE_MODE;
        else if (udisk_connect || sdmmc_connect)
            work_mode = MUSIC_MODE;
#else
       // if (udisk_connect || sdmmc_connect)
       //     work_mode = MUSIC_MODE;
#endif
    }
#endif

}

/*----------------------------------------------------------------------------*/
void enter_fm_rev(void)
{
    u8 i;
    	all_channl = read_info(MEM_ALL_CHANNL);
   	if (all_channl > MAX_CHANNL)
    	{
        	all_channl = MAX_CHANNL;
   	}

	for (i = 0;i<all_channl;i++)
       {
            fre_point[i] = read_info(MEM_CHANNL+i);

#ifdef UART_ENABLE_FM		
	     printf(" ----FM read  station from ROM  %4u \r\n",(u16)(fre_point[i]+MIN_FRE));
#endif			
       }


    fre_channl = read_info(MEM_FRE_CHANNL);//MEM_FRE
    if (fre_channl > all_channl)
    {
        fre_channl = 1;
    }
    else if (!fre_channl)
    {
        fre_channl = 1;
    }
    frequency = read_info(MEM_FRE)+MIN_FRE;
    if ( frequency > MAX_FRE)
    {
        frequency = MIN_FRE;
    }
    else if (frequency < MIN_FRE)
    {
        frequency = MIN_FRE;
    }

#if defined(K738_LHD_LTB1_V001)||defined(K740_LHD_916_V001)
        frequency = 880;
#endif
#if defined(CUSTOM_RADIO_FREQ_875)
        frequency = 875;
#endif

}

void mustgetpartinfo(const char *filename, struct partinfo *ri) {
  FILE *part;

  part= fopen(filename,"r");
  if (!part) ohshite(_("cannot open archive part file `%.250s'"),filename);
  if (!read_info(part,filename,ri))
    ohshite(_("file `%.250s' is not an archive part"),filename);
  fclose(part);
}

/** Try to open project /name/. Returns 0 if sucsessful, an error code
 * otherwise */
int
Project::open ( const char *name )
{
    if ( ! validate( name ) )
        return E_INVALID;

    close();

    chdir( name );

    if ( ! acquire_lock( &_lockfd, ".lock" ) )
        return E_LOCKED;

    int version;
    char *creation_date;
    char *created_by;

    if ( ! read_info( &version, &creation_date, &created_by ) )
        return E_INVALID;

    if ( strncmp( created_by, APP_TITLE, strlen( APP_TITLE ) ) )
        return E_INVALID;

    if ( version != PROJECT_VERSION )
        return E_VERSION;

    _is_opening = true;
    
    if ( ! Loggable::replay( "snapshot" ) )
        return E_INVALID;

    if ( creation_date )
    {
        strcpy( _created_on, creation_date );
        free( creation_date );
    }
    else
        *_created_on = 0;


    getcwd( _path, sizeof( _path ) );

    set_name( _path );

    _is_open = true;

    _is_opening = false;
//    tle->load_timeline_settings();

//    timeline->zoom_fit();

//    Loggable::clear_dirty();

    MESSAGE( "Loaded project \"%s\"", name );

    return 0;
}

 void read_info(typename Ptree::BOOST_NESTED_TEMPLATE for_char<Ch>::basic_istream &stream, Ptree &pt,
                const Ptree &default_ptree)
 {
     try {
         read_info(stream, pt);
     } catch(file_parser_error &) {
         pt = default_ptree;
     }
 }

 void read_info(std::basic_istream<Ch> &stream, Ptree &pt,
                const Ptree &default_ptree)
 {
     try {
         read_info(stream, pt);
     } catch(file_parser_error &) {
         pt = default_ptree;
     }
 }