Test results for the library celt-0.6.1 on x86

Summary

Total tests	16
Passed / Failed tests	14 / 2
Warnings	14
Verdict	Test Failed

Problem Summary

Received signal SEGV

Failed Tests (2)

[+] Received signal SEGV (2 problems)

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

received signal SEGV

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

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

#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);

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

celt_decode_float(

st,

(unsigned char const*) "data",

pcm); //target call

return 0;

}

[+] celt_encode_float ( CELTEncoder* st, float const* pcm, float* optional_synthesis, unsigned char* compressed, int nbCompressedBytes ):int

received signal SEGV

warning: Sampling rate must be between 32 kHz and 96 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
26
27
28
29
30
31
32
33
34

#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);

float pcm [] = {

1.5f,

2.5f,

3.5f,

4.5f};

float optional_synthesis [] = {

5.5f,

6.5f,

7.5f,

8.5f};

unsigned char compressed [] = {

'A',

'B',

'C',

'D',

'\0'};

celt_encode_float(

st,

pcm,

optional_synthesis,

compressed,

3); //target call

return 0;

}

to the top

Warnings (14)

[+] Unexpected Output (14 warnings)

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

warning: Sampling rate must be between 32 kHz and 96 kHz
warning: NULL passed a decoder structure

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

#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);

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

celt_decode(

st,

(unsigned char const*) "data",

pcm); //target call

return 0;

}

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

warning: Sampling rate must be between 32 kHz and 96 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_ctl ( CELTDecoder* st, int request, ... ):int

warning: Sampling rate must be between 32 kHz and 96 kHz
warning: NULL passed a decoder structure

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_ctl(st, 3, 0); //target call

return 0;

}

[+] celt_decoder_destroy ( CELTDecoder* st ):void

warning: Sampling rate must be between 32 kHz and 96 kHz
warning: NULL passed to celt_decoder_destroy

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 const* pcm, celt_int16_t* optional_synthesis, unsigned char* compressed, int nbCompressedBytes ):int

warning: Sampling rate must be between 32 kHz and 96 kHz
warning: NULL passed as an encoder structure

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
26
27
28
29
30
31
32
33
34

#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 [] = {

3};

celt_int16_t optional_synthesis [] = {

3};

unsigned char compressed [] = {

'A',

'B',

'C',

'D',

'\0'};

celt_encode(

st,

pcm,

optional_synthesis,

compressed,

3); //target call

return 0;

}

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

warning: Sampling rate must be between 32 kHz and 96 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_ctl ( CELTEncoder* st, int request, ... ):int

warning: Sampling rate must be between 32 kHz and 96 kHz
warning: NULL passed as an encoder structure

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_ctl(st, 3, 0); //target call

return 0;

}

[+] celt_encoder_destroy ( CELTEncoder* st ):void

warning: Sampling rate must be between 32 kHz and 96 kHz
warning: NULL passed to celt_encoder_destroy

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_create ( celt_int32_t Fs, int channels, int frame_size, int* error ):CELTMode*

warning: Sampling rate must be between 32 kHz and 96 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_destroy ( CELTMode* mode ):void

warning: Sampling rate must be between 32 kHz and 96 kHz
warning: NULL passed to celt_mode_destroy

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_mode_info ( CELTMode const* mode, int request, celt_int32_t* value ):int

warning: Sampling rate must be between 32 kHz and 96 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;

}

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

warning: Sampling rate must be between 32 kHz and 96 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 ):int

warning: Sampling rate must be between 32 kHz and 96 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

warning: Sampling rate must be between 32 kHz and 96 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