예제 #1
0
blargg_err_t Sfm_Emu::start_track_( int track )
{
    RETURN_ERR( Music_Emu::start_track_( track ) );
    resampler.clear();
    filter.clear();
    const byte * ptr = file_begin();
    int metadata_size = get_le32(ptr + 4);
    if ( file_size() < metadata_size + Sfm_Emu::sfm_min_file_size )
        return "SFM file too small";
    char * temp = new char[metadata_size + 1];
    temp[metadata_size] = '\0';
    memcpy(temp, ptr + 8, metadata_size);
    metadata.parseDocument(temp);
    delete [] temp;
    
    apu.init_rom( ipl_rom );
    
    apu.reset();
    
    memcpy( apu.m.ram.ram, ptr + 8 + metadata_size, 65536 );
    
    memcpy( apu.dsp.m.regs, ptr + 8 + metadata_size + 65536, 128 );
    
    apu.set_sfm_queue( ptr + 8 + metadata_size + 65536 + 128, ptr + file_size() );
    
    byte regs[Snes_Spc::reg_count] = {0};
    
    char * end;
    const char * value;
    
    regs[Snes_Spc::r_test] = META_ENUM_INT("smp:test");
    regs[Snes_Spc::r_control] |= META_ENUM_INT("smp:iplrom") ? 0x80 : 0;
    regs[Snes_Spc::r_dspaddr] = META_ENUM_INT("smp:dspaddr");
    
    value = metadata.enumValue("smp:ram");
    if (value)
    {
        regs[Snes_Spc::r_f8] = strtoul(value, &end, 10);
        if (*end)
        {
            value = end + 1;
            regs[Snes_Spc::r_f9] = strtoul(value, &end, 10);
        }
    }
    
    char temp_path[256];
    for (int i = 0; i < 3; ++i)
    {
        sprintf(temp_path, "smp:timer[%u]:", i);
        size_t length = strlen(temp_path);
        strcpy(temp_path + length, "enable");
        value = metadata.enumValue(temp_path);
        if (value)
        {
            regs[Snes_Spc::r_control] |= strtoul(value, &end, 10) ? 1 << i : 0;
        }
        strcpy(temp_path + length, "target");
        value = metadata.enumValue(temp_path);
        if (value)
        {
            regs[Snes_Spc::r_t0target + i] = strtoul(value, &end, 10);
        }
        strcpy(temp_path + length, "stage");
        value = metadata.enumValue(temp_path);
        if (value)
        {
            for (int j = 0; j < 3; ++j)
            {
                if (value) value = strchr(value, ',');
                if (value) ++value;
            }
            if (value)
            {
                regs[Snes_Spc::r_t0out + i] = strtoul(value, &end, 10);
            }
        }
    }
    
    apu.load_regs( regs );
    apu.m.rom_enabled = 0;
    apu.regs_loaded();
    
    for (int i = 0; i < 3; ++i)
    {
        sprintf(temp_path, "smp:timer[%u]:", i);
        size_t length = strlen(temp_path);
        strcpy(temp_path + length, "stage");
        value = metadata.enumValue(temp_path);
        if (value)
        {
            const char * stage = value;
            apu.m.timers[i].next_time = strtoul(stage, &end, 10) + 1;
            for (int j = 0; j < 2; ++j)
            {
                if (stage) stage = strchr(stage, ',');
                if (stage) ++stage;
            }
            if (stage)
            {
                apu.m.timers[i].divider = strtoul(value, &end, 10);
            }
        }
    }
    
    apu.dsp.m.echo_hist_pos = &apu.dsp.m.echo_hist[META_ENUM_INT("dsp:echohistaddr")];
    
    value = metadata.enumValue("dsp:echohistdata");
    if (value)
    {
        for (int i = 0; i < 8; ++i)
        {
            apu.dsp.m.echo_hist[i][0] = strtoul(value, &end, 10);
            value = strchr(value, ',');
            if (!value) break;
            ++value;
            apu.dsp.m.echo_hist[i][1] = strtoul(value, &end, 10);
            value = strchr(value, ',');
            if (!value) break;
            ++value;
        }
    }
    
    apu.dsp.m.phase = META_ENUM_INT("dsp:sample");
    apu.dsp.m.kon = META_ENUM_INT("dsp:kon");
    apu.dsp.m.noise = META_ENUM_INT("dsp:noise");
    apu.dsp.m.counter = META_ENUM_INT("dsp:counter");
    apu.dsp.m.echo_offset = META_ENUM_INT("dsp:echooffset");
    apu.dsp.m.echo_length = META_ENUM_INT("dsp:echolength");
    apu.dsp.m.new_kon = META_ENUM_INT("dsp:koncache");
    apu.dsp.m.endx_buf = META_ENUM_INT("dsp:endx");
    apu.dsp.m.envx_buf = META_ENUM_INT("dsp:envx");
    apu.dsp.m.outx_buf = META_ENUM_INT("dsp:outx");
    apu.dsp.m.t_pmon = META_ENUM_INT("dsp:pmon");
    apu.dsp.m.t_non = META_ENUM_INT("dsp:non");
    apu.dsp.m.t_eon = META_ENUM_INT("dsp:eon");
    apu.dsp.m.t_dir = META_ENUM_INT("dsp:dir");
    apu.dsp.m.t_koff = META_ENUM_INT("dsp:koff");
    apu.dsp.m.t_brr_next_addr = META_ENUM_INT("dsp:brrnext");
    apu.dsp.m.t_adsr0 = META_ENUM_INT("dsp:adsr0");
    apu.dsp.m.t_brr_header = META_ENUM_INT("dsp:brrheader");
    apu.dsp.m.t_brr_byte = META_ENUM_INT("dsp:brrdata");
    apu.dsp.m.t_srcn = META_ENUM_INT("dsp:srcn");
    apu.dsp.m.t_esa = META_ENUM_INT("dsp:esa");
    apu.dsp.m.t_echo_enabled = !META_ENUM_INT("dsp:echodisable");
    apu.dsp.m.t_dir_addr = META_ENUM_INT("dsp:diraddr");
    apu.dsp.m.t_pitch = META_ENUM_INT("dsp:pitch");
    apu.dsp.m.t_output = META_ENUM_INT("dsp:output");
    apu.dsp.m.t_looped = META_ENUM_INT("dsp:looped");
    apu.dsp.m.t_echo_ptr = META_ENUM_INT("dsp:echoaddr");
    
    
#define META_ENUM_LEVELS(n, o) \
value = metadata.enumValue(n); \
if (value) \
{ \
(o)[0] = strtoul(value, &end, 10); \
if (*end) \
{ \
value = end + 1; \
(o)[1] = strtoul(value, &end, 10); \
} \
}
    
    META_ENUM_LEVELS("dsp:mainout", apu.dsp.m.t_main_out);
    META_ENUM_LEVELS("dsp:echoout", apu.dsp.m.t_echo_out);
    META_ENUM_LEVELS("dsp:echoin", apu.dsp.m.t_echo_in);
    
#undef META_ENUM_LEVELS
    
    for (int i = 0; i < 8; ++i)
    {
        sprintf(temp_path, "dsp:voice[%u]:", i);
        size_t length = strlen(temp_path);
        Spc_Dsp::voice_t & voice = apu.dsp.m.voices[i];
        strcpy(temp_path + length, "brrhistaddr");
        value = metadata.enumValue(temp_path);
        if (value)
        {
            voice.buf_pos = strtoul(value, &end, 10);
        }
        strcpy(temp_path + length, "brrhistdata");
        value = metadata.enumValue(temp_path);
        if (value)
        {
            for (int j = 0; j < Spc_Dsp::brr_buf_size; ++j)
            {
                voice.buf[j] = voice.buf[j + Spc_Dsp::brr_buf_size] = strtoul(value, &end, 10);
                if (!*end) break;
                value = end + 1;
            }
        }
        strcpy(temp_path + length, "interpaddr");
        voice.interp_pos = META_ENUM_INT(temp_path);
        strcpy(temp_path + length, "brraddr");
        voice.brr_addr = META_ENUM_INT(temp_path);
        strcpy(temp_path + length, "brroffset");
        voice.brr_offset = META_ENUM_INT(temp_path);
        strcpy(temp_path + length, "vbit");
        voice.vbit = META_ENUM_INT(temp_path);
        strcpy(temp_path + length, "vidx");
        voice.regs = &apu.dsp.m.regs[META_ENUM_INT(temp_path)];
        strcpy(temp_path + length, "kondelay");
        voice.kon_delay = META_ENUM_INT(temp_path);
        strcpy(temp_path + length, "envmode");
        voice.env_mode = (Spc_Dsp::env_mode_t) META_ENUM_INT(temp_path);
        strcpy(temp_path + length, "env");
        voice.env = META_ENUM_INT(temp_path);
        strcpy(temp_path + length, "envxout");
        voice.t_envx_out = META_ENUM_INT(temp_path);
        strcpy(temp_path + length, "envcache");
        voice.hidden_env = META_ENUM_INT(temp_path);
    }
    
    filter.set_gain( (int) (gain() * Spc_Filter::gain_unit) );
    apu.clear_echo( true );
    return blargg_ok;
}
예제 #2
0
blargg_err_t Zip_Extractor::open_path_v()
{
	RETURN_ERR( open_arc_file( true ) );
	return File_Extractor::open_path_v();
}
int DthAudio_startAudioPlayback(e_HatsAudioDevice_t dev, const char *file, const char *filef)
{
    DECLARE_ERR();
    hats_audio_err_t vl_audioerr = HATS_AUDIO_NO_ERROR;
    struct stat stat_src, stat_final;
    int res_stat_src, res_stat_final;

    res_stat_final = stat(filef, &stat_final);
    SYSLOG(LOG_DEBUG, "Audio file %s %s.", filef, (0 == res_stat_final) ? "exists" : "does NOT exist");

    res_stat_src = stat(file, &stat_src);
    SYSLOG(LOG_DEBUG, "Uploaded file %s %s.", file, (0 == res_stat_src) ? "exists" : "does NOT exist");

    /* error case: no audio file available */
    if ((-1 == res_stat_final) && (-1 == res_stat_src)) {
        SYSLOG(LOG_ERR, "No audio file available for playback.\nPlease upload one and try again.");
        TAT_SET_LAST_ERR(TAT_ERROR_FILE_OPEN);
    } else {
        /* need to generate the converted file if it is older than the uploaded one or if it does not exist */
        if ((-1 == res_stat_final) || (stat_final.st_mtime < stat_src.st_mtime)) {
            SYSLOG(LOG_NOTICE, "Converting %s to %s via device %u...", file, filef, dev);
            vl_audioerr = ConvWaveFile(dev, file, filef);

            if (HATS_AUDIO_NO_ERROR == vl_audioerr) {
                /* conversion succeeded */
                SYSLOG(LOG_NOTICE, "File successfully converted.");
            } else {
                /* error on conversion*/
                SYSLOG(LOG_ERR, "Conversion failed");
            }
        }

        /* if the conversion succeed , try to play the file */
        if (HATS_AUDIO_NO_ERROR == vl_audioerr) {
            vl_audioerr = StartPCMTransfer(dev, CODEC_PLAYBACK, NORMAL_PLAYBACK_MODE, (char *) filef);
            if (HATS_AUDIO_NO_ERROR == vl_audioerr) {
                /* play on going */
                SYSLOG(LOG_NOTICE, "File is playing...");
                dthaudio_activity = TATAUDIO_PLAYBACK_ON;

            } else {
                /* error when playing the converted file */
                SYSLOG(LOG_ERR, "Fail to play the converted file");
                /* Try to play the non converted file*/
                vl_audioerr = StartPCMTransfer(dev, CODEC_PLAYBACK, NORMAL_PLAYBACK_MODE, (char *) file);
                if (HATS_AUDIO_NO_ERROR == vl_audioerr) {
                    /* play on going */
                    SYSLOG(LOG_NOTICE, "Non-converted File is playing...");
                    dthaudio_activity = TATAUDIO_PLAYBACK_ON;
                } else {
                    /* error: what? */
                    TAT_SET_LAST_ERR(hats_audio_err_to_dth(vl_audioerr));
                    SYSLOG(LOG_ERR, "Fail to play the Non-converted file");
                    SYSLOG(LOG_ERR, "Unkown error...\n");

                }
            }
        } else {
            /*conversion has failed, file should be directly played*/
            vl_audioerr = StartPCMTransfer(dev, CODEC_PLAYBACK, NORMAL_PLAYBACK_MODE, (char *) file);
            if (HATS_AUDIO_NO_ERROR == vl_audioerr) {
                /* play on going */
                SYSLOG(LOG_NOTICE, "Non-converted File is playing...");
                dthaudio_activity = TATAUDIO_PLAYBACK_ON;
            } else {
                TAT_SET_LAST_ERR(hats_audio_err_to_dth(vl_audioerr));
                SYSLOG(LOG_ERR, "Fail to play the Non-converted file");
                printf("Unkown error...\n");
            }
        }
    }

    RETURN_ERR();
}
예제 #4
0
	blargg_err_t load_mem_( byte const begin [], int size )
	{
		RETURN_ERR( parse_header( begin, size, &file ) );
		set_track_count( file.header->max_track + 1 );
		return blargg_ok;
	}
int DthAudio_01SimpleGet(struct dth_element *elem, void *value)
{
    DECLARE_ERR();
    uint32_t *pl_value = STATIC_CAST(value, uint32_t *);
    SYSLOG(LOG_DEBUG, "DTH Get with  elem->user_data=%u", elem->user_data);

    switch (elem->user_data) {
#if defined HATS_AB_8520_HW
    case TATAUDIO_MODEM_LOOP:

        VERIFY_DTH_TYPE(elem, DTH_TYPE_U32);
        TAT_IF_OK(*pl_value = dthaudio_loop_interface);
        break;
#endif
    case TATAUDIO_AUDIT_ACTIVITY:

        VERIFY_DTH_TYPE(elem, DTH_TYPE_U32);
        TAT_IF_OK(*pl_value = dthaudio_activity);
        break;

    case TATAUDIO_DEVICE:

        VERIFY_DTH_TYPE(elem, DTH_TYPE_U32);
        TAT_IF_OK(*pl_value = dthaudio_playback_device);
        break;

    case TATAUDIO_SRC:

        VERIFY_DTH_TYPE(elem, DTH_TYPE_U32);
        TAT_IF_OK(*pl_value = dthaudio_source);
        break;

    case TATAUDIO_SINK:

        VERIFY_DTH_TYPE(elem, DTH_TYPE_U32);
        TAT_IF_OK(*pl_value = dthaudio_sink);
        break;

    case TATAUDIO_AVCONNECTOR:

        VERIFY_DTH_TYPE(elem, DTH_TYPE_U32);
        TAT_IF_OK(*pl_value = dthaudio_avconnector);
        break;

#if defined HATS_AB_8520_HW
    case TATAUDIO_JACK_USB_MIC_SWITCH:
        VERIFY_DTH_TYPE(elem, DTH_TYPE_U32);
        TAT_IF_OK(*pl_value = dthaudio_micswitch);
        break;

    case TATAUDIO_HEADSET_SWITCH:
        VERIFY_DTH_TYPE(elem, DTH_TYPE_U32);
        TAT_IF_OK(*pl_value = dthaudio_headsetswitch);
        break;
#endif

    default:
        TAT_SET_LAST_ERR(TAT_BAD_REQ);
    }

    RETURN_ERR();
}
int DthAudio_03SimpleExec(struct dth_element *elem)
{
    DECLARE_ERR();

    SYSLOG(LOG_DEBUG, "DTH Exec with elem->user_data=%u", elem->user_data);

    switch (elem->user_data) {

    case TATAUDIO_DIGITAL_LOOP_IN_AB:
        if (TATAUDIO_START == dthaudio_digital_loop_in_ab_action) {
            TAT_TRY(DthAudio_startABDigitalAudioLoop());
        } else
            TAT_TRY(DthAudio_stopAudioLoop(CODEC_PLAYBACK));

        break;

    case TATAUDIO_DIGITAL_LOOP_IN_AP:
        if (TATAUDIO_START == dthaudio_digital_loop_in_ap_action) {
            TAT_TRY(DthAudio_startAPDigitalAudioLoop());
        } else
            TAT_TRY(DthAudio_stopAudioLoop(CODEC_PLAYBACK));

        break;

    case TATAUDIO_ANALOG_LOOP:
        if (TATAUDIO_START == dthaudio_analog_loop_action) {
            TAT_TRY(DthAudio_startAnalogAudioLoop());
        } else
            TAT_TRY(DthAudio_stopAudioLoop(CODEC_CAPTURE));

        break;
#if 0
    case TATAUDIO_DIGITAL_LOOP_IN_MODEM:
        if (TATAUDIO_MOD_START == dthaudio_digital_loop_in_modem_action) {
            TAT_TRY(DthAudio_startModemAudioLoop());
        } else if (TATAUDIO_MOD_STOP == dthaudio_digital_loop_in_modem_action) {
            TAT_TRY(DthAudio_stopModemAudioLoop());
        } else if (TATAUDIO_SET_MODEM_MODE == dthaudio_digital_loop_in_modem_action) {
            TAT_TRY(DthAudio_setModemAudioLoop());
        }

        break;
#endif
    case TATAUDIO_PLAYBACK:
        if (TATAUDIO_START == dthaudio_playback_action) {
            if (TATAUDIO_HDMI_DEVICE == dthaudio_playback_device) {
                TAT_TRY(DthAudio_startAudioPlayback(AUDIO_DEVICE_HDMI, PLAYBACK_UPLOAD_FILE, PLAYBACK_FINAL_FILE));
            } else {
                TAT_TRY(DthAudio_startAudioPlayback(AUDIO_DEVICE_0, PLAYBACK_UPLOAD_FILE, PLAYBACK_FINAL_FILE));
            }
        } else if (TATAUDIO_STOP == dthaudio_playback_action) {
            if (TATAUDIO_HDMI_DEVICE == dthaudio_playback_device) {
                TAT_TRY(DthAudio_stopAudioPlayback(AUDIO_DEVICE_HDMI));
            } else {
                TAT_TRY(DthAudio_stopAudioPlayback(AUDIO_DEVICE_0));
            }
        }

        break;

    case TATAUDIO_RECORD:
        if (TATAUDIO_START == dthaudio_record_action) {
            if (TATAUDIO_HDMI_DEVICE == dthaudio_playback_device) {
                TAT_TRY(StartPCMTransfer(AUDIO_DEVICE_HDMI, CODEC_CAPTURE, NORMAL_CAPTURE_MODE, RECORD_FILE));
            } else {
                TAT_TRY(StartPCMTransfer(AUDIO_DEVICE_0, CODEC_CAPTURE, NORMAL_CAPTURE_MODE, RECORD_FILE));
            }
        } else if (TATAUDIO_STOP == dthaudio_record_action) {
            if (TATAUDIO_HDMI_DEVICE == dthaudio_playback_device) {
                TAT_TRY(StopPCMTransfer(AUDIO_DEVICE_HDMI, CODEC_CAPTURE));
            } else {
                TAT_TRY(StopPCMTransfer(AUDIO_DEVICE_0, CODEC_CAPTURE));
            }
        }

        break;

    default:
        TAT_SET_LAST_ERR(TAT_BAD_REQ);
    }

    /* sends asychronous events in order to indicate a value change in the parameters values*/
    SYSLOG(LOG_INFO, "DthAudio_SendAsyncEventParameters VALUE_CHANGED ...");
    //printf("\nDthAudio_SendAsyncEventParameters VALUE_CHANGED for full list....\n");
    DthAudio_SendAsyncEventParameters(a_dthaudio_fulllistpath, VALUE_CHANGED, (mode_t)0);
    libtatasync_msg_send(VALUE_CHANGED, "/DTH/AUDIO/Tests/Activity");

    RETURN_ERR();
}
예제 #7
0
void main()
{
    int     err;
        int     verify_client = OFF; /* To verify a client certificate, set ON */
 
      int     listen_sock;
        int     sock;
       struct sockaddr_in sa_serv;
         struct sockaddr_in sa_cli;
          size_t client_len;
          char    *str;
       char     buf[4096];
 
    SSL_CTX         *ctx;
        SSL            *ssl;
       SSL_METHOD      *meth;

        X509            *client_cert = NULL;
 
   short int       s_port = 5555;
/*----------------------------------------------------------------*/
      /* Load encryption & hashing algorithms for the SSL program */
  SSL_library_init();
 
    /* Load the error strings for SSL & CRYPTO APIs */
      SSL_load_error_strings();
 
      /* Create a SSL_METHOD structure (choose a SSL/TLS protocol version) */
     meth = SSLv3_method();
 
 /* Create a SSL_CTX structure */
    ctx = SSL_CTX_new(meth);
 
       if (!ctx) {
 
            ERR_print_errors_fp(stderr);
 
           exit(1);
 
       }
 
      /* Load the server certificate into the SSL_CTX structure */
        if (SSL_CTX_use_certificate_file(ctx, RSA_SERVER_CERT, SSL_FILETYPE_PEM) <= 0) {
 
                    ERR_print_errors_fp(stderr);
 
                   exit(1);
 
       }
 
      /* Load the private-key corresponding to the server certificate */
          if (SSL_CTX_use_PrivateKey_file(ctx, RSA_SERVER_KEY, SSL_FILETYPE_PEM) <= 0) {
 
              ERR_print_errors_fp(stderr);
                exit(1);
    }
 
      /* Check if the server certificate and private-key matches */
       if (!SSL_CTX_check_private_key(ctx)) {
 
                 fprintf(stderr,"Private key does not match the certificate public key\n");
                  exit(1);
    }
 
      if(verify_client == ON)
 
        {
 
              /* Load the RSA CA certificate into the SSL_CTX structure */
                if (!SSL_CTX_load_verify_locations(ctx, RSA_SERVER_CA_CERT, NULL)) {
 
                   ERR_print_errors_fp(stderr);
                        exit(1);
            }
 
              /* Set to require peer (client) certificate verification */
         SSL_CTX_set_verify(ctx,SSL_VERIFY_PEER,NULL);
 
          /* Set the verification depth to 1 */
               SSL_CTX_set_verify_depth(ctx,1);
 
       }
   /* ----------------------------------------------- */
       /* Set up a TCP socket */
 
      listen_sock = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP);   
 
    RETURN_ERR(listen_sock, "socket");
          memset (&sa_serv, '\0', sizeof(sa_serv));
       sa_serv.sin_family      = AF_INET;
          sa_serv.sin_addr.s_addr = INADDR_ANY;
       sa_serv.sin_port        = htons (s_port);          /* Server Port number */
         err = bind(listen_sock, (struct sockaddr*)&sa_serv,sizeof(sa_serv));
 
       RETURN_ERR(err, "bind");
     
   /* Wait for an incoming TCP connection. */
          err = listen(listen_sock, 5);                    
 
      RETURN_ERR(err, "listen");
          client_len = sizeof(sa_cli);
 
   /* Socket for a TCP/IP connection is created */
     sock = accept(listen_sock, (struct sockaddr*)&sa_cli, &client_len);
 
    RETURN_ERR(sock, "accept");
         close (listen_sock);
 
   printf ("Connection from %lx, port %x\n", sa_cli.sin_addr.s_addr, 
   sa_cli.sin_port);
 
     /* ----------------------------------------------- */
       /* TCP connection is ready. */
      /* A SSL structure is created */
    ssl = SSL_new(ctx);
 
    RETURN_NULL(ssl);
 
      /* Assign the socket into the SSL structure (SSL and socket without BIO) */
 SSL_set_fd(ssl, sock);
 
 /* Perform SSL Handshake on the SSL server */
       err = SSL_accept(ssl);
 
 RETURN_SSL(err);
 
       /* Informational output (optional) */
       printf("SSL connection using %s\n", SSL_get_cipher (ssl));
 
     if (verify_client == ON)
    {
 
          /* Get the client's certificate (optional) */
       client_cert = SSL_get_peer_certificate(ssl);
        if (client_cert != NULL) 
           {
 
              printf ("Client certificate:\n");     
              str = X509_NAME_oneline(X509_get_subject_name(client_cert), 0, 0);
                  RETURN_NULL(str);
                   printf ("\t subject: %s\n", str);
                   free (str);
                 str = X509_NAME_oneline(X509_get_issuer_name(client_cert), 0, 0);
                   RETURN_NULL(str);
                   printf ("\t issuer: %s\n", str);
                    free (str);
                 X509_free(client_cert);
     } 
 
     else
 
                   printf("The SSL client does not have certificate.\n");
  }
 
      /*------- DATA EXCHANGE - Receive message and send reply. -------*/
 /* Receive data from the SSL client */
      err = SSL_read(ssl, buf, sizeof(buf) - 1);
 
     RETURN_SSL(err);
 
       buf[err] = '\0';
 
       printf ("Received %d chars:'%s'\n", err, buf);
 
 /* Send data to the SSL client */
   err = SSL_write(ssl, "This message is from the SSL server", 
 
   strlen("This message is from the SSL server"));
 
        RETURN_SSL(err);
 
       /*--------------- SSL closure ---------------*/
     /* Shutdown this side (server) of the connection. */
 
   err = SSL_shutdown(ssl);
 
       RETURN_SSL(err);
 
       /* Terminate communication on a socket */
   err = close(sock);
 
     RETURN_ERR(err, "close");
 
      /* Free the SSL structure */
        SSL_free(ssl);
 
 /* Free the SSL_CTX structure */
    SSL_CTX_free(ctx);
 
}
예제 #8
0
// @pymethod int|PyCTreeCtrl|InsertItem|Inserts an item into the list.
PyObject *PyCTreeCtrl_InsertItem( PyObject *self, PyObject *args )
{
	CTreeCtrl *pList;
	HTREEITEM ret = NULL;
	UINT mask;
	int image, selImage, state, stateMask;
	PyObject *obParent, *obInsertAfter;
	LPARAM lParam;
	HTREEITEM hParent, hInsertAfter;
	TCHAR *text=NULL;
	PyObject *obtext=Py_None;
	if (!(pList=GetTreeCtrl(self)))
		return NULL;

	if (PyArg_ParseTuple(args, "iOiiiiOOO:InsertItem", 
						&mask, // @pyparmalt1 int|mask||Integer specifying which attributes to set
						&obtext, // @pyparmalt1 string|text||The text of the item.
						&image, // @pyparmalt1 int|image||The index of the image to use.
						&selImage, // @pyparmalt1 int|selectedImage||The index of the items selected image.
						&state, // @pyparmalt1 int|state||The initial state of the item.
						&stateMask, // @pyparmalt1 int|stateMask||Specifies which bits of the state are valid.
						&lParam, // @pyparmalt1 object|lParam||A user defined object for the item.
						&obParent, // @pyparmalt1 HTREEITEM|parent||The parent of the item.
						&obInsertAfter)) { // @pyparmalt1 HTREEITEM|parent||The parent of the item.
		if (!PyWinObject_AsHANDLE(obParent, (HANDLE *)&hParent))
			return NULL;
		if (!PyWinObject_AsHANDLE(obInsertAfter, (HANDLE *)&hInsertAfter))
			return NULL;
		if (!PyWinObject_AsTCHAR(obtext, &text, TRUE))
			return NULL;
		GUI_BGN_SAVE;
		ret = pList->InsertItem(mask, text, image, selImage, state, stateMask, lParam, hParent, hInsertAfter);
	 	GUI_END_SAVE;
		goto done;
		}

	PyErr_Clear();
	hParent = TVI_ROOT;
	hInsertAfter = TVI_LAST;
	if (PyArg_ParseTuple(args, "Oii|O&O&:InsertItem", 
			&obtext, // @pyparmalt2 string|text||The text for the item.
			&image, // @pyparmalt2 int|image||The index of the image to use.
			&selImage, // @pyparmalt2 int|selectedImage||The index of the items selected image.
			PyWinObject_AsHANDLE, &hParent,	// @pyparmalt2 HTREEITEM|parent|commctrl.TVI_ROOT|The parent of the item.
			PyWinObject_AsHANDLE, &hInsertAfter)	// @pyparmalt2 HTREEITEM|insertAfter|commctrl.TVI_LAST|The item to insert the new item after, or TVI_FIRST, TVI_LAST or TVI_SORT
		&& PyWinObject_AsTCHAR(obtext, &text, FALSE)){
		GUI_BGN_SAVE;
		ret = pList->InsertItem(text, image, selImage, hParent, hInsertAfter);
		GUI_END_SAVE;
		goto done;
		}

	// This arg format conflicts with the above.  Handle's can be parsed as ints, so if both optional items are
	//	passed, they will be caught by the above and never get here !
	PyErr_Clear();
	hParent = TVI_ROOT;
	hInsertAfter = TVI_LAST;
	if (PyArg_ParseTuple(args, "O|O&O&:InsertItem", 
			&obtext,	// @pyparmalt3 string|text||The text for the item.
			PyWinObject_AsHANDLE, &hParent,	// @pyparmalt3 HTREEITEM|parent|commctrl.TVI_ROOT|The parent of the item.
			PyWinObject_AsHANDLE, &hInsertAfter)	// @pyparmalt3 HTREEITEM|parent|commctrl.TVI_LAST|The parent of the item.
		&& PyWinObject_AsTCHAR(obtext, &text, FALSE)){	
		GUI_BGN_SAVE;
		ret = pList->InsertItem(text, hParent, hInsertAfter);
		GUI_END_SAVE;
		goto done;
		}

	PyErr_Clear();
	PyObject *obTVItem;
	TV_INSERTSTRUCT tvItem;
	if (PyArg_ParseTuple(args, "O&O&O:InsertItem",
			PyWinObject_AsHANDLE, &tvItem.hParent, // @pyparm HTREEITEM|hParent||The parent item.  If commctrl.TVI_ROOT or 0, it is added to the root.
			PyWinObject_AsHANDLE, &tvItem.hInsertAfter, // @pyparm HTREEITEM|hInsertAfter||The item to insert after.  Can be an item or TVI_FIRST, TVI_LAST or TVI_SORT
			&obTVItem)) { // @pyparm <o TV_ITEM>|item||A tuple describing the new item.
		if (!PyWinObject_AsTV_ITEM(obTVItem, &tvItem.item))
			return NULL;
		GUI_BGN_SAVE;
		ret = pList->InsertItem(&tvItem);
		GUI_END_SAVE;
		PyWinObject_FreeTV_ITEM(&tvItem.item);
		goto done;
		}

	PyErr_Clear();
	RETURN_ERR("InsertItem could not parse the params.");
	// And you will beat your brains out determining why ...

done:
	PyWinObject_FreeTCHAR(text);
	if (ret==NULL)
		RETURN_ERR("InsertItem failed");
	return PyWinLong_FromHANDLE(ret);
}
예제 #9
0
blargg_err_t Stereo_Buffer::set_sample_rate( long rate, int msec )
{
	for ( int i = 0; i < buf_count; i++ )
		RETURN_ERR( bufs [i].set_sample_rate( rate, msec ) );
	return Multi_Buffer::set_sample_rate( bufs [0].sample_rate(), bufs [0].length() );
}
예제 #10
0
blargg_err_t Binary_Extractor::stat_v()
{
	RETURN_ERR( open_arc_file() );
	RETURN_ERR( arc().seek( 0 ) );
	return open_v();
}
예제 #11
0
blargg_err_t Mono_Buffer::set_sample_rate( long rate, int msec )
{
	RETURN_ERR( buf.set_sample_rate( rate, msec ) );
	return Multi_Buffer::set_sample_rate( buf.sample_rate(), buf.length() );
}
예제 #12
0
blargg_err_t File_Extractor::open_path_v()
{
	RETURN_ERR( open_arc_file() );
	
	return open_v();
}
예제 #13
0
blargg_err_t Sfm_Emu::play_and_filter( int count, sample_t out [] )
{
    RETURN_ERR( apu.play( count, out ) );
    filter.run( out, count );
    return blargg_ok;
}
blargg_err_t Fir_Resampler_::buffer_size( int new_size )
{
	RETURN_ERR( buf.resize( new_size + write_offset ) );
	clear();
	return 0;
}
예제 #15
0
blargg_err_t Gme_File::load_( Data_Reader& in )
{
	RETURN_ERR( file_data.resize( in.remain() ) );
	RETURN_ERR( in.read( file_data.begin(), file_data.size() ) );
	return load_mem_( file_data.begin(), file_data.size() );
}
예제 #16
0
파일: kloxo.c 프로젝트: BHWD/kloxo
char* ssl_sock_read(int sock, SSL_CTX *ctx)
{
	int err;
	int verify_client = OFF; /* To verify a client certificate, set ON */
	int pid;
	struct sockaddr_in sa_serv;
	struct sockaddr_in sa_cli;
	size_t client_len;
	char *str;
	char buf[4096];
	SSL *ssl;
	SSL_METHOD *meth;
	X509 *client_cert = NULL;

	/* ----------------------------------------------- */
	/* TCP connection is ready. */
	/* A SSL structure is created */
	ssl = SSL_new(ctx);

	RETURN_NULL(ssl);

	/* Assign the socket into the SSL structure (SSL and socket without BIO) */
	SSL_set_fd(ssl, sock);

	/* Perform SSL Handshake on the SSL server */
	err = SSL_accept(ssl);

	RETURN_SSL(err);

	/* Informational output (optional) */
	//printf("SSL connection using %s\n", SSL_get_cipher (ssl));

	if (verify_client == ON) {
		/* Get the client's certificate (optional) */
		client_cert = SSL_get_peer_certificate(ssl);
		if (client_cert != NULL) {
			//printf ("Client certificate:\n");
			str = X509_NAME_oneline(X509_get_subject_name(client_cert), 0, 0);
			RETURN_NULL(str);
			//printf ("\t subject: %s\n", str);
			free(str);
			str = X509_NAME_oneline(X509_get_issuer_name(client_cert), 0, 0);
			RETURN_NULL(str);
			//printf ("\t issuer: %s\n", str);
			free(str);
			X509_free(client_cert);
		} else {
			printf("The SSL client does not have certificate.\n");
		}
	}

	/*------- DATA EXCHANGE - Receive message and send reply. -------*/
	/* Receive data from the SSL client */
	/* Send data to the SSL client */

	run_php_prog_ssl(ssl, 0);

	/*--------------- SSL closure ---------------*/
	/* Shutdown this side (server) of the connection. */
	err = SSL_shutdown(ssl);
	RETURN_SSL(err);
	/* Terminate communication on a socket */
	err = close(sock);
	RETURN_ERR(err, "close");
	/* Free the SSL structure */
	//SSL_free(ssl);
	/* Free the SSL_CTX structure */
	//SSL_CTX_free(ctx);
	exit(0);
}
예제 #17
0
파일: fex.cpp 프로젝트: BigEd/snes-sdk
BLARGG_EXPORT fex_err_t fex_read( fex_t* fe, void* out, int count )
{
	RETURN_ERR( fe->stat() );
	return fe->reader().read( out, count );
}
예제 #18
0
	blargg_err_t load_mem_( byte const begin [], int size )
	{
		RETURN_ERR( parse_info( begin, size, &info ) );
		set_track_count( info.track_count );
		return blargg_ok;
	}
예제 #19
0
 blargg_err_t load_mem_( byte const* begin, long size )
 {
     RETURN_ERR( parse_info( begin, size, &info ) );
     set_track_count( info.track_count );
     return 0;
 }
int DthAudio_02SimpleSet(struct dth_element *elem, void *value)
{
    DECLARE_ERR();
    uint32_t vl_value = DEREF_PTR(value, uint32_t);
    hats_audio_err_t vl_audioerr;

    SYSLOG(LOG_DEBUG, "DTH set with elem->user_data= %u", elem->user_data);

    switch (elem->user_data) {
    case TATAUDIO_DIGITAL_LOOP_IN_AB:

        VERIFY_DTH_TYPE(elem, DTH_TYPE_U32);
        VERIFY_ENUM(vl_value, TATAUDIO_STOP);
        if (TAT_LAST_OK()) {
            dthaudio_digital_loop_in_ab_action = vl_value;
            SYSLOG(LOG_INFO, "Digital AB Audio loop operation set to %u.", dthaudio_digital_loop_in_ab_action);
        }
        break;

    case TATAUDIO_DIGITAL_LOOP_IN_AP:

        VERIFY_DTH_TYPE(elem, DTH_TYPE_U32);
        VERIFY_ENUM(vl_value, TATAUDIO_STOP);
        if (TAT_LAST_OK()) {
            dthaudio_digital_loop_in_ap_action = vl_value;
            SYSLOG(LOG_INFO, "Digital AP Audio loop operation set to %u.", dthaudio_digital_loop_in_ap_action);
        }
        break;

    case TATAUDIO_ANALOG_LOOP:

        VERIFY_DTH_TYPE(elem, DTH_TYPE_U32);
        VERIFY_ENUM(vl_value, TATAUDIO_STOP);
        if (TAT_LAST_OK()) {
            dthaudio_analog_loop_action = vl_value;
            SYSLOG(LOG_INFO, "ANALOG Audio loop operation set to %u.", dthaudio_analog_loop_action);
        }
        break;

#if defined HATS_AB_8520_HW
    case TATAUDIO_DIGITAL_LOOP_IN_MODEM:

        VERIFY_DTH_TYPE(elem, DTH_TYPE_U32);
        VERIFY_ENUM(vl_value, TATAUDIO_MOD_STOP);
        if (TAT_LAST_OK()) {
            dthaudio_digital_loop_in_modem_action = vl_value;
            SYSLOG(LOG_INFO, "Modem Audio loop operation set to %u.", dthaudio_digital_loop_in_modem_action);
        }
        break;

    case TATAUDIO_MODEM_LOOP:

        VERIFY_DTH_TYPE(elem, DTH_TYPE_U32);
        VERIFY_ENUM(vl_value, TATAUDIO_MODEM_LOOP2);
        if (TAT_LAST_OK()) {
            dthaudio_loop_interface = vl_value;
            SYSLOG(LOG_INFO, "Modem Audio loop interface set to %u.", dthaudio_loop_interface);
        }
        break;
#endif
    case TATAUDIO_PLAYBACK:

        VERIFY_DTH_TYPE(elem, DTH_TYPE_U32);
        VERIFY_ENUM(vl_value, TATAUDIO_STOP);
        if (TAT_LAST_OK()) {
            dthaudio_playback_action = vl_value;
            SYSLOG(LOG_INFO, "Audio playback operation set to %u.", dthaudio_playback_action);
        }
        break;

    case TATAUDIO_RECORD:

        VERIFY_DTH_TYPE(elem, DTH_TYPE_U32);
        VERIFY_ENUM(vl_value, TATAUDIO_STOP);
        if (TAT_LAST_OK()) {
            dthaudio_record_action = vl_value;
            SYSLOG(LOG_INFO, "Audio record operation set to %u.", dthaudio_record_action);
        }
        break;

    case TATAUDIO_DEVICE:

        VERIFY_DTH_TYPE(elem, DTH_TYPE_U32);
        VERIFY_ENUM(vl_value, TATAUDIO_HDMI_DEVICE);
        if (TAT_LAST_OK()) {
            dthaudio_playback_device = vl_value;
            SYSLOG(LOG_INFO, "Playback device %u (0=MAIN, 1=HDMI) selected.", dthaudio_playback_device);
        }
        break;

    case TATAUDIO_SRC:

        VERIFY_DTH_TYPE(elem, DTH_TYPE_U32);
        VERIFY_ENUM(vl_value, TATAUDIO_ENUM_SRC_MAX);

        if (TAT_LAST_OK()) {
            vl_audioerr = SetSrc(AUDIO_DEVICE_0, (e_HatsAudioInput_t) Dthaudio_codec_src_tab[vl_value]);
            if (HATS_AUDIO_NO_ERROR == vl_audioerr) {
                dthaudio_source = vl_value;
                SYSLOG(LOG_INFO, "Audio source changed to %u", dthaudio_source);

            } else {
                TAT_SET_LAST_ERR(hats_audio_err_to_dth(vl_audioerr));
                SYSLOG(LOG_ERR, "Failed to set audio source");
            }
        }

        if (TAT_LAST_OK()) {
            if (TATAUDIO_SRC_MICRO_AN1B == vl_value) {
#if defined HATS_AB_8520_HW
                dthaudio_micswitch = TATAUDIO_JACKMIC;
                DthAudio_GpioConfig(TATAUDIO_GPIO_MICCTRL_DIR, TATAUDIO_GPIO_MICCTRL_OUT, TATAUDIO_GPIO_MICCTRL_PUD,
                                    TATAUDIO_GPIO_MICCTRL_OFFSET_IN_REGISTER, 1, 1, 0);
                TAT_TRY(libtatasync_msg_send(VALUE_CHANGED, "/DTH/AUDIO/Tests/Setup/GPIO_MIC_CTRL"));
#endif

                dthaudio_avconnector = TATAUDIO_AVCONN_AUDIO;
                DthAudio_GpioConfig(TATAUDIO_GPIO_VIDEOCTRL_DIR, TATAUDIO_GPIO_VIDEOCTRL_OUT, TATAUDIO_GPIO_VIDEOCTRL_PUD,
                                    TATAUDIO_GPIO_VIDEOCTRL_OFFSET_IN_REGISTER, 1, 1, 0);;
                TAT_TRY(libtatasync_msg_send(VALUE_CHANGED, "/DTH/AUDIO/Tests/Setup/GPIO_MICVIDEO_CTRL"));
            }
#if defined HATS_AB_8520_HW
			 else if (TATAUDIO_SRC_MICRO_USB == vl_value) {
                dthaudio_micswitch = TATAUDIO_USBMIC;
                DthAudio_GpioConfig(TATAUDIO_GPIO_MICCTRL_DIR, TATAUDIO_GPIO_MICCTRL_OUT, TATAUDIO_GPIO_MICCTRL_PUD,
                                    TATAUDIO_GPIO_MICCTRL_OFFSET_IN_REGISTER, 1, 0, 0);
                TAT_TRY(libtatasync_msg_send(VALUE_CHANGED, "/DTH/AUDIO/Tests/Setup/GPIO_MIC_CTRL"));

                dthaudio_avconnector = TATAUDIO_AVCONN_AUDIO;
                DthAudio_GpioConfig(TATAUDIO_GPIO_VIDEOCTRL_DIR, TATAUDIO_GPIO_VIDEOCTRL_OUT, TATAUDIO_GPIO_VIDEOCTRL_PUD,
                                    TATAUDIO_GPIO_VIDEOCTRL_OFFSET_IN_REGISTER, 1, 1, 0);;
                TAT_TRY(libtatasync_msg_send(VALUE_CHANGED, "/DTH/AUDIO/Tests/Setup/GPIO_MICVIDEO_CTRL"));
            }
#endif
        }
        break;


    case TATAUDIO_SINK:

        VERIFY_DTH_TYPE(elem, DTH_TYPE_U32);

        VERIFY_ENUM(vl_value, TATAUDIO_ENUM_SINK_MAX);

        if (TAT_LAST_OK()) {
            vl_audioerr = SetSink(AUDIO_DEVICE_0, (e_HatsAudioOutput_t) Dthaudio_codec_sink_tab[vl_value]);
            if (HATS_AUDIO_NO_ERROR == vl_audioerr) {
                dthaudio_sink = vl_value;
                SYSLOG(LOG_INFO, "Audio sink set to %u", dthaudio_sink);

            } else {
                TAT_SET_LAST_ERR(hats_audio_err_to_dth(vl_audioerr));
                SYSLOG(LOG_ERR, "Failed to set audio sink");
            }
        }
        break;



    case TATAUDIO_AVCONNECTOR:
        VERIFY_DTH_TYPE(elem, DTH_TYPE_U32);
        VERIFY_ENUM(vl_value, TATAUDIO_AVCONN_VIDEO);

        if (TAT_LAST_OK()) {
            if (TATAUDIO_AVCONN_VIDEO == vl_value) {
                DthAudio_GpioConfig(TATAUDIO_GPIO_VIDEOCTRL_DIR, TATAUDIO_GPIO_VIDEOCTRL_OUT, TATAUDIO_GPIO_VIDEOCTRL_PUD,
                                    TATAUDIO_GPIO_VIDEOCTRL_OFFSET_IN_REGISTER, 1, 0, 0);

                SYSLOG(LOG_INFO, "AV connector set to VIDEO_SOURCE");
            } else if (TATAUDIO_AVCONN_AUDIO == vl_value) {
                DthAudio_GpioConfig(TATAUDIO_GPIO_VIDEOCTRL_DIR, TATAUDIO_GPIO_VIDEOCTRL_OUT, TATAUDIO_GPIO_VIDEOCTRL_PUD,
                                    TATAUDIO_GPIO_VIDEOCTRL_OFFSET_IN_REGISTER, 1, 1, 0);;

                SYSLOG(LOG_INFO, "AV connector set to AUDIO_SOURCE");
            }
            if (TAT_LAST_OK()) {
                dthaudio_avconnector = vl_value;
            } else {
                SYSLOG(LOG_ERR, "Failed to set AV connector");
            }
        }
        break;

#if defined HATS_AB_8520_HW
    case TATAUDIO_JACK_USB_MIC_SWITCH:
        VERIFY_DTH_TYPE(elem, DTH_TYPE_U32);
        VERIFY_ENUM(vl_value, TATAUDIO_USBMIC);
        if (TAT_LAST_OK()) {
            if (TATAUDIO_JACKMIC == vl_value) {
                DthAudio_GpioConfig(TATAUDIO_GPIO_MICCTRL_DIR, TATAUDIO_GPIO_MICCTRL_OUT, TATAUDIO_GPIO_MICCTRL_PUD,
                                    TATAUDIO_GPIO_MICCTRL_OFFSET_IN_REGISTER, 1, 1, 0);

                SYSLOG(LOG_INFO, "Mic switch set to JACK");
            } else if (TATAUDIO_USBMIC == vl_value) {
                DthAudio_GpioConfig(TATAUDIO_GPIO_MICCTRL_DIR, TATAUDIO_GPIO_MICCTRL_OUT, TATAUDIO_GPIO_MICCTRL_PUD,
                                    TATAUDIO_GPIO_MICCTRL_OFFSET_IN_REGISTER, 1, 0, 0);;

                SYSLOG(LOG_INFO, "Mic switch set to USB");
            }
            if (TAT_LAST_OK()) {
                dthaudio_micswitch = vl_value;
            } else {
                SYSLOG(LOG_ERR, "Failed to set Mic switch");
            }
        }
        break;

#endif

    default:
        TAT_SET_LAST_ERR(TAT_BAD_REQ);
    }

    RETURN_ERR();
}
예제 #21
0
파일: Nsf_Emu.cpp 프로젝트: 1Akula1/gzdoom
blargg_err_t Nsf_Emu::load_( Data_Reader& in )
{
	assert( offsetof (header_t,unused [4]) == header_size );
	RETURN_ERR( rom.load( in, header_size, &header_, 0 ) );
	
	set_track_count( header_.track_count );
	RETURN_ERR( check_nsf_header( &header_ ) );
	
	if ( header_.vers != 1 )
		set_warning( "Unknown file version" );
	
	// sound and memory
	blargg_err_t err = init_sound();
	if ( err )
		return err;
	
	// set up data
	nes_addr_t load_addr = get_le16( header_.load_addr );
	init_addr = get_le16( header_.init_addr );
	play_addr = get_le16( header_.play_addr );
	if ( !load_addr ) load_addr = rom_begin;
	if ( !init_addr ) init_addr = rom_begin;
	if ( !play_addr ) play_addr = rom_begin;
	if ( load_addr < rom_begin || init_addr < rom_begin )
	{
		const char* w = warning();
		if ( !w )
			w = "Corrupt file (invalid load/init/play address)";
		return w;
	}
	
	rom.set_addr( load_addr % bank_size );
	int total_banks = rom.size() / bank_size;
	
	// bank switching
	int first_bank = (load_addr - rom_begin) / bank_size;
	for ( int i = 0; i < bank_count; i++ )
	{
		unsigned bank = i - first_bank;
		if ( bank >= (unsigned) total_banks )
			bank = 0;
		initial_banks [i] = bank;
		
		if ( header_.banks [i] )
		{
			// bank-switched
			memcpy( initial_banks, header_.banks, sizeof initial_banks );
			break;
		}
	}
	
	pal_only = (header_.speed_flags & 3) == 1;
	
	#if !NSF_EMU_EXTRA_FLAGS
		header_.speed_flags = 0;
	#endif
	
	set_tempo( tempo() );
	
	return setup_buffer( (long) (clock_rate_ + 0.5) );
}
int DthAudio_stopModemAudioLoop(void)
{
    DECLARE_ERR();
#if 0
    int vl_status = 0;

    VERIFY_ENUM(dthaudio_loop_interface, TATAUDIO_MODEM_LOOP2);
    if (TAT_LAST_OK()) {
        switch (dthaudio_loop_interface) {

        case TATAUDIO_MODEM_LOOP1:

            SYSLOG(LOG_INFO, "Stopping modem audio loop 1 ...");
            if (modemMngt_getModemConfig() == 1) {
                printf("Modem Loopback is not supported in this config\n");
                TAT_SET_LAST_ERR(TAT_BAD_REQ);
            } else {
                //printf("Modem Loopback will be supported in this config\n");
                /* check modem mode */
                if (modemMngt_getModemMode() != 0 /*normal*/) {
                    /* change to normal mode and indicate to reboot...*/
                    modemMngt_setModemMode(NORMAL_MODE);
                    printf("/!\\ NEED TO REBOOT TO BE IN NORMAL MODEM MODE!\n");
                    modemMngt_setModemState(2);
                    ///system("reboot"); /* normal modem mode is off after reboot */
                    system("poweroff");
                    printf("Reboot has been launched, if it has no effect, please poweroff then poweron manually..\n");
                } else {
                    char Cmd[1000] = "";
                    vl_status = modemLstr_rcvResponse(0, (char**) &Cmd, 1000);
                    /* send atcommand for modem loopback*/
                    //printf("prepare to send a modem command...\n");
                    memset(Cmd, 0, 1000);
                    strncpy(Cmd, "AT*EAUR=3,0,3\r\n", strlen("AT*EAUR=3,0,3\r\n"));
                    vl_status = modemLstr_sendCmd(0, Cmd, 1000);
                    printf("AT*EAUR=3,0,3 has been send.\n");
                    /* check response */
                    memset(Cmd, 0, 1000);
                    vl_status = modemLstr_rcvResponse(0, (char**) &Cmd, 1000);
                    printf("Modem Response is: ");
                    printf(Cmd);
                    printf("\n");

                    system("/usr/local/bin/audio/AudioCallmpc_Headset.sh 0");
                }
            }

            break;

        case TATAUDIO_MODEM_LOOP2:

            SYSLOG(LOG_INFO, "Stopping modem audio loop 2 ...");
            /* */

            break;

        default:
            TAT_SET_LAST_ERR(TAT_BAD_REQ);
        }
    }
#endif
    RETURN_ERR();
}
예제 #23
0
blargg_err_t Kss_Emu::load_( Data_Reader& in )
{
	RETURN_ERR( core.load( in ) );
	set_warning( core.warning() );

	set_track_count( get_le16( header().last_track ) + 1 );

	core.scc_enabled = false;
	if ( header().device_flags & 0x02 ) // Sega Master System
	{
		int const osc_count = Sms_Apu::osc_count + Opl_Apu::osc_count;
		static const char* const names [osc_count] = {
			"Square 1", "Square 2", "Square 3", "Noise", "FM"
		};
		set_voice_names( names );

		static int const types [osc_count] = {
			wave_type+1, wave_type+3, wave_type+2, mixed_type+1, wave_type+0
		};
		set_voice_types( types );

		// sms.psg
		set_voice_count( Sms_Apu::osc_count );
		check( !core.sms.psg );
		CHECK_ALLOC( core.sms.psg = BLARGG_NEW Sms_Apu );

		// sms.fm
		if ( header().device_flags & 0x01 )
		{
			set_voice_count( osc_count );
			RETURN_ERR( new_opl_apu( Opl_Apu::type_smsfmunit, &core.sms.fm ) );
		}

	}
	else // MSX
	{
		int const osc_count = Ay_Apu::osc_count + Opl_Apu::osc_count;
		static const char* const names [osc_count] = {
			"Square 1", "Square 2", "Square 3", "FM"
		};
		set_voice_names( names );

		static int const types [osc_count] = {
			wave_type+1, wave_type+3, wave_type+2, wave_type+0
		};
		set_voice_types( types );

		// msx.psg
		set_voice_count( Ay_Apu::osc_count );
		check( !core.msx.psg );
		CHECK_ALLOC( core.msx.psg = BLARGG_NEW Ay_Apu );

		if ( header().device_flags & 0x10 )
			set_warning( "MSX stereo not supported" );

		// msx.music
		if ( header().device_flags & 0x01 )
		{
			set_voice_count( osc_count );
			RETURN_ERR( new_opl_apu( Opl_Apu::type_msxmusic, &core.msx.music ) );
		}

		// msx.audio
		if ( header().device_flags & 0x08 )
		{
			set_voice_count( osc_count );
			RETURN_ERR( new_opl_apu( Opl_Apu::type_msxaudio, &core.msx.audio ) );
		}

		if ( !(header().device_flags & 0x80) )
		{
			if ( !(header().device_flags & 0x84) )
				core.scc_enabled = core.scc_enabled_true;

			// msx.scc
			check( !core.msx.scc );
			CHECK_ALLOC( core.msx.scc = BLARGG_NEW Scc_Apu );

			int const osc_count = Ay_Apu::osc_count + Scc_Apu::osc_count;
			static const char* const names [osc_count] = {
				"Square 1", "Square 2", "Square 3",
				"Wave 1", "Wave 2", "Wave 3", "Wave 4", "Wave 5"
			};
			set_voice_names( names );

			static int const types [osc_count] = {
				wave_type+1, wave_type+3, wave_type+2,
				wave_type+0, wave_type+4, wave_type+5, wave_type+6, wave_type+7,
			};
			set_voice_types( types );

			set_voice_count( osc_count );
		}
	}

	set_silence_lookahead( 6 );
	if ( core.sms.fm || core.msx.music || core.msx.audio )
	{
		if ( !Opl_Apu::supported() )
			set_warning( "FM sound not supported" );
		else
			set_silence_lookahead( 3 ); // Opl_Apu is really slow
	}

	return setup_buffer( ::clock_rate );
}
예제 #24
0
int set_key_cmd_cb(int numParam, char* buf, void* ctx) {
	struct wl_ssid_t ssid;
    struct wl_mac_addr_t bssid;
    uint8_t idx=0, len=0;
    char key[13], key_hex[27];
    char keyIdx[2];
	wl_err_t err = WL_SUCCESS;
	tParam* params = (tParam*) buf;

    INFO_SPI("%s params=%d\n", __FUNCTION__, numParam);

    // SSID
    memset(&ssid, 0, sizeof ssid);

	if (params->paramLen < WL_SSID_MAX_LENGTH) {
		memcpy(ssid.ssid, &params->param, params->paramLen);
		ssid.len = params->paramLen;
		INFO_SPI("%s\n", ssid.ssid);
	} else {
		//printk("SSID len out of range");
		RETURN_ERR(WL_FAILURE)
	}

    params = (tParam*)((char*)buf+PARAM_LEN_SIZE+params->paramLen);
    strncpy(keyIdx, (const char*)&params->param, params->paramLen);
    keyIdx[(uint8_t)params->paramLen]='\0';

    idx = (uint8_t)atoi(keyIdx);
    // KEY IDX
    if ((params->paramLen != 1)||(idx < 0)||(idx > 3)){
        //printk("KEY IDX out of range %d\n", idx);
        RETURN_ERR(WL_FAILURE)
    }

    params = (tParam*)((char*)params+PARAM_LEN_SIZE+params->paramLen);
    strncpy(key_hex, (const char*)&params->param, params->paramLen);
    key_hex[(uint8_t)params->paramLen]='\0';
    len = ascii_to_key(key, key_hex);
    // KEY
    if (( len != 5)&&(len != 13))
    {
        //printk("KEY len out of range %d", len);
        RETURN_ERR(WL_FAILURE)
    }
#if 0
    printk("KEY IDX = %d\n", idx);
    dump(key, len);
    printk("KEY len %d\n", len);
#endif
    memset(&bssid.octet, 0xff, sizeof bssid.octet);

    wl_add_wep_key(idx, len, key, &bssid);
    //wl_set_auth_mode(AUTH_MODE_SHARED_KEY);
    wl_set_default_wep_key(idx);

    //Connect
    err = wl_cm_set_network(&ssid, NULL);
    if (err != 1)
        WARN("err=%d\n", err);
    RETURN_ERR(err)
}
예제 #25
0
파일: optimize.c 프로젝트: falkcarl/OpenMx
/* unlike nlopt_optimize() below, only handles minimization case */
static nlopt_result nlopt_optimize_(nlopt_opt opt, double *x, double *minf)
{
     const double *lb, *ub;
     nlopt_algorithm algorithm;
     nlopt_func f; void *f_data;
     unsigned n, i;
     int ni;
     nlopt_stopping stop;

     if (!opt || !x || !minf || !opt->f
	 || opt->maximize) RETURN_ERR(NLOPT_INVALID_ARGS, opt,
                                      "NULL args to nlopt_optimize_");

     /* reset stopping flag */
     nlopt_set_force_stop(opt, 0);
     opt->force_stop_child = NULL;
     
     /* copy a few params to local vars for convenience */
     n = opt->n;
     ni = (int) n; /* most of the subroutines take "int" arg */
     lb = opt->lb; ub = opt->ub;
     algorithm = opt->algorithm;
     f = opt->f; f_data = opt->f_data;

     if (n == 0) { /* trivial case: no degrees of freedom */
	  *minf = opt->f(n, x, NULL, opt->f_data);
	  return NLOPT_SUCCESS;
     }

     *minf = HUGE_VAL;
     
     /* check bound constraints */
     for (i = 0; i < n; ++i)
         if (lb[i] > ub[i] || x[i] < lb[i] || x[i] > ub[i]) {
             nlopt_set_errmsg(opt, "bounds %d fail %g <= %g <= %g",
                              i, lb[i], x[i], ub[i]);
             return NLOPT_INVALID_ARGS;
         }

     stop.n = n;
     stop.minf_max = opt->stopval;
     stop.ftol_rel = opt->ftol_rel;
     stop.ftol_abs = opt->ftol_abs;
     stop.xtol_rel = opt->xtol_rel;
     stop.xtol_abs = opt->xtol_abs;
     stop.nevals = 0;
     stop.maxeval = opt->maxeval;
     stop.maxtime = opt->maxtime;
     stop.force_stop = &(opt->force_stop);
     stop.stop_msg = &(opt->errmsg);

     switch (algorithm) {
	 case NLOPT_LD_SLSQP:
	      return nlopt_slsqp(n, f, f_data,
				 opt->m, opt->fc,
				 opt->p, opt->h,
				 lb, ub, x, minf, &stop);
				     
	 default:
	      return NLOPT_INVALID_ARGS;
     }

     return NLOPT_SUCCESS; /* never reached */
}
예제 #26
0
blargg_err_t Ay_Emu::start_track_( int track )
{
	RETURN_ERR( Classic_Emu::start_track_( track ) );
	
	byte* const mem = core.mem();
	
	memset( mem + 0x0000, 0xC9, 0x100 ); // fill RST vectors with RET
	memset( mem + 0x0100, 0xFF, 0x4000 - 0x100 );
	memset( mem + core.ram_addr, 0x00, core.mem_size - core.ram_addr );

	// locate data blocks
	byte const* const data = get_data( file, file.tracks + track * 4 + 2, 14 );
	if ( !data )
		return BLARGG_ERR( BLARGG_ERR_FILE_CORRUPT, "file data missing" );
	
	byte const* const more_data = get_data( file, data + 10, 6 );
	if ( !more_data )
		return BLARGG_ERR( BLARGG_ERR_FILE_CORRUPT, "file data missing" );
	
	byte const* blocks = get_data( file, data + 12, 8 );
	if ( !blocks )
		return BLARGG_ERR( BLARGG_ERR_FILE_CORRUPT, "file data missing" );
	
	// initial addresses
	unsigned addr = get_be16( blocks );
	if ( !addr )
		return BLARGG_ERR( BLARGG_ERR_FILE_CORRUPT, "file data missing" );
	
	unsigned init = get_be16( more_data + 2 );
	if ( !init )
		init = addr;
	
	// copy blocks into memory
	do
	{
		blocks += 2;
		unsigned len = get_be16( blocks ); blocks += 2;
		if ( addr + len > core.mem_size )
		{
			set_warning( "Bad data block size" );
			len = core.mem_size - addr;
		}
		check( len );
		byte const* in = get_data( file, blocks, 0 ); blocks += 2;
		if (!in) {
			break;
		}
		if ( len > (unsigned) (file.end - in) )
		{
			set_warning( "File data missing" );
			len = file.end - in;
		}
		//dprintf( "addr: $%04X, len: $%04X\n", addr, len );
		if ( addr < core.ram_addr && addr >= 0x400 ) // several tracks use low data
			dprintf( "Block addr in ROM\n" );
		memcpy( mem + addr, in, len );
		
		if ( file.end - blocks < 8 )
		{
			set_warning( "File data missing" );
			break;
		}
	}
	while ( (addr = get_be16( blocks )) != 0 );
	
	// copy and configure driver
	static byte const passive [] = {
		0xF3,       // DI
		0xCD, 0, 0, // CALL init
		0xED, 0x5E, // LOOP: IM 2
		0xFB,       // EI
		0x76,       // HALT
		0x18, 0xFA  // JR LOOP
	};
	static byte const active [] = {
		0xF3,       // DI
		0xCD, 0, 0, // CALL init
		0xED, 0x56, // LOOP: IM 1
		0xFB,       // EI
		0x76,       // HALT
		0xCD, 0, 0, // CALL play
		0x18, 0xF7  // JR LOOP
	};
	memcpy( mem, passive, sizeof passive );
	int const play_addr = get_be16( more_data + 4 );
	if ( play_addr )
	{
		memcpy( mem, active, sizeof active );
		mem [ 9] = play_addr;
		mem [10] = play_addr >> 8;
	}
	mem [2] = init;
	mem [3] = init >> 8;
	
	mem [0x38] = 0xFB; // Put EI at interrupt vector (followed by RET)
	
	// start at spectrum speed
	change_clock_rate( spectrum_clock );
	set_tempo( tempo() );
	
	Ay_Core::registers_t r = { };
	r.sp = get_be16( more_data );
	r.b.a     = r.b.b = r.b.d = r.b.h = data [8];
	r.b.flags = r.b.c = r.b.e = r.b.l = data [9];
	r.alt.w = r.w;
	r.ix = r.iy = r.w.hl;
	
	core.start_track( r, play_addr );
	
	return blargg_ok;
}
예제 #27
0
파일: Gme_File.cpp 프로젝트: kode54/Cog
blargg_err_t Gme_File::track_info( track_info_t* out, int track ) const
{
	out->track_count   = track_count();
	out->length        = -1;
	out->loop_length   = -1;
	out->intro_length  = -1;
	out->fade_length   = -1;
	out->play_length   = -1;
	out->repeat_count  = -1;
	out->song      [0] = 0;
	out->game      [0] = 0;
	out->author    [0] = 0;
	out->composer  [0] = 0;
	out->engineer  [0] = 0;
	out->sequencer [0] = 0;
	out->tagger    [0] = 0;
	out->copyright [0] = 0;
	out->date      [0] = 0;
	out->comment   [0] = 0;
	out->dumper    [0] = 0;
	out->system    [0] = 0;
	out->disc      [0] = 0;
	out->track     [0] = 0;
	out->ost       [0] = 0;
	
	copy_field_( out->system, type()->system );
	
	int remapped = track;
	RETURN_ERR( remap_track_( &remapped ) );
	RETURN_ERR( track_info_( out, remapped ) );
	
	// override with m3u info
	if ( playlist.size() )
	{
		M3u_Playlist::info_t const& i = playlist.info();
		copy_field_( out->game     , i.title );
		copy_field_( out->author   , i.artist );
		copy_field_( out->engineer , i.engineer );
		copy_field_( out->composer , i.composer );
		copy_field_( out->sequencer, i.sequencer );
		copy_field_( out->copyright, i.copyright );
		copy_field_( out->dumper   , i.ripping );
		copy_field_( out->tagger   , i.tagging );
		copy_field_( out->date     , i.date );
		
		M3u_Playlist::entry_t const& e = playlist [track];
		if ( e.length >= 0 ) out->length       = e.length;
		if ( e.intro  >= 0 ) out->intro_length = e.intro;
		if ( e.loop   >= 0 ) out->loop_length  = e.loop;
		if ( e.fade   >= 0 ) out->fade_length  = e.fade;
		if ( e.repeat >= 0 ) out->repeat_count = e.repeat;
		copy_field_( out->song, e.name );
	}
	
	// play_length
	out->play_length = out->length;
	if ( out->play_length <= 0 )
	{
		out->play_length = out->intro_length + 2 * out->loop_length; // intro + 2 loops
		if ( out->play_length <= 0 )
			out->play_length = 150 * 1000; // 2.5 minutes
	}
	
	return blargg_ok;
}