static void uf_zerofill_normal(N_RECINFO *rec, BIT_BUFF *bit_buff, uchar *to, uchar *end)
{
#ifdef WORDS_BIGENDIAN
bzero((char*) to,rec->space_length_bits);
decode_bytes(rec,bit_buff,(uchar*) to+rec->space_length_bits,end);
#else
end-=rec->space_length_bits;
decode_bytes(rec,bit_buff,(uchar*) to,end);
bzero((byte*) end,rec->space_length_bits);
#endif
}
bool cass::AuthSuccessResponse::decode(int version, char* buffer, size_t size) {
if (version < 2) {
return false;
}
decode_bytes(buffer, &token_, token_size_);
return true;
}
static void uf_skipp_zero(N_RECINFO *rec, BIT_BUFF *bit_buff, uchar *to, uchar *end)
{
if (get_bit(bit_buff))
bzero((char*) to,(uint) (end-to));
else
decode_bytes(rec,bit_buff,to,end);
}
static void uf_space_normal(N_RECINFO *rec, BIT_BUFF *bit_buff, uchar *to, uchar *end)
{
if (get_bit(bit_buff))
bfill((byte*) to,(end-to),' ');
else
decode_bytes(rec,bit_buff,to,end);
}
static void uf_zerofill_skipp_zero(N_RECINFO *rec, BIT_BUFF *bit_buff, uchar *to, uchar *end)
{
if (get_bit(bit_buff))
bzero((char*) to,(uint) (end-to));
else
{
#ifdef WORDS_BIGENDIAN
bzero((char*) to,rec->space_length_bits);
decode_bytes(rec,bit_buff,to+rec->space_length_bits,end);
#else
end-=rec->space_length_bits;
decode_bytes(rec,bit_buff,to,end);
bzero((byte*) end,rec->space_length_bits);
#endif
}
}
inline mtn::byte_t*
decode_index_key(const mtn::byte_t* input,
uint16_t* partition,
mtn::byte_t** bucket,
uint16_t* bucket_size,
mtn::byte_t** field,
uint16_t* field_size,
mtn_index_address_t* value,
mtn_index_address_t* offset)
{
mtn::byte_t* output = decode_parition(input, partition);
output = decode_bytes(output, bucket, bucket_size);
output = decode_bytes(output, field, field_size);
output = decode_uint128(output, value);
return decode_uint128(output, offset);
}
/* parse all base types */
static int gen_parse_base(const struct parse_struct *pinfo,
char *ptr,
const char *str)
{
if (pinfo->parse_fn == gen_parse_char && pinfo->ptr_count==1) {
unsigned len;
char *s = decode_bytes(str, &len);
if (!s) return -1;
*(char **)ptr = s;
return 0;
}
if (pinfo->ptr_count) {
struct parse_struct p2 = *pinfo;
*(void **)ptr = calloc(1, pinfo->ptr_count>1?sizeof(void *):pinfo->size);
if (! *(void **)ptr) {
return -1;
}
ptr = *(char **)ptr;
p2.ptr_count--;
return gen_parse_base(&p2, ptr, str);
}
return pinfo->parse_fn(ptr, str);
}
static void uf_prespace_selected(N_RECINFO *rec, BIT_BUFF *bit_buff, uchar *to, uchar *end)
{
uint spaces;
if (get_bit(bit_buff))
{
if ((spaces=get_bits(bit_buff,rec->space_length_bits))+to > end)
{
bit_buff->error=1;
return;
}
bfill((byte*) to,spaces,' ');
if (to+spaces != end)
decode_bytes(rec,bit_buff,to+spaces,end);
}
else
decode_bytes(rec,bit_buff,to,end);
}
char* ResultResponse::decode_metadata(char* input, ResultMetadata::Ptr* metadata,
bool has_pk_indices) {
int32_t flags = 0;
char* buffer = decode_int32(input, flags);
int32_t column_count = 0;
buffer = decode_int32(buffer, column_count);
if (has_pk_indices) {
int32_t pk_count = 0;
buffer = decode_int32(buffer, pk_count);
for (int i = 0; i < pk_count; ++i) {
uint16_t pk_index = 0;
buffer = decode_uint16(buffer, pk_index);
pk_indices_.push_back(pk_index);
}
}
if (flags & CASS_RESULT_FLAG_HAS_MORE_PAGES) {
has_more_pages_ = true;
buffer = decode_bytes(buffer, &paging_state_);
} else {
has_more_pages_ = false;
}
if (!(flags & CASS_RESULT_FLAG_NO_METADATA)) {
bool global_table_spec = flags & CASS_RESULT_FLAG_GLOBAL_TABLESPEC;
if (global_table_spec) {
buffer = decode_string(buffer, &keyspace_);
buffer = decode_string(buffer, &table_);
}
metadata->reset(new ResultMetadata(column_count));
for (int i = 0; i < column_count; ++i) {
ColumnDefinition def;
def.index = i;
if (!global_table_spec) {
buffer = decode_string(buffer, &def.keyspace);
buffer = decode_string(buffer, &def.table);
}
buffer = decode_string(buffer, &def.name);
DataTypeDecoder type_decoder(buffer);
def.data_type = DataType::ConstPtr(type_decoder.decode());
buffer = type_decoder.buffer();
(*metadata)->add(def);
}
}
return buffer;
}
/* parse a generic array */
static int gen_parse_array(const struct parse_struct *pinfo,
char *ptr,
const char *str,
int array_len)
{
char *p, *p2;
unsigned size = pinfo->size;
/* special handling of fixed length strings */
if (array_len != 0 &&
pinfo->ptr_count == 0 &&
pinfo->dump_fn == gen_dump_char) {
unsigned len = 0;
char *s = decode_bytes(str, &len);
if (!s) return -1;
memset(ptr, 0, array_len);
memcpy(ptr, s, len);
free(s);
return 0;
}
if (pinfo->ptr_count) {
size = sizeof(void *);
}
while (*str) {
unsigned idx;
int done;
idx = atoi(str);
p = strchr(str,':');
if (!p) break;
p++;
p2 = match_braces(p, ',');
done = (*p2 != ',');
*p2 = 0;
if (*p == '{') {
p++;
p[strlen(p)-1] = 0;
}
if (gen_parse_base(pinfo, ptr + idx*size, p) != 0) {
return -1;
}
if (done) break;
str = p2+1;
}
return 0;
}
static void uf_endspace(N_RECINFO *rec, BIT_BUFF *bit_buff, uchar *to,
uchar *end)
{
uint spaces;
if ((spaces=get_bits(bit_buff,rec->space_length_bits))+to > end)
{
bit_buff->error=1;
return;
}
if (to+spaces != end)
decode_bytes(rec,bit_buff,to,end-spaces);
bfill((byte*) end-spaces,spaces,' ');
}
char* Response::decode_custom_payload(char* buffer, size_t size) {
uint16_t item_count;
char* pos = decode_uint16(buffer, item_count);
for (uint16_t i = 0; i < item_count; ++i) {
StringRef name;
StringRef value;
pos = decode_string(pos, &name);
pos = decode_bytes(pos, &value);
custom_payload_.push_back(CustomPayloadItem(name, value));
}
return pos;
}
/**
* First part of subpacket decoding:
* decode raw stream bytes and read gain info.
*
* @param q pointer to the COOKContext
* @param inbuffer pointer to raw stream data
* @param gains_ptr array of current/prev gain pointers
*/
static inline void decode_bytes_and_gain(COOKContext *q, COOKSubpacket *p,
const uint8_t *inbuffer,
cook_gains *gains_ptr)
{
int offset;
offset = decode_bytes(inbuffer, q->decoded_bytes_buffer,
p->bits_per_subpacket / 8);
init_get_bits(&q->gb, q->decoded_bytes_buffer + offset,
p->bits_per_subpacket);
decode_gain_info(&q->gb, gains_ptr->now);
/* Swap current and previous gains */
FFSWAP(int *, gains_ptr->now, gains_ptr->previous);
}
static int decode_subpacket(COOKContext *q, uint8_t *inbuffer,
int sub_packet_size, int16_t *outbuffer) {
int i,j;
int value;
float* tmp_ptr;
/* packet dump */
// for (i=0 ; i<sub_packet_size ; i++) {
// av_log(NULL, AV_LOG_ERROR, "%02x", inbuffer[i]);
// }
// av_log(NULL, AV_LOG_ERROR, "\n");
decode_bytes(inbuffer, q->decoded_bytes_buffer, sub_packet_size);
init_get_bits(&q->gb, q->decoded_bytes_buffer, sub_packet_size*8);
decode_gain_info(&q->gb, &q->gain_current);
if(q->nb_channels==2 && q->joint_stereo==1){
joint_decode(q, q->decode_buf_ptr[0], q->decode_buf_ptr[2]);
/* Swap buffer pointers. */
tmp_ptr = q->decode_buf_ptr[1];
q->decode_buf_ptr[1] = q->decode_buf_ptr[0];
q->decode_buf_ptr[0] = tmp_ptr;
tmp_ptr = q->decode_buf_ptr[3];
q->decode_buf_ptr[3] = q->decode_buf_ptr[2];
q->decode_buf_ptr[2] = tmp_ptr;
/* FIXME: Rethink the gainbuffer handling, maybe a rename?
now/previous swap */
q->gain_now_ptr = &q->gain_now;
q->gain_previous_ptr = &q->gain_previous;
for (i=0 ; i<q->nb_channels ; i++){
cook_imlt(q, q->decode_buf_ptr[i*2], q->mono_mdct_output, q->mlt_tmp);
gain_compensate(q, q->mono_mdct_output, q->gain_now_ptr,
q->gain_previous_ptr, q->previous_buffer_ptr[0]);
/* Swap out the previous buffer. */
tmp_ptr = q->previous_buffer_ptr[0];
q->previous_buffer_ptr[0] = q->previous_buffer_ptr[1];
q->previous_buffer_ptr[1] = tmp_ptr;
/* Clip and convert the floats to 16 bits. */
for (j=0 ; j<q->samples_per_frame ; j++){
value = lrintf(q->mono_mdct_output[j]);
if(value < -32768) value = -32768;
else if(value > 32767) value = 32767;
outbuffer[2*j+i] = value;
}
}
memcpy(&q->gain_now, &q->gain_previous, sizeof(COOKgain));
memcpy(&q->gain_previous, &q->gain_current, sizeof(COOKgain));
} else if (q->nb_channels==2 && q->joint_stereo==0) {
/* channel 0 */
mono_decode(q, q->decode_buf_ptr2[0]);
tmp_ptr = q->decode_buf_ptr2[0];
q->decode_buf_ptr2[0] = q->decode_buf_ptr2[1];
q->decode_buf_ptr2[1] = tmp_ptr;
memcpy(&q->gain_channel1[0], &q->gain_current ,sizeof(COOKgain));
q->gain_now_ptr = &q->gain_channel1[0];
q->gain_previous_ptr = &q->gain_channel1[1];
cook_imlt(q, q->decode_buf_ptr2[0], q->mono_mdct_output,q->mlt_tmp);
gain_compensate(q, q->mono_mdct_output, q->gain_now_ptr,
q->gain_previous_ptr, q->mono_previous_buffer1);
memcpy(&q->gain_channel1[1], &q->gain_channel1[0],sizeof(COOKgain));
for (j=0 ; j<q->samples_per_frame ; j++){
value = lrintf(q->mono_mdct_output[j]);
if(value < -32768) value = -32768;
else if(value > 32767) value = 32767;
outbuffer[2*j+1] = value;
}
/* channel 1 */
//av_log(NULL,AV_LOG_ERROR,"bits = %d\n",get_bits_count(&q->gb));
init_get_bits(&q->gb, q->decoded_bytes_buffer, sub_packet_size*8+q->bits_per_subpacket);
q->gain_now_ptr = &q->gain_channel2[0];
q->gain_previous_ptr = &q->gain_channel2[1];
decode_gain_info(&q->gb, &q->gain_channel2[0]);
mono_decode(q, q->decode_buf_ptr[0]);
tmp_ptr = q->decode_buf_ptr[0];
q->decode_buf_ptr[0] = q->decode_buf_ptr[1];
q->decode_buf_ptr[1] = tmp_ptr;
cook_imlt(q, q->decode_buf_ptr[0], q->mono_mdct_output,q->mlt_tmp);
gain_compensate(q, q->mono_mdct_output, q->gain_now_ptr,
q->gain_previous_ptr, q->mono_previous_buffer2);
/* Swap out the previous buffer. */
tmp_ptr = q->previous_buffer_ptr[0];
q->previous_buffer_ptr[0] = q->previous_buffer_ptr[1];
q->previous_buffer_ptr[1] = tmp_ptr;
memcpy(&q->gain_channel2[1], &q->gain_channel2[0] ,sizeof(COOKgain));
for (j=0 ; j<q->samples_per_frame ; j++){
value = lrintf(q->mono_mdct_output[j]);
if(value < -32768) value = -32768;
else if(value > 32767) value = 32767;
outbuffer[2*j] = value;
}
} else {
mono_decode(q, q->decode_buf_ptr[0]);
/* Swap buffer pointers. */
tmp_ptr = q->decode_buf_ptr[1];
q->decode_buf_ptr[1] = q->decode_buf_ptr[0];
q->decode_buf_ptr[0] = tmp_ptr;
/* FIXME: Rethink the gainbuffer handling, maybe a rename?
now/previous swap */
q->gain_now_ptr = &q->gain_now;
q->gain_previous_ptr = &q->gain_previous;
cook_imlt(q, q->decode_buf_ptr[0], q->mono_mdct_output,q->mlt_tmp);
gain_compensate(q, q->mono_mdct_output, q->gain_now_ptr,
q->gain_previous_ptr, q->mono_previous_buffer1);
/* Clip and convert the floats to 16 bits */
for (j=0 ; j<q->samples_per_frame ; j++){
value = lrintf(q->mono_mdct_output[j]);
if(value < -32768) value = -32768;
else if(value > 32767) value = 32767;
outbuffer[j] = value;
}
memcpy(&q->gain_now, &q->gain_previous, sizeof(COOKgain));
memcpy(&q->gain_previous, &q->gain_current, sizeof(COOKgain));
}
return q->samples_per_frame * sizeof(int16_t);
}
