int wav_header_encode(FILE *f, uint16_t format, uint16_t channels,
uint32_t srate, uint16_t bps, size_t bytes)
{
int err;
err = chunk_encode(f, "RIFF", 36 + bytes);
if (err)
return err;
if (1 != fwrite("WAVE", 4, 1, f))
return ferror(f);
err = chunk_encode(f, "fmt ", WAVE_FMT_SIZE);
if (err)
return err;
err = write_u16(f, format);
err |= write_u16(f, channels);
err |= write_u32(f, srate);
err |= write_u32(f, srate * channels * bps / 8);
err |= write_u16(f, channels * bps / 8);
err |= write_u16(f, bps);
if (err)
return err;
return chunk_encode(f, "data", bytes);
}
void btstack_libusb_device_base::send_acl_package( std::uint8_t* acl_buffer, std::size_t size )
{
const int pb = hci_non_flushable_packet_boundary_flag_supported() ? 0x00 : 0x02;
// 0 - Connection handle : PB=pb : BC=00
write_u16(acl_buffer + 0, connection_handle_ | (pb << 12) | (0 << 14));
write_u16(acl_buffer + 2, size - 4);
write_u16(acl_buffer + 4, size - 8);
// 6 - L2CAP channel = 1
write_u16(acl_buffer + 6, 0x0004);
log_info("*send_acl_package: %i", size );
hexdump( acl_buffer, size );
hci_send_acl_packet_buffer( size );
}
static void do_test_libeprom24x(void)
{
int value;
do {
print_menu();
printf("Enter choice : ");
scanf("%d",&value);
switch(value) {
case 1:
get_prod_info();
break;
case 2:
get_last_error();
break;
case 3:
initialize();
break;
case 4:
finalize();
break;
case 5:
read_u8();
break;
case 6:
read_u16();
break;
case 7:
read_u32();
break;
case 8:
read_to_buffer();
break;
case 9:
write_u8();
break;
case 10:
write_u16();
break;
case 11:
write_u32();
break;
case 12:
write_from_buffer();
break;
case 13:
erase_chip();
break;
case 100: /* Exit */
break;
default:
printf("Illegal choice!\n");
}
} while (value != 100);
return;
}
u32 xbinary_writer::write(u16 b)
{
if (_can_write(len_, cursor_, sizeof(b)))
{
write_u16(buffer_ + cursor_, b);
cursor_ += sizeof(b);
return sizeof(b);
}
return 0;
}
int blob_encode_t::input(char *s,int len)
{
assert(current_len+len+sizeof(u16_t) +100<sizeof(input_buf));
assert(len<=65535&&len>=0);
counter++;
assert(counter<=max_blob_packet_num);
write_u16(input_buf+current_len,len);
current_len+=sizeof(u16_t);
memcpy(input_buf+current_len,s,len);
current_len+=len;
return 0;
}
void type_write(type_t t, type_wr_ctx_t ctx)
{
fbuf_t *f = tree_write_file(ctx->tree_ctx);
if (t == NULL) {
write_u16(UINT16_C(0xffff), f); // Null marker
return;
}
if (t->generation == ctx->generation) {
// Already visited this type
write_u16(UINT16_C(0xfffe), f); // Back reference marker
write_u32(t->index, f);
return;
}
t->generation = ctx->generation;
t->index = (ctx->n_types)++;
write_u16(t->kind, f);
// Call type_ident here to generate an arbitrary name if needed
ident_write(type_ident(t), ctx->ident_ctx);
const uint32_t has = has_map[t->kind];
const int nitems = __builtin_popcount(has);
uint32_t mask = 1;
for (int n = 0; n < nitems; mask <<= 1) {
if (has & mask) {
if (ITEM_TYPE_ARRAY & mask) {
type_array_t *a = &(t->items[n].type_array);
write_u16(a->count, f);
for (unsigned i = 0; i < a->count; i++)
type_write(a->items[i], ctx);
}
else if (ITEM_TYPE & mask)
type_write(t->items[n].type, ctx);
else if (ITEM_TREE & mask)
tree_write(t->items[n].tree, ctx->tree_ctx);
else if (ITEM_TREE_ARRAY & mask) {
tree_array_t *a = &(t->items[n].tree_array);
write_u16(a->count, f);
for (unsigned i = 0; i < a->count; i++)
tree_write(a->items[i], ctx->tree_ctx);
}
else if (ITEM_RANGE_ARRAY & mask) {
range_array_t *a = &(t->items[n].range_array);
write_u16(a->count, f);
for (unsigned i = 0; i < a->count; i++) {
write_u8(a->items[i].kind, f);
tree_write(a->items[i].left, ctx->tree_ctx);
tree_write(a->items[i].right, ctx->tree_ctx);
}
}
else
item_without_type(mask);
n++;
}
}
}
static void write_u16_func(void** state) {
char buf[27];
char comp_buf[27];
uint16_t value = 0;
uint32_t idx = 0;
for(uint32_t i = 0; i < CHAR_SIZE; i += 2) {
value = (('a' + i) << 8) | ('b' + i);
sprintf(comp_buf + i, "%c%c%c", 'a' + i, 'b' + i, '\0');
write_u16(buf, value, &idx);
buf[idx] = '\0';
assert_string_equal(buf, comp_buf);
}
}
static ssize_t
mdns_write_hdr(uint8_t *ptr, const struct mdns_hdr *hdr)
{
uint8_t *p = ptr;
p = write_u16(p, hdr->id);
p = write_u16(p, hdr->flags);
p = write_u16(p, hdr->num_qn);
p = write_u16(p, hdr->num_ans_rr);
p = write_u16(p, hdr->num_auth_rr);
p = write_u16(p, hdr->num_add_rr);
return (p - ptr);
}
int fec_encode_manager_t::append(char *s,int len/*,int &is_first_packet*/)
{
if(counter==0)
{
itimerspec its;
memset(&its.it_interval,0,sizeof(its.it_interval));
first_packet_time=get_current_time_us();
my_time_t tmp_time=fec_timeout+first_packet_time;
its.it_value.tv_sec=tmp_time/1000000llu;
its.it_value.tv_nsec=(tmp_time%1000000llu)*1000llu;
timerfd_settime(timer_fd,TFD_TIMER_ABSTIME,&its,0);
}
if(fec_mode==0)//for type 0 use blob
{
assert(blob_encode.input(s,len)==0);
}
else if(fec_mode==1)//for tpe 1 use input_buf and counter
{
mylog(log_trace,"counter=%d\n",counter);
assert(len<=65535&&len>=0);
//assert(len<=fec_mtu);//relax this limitation
char * p=input_buf[counter]+sizeof(u32_t)+4*sizeof(char);//copy directly to final position,avoid unnecessary copy.
//remember to change this,if protocol is modified
write_u16(p,(u16_t)((u32_t)len)); //TODO omit this u16 for data packet while sending
p+=sizeof(u16_t);
memcpy(p,s,len);
input_len[counter]=len+sizeof(u16_t);
}
else
{
assert(0==1);
}
counter++;
return 0;
}
// class method to play a note based on AnalogOut class
void Buzzer::play(float freq, int dur, float vol) {
// we create a new array here where each value is scaled by some
// value. This changes the buzzer's volume.
for (size_t i = 0; i < numPts; i++)
analog_data_scaled.at(i) = vol * analog_data.at(i);
// reset our lut index
j = 0;
// setup an interrupt timer that updates the currenly set
// value at the given duration. This depends on our playing
// frequency's period and the number of elements in our lookup table.
RtosTimerHelper sin_wave(this, &Buzzer::analogUpdate, osTimerPeriodic);
sin_wave.start(1.0 / (freq * numPts));
// keep the timer interrupt active for however long we
// need to play this note. Disabling the interrupt once
// we've waiting long enough
Thread::wait(dur);
sin_wave.stop();
// sets output to mid range - analog zero
write_u16(32768);
}
