extern VERTEX_ARRAY*
store_vertices_buffers(const VIDEO_VERTICES_INFO *info) {
store_buffer(info->vertices);
store_buffer(info->elements);
return store_vertex_array(info->array);
}
static void loop_store_buffer(MYSQL_STMT *stmt, MYSQL_BIND *bind, int total_blob_length, VALUE block, VALUE obj)
{
long loops = abs(total_blob_length / bind->buffer_length);
long i;
for (i = 0; i < loops; ++i) {
store_buffer(stmt, i * bind->buffer_length, bind, bind->buffer_length, block, obj);
}
int new_bufflen = total_blob_length % bind->buffer_length;
if (new_bufflen) {
store_buffer(stmt, loops * bind->buffer_length, bind, new_bufflen, block, obj);
}
}
int main(){
wave test;
int samples = 2000000,i,j,sounds,f;
wave_buffer **bufs;
scanf("%d",&sounds);
bufs = (wave_buffer**) malloc( (sounds+1) * sizeof(wave_buffer*));
for (i = 0;i < sounds;i++){
bufs[i] = (wave_buffer*) malloc(sizeof(wave_buffer));
init_buffer(bufs[i],mono,44100,16,samples);
alloc_buffer(bufs[i]);
scanf("%d",&f);
for (j = 0; j < samples;j++)
bufs[i]->buffer[j] = Round(sinf( (float) j / f) * 30000);
}
bufs[i] = NULL;
mix_wave_buffers(*bufs,bufs+1,0);
buffer_make_chunk(*bufs,&test);
wave_open_file("test.wav","wb",&test);
wave_write_chunk(&test);
store_buffer(*bufs,&test,0);
wave_finalize(&test);
wave_close_file(&test);
for (i = 0; i < sounds;i++)
free_buffer(bufs[i]);
free(bufs);
}
void FileAccess::store_string(const String &p_string) {
if (p_string.length() == 0)
return;
CharString cs = p_string.utf8();
store_buffer((uint8_t *)&cs[0], cs.length());
}
void loop(){
int i;
static u8 zero[32] = {0};
if (is_playing){
int buf_len = mp3_buffer_len();
static int last_second = -1;
int second;
store_buffer();
if (buf_len < 32){
for (i=0;i<8;i++) fill_mp3_buffer();
}else if (mp3_need_data()){
if (wifi_available_len() < 30 && last_second < 2){
printf("oooooverrrrrrrrr\r\n");
while (wifi_available_len() > 0) wifi_receive();
mp3_input_data(zero);
cur_song_init();
is_playing = 0;
return;
}
mp3_input_data(cur_song.buffer);
for (i=32;i<cur_song.buffer_idx;i++){
cur_song.buffer[i-32] = cur_song.buffer[i];
}
cur_song.buffer_idx -= 32;
if (cur_song.frame_size > 0){
second = cur_song.content_remain / cur_song.frame_size * 26 /1000;
if (second != last_second) printf("time : -%d\r\n",second);
last_second = second;
}
}
}else{
char * sg;
sg = next_song();
printf(">>> %s\r\n",sg);
send_fetch_song(sg);
is_playing = 1;
}
}
void _File::store_var(const Variant& p_var) {
ERR_FAIL_COND(!f);
int len;
Error err = encode_variant(p_var,NULL,len);
ERR_FAIL_COND( err != OK );
DVector<uint8_t> buff;
buff.resize(len);
DVector<uint8_t>::Write w = buff.write();
err = encode_variant(p_var,&w[0],len);
ERR_FAIL_COND( err != OK );
w=DVector<uint8_t>::Write();
store_32(len);
store_buffer(buff);
}
OM_uint32
gssEapExportSecContext(OM_uint32 *minor,
gss_ctx_id_t ctx,
gss_buffer_t token)
{
OM_uint32 major, tmpMinor;
size_t length;
gss_buffer_desc initiatorName = GSS_C_EMPTY_BUFFER;
gss_buffer_desc acceptorName = GSS_C_EMPTY_BUFFER;
gss_buffer_desc partialCtx = GSS_C_EMPTY_BUFFER;
gss_buffer_desc key;
unsigned char *p;
if ((CTX_IS_INITIATOR(ctx) && !CTX_IS_ESTABLISHED(ctx)) ||
ctx->mechanismUsed == GSS_C_NO_OID) {
*minor = GSSEAP_CONTEXT_INCOMPLETE;
return GSS_S_NO_CONTEXT;
}
key.length = KRB_KEY_LENGTH(&ctx->rfc3961Key);
key.value = KRB_KEY_DATA(&ctx->rfc3961Key);
if (ctx->initiatorName != GSS_C_NO_NAME) {
major = gssEapExportNameInternal(minor, ctx->initiatorName,
&initiatorName,
EXPORT_NAME_FLAG_COMPOSITE);
if (GSS_ERROR(major))
goto cleanup;
}
if (ctx->acceptorName != GSS_C_NO_NAME) {
major = gssEapExportNameInternal(minor, ctx->acceptorName,
&acceptorName,
EXPORT_NAME_FLAG_COMPOSITE);
if (GSS_ERROR(major))
goto cleanup;
}
#ifdef GSSEAP_ENABLE_ACCEPTOR
/*
* The partial context is only transmitted for unestablished acceptor
* contexts.
*/
if (!CTX_IS_INITIATOR(ctx) && !CTX_IS_ESTABLISHED(ctx) &&
(ctx->flags & CTX_FLAG_KRB_REAUTH) == 0) {
major = gssEapExportPartialContext(minor, ctx, &partialCtx);
if (GSS_ERROR(major))
goto cleanup;
}
#endif
length = 16; /* version, state, flags, */
length += 4 + ctx->mechanismUsed->length; /* mechanismUsed */
length += 12 + key.length; /* rfc3961Key.value */
length += 4 + initiatorName.length; /* initiatorName.value */
length += 4 + acceptorName.length; /* acceptorName.value */
length += 24 + sequenceSize(ctx->seqState); /* seqState */
if (partialCtx.value != NULL)
length += 4 + partialCtx.length; /* partialCtx.value */
token->value = GSSEAP_MALLOC(length);
if (token->value == NULL) {
major = GSS_S_FAILURE;
*minor = ENOMEM;
goto cleanup;
}
token->length = length;
p = (unsigned char *)token->value;
store_uint32_be(EAP_EXPORT_CONTEXT_V1, &p[0]); /* version */
store_uint32_be(GSSEAP_SM_STATE(ctx), &p[4]);
store_uint32_be(ctx->flags, &p[8]);
store_uint32_be(ctx->gssFlags, &p[12]);
p = store_oid(ctx->mechanismUsed, &p[16]);
store_uint32_be(ctx->checksumType, &p[0]);
store_uint32_be(ctx->encryptionType, &p[4]);
p = store_buffer(&key, &p[8], FALSE);
p = store_buffer(&initiatorName, p, FALSE);
p = store_buffer(&acceptorName, p, FALSE);
store_uint64_be(ctx->expiryTime, &p[0]);
store_uint64_be(ctx->sendSeq, &p[8]);
store_uint64_be(ctx->recvSeq, &p[16]);
p += 24;
major = sequenceExternalize(minor, ctx->seqState, &p, &length);
if (GSS_ERROR(major))
goto cleanup;
if (partialCtx.value != NULL)
p = store_buffer(&partialCtx, p, FALSE);
GSSEAP_ASSERT(p == (unsigned char *)token->value + token->length);
major = GSS_S_COMPLETE;
*minor = 0;
cleanup:
if (GSS_ERROR(major))
gss_release_buffer(&tmpMinor, token);
gss_release_buffer(&tmpMinor, &initiatorName);
gss_release_buffer(&tmpMinor, &acceptorName);
gss_release_buffer(&tmpMinor, &partialCtx);
return major;
}
void FileAccess::store_pascal_string(const String &p_string) {
CharString cs = p_string.utf8();
store_32(cs.length());
store_buffer((uint8_t *)&cs[0], cs.length());
};
