Test results for the library celt-0.4.0 on x86

Summary

Total tests	12
Passed / Failed tests	2 / 10
Warnings	2
Verdict	Test Failed

Problem Summary

Received signal SEGV

Failed Tests (10)

[+] Received signal SEGV (10 problems)

celt.h, libcelt.so.0.0.0
[+] celt_decode ( CELTDecoder* st, unsigned char* data, int len, celt_int16_t* pcm ):int

received signal SEGV

warning: Sampling rate must be between 32 kHz and 64 kHz

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

#include <stdlib.h>

#include <celt/celt.h>

int main(int argc, char *argv[])

{

int error = 0;

CELTMode* mode = celt_mode_create(

&error);

CELTDecoder* st = celt_decoder_create(mode);

unsigned char data [] = {

'A',

'B',

'C',

'D',

'\0'};

celt_int16_t* pcm = (celt_int16_t*) malloc(sizeof(celt_int16_t)*256);

celt_decode(

st,

data,

pcm); //target call

return 0;

}

[+] celt_decoder_create ( CELTMode const* mode ):CELTDecoder*

received signal SEGV

warning: Sampling rate must be between 32 kHz and 64 kHz

1
2
3
4
5
6
7
8
9
10
11
12

#include <celt/celt.h>

int main(int argc, char *argv[])

{

int error = 0;

CELTMode* mode = celt_mode_create(

&error);

celt_decoder_create(mode); //target call

return 0;

}

[+] celt_decoder_destroy ( CELTDecoder* st ):void

received signal SEGV

warning: Sampling rate must be between 32 kHz and 64 kHz

1
2
3
4
5
6
7
8
9
10
11
12
13

#include <celt/celt.h>

int main(int argc, char *argv[])

{

int error = 0;

CELTMode* mode = celt_mode_create(

&error);

CELTDecoder* st = celt_decoder_create(mode);

celt_decoder_destroy(st); //target call

return 0;

}

[+] celt_encode ( CELTEncoder* st, celt_int16_t* pcm, unsigned char* compressed, int nbCompressedBytes ):int

received signal SEGV

warning: Sampling rate must be between 32 kHz and 64 kHz

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

#include <stdlib.h>

#include <celt/celt.h>

int main(int argc, char *argv[])

{

int error = 0;

CELTMode* mode = celt_mode_create(

&error);

CELTEncoder* st = celt_encoder_create(mode);

celt_int16_t* pcm = (celt_int16_t*) malloc(sizeof(celt_int16_t)*256);

unsigned char compressed [] = {

'A',

'B',

'C',

'D',

'\0'};

celt_encode(

st,

pcm,

compressed,

3); //target call

return 0;

}

[+] celt_encoder_create ( CELTMode const* mode ):CELTEncoder*

received signal SEGV

warning: Sampling rate must be between 32 kHz and 64 kHz

1
2
3
4
5
6
7
8
9
10
11
12

#include <celt/celt.h>

int main(int argc, char *argv[])

{

int error = 0;

CELTMode* mode = celt_mode_create(

&error);

celt_encoder_create(mode); //target call

return 0;

}

[+] celt_encoder_destroy ( CELTEncoder* st ):void

received signal SEGV

warning: Sampling rate must be between 32 kHz and 64 kHz

1
2
3
4
5
6
7
8
9
10
11
12
13

#include <celt/celt.h>

int main(int argc, char *argv[])

{

int error = 0;

CELTMode* mode = celt_mode_create(

&error);

CELTEncoder* st = celt_encoder_create(mode);

celt_encoder_destroy(st); //target call

return 0;

}

[+] celt_mode_destroy ( CELTMode* mode ):void

received signal SEGV

warning: Sampling rate must be between 32 kHz and 64 kHz

1
2
3
4
5
6
7
8
9
10
11
12

#include <celt/celt.h>

int main(int argc, char *argv[])

{

int error = 0;

CELTMode* mode = celt_mode_create(

&error);

celt_mode_destroy(mode); //target call

return 0;

}

celt_header.h, libcelt.so.0.0.0
[+] celt_header_from_packet ( unsigned char const* packet, celt_uint32_t size, CELTHeader* header ):int

received signal SEGV

warning: Sampling rate must be between 32 kHz and 64 kHz

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

#include <celt/celt_header.h>

int main(int argc, char *argv[])

{

int error = 0;

CELTMode* m = celt_mode_create(

&error);

CELTHeader header;

celt_header_init(&header, m);

celt_header_from_packet((unsigned char const*) "packet", 6, &header); //target call

return 0;

}

[+] celt_header_init ( CELTHeader* header, CELTMode const* m ):void

received signal SEGV

warning: Sampling rate must be between 32 kHz and 64 kHz

1
2
3
4
5
6
7
8
9
10
11
12
13

#include <celt/celt_header.h>

int main(int argc, char *argv[])

{

CELTHeader header;

int error = 0;

CELTMode* m = celt_mode_create(

&error);

celt_header_init(&header, m); //target call

return 0;

}

[+] celt_header_to_packet ( CELTHeader const* header, unsigned char* packet, celt_uint32_t size ):int

received signal SEGV

warning: Sampling rate must be between 32 kHz and 64 kHz

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

#include <celt/celt_header.h>

int main(int argc, char *argv[])

{

int error = 0;

CELTMode* m = celt_mode_create(

&error);

CELTHeader header;

celt_header_init(&header, m);

unsigned char packet [] = {

'A',

'B',

'C',

'D',

'\0'};

celt_header_to_packet(&header, packet, 4); //target call

return 0;

}

to the top

Warnings (2)

[+] Unexpected Output (2 warnings)

celt.h, libcelt.so.0.0.0
[+] celt_mode_create ( celt_int32_t Fs, int channels, int frame_size, int* error ):CELTMode*

warning: Sampling rate must be between 32 kHz and 64 kHz

1
2
3
4
5
6
7
8
9
10
11

#include <celt/celt.h>

int main(int argc, char *argv[])

{

int error = 0;

celt_mode_create(

&error); //target call

return 0;

}

[+] celt_mode_info ( CELTMode const* mode, int request, celt_int32_t* value ):int

warning: Sampling rate must be between 32 kHz and 64 kHz

1
2
3
4
5
6
7
8
9
10
11
12
13
14

#include <stdlib.h>

#include <celt/celt.h>

int main(int argc, char *argv[])

{

int error = 0;

CELTMode* mode = celt_mode_create(

&error);

celt_int32_t* value = (celt_int32_t*) malloc(sizeof(celt_int32_t)*256);

celt_mode_info(mode, 3, value); //target call

return 0;

}

to the top