ruby-brs 1.1.1 → 1.2.0
Sign up to get free protection for your applications and to get access to all the features.
- checksums.yaml +4 -4
- data/README.md +87 -85
- data/ext/brs_ext/buffer.c +21 -7
- data/ext/brs_ext/buffer.h +7 -7
- data/ext/brs_ext/common.h +3 -0
- data/ext/brs_ext/error.c +0 -1
- data/ext/brs_ext/error.h +2 -1
- data/ext/brs_ext/gvl.h +24 -0
- data/ext/brs_ext/io.c +273 -157
- data/ext/brs_ext/main.c +0 -1
- data/ext/brs_ext/option.c +37 -30
- data/ext/brs_ext/option.h +39 -32
- data/ext/brs_ext/stream/compressor.c +124 -61
- data/ext/brs_ext/stream/compressor.h +7 -4
- data/ext/brs_ext/stream/decompressor.c +60 -31
- data/ext/brs_ext/stream/decompressor.h +7 -4
- data/ext/brs_ext/string.c +118 -66
- data/ext/extconf.rb +9 -0
- data/lib/brs/file.rb +4 -0
- data/lib/brs/option.rb +6 -0
- data/lib/brs/stream/abstract.rb +9 -12
- data/lib/brs/stream/raw/abstract.rb +6 -2
- data/lib/brs/stream/raw/compressor.rb +3 -7
- data/lib/brs/stream/raw/decompressor.rb +1 -5
- data/lib/brs/stream/reader.rb +71 -52
- data/lib/brs/stream/writer.rb +10 -5
- data/lib/brs/stream/writer_helpers.rb +6 -5
- data/lib/brs/validation.rb +15 -2
- data/lib/brs/version.rb +1 -1
- metadata +20 -19
checksums.yaml
CHANGED
|
@@ -1,7 +1,7 @@
|
|
|
1
1
|
---
|
|
2
2
|
SHA256:
|
|
3
|
-
metadata.gz:
|
|
4
|
-
data.tar.gz:
|
|
3
|
+
metadata.gz: 239de67878a08e54f6b89af1381711ad94c70c1f29d99c8dca22ced06ebd850a
|
|
4
|
+
data.tar.gz: 2601159e2ede572b8bcdc8ce0ee7ca738f06f42cb0d6e59a159eb525e2f70420
|
|
5
5
|
SHA512:
|
|
6
|
-
metadata.gz:
|
|
7
|
-
data.tar.gz:
|
|
6
|
+
metadata.gz: d12cfbf9280a63ad850ce4198e1bdaa044afc4502bccdeadeef8af746f1806182fb560bd580dd0bafafeaff93fd8e2e40435d7ac12079bad89a79b9cb22ef088
|
|
7
|
+
data.tar.gz: 13cb28b02d174fe3c448f291b85a80625cabb3f07ab32f5a5233a244425299ed04f248737be934d9f3171c6bc93c31062cbb1e7daf9f146e46a617163298a678
|
data/README.md
CHANGED
|
@@ -1,8 +1,8 @@
|
|
|
1
1
|
# Ruby bindings for brotli library
|
|
2
2
|
|
|
3
|
-
| Travis | AppVeyor |
|
|
4
|
-
| :---: | :---: | :---: | :---:
|
|
5
|
-
| [](https://travis-ci.com/andrew-aladev/ruby-brs) | [](https://ci.appveyor.com/project/andrew-aladev/ruby-brs/branch/master) | [](https://travis-ci.com/andrew-aladev/ruby-brs) | [](https://ci.appveyor.com/project/andrew-aladev/ruby-brs/branch/master) | [](https://circleci.com/gh/andrew-aladev/ruby-brs/tree/master) | [](https://codecov.io/gh/andrew-aladev/ruby-brs) | [](https://rubygems.org/gems/ruby-brs) |
|
|
6
6
|
|
|
7
7
|
See [brotli library](https://github.com/google/brotli).
|
|
8
8
|
|
|
@@ -21,6 +21,8 @@ rake gem
|
|
|
21
21
|
gem install pkg/ruby-brs-*.gem
|
|
22
22
|
```
|
|
23
23
|
|
|
24
|
+
You can also use [overlay](https://github.com/andrew-aladev/overlay) for gentoo.
|
|
25
|
+
|
|
24
26
|
## Usage
|
|
25
27
|
|
|
26
28
|
There are simple APIs: `String` and `File`. Also you can use generic streaming API: `Stream::Writer` and `Stream::Reader`.
|
|
@@ -36,9 +38,30 @@ BRS::File.decompress "file.txt.br", "file.txt"
|
|
|
36
38
|
|
|
37
39
|
BRS::Stream::Writer.open("file.txt.br") { |writer| writer << "sample string" }
|
|
38
40
|
puts BRS::Stream::Reader.open("file.txt.br") { |reader| reader.read }
|
|
41
|
+
|
|
42
|
+
writer = BRS::Stream::Writer.new output_socket
|
|
43
|
+
begin
|
|
44
|
+
bytes_written = writer.write_nonblock "sample string"
|
|
45
|
+
# handle "bytes_written"
|
|
46
|
+
rescue IO::WaitWritable
|
|
47
|
+
# handle wait
|
|
48
|
+
ensure
|
|
49
|
+
writer.close
|
|
50
|
+
end
|
|
51
|
+
|
|
52
|
+
reader = BRS::Stream::Reader.new input_socket
|
|
53
|
+
begin
|
|
54
|
+
puts reader.read_nonblock(512)
|
|
55
|
+
rescue IO::WaitReadable
|
|
56
|
+
# handle wait
|
|
57
|
+
rescue ::EOFError
|
|
58
|
+
# handle eof
|
|
59
|
+
ensure
|
|
60
|
+
reader.close
|
|
61
|
+
end
|
|
39
62
|
```
|
|
40
63
|
|
|
41
|
-
You can create and read `tar.br` archives with
|
|
64
|
+
You can create and read `tar.br` archives with [minitar](https://github.com/halostatue/minitar) for example.
|
|
42
65
|
|
|
43
66
|
```ruby
|
|
44
67
|
require "brs"
|
|
@@ -60,76 +83,58 @@ BRS::Stream::Reader.open "file.tar.br" do |reader|
|
|
|
60
83
|
end
|
|
61
84
|
```
|
|
62
85
|
|
|
63
|
-
|
|
64
|
-
|
|
65
|
-
Each API supports several options:
|
|
66
|
-
|
|
67
|
-
```
|
|
68
|
-
:source_buffer_length
|
|
69
|
-
:destination_buffer_length
|
|
70
|
-
```
|
|
71
|
-
|
|
72
|
-
There are internal buffers for compressed and decompressed data.
|
|
73
|
-
For example you want to use 1 KB as source buffer length for compressor - please use 256 B as destination buffer length.
|
|
74
|
-
You want to use 256 B as source buffer length for decompressor - please use 1 KB as destination buffer length.
|
|
75
|
-
|
|
76
|
-
Values: 0 - infinity, default value: 0.
|
|
77
|
-
0 means automatic buffer length selection.
|
|
78
|
-
|
|
79
|
-
```
|
|
80
|
-
:mode
|
|
81
|
-
```
|
|
82
|
-
|
|
83
|
-
Values: `BRS::Option::MODES`, default value: `:generic`.
|
|
84
|
-
|
|
85
|
-
```
|
|
86
|
-
:quality
|
|
87
|
-
```
|
|
88
|
-
|
|
89
|
-
Values: `BRS::Option::MIN_QUALITY` - `BRS::Option::MAX_QUALITY`, default value: `BRS::Option::MAX_QUALITY`.
|
|
90
|
-
|
|
91
|
-
```
|
|
92
|
-
:lgwin
|
|
93
|
-
```
|
|
94
|
-
|
|
95
|
-
Values: `BRS::Option::MIN_LGWIN` - `BRS::Option::MAX_LGWIN`, default value: `22`.
|
|
86
|
+
You can also use `Content-Encoding: br` with [sinatra](http://sinatrarb.com):
|
|
96
87
|
|
|
97
|
-
```
|
|
98
|
-
|
|
99
|
-
|
|
100
|
-
|
|
101
|
-
Values: `BRS::Option::MIN_LGBLOCK` - `BRS::Option::MAX_LGBLOCK`, default value: none.
|
|
88
|
+
```ruby
|
|
89
|
+
require "brs"
|
|
90
|
+
require "sinatra"
|
|
102
91
|
|
|
103
|
-
|
|
104
|
-
|
|
92
|
+
get "/" do
|
|
93
|
+
headers["Content-Encoding"] = "br"
|
|
94
|
+
BRS::String.compress "sample string"
|
|
95
|
+
end
|
|
105
96
|
```
|
|
106
97
|
|
|
107
|
-
|
|
98
|
+
## Options
|
|
108
99
|
|
|
109
|
-
|
|
110
|
-
|
|
111
|
-
|
|
100
|
+
| Option | Values | Default | Description |
|
|
101
|
+
|------------------------------------|------------|------------|-------------|
|
|
102
|
+
| `source_buffer_length` | 0 - inf | 0 (auto) | internal buffer length for source data |
|
|
103
|
+
| `destination_buffer_length` | 0 - inf | 0 (auto) | internal buffer length for description data |
|
|
104
|
+
| `gvl` | true/false | false | enables global VM lock where possible |
|
|
105
|
+
| `mode` | `MODES` | `:generic` | compressor mode |
|
|
106
|
+
| `quality` | 0 - 11 | 11 | compression level |
|
|
107
|
+
| `lgwin` | 10 - 24 | 22 | compressor window size |
|
|
108
|
+
| `lgblock` | 16 - 24 | nil (auto) | compressor input block size |
|
|
109
|
+
| `disable_literal_context_modeling` | true/false | false | disables literal context modeling format |
|
|
110
|
+
| `disable_ring_buffer_reallocation` | true/false | false | disables ring buffer reallocation |
|
|
111
|
+
| `size_hint` | 0 - inf | 0 (auto) | size of input (if known) |
|
|
112
|
+
| `large_window` | true/false | false | enables large window |
|
|
112
113
|
|
|
113
|
-
|
|
114
|
+
There are internal buffers for compressed and decompressed data.
|
|
115
|
+
For example you want to use 1 KB as `source_buffer_length` for compressor - please use 256 B as `destination_buffer_length`.
|
|
116
|
+
You want to use 256 B as `source_buffer_length` for decompressor - please use 1 KB as `destination_buffer_length`.
|
|
114
117
|
|
|
115
|
-
|
|
116
|
-
|
|
117
|
-
|
|
118
|
+
`gvl` is disabled by default, this mode allows running multiple compressors/decompressors in different threads simultaneously.
|
|
119
|
+
Please consider enabling `gvl` if you don't want to launch processors in separate threads.
|
|
120
|
+
If `gvl` is enabled ruby won't waste time on acquiring/releasing VM lock.
|
|
118
121
|
|
|
119
|
-
Values: 0 - infinity, default value: 0.
|
|
120
|
-
It is reasonable to provide size of input (if known) for streaming api.
|
|
121
122
|
`String` and `File` will set `:size_hint` automaticaly.
|
|
122
123
|
|
|
123
|
-
|
|
124
|
-
:large_window
|
|
125
|
-
```
|
|
126
|
-
|
|
127
|
-
Values: true/false, default value: false.
|
|
124
|
+
You can also read brotli docs for more info about options.
|
|
128
125
|
|
|
129
|
-
|
|
126
|
+
| Option | Related constants |
|
|
127
|
+
|-----------|-------------------|
|
|
128
|
+
| `mode` | `BRS::Option::MODES` = `%i[text font generic]` |
|
|
129
|
+
| `quality` | `BRS::Option::MIN_QUALITY` = 0, `BRS::Option::MAX_QUALITY` = 11 |
|
|
130
|
+
| `lgwin` | `BRS::Option::MIN_LGWIN` = 10, `BRS::Option::MAX_LGWIN` = 24 |
|
|
131
|
+
| `lgblock` | `BRS::Option::MIN_LGBLOCK` = 16, `BRS::Option::MAX_LGBLOCK` = 24 |
|
|
130
132
|
|
|
131
133
|
Possible compressor options:
|
|
132
134
|
```
|
|
135
|
+
:source_buffer_length
|
|
136
|
+
:destination_buffer_length
|
|
137
|
+
:gvl
|
|
133
138
|
:mode
|
|
134
139
|
:quality
|
|
135
140
|
:lgwin
|
|
@@ -141,6 +146,9 @@ Possible compressor options:
|
|
|
141
146
|
|
|
142
147
|
Possible decompressor options:
|
|
143
148
|
```
|
|
149
|
+
:source_buffer_length
|
|
150
|
+
:destination_buffer_length
|
|
151
|
+
:gvl
|
|
144
152
|
:disable_ring_buffer_reallocation
|
|
145
153
|
:large_window
|
|
146
154
|
```
|
|
@@ -154,18 +162,6 @@ data = BRS::String.compress "sample string", :quality => 5
|
|
|
154
162
|
puts BRS::String.decompress(data, :disable_ring_buffer_reallocation => true)
|
|
155
163
|
```
|
|
156
164
|
|
|
157
|
-
HTTP encoding (`Content-Encoding: br`) using default options:
|
|
158
|
-
|
|
159
|
-
```ruby
|
|
160
|
-
require "brs"
|
|
161
|
-
require "sinatra"
|
|
162
|
-
|
|
163
|
-
get "/" do
|
|
164
|
-
headers["Content-Encoding"] = "br"
|
|
165
|
-
BRS::String.compress "sample string"
|
|
166
|
-
end
|
|
167
|
-
```
|
|
168
|
-
|
|
169
165
|
## String
|
|
170
166
|
|
|
171
167
|
String maintains destination buffer only, so it accepts `destination_buffer_length` option only.
|
|
@@ -190,7 +186,7 @@ File maintains both source and destination buffers, it accepts both `source_buff
|
|
|
190
186
|
|
|
191
187
|
## Stream::Writer
|
|
192
188
|
|
|
193
|
-
Its behaviour is similar to builtin [`Zlib::GzipWriter`](https://ruby-doc.org/stdlib-2.
|
|
189
|
+
Its behaviour is similar to builtin [`Zlib::GzipWriter`](https://ruby-doc.org/stdlib-2.7.0/libdoc/zlib/rdoc/Zlib/GzipWriter.html).
|
|
194
190
|
|
|
195
191
|
Writer maintains destination buffer only, so it accepts `destination_buffer_length` option only.
|
|
196
192
|
|
|
@@ -228,7 +224,7 @@ Set another encodings, `nil` is just for compatibility with `IO`.
|
|
|
228
224
|
#tell
|
|
229
225
|
```
|
|
230
226
|
|
|
231
|
-
See [`IO`](https://ruby-doc.org/core-2.
|
|
227
|
+
See [`IO`](https://ruby-doc.org/core-2.7.0/IO.html) docs.
|
|
232
228
|
|
|
233
229
|
```
|
|
234
230
|
#write(*objects)
|
|
@@ -238,7 +234,7 @@ See [`IO`](https://ruby-doc.org/core-2.6.1/IO.html) docs.
|
|
|
238
234
|
#closed?
|
|
239
235
|
```
|
|
240
236
|
|
|
241
|
-
See [`Zlib::GzipWriter`](https://ruby-doc.org/stdlib-2.
|
|
237
|
+
See [`Zlib::GzipWriter`](https://ruby-doc.org/stdlib-2.7.0/libdoc/zlib/rdoc/Zlib/GzipWriter.html) docs.
|
|
242
238
|
|
|
243
239
|
```
|
|
244
240
|
#write_nonblock(object, *options)
|
|
@@ -260,11 +256,11 @@ Behaviour is the same as `IO#write_nonblock` method.
|
|
|
260
256
|
#puts(*objects)
|
|
261
257
|
```
|
|
262
258
|
|
|
263
|
-
Typical helpers, see [`Zlib::GzipWriter`](https://ruby-doc.org/stdlib-2.
|
|
259
|
+
Typical helpers, see [`Zlib::GzipWriter`](https://ruby-doc.org/stdlib-2.7.0/libdoc/zlib/rdoc/Zlib/GzipWriter.html) docs.
|
|
264
260
|
|
|
265
261
|
## Stream::Reader
|
|
266
262
|
|
|
267
|
-
Its behaviour is similar to builtin [`Zlib::GzipReader`](https://ruby-doc.org/stdlib-2.
|
|
263
|
+
Its behaviour is similar to builtin [`Zlib::GzipReader`](https://ruby-doc.org/stdlib-2.7.0/libdoc/zlib/rdoc/Zlib/GzipReader.html).
|
|
268
264
|
|
|
269
265
|
Reader maintains both source and destination buffers, it accepts both `source_buffer_length` and `destination_buffer_length` options.
|
|
270
266
|
|
|
@@ -299,7 +295,7 @@ Set another encodings.
|
|
|
299
295
|
#tell
|
|
300
296
|
```
|
|
301
297
|
|
|
302
|
-
See [`IO`](https://ruby-doc.org/core-2.
|
|
298
|
+
See [`IO`](https://ruby-doc.org/core-2.7.0/IO.html) docs.
|
|
303
299
|
|
|
304
300
|
```
|
|
305
301
|
#read(bytes_to_read = nil, out_buffer = nil)
|
|
@@ -309,14 +305,14 @@ See [`IO`](https://ruby-doc.org/core-2.6.1/IO.html) docs.
|
|
|
309
305
|
#closed?
|
|
310
306
|
```
|
|
311
307
|
|
|
312
|
-
See [`Zlib::GzipReader`](https://ruby-doc.org/stdlib-2.
|
|
308
|
+
See [`Zlib::GzipReader`](https://ruby-doc.org/stdlib-2.7.0/libdoc/zlib/rdoc/Zlib/GzipReader.html) docs.
|
|
313
309
|
|
|
314
310
|
```
|
|
315
311
|
#readpartial(bytes_to_read = nil, out_buffer = nil)
|
|
316
312
|
#read_nonblock(bytes_to_read, out_buffer = nil, *options)
|
|
317
313
|
```
|
|
318
314
|
|
|
319
|
-
See [`IO`](https://ruby-doc.org/core-2.
|
|
315
|
+
See [`IO`](https://ruby-doc.org/core-2.7.0/IO.html) docs.
|
|
320
316
|
|
|
321
317
|
```
|
|
322
318
|
#getbyte
|
|
@@ -339,14 +335,20 @@ See [`IO`](https://ruby-doc.org/core-2.6.1/IO.html) docs.
|
|
|
339
335
|
#ungetline(line)
|
|
340
336
|
```
|
|
341
337
|
|
|
342
|
-
Typical helpers, see [`Zlib::GzipReader`](https://ruby-doc.org/stdlib-2.
|
|
338
|
+
Typical helpers, see [`Zlib::GzipReader`](https://ruby-doc.org/stdlib-2.7.0/libdoc/zlib/rdoc/Zlib/GzipReader.html) docs.
|
|
339
|
+
|
|
340
|
+
## Thread safety
|
|
341
|
+
|
|
342
|
+
`:gvl` option is disabled by default, you can use bindings effectively in multiple threads.
|
|
343
|
+
Please be careful: bindings are not thread safe.
|
|
344
|
+
You should lock all shared data between threads.
|
|
343
345
|
|
|
344
346
|
## CI
|
|
345
347
|
|
|
346
|
-
|
|
347
|
-
|
|
348
|
-
|
|
348
|
+
Please visit [scripts/test-images](scripts/test-images).
|
|
349
|
+
See universal test script [scripts/ci_test.sh](scripts/ci_test.sh) for CI.
|
|
350
|
+
You can run this script using many native and cross images.
|
|
349
351
|
|
|
350
352
|
## License
|
|
351
353
|
|
|
352
|
-
MIT license, see LICENSE and AUTHORS.
|
|
354
|
+
MIT license, see [LICENSE](LICENSE) and [AUTHORS](AUTHORS).
|
data/ext/brs_ext/buffer.c
CHANGED
|
@@ -10,10 +10,11 @@ VALUE brs_ext_create_string_buffer(VALUE length)
|
|
|
10
10
|
return rb_str_new(NULL, NUM2SIZET(length));
|
|
11
11
|
}
|
|
12
12
|
|
|
13
|
-
VALUE brs_ext_resize_string_buffer(VALUE
|
|
13
|
+
VALUE brs_ext_resize_string_buffer(VALUE buffer_args)
|
|
14
14
|
{
|
|
15
|
-
VALUE buffer = rb_ary_entry(
|
|
16
|
-
VALUE length = rb_ary_entry(
|
|
15
|
+
VALUE buffer = rb_ary_entry(buffer_args, 0);
|
|
16
|
+
VALUE length = rb_ary_entry(buffer_args, 1);
|
|
17
|
+
|
|
17
18
|
return rb_str_resize(buffer, NUM2SIZET(length));
|
|
18
19
|
}
|
|
19
20
|
|
|
@@ -21,8 +22,21 @@ void brs_ext_buffer_exports(VALUE root_module)
|
|
|
21
22
|
{
|
|
22
23
|
VALUE module = rb_define_module_under(root_module, "Buffer");
|
|
23
24
|
|
|
24
|
-
rb_define_const(
|
|
25
|
-
|
|
26
|
-
|
|
27
|
-
rb_define_const(
|
|
25
|
+
rb_define_const(
|
|
26
|
+
module, "DEFAULT_SOURCE_BUFFER_LENGTH_FOR_COMPRESSOR", SIZET2NUM(BRS_DEFAULT_SOURCE_BUFFER_LENGTH_FOR_COMPRESSOR));
|
|
27
|
+
|
|
28
|
+
rb_define_const(
|
|
29
|
+
module,
|
|
30
|
+
"DEFAULT_DESTINATION_BUFFER_LENGTH_FOR_COMPRESSOR",
|
|
31
|
+
SIZET2NUM(BRS_DEFAULT_DESTINATION_BUFFER_LENGTH_FOR_COMPRESSOR));
|
|
32
|
+
|
|
33
|
+
rb_define_const(
|
|
34
|
+
module,
|
|
35
|
+
"DEFAULT_SOURCE_BUFFER_LENGTH_FOR_DECOMPRESSOR",
|
|
36
|
+
SIZET2NUM(BRS_DEFAULT_SOURCE_BUFFER_LENGTH_FOR_DECOMPRESSOR));
|
|
37
|
+
|
|
38
|
+
rb_define_const(
|
|
39
|
+
module,
|
|
40
|
+
"DEFAULT_DESTINATION_BUFFER_LENGTH_FOR_DECOMPRESSOR",
|
|
41
|
+
SIZET2NUM(BRS_DEFAULT_DESTINATION_BUFFER_LENGTH_FOR_DECOMPRESSOR));
|
|
28
42
|
}
|
data/ext/brs_ext/buffer.h
CHANGED
|
@@ -6,10 +6,10 @@
|
|
|
6
6
|
|
|
7
7
|
#include "ruby.h"
|
|
8
8
|
|
|
9
|
-
#define BRS_DEFAULT_SOURCE_BUFFER_LENGTH_FOR_COMPRESSOR
|
|
9
|
+
#define BRS_DEFAULT_SOURCE_BUFFER_LENGTH_FOR_COMPRESSOR (1 << 18) // 256 KB
|
|
10
10
|
#define BRS_DEFAULT_DESTINATION_BUFFER_LENGTH_FOR_COMPRESSOR (1 << 16) // 64 KB
|
|
11
11
|
|
|
12
|
-
#define BRS_DEFAULT_SOURCE_BUFFER_LENGTH_FOR_DECOMPRESSOR
|
|
12
|
+
#define BRS_DEFAULT_SOURCE_BUFFER_LENGTH_FOR_DECOMPRESSOR (1 << 16) // 64 KB
|
|
13
13
|
#define BRS_DEFAULT_DESTINATION_BUFFER_LENGTH_FOR_DECOMPRESSOR (1 << 18) // 256 KB
|
|
14
14
|
|
|
15
15
|
VALUE brs_ext_create_string_buffer(VALUE length);
|
|
@@ -17,12 +17,12 @@ VALUE brs_ext_create_string_buffer(VALUE length);
|
|
|
17
17
|
#define BRS_EXT_CREATE_STRING_BUFFER(buffer, length, exception) \
|
|
18
18
|
VALUE buffer = rb_protect(brs_ext_create_string_buffer, SIZET2NUM(length), &exception);
|
|
19
19
|
|
|
20
|
-
VALUE brs_ext_resize_string_buffer(VALUE
|
|
20
|
+
VALUE brs_ext_resize_string_buffer(VALUE buffer_args);
|
|
21
21
|
|
|
22
|
-
#define BRS_EXT_RESIZE_STRING_BUFFER(buffer, length, exception)
|
|
23
|
-
VALUE
|
|
24
|
-
buffer
|
|
25
|
-
RB_GC_GUARD(
|
|
22
|
+
#define BRS_EXT_RESIZE_STRING_BUFFER(buffer, length, exception) \
|
|
23
|
+
VALUE buffer_args = rb_ary_new_from_args(2, buffer, SIZET2NUM(length)); \
|
|
24
|
+
buffer = rb_protect(brs_ext_resize_string_buffer, buffer_args, &exception); \
|
|
25
|
+
RB_GC_GUARD(buffer_args);
|
|
26
26
|
|
|
27
27
|
void brs_ext_buffer_exports(VALUE root_module);
|
|
28
28
|
|
data/ext/brs_ext/common.h
CHANGED
data/ext/brs_ext/error.c
CHANGED
data/ext/brs_ext/error.h
CHANGED
data/ext/brs_ext/gvl.h
ADDED
|
@@ -0,0 +1,24 @@
|
|
|
1
|
+
// Ruby bindings for brotli library.
|
|
2
|
+
// Copyright (c) 2019 AUTHORS, MIT License.
|
|
3
|
+
|
|
4
|
+
#if !defined(BRS_EXT_GVL_H)
|
|
5
|
+
#define BRS_EXT_GVL_H
|
|
6
|
+
|
|
7
|
+
#ifdef HAVE_RB_THREAD_CALL_WITHOUT_GVL
|
|
8
|
+
|
|
9
|
+
#include "ruby/thread.h"
|
|
10
|
+
|
|
11
|
+
#define BRS_EXT_GVL_WRAP(gvl, function, data) \
|
|
12
|
+
if (gvl) { \
|
|
13
|
+
function((void*) data); \
|
|
14
|
+
} else { \
|
|
15
|
+
rb_thread_call_without_gvl(function, (void*) data, RUBY_UBF_IO, NULL); \
|
|
16
|
+
}
|
|
17
|
+
|
|
18
|
+
#else
|
|
19
|
+
|
|
20
|
+
#define BRS_EXT_GVL_WRAP(_gvl, function, data) function((void*) data);
|
|
21
|
+
|
|
22
|
+
#endif
|
|
23
|
+
|
|
24
|
+
#endif // BRS_EXT_GVL_H
|
data/ext/brs_ext/io.c
CHANGED
|
@@ -1,32 +1,33 @@
|
|
|
1
1
|
// Ruby bindings for brotli library.
|
|
2
2
|
// Copyright (c) 2019 AUTHORS, MIT License.
|
|
3
3
|
|
|
4
|
-
#include "
|
|
4
|
+
#include "brs_ext/io.h"
|
|
5
5
|
|
|
6
6
|
#include <brotli/decode.h>
|
|
7
7
|
#include <brotli/encode.h>
|
|
8
8
|
#include <brotli/types.h>
|
|
9
|
-
#include <stdint.h>
|
|
10
9
|
#include <stdio.h>
|
|
11
10
|
#include <stdlib.h>
|
|
12
11
|
#include <string.h>
|
|
13
12
|
|
|
14
13
|
#include "brs_ext/buffer.h"
|
|
15
|
-
#include "brs_ext/common.h"
|
|
16
14
|
#include "brs_ext/error.h"
|
|
17
|
-
#include "brs_ext/
|
|
15
|
+
#include "brs_ext/gvl.h"
|
|
18
16
|
#include "brs_ext/macro.h"
|
|
19
17
|
#include "brs_ext/option.h"
|
|
20
18
|
#include "ruby.h"
|
|
19
|
+
#include "ruby/io.h"
|
|
21
20
|
|
|
22
21
|
// Additional possible results:
|
|
23
|
-
enum
|
|
22
|
+
enum
|
|
23
|
+
{
|
|
24
24
|
BRS_EXT_FILE_READ_FINISHED = 128
|
|
25
25
|
};
|
|
26
26
|
|
|
27
27
|
// -- file --
|
|
28
28
|
|
|
29
|
-
static inline brs_ext_result_t
|
|
29
|
+
static inline brs_ext_result_t
|
|
30
|
+
read_file(FILE* source_file, brs_ext_byte_t* source_buffer, size_t* source_length_ptr, size_t source_buffer_length)
|
|
30
31
|
{
|
|
31
32
|
size_t read_length = fread(source_buffer, 1, source_buffer_length, source_file);
|
|
32
33
|
if (read_length == 0 && feof(source_file)) {
|
|
@@ -42,7 +43,8 @@ static inline brs_ext_result_t read_file(FILE* source_file, uint8_t* source_buff
|
|
|
42
43
|
return 0;
|
|
43
44
|
}
|
|
44
45
|
|
|
45
|
-
static inline brs_ext_result_t
|
|
46
|
+
static inline brs_ext_result_t
|
|
47
|
+
write_file(FILE* destination_file, brs_ext_byte_t* destination_buffer, size_t destination_length)
|
|
46
48
|
{
|
|
47
49
|
size_t written_length = fwrite(destination_buffer, 1, destination_length, destination_file);
|
|
48
50
|
if (written_length != destination_length) {
|
|
@@ -55,15 +57,17 @@ static inline brs_ext_result_t write_file(FILE* destination_file, uint8_t* desti
|
|
|
55
57
|
// -- buffer --
|
|
56
58
|
|
|
57
59
|
static inline brs_ext_result_t create_buffers(
|
|
58
|
-
|
|
59
|
-
|
|
60
|
+
brs_ext_byte_t** source_buffer_ptr,
|
|
61
|
+
size_t source_buffer_length,
|
|
62
|
+
brs_ext_byte_t** destination_buffer_ptr,
|
|
63
|
+
size_t destination_buffer_length)
|
|
60
64
|
{
|
|
61
|
-
|
|
65
|
+
brs_ext_byte_t* source_buffer = malloc(source_buffer_length);
|
|
62
66
|
if (source_buffer == NULL) {
|
|
63
67
|
return BRS_EXT_ERROR_ALLOCATE_FAILED;
|
|
64
68
|
}
|
|
65
69
|
|
|
66
|
-
|
|
70
|
+
brs_ext_byte_t* destination_buffer = malloc(destination_buffer_length);
|
|
67
71
|
if (destination_buffer == NULL) {
|
|
68
72
|
free(source_buffer);
|
|
69
73
|
return BRS_EXT_ERROR_ALLOCATE_FAILED;
|
|
@@ -82,12 +86,14 @@ static inline brs_ext_result_t create_buffers(
|
|
|
82
86
|
// Algorithm can use same buffer again.
|
|
83
87
|
|
|
84
88
|
static inline brs_ext_result_t read_more_source(
|
|
85
|
-
FILE*
|
|
86
|
-
const
|
|
87
|
-
|
|
89
|
+
FILE* source_file,
|
|
90
|
+
const brs_ext_byte_t** source_ptr,
|
|
91
|
+
size_t* source_length_ptr,
|
|
92
|
+
brs_ext_byte_t* source_buffer,
|
|
93
|
+
size_t source_buffer_length)
|
|
88
94
|
{
|
|
89
|
-
const
|
|
90
|
-
size_t
|
|
95
|
+
const brs_ext_byte_t* source = *source_ptr;
|
|
96
|
+
size_t source_length = *source_length_ptr;
|
|
91
97
|
|
|
92
98
|
if (source != source_buffer) {
|
|
93
99
|
if (source_length != 0) {
|
|
@@ -104,10 +110,12 @@ static inline brs_ext_result_t read_more_source(
|
|
|
104
110
|
return BRS_EXT_ERROR_NOT_ENOUGH_SOURCE_BUFFER;
|
|
105
111
|
}
|
|
106
112
|
|
|
107
|
-
|
|
108
|
-
size_t
|
|
113
|
+
brs_ext_byte_t* remaining_source_buffer = source_buffer + source_length;
|
|
114
|
+
size_t new_source_length;
|
|
115
|
+
|
|
116
|
+
brs_ext_result_t ext_result =
|
|
117
|
+
read_file(source_file, remaining_source_buffer, &new_source_length, remaining_source_buffer_length);
|
|
109
118
|
|
|
110
|
-
brs_ext_result_t ext_result = read_file(source_file, remaining_source_buffer, &new_source_length, remaining_source_buffer_length);
|
|
111
119
|
if (ext_result != 0) {
|
|
112
120
|
return ext_result;
|
|
113
121
|
}
|
|
@@ -117,42 +125,37 @@ static inline brs_ext_result_t read_more_source(
|
|
|
117
125
|
return 0;
|
|
118
126
|
}
|
|
119
127
|
|
|
120
|
-
#define BUFFERED_READ_SOURCE(function, ...)
|
|
121
|
-
do {
|
|
122
|
-
bool is_function_called = false;
|
|
123
|
-
|
|
124
|
-
while (true) {
|
|
125
|
-
ext_result = read_more_source(
|
|
126
|
-
|
|
127
|
-
|
|
128
|
-
|
|
129
|
-
|
|
130
|
-
|
|
131
|
-
|
|
132
|
-
|
|
133
|
-
|
|
134
|
-
|
|
135
|
-
|
|
136
|
-
|
|
137
|
-
|
|
138
|
-
return ext_result;
|
|
139
|
-
}
|
|
140
|
-
|
|
141
|
-
|
|
142
|
-
|
|
143
|
-
|
|
144
|
-
|
|
145
|
-
|
|
146
|
-
|
|
147
|
-
|
|
148
|
-
|
|
149
|
-
|
|
150
|
-
|
|
151
|
-
ext_result = function(__VA_ARGS__); \
|
|
152
|
-
if (ext_result != 0) { \
|
|
153
|
-
return ext_result; \
|
|
154
|
-
} \
|
|
155
|
-
} \
|
|
128
|
+
#define BUFFERED_READ_SOURCE(function, ...) \
|
|
129
|
+
do { \
|
|
130
|
+
bool is_function_called = false; \
|
|
131
|
+
\
|
|
132
|
+
while (true) { \
|
|
133
|
+
ext_result = read_more_source(source_file, &source, &source_length, source_buffer, source_buffer_length); \
|
|
134
|
+
if (ext_result == BRS_EXT_FILE_READ_FINISHED) { \
|
|
135
|
+
if (source_length != 0) { \
|
|
136
|
+
/* Brotli won't provide any remainder by design. */ \
|
|
137
|
+
return BRS_EXT_ERROR_READ_IO; \
|
|
138
|
+
} \
|
|
139
|
+
break; \
|
|
140
|
+
} else if (ext_result != 0) { \
|
|
141
|
+
return ext_result; \
|
|
142
|
+
} \
|
|
143
|
+
\
|
|
144
|
+
ext_result = function(__VA_ARGS__); \
|
|
145
|
+
if (ext_result != 0) { \
|
|
146
|
+
return ext_result; \
|
|
147
|
+
} \
|
|
148
|
+
\
|
|
149
|
+
is_function_called = true; \
|
|
150
|
+
} \
|
|
151
|
+
\
|
|
152
|
+
if (!is_function_called) { \
|
|
153
|
+
/* Function should be called at least once. */ \
|
|
154
|
+
ext_result = function(__VA_ARGS__); \
|
|
155
|
+
if (ext_result != 0) { \
|
|
156
|
+
return ext_result; \
|
|
157
|
+
} \
|
|
158
|
+
} \
|
|
156
159
|
} while (false);
|
|
157
160
|
|
|
158
161
|
// Algorithm has written data into destination buffer.
|
|
@@ -160,8 +163,10 @@ static inline brs_ext_result_t read_more_source(
|
|
|
160
163
|
// Than algorithm can use same buffer again.
|
|
161
164
|
|
|
162
165
|
static inline brs_ext_result_t flush_destination_buffer(
|
|
163
|
-
FILE*
|
|
164
|
-
|
|
166
|
+
FILE* destination_file,
|
|
167
|
+
brs_ext_byte_t* destination_buffer,
|
|
168
|
+
size_t* destination_length_ptr,
|
|
169
|
+
size_t destination_buffer_length)
|
|
165
170
|
{
|
|
166
171
|
if (*destination_length_ptr == 0) {
|
|
167
172
|
// We want to write more data at once, than buffer has.
|
|
@@ -178,7 +183,8 @@ static inline brs_ext_result_t flush_destination_buffer(
|
|
|
178
183
|
return 0;
|
|
179
184
|
}
|
|
180
185
|
|
|
181
|
-
static inline brs_ext_result_t
|
|
186
|
+
static inline brs_ext_result_t
|
|
187
|
+
write_remaining_destination(FILE* destination_file, brs_ext_byte_t* destination_buffer, size_t destination_length)
|
|
182
188
|
{
|
|
183
189
|
if (destination_length == 0) {
|
|
184
190
|
return 0;
|
|
@@ -200,29 +206,57 @@ static inline brs_ext_result_t write_remaining_destination(FILE* destination_fil
|
|
|
200
206
|
brs_ext_raise_error(BRS_EXT_ERROR_ACCESS_IO); \
|
|
201
207
|
}
|
|
202
208
|
|
|
203
|
-
// -- compress --
|
|
209
|
+
// -- buffered compress --
|
|
210
|
+
|
|
211
|
+
typedef struct
|
|
212
|
+
{
|
|
213
|
+
BrotliEncoderState* state_ptr;
|
|
214
|
+
const brs_ext_byte_t** source_ptr;
|
|
215
|
+
size_t* source_length_ptr;
|
|
216
|
+
brs_ext_byte_t* remaining_destination_buffer;
|
|
217
|
+
size_t* remaining_destination_buffer_length_ptr;
|
|
218
|
+
BROTLI_BOOL result;
|
|
219
|
+
} compress_args_t;
|
|
220
|
+
|
|
221
|
+
static inline void* compress_wrapper(void* data)
|
|
222
|
+
{
|
|
223
|
+
compress_args_t* args = data;
|
|
224
|
+
|
|
225
|
+
args->result = BrotliEncoderCompressStream(
|
|
226
|
+
args->state_ptr,
|
|
227
|
+
BROTLI_OPERATION_PROCESS,
|
|
228
|
+
args->source_length_ptr,
|
|
229
|
+
args->source_ptr,
|
|
230
|
+
args->remaining_destination_buffer_length_ptr,
|
|
231
|
+
&args->remaining_destination_buffer,
|
|
232
|
+
NULL);
|
|
233
|
+
|
|
234
|
+
return NULL;
|
|
235
|
+
}
|
|
204
236
|
|
|
205
237
|
static inline brs_ext_result_t buffered_compress(
|
|
206
|
-
BrotliEncoderState*
|
|
207
|
-
const
|
|
208
|
-
|
|
238
|
+
BrotliEncoderState* state_ptr,
|
|
239
|
+
const brs_ext_byte_t** source_ptr,
|
|
240
|
+
size_t* source_length_ptr,
|
|
241
|
+
FILE* destination_file,
|
|
242
|
+
brs_ext_byte_t* destination_buffer,
|
|
243
|
+
size_t* destination_length_ptr,
|
|
244
|
+
size_t destination_buffer_length,
|
|
245
|
+
bool gvl)
|
|
209
246
|
{
|
|
210
|
-
BROTLI_BOOL result;
|
|
211
247
|
brs_ext_result_t ext_result;
|
|
248
|
+
compress_args_t args = {.state_ptr = state_ptr, .source_ptr = source_ptr, .source_length_ptr = source_length_ptr};
|
|
212
249
|
|
|
213
250
|
while (true) {
|
|
214
|
-
|
|
215
|
-
size_t
|
|
216
|
-
size_t
|
|
217
|
-
|
|
218
|
-
|
|
219
|
-
|
|
220
|
-
|
|
221
|
-
|
|
222
|
-
|
|
223
|
-
NULL);
|
|
224
|
-
|
|
225
|
-
if (!result) {
|
|
251
|
+
brs_ext_byte_t* remaining_destination_buffer = destination_buffer + *destination_length_ptr;
|
|
252
|
+
size_t remaining_destination_buffer_length = destination_buffer_length - *destination_length_ptr;
|
|
253
|
+
size_t prev_remaining_destination_buffer_length = remaining_destination_buffer_length;
|
|
254
|
+
|
|
255
|
+
args.remaining_destination_buffer = remaining_destination_buffer;
|
|
256
|
+
args.remaining_destination_buffer_length_ptr = &remaining_destination_buffer_length;
|
|
257
|
+
|
|
258
|
+
BRS_EXT_GVL_WRAP(gvl, compress_wrapper, &args);
|
|
259
|
+
if (!args.result) {
|
|
226
260
|
return BRS_EXT_ERROR_UNEXPECTED;
|
|
227
261
|
}
|
|
228
262
|
|
|
@@ -230,8 +264,7 @@ static inline brs_ext_result_t buffered_compress(
|
|
|
230
264
|
|
|
231
265
|
if (BrotliEncoderHasMoreOutput(state_ptr)) {
|
|
232
266
|
ext_result = flush_destination_buffer(
|
|
233
|
-
destination_file,
|
|
234
|
-
destination_buffer, destination_length_ptr, destination_buffer_length);
|
|
267
|
+
destination_file, destination_buffer, destination_length_ptr, destination_buffer_length);
|
|
235
268
|
|
|
236
269
|
if (ext_result != 0) {
|
|
237
270
|
return ext_result;
|
|
@@ -246,29 +279,57 @@ static inline brs_ext_result_t buffered_compress(
|
|
|
246
279
|
return 0;
|
|
247
280
|
}
|
|
248
281
|
|
|
282
|
+
// -- buffered compressor finish --
|
|
283
|
+
|
|
284
|
+
typedef struct
|
|
285
|
+
{
|
|
286
|
+
BrotliEncoderState* state_ptr;
|
|
287
|
+
const brs_ext_byte_t** source_ptr;
|
|
288
|
+
size_t* source_length_ptr;
|
|
289
|
+
brs_ext_byte_t* remaining_destination_buffer;
|
|
290
|
+
size_t* remaining_destination_buffer_length_ptr;
|
|
291
|
+
BROTLI_BOOL result;
|
|
292
|
+
} compressor_finish_args_t;
|
|
293
|
+
|
|
294
|
+
static inline void* compressor_finish_wrapper(void* data)
|
|
295
|
+
{
|
|
296
|
+
compressor_finish_args_t* args = data;
|
|
297
|
+
|
|
298
|
+
args->result = BrotliEncoderCompressStream(
|
|
299
|
+
args->state_ptr,
|
|
300
|
+
BROTLI_OPERATION_FINISH,
|
|
301
|
+
args->source_length_ptr,
|
|
302
|
+
args->source_ptr,
|
|
303
|
+
args->remaining_destination_buffer_length_ptr,
|
|
304
|
+
&args->remaining_destination_buffer,
|
|
305
|
+
NULL);
|
|
306
|
+
|
|
307
|
+
return NULL;
|
|
308
|
+
}
|
|
309
|
+
|
|
249
310
|
static inline brs_ext_result_t buffered_compressor_finish(
|
|
250
311
|
BrotliEncoderState* state_ptr,
|
|
251
|
-
FILE*
|
|
312
|
+
FILE* destination_file,
|
|
313
|
+
brs_ext_byte_t* destination_buffer,
|
|
314
|
+
size_t* destination_length_ptr,
|
|
315
|
+
size_t destination_buffer_length,
|
|
316
|
+
bool gvl)
|
|
252
317
|
{
|
|
253
|
-
|
|
254
|
-
|
|
255
|
-
|
|
256
|
-
|
|
257
|
-
size_t source_length = 0;
|
|
318
|
+
brs_ext_result_t ext_result;
|
|
319
|
+
const brs_ext_byte_t* source = NULL;
|
|
320
|
+
size_t source_length = 0;
|
|
321
|
+
compressor_finish_args_t args = {.state_ptr = state_ptr, .source_ptr = &source, .source_length_ptr = &source_length};
|
|
258
322
|
|
|
259
323
|
while (true) {
|
|
260
|
-
|
|
261
|
-
size_t
|
|
262
|
-
size_t
|
|
263
|
-
|
|
264
|
-
|
|
265
|
-
|
|
266
|
-
|
|
267
|
-
|
|
268
|
-
|
|
269
|
-
NULL);
|
|
270
|
-
|
|
271
|
-
if (!result) {
|
|
324
|
+
brs_ext_byte_t* remaining_destination_buffer = destination_buffer + *destination_length_ptr;
|
|
325
|
+
size_t remaining_destination_buffer_length = destination_buffer_length - *destination_length_ptr;
|
|
326
|
+
size_t prev_remaining_destination_buffer_length = remaining_destination_buffer_length;
|
|
327
|
+
|
|
328
|
+
args.remaining_destination_buffer = remaining_destination_buffer;
|
|
329
|
+
args.remaining_destination_buffer_length_ptr = &remaining_destination_buffer_length;
|
|
330
|
+
|
|
331
|
+
BRS_EXT_GVL_WRAP(gvl, compressor_finish_wrapper, &args);
|
|
332
|
+
if (!args.result) {
|
|
272
333
|
return BRS_EXT_ERROR_UNEXPECTED;
|
|
273
334
|
}
|
|
274
335
|
|
|
@@ -276,8 +337,7 @@ static inline brs_ext_result_t buffered_compressor_finish(
|
|
|
276
337
|
|
|
277
338
|
if (BrotliEncoderHasMoreOutput(state_ptr) || !BrotliEncoderIsFinished(state_ptr)) {
|
|
278
339
|
ext_result = flush_destination_buffer(
|
|
279
|
-
destination_file,
|
|
280
|
-
destination_buffer, destination_length_ptr, destination_buffer_length);
|
|
340
|
+
destination_file, destination_buffer, destination_length_ptr, destination_buffer_length);
|
|
281
341
|
|
|
282
342
|
if (ext_result != 0) {
|
|
283
343
|
return ext_result;
|
|
@@ -292,26 +352,36 @@ static inline brs_ext_result_t buffered_compressor_finish(
|
|
|
292
352
|
return 0;
|
|
293
353
|
}
|
|
294
354
|
|
|
355
|
+
// -- compress --
|
|
356
|
+
|
|
295
357
|
static inline brs_ext_result_t compress(
|
|
296
358
|
BrotliEncoderState* state_ptr,
|
|
297
|
-
FILE*
|
|
298
|
-
|
|
359
|
+
FILE* source_file,
|
|
360
|
+
brs_ext_byte_t* source_buffer,
|
|
361
|
+
size_t source_buffer_length,
|
|
362
|
+
FILE* destination_file,
|
|
363
|
+
brs_ext_byte_t* destination_buffer,
|
|
364
|
+
size_t destination_buffer_length,
|
|
365
|
+
bool gvl)
|
|
299
366
|
{
|
|
300
|
-
brs_ext_result_t
|
|
301
|
-
|
|
302
|
-
|
|
303
|
-
size_t
|
|
304
|
-
size_t destination_length = 0;
|
|
367
|
+
brs_ext_result_t ext_result;
|
|
368
|
+
const brs_ext_byte_t* source = source_buffer;
|
|
369
|
+
size_t source_length = 0;
|
|
370
|
+
size_t destination_length = 0;
|
|
305
371
|
|
|
306
372
|
BUFFERED_READ_SOURCE(
|
|
307
373
|
buffered_compress,
|
|
308
374
|
state_ptr,
|
|
309
|
-
&source,
|
|
310
|
-
|
|
375
|
+
&source,
|
|
376
|
+
&source_length,
|
|
377
|
+
destination_file,
|
|
378
|
+
destination_buffer,
|
|
379
|
+
&destination_length,
|
|
380
|
+
destination_buffer_length,
|
|
381
|
+
gvl);
|
|
311
382
|
|
|
312
383
|
ext_result = buffered_compressor_finish(
|
|
313
|
-
state_ptr,
|
|
314
|
-
destination_file, destination_buffer, &destination_length, destination_buffer_length);
|
|
384
|
+
state_ptr, destination_file, destination_buffer, &destination_length, destination_buffer_length, gvl);
|
|
315
385
|
|
|
316
386
|
if (ext_result != 0) {
|
|
317
387
|
return ext_result;
|
|
@@ -325,9 +395,10 @@ VALUE brs_ext_compress_io(VALUE BRS_EXT_UNUSED(self), VALUE source, VALUE destin
|
|
|
325
395
|
GET_FILE(source);
|
|
326
396
|
GET_FILE(destination);
|
|
327
397
|
Check_Type(options, T_HASH);
|
|
398
|
+
BRS_EXT_GET_SIZE_OPTION(options, source_buffer_length);
|
|
399
|
+
BRS_EXT_GET_SIZE_OPTION(options, destination_buffer_length);
|
|
400
|
+
BRS_EXT_GET_BOOL_OPTION(options, gvl);
|
|
328
401
|
BRS_EXT_GET_COMPRESSOR_OPTIONS(options);
|
|
329
|
-
BRS_EXT_GET_BUFFER_LENGTH_OPTION(options, source_buffer_length);
|
|
330
|
-
BRS_EXT_GET_BUFFER_LENGTH_OPTION(options, destination_buffer_length);
|
|
331
402
|
|
|
332
403
|
BrotliEncoderState* state_ptr = BrotliEncoderCreateInstance(NULL, NULL, NULL);
|
|
333
404
|
if (state_ptr == NULL) {
|
|
@@ -347,13 +418,10 @@ VALUE brs_ext_compress_io(VALUE BRS_EXT_UNUSED(self), VALUE source, VALUE destin
|
|
|
347
418
|
destination_buffer_length = BRS_DEFAULT_DESTINATION_BUFFER_LENGTH_FOR_COMPRESSOR;
|
|
348
419
|
}
|
|
349
420
|
|
|
350
|
-
|
|
351
|
-
|
|
352
|
-
|
|
353
|
-
ext_result = create_buffers(
|
|
354
|
-
&source_buffer, source_buffer_length,
|
|
355
|
-
&destination_buffer, destination_buffer_length);
|
|
421
|
+
brs_ext_byte_t* source_buffer;
|
|
422
|
+
brs_ext_byte_t* destination_buffer;
|
|
356
423
|
|
|
424
|
+
ext_result = create_buffers(&source_buffer, source_buffer_length, &destination_buffer, destination_buffer_length);
|
|
357
425
|
if (ext_result != 0) {
|
|
358
426
|
BrotliEncoderDestroyInstance(state_ptr);
|
|
359
427
|
brs_ext_raise_error(ext_result);
|
|
@@ -361,8 +429,13 @@ VALUE brs_ext_compress_io(VALUE BRS_EXT_UNUSED(self), VALUE source, VALUE destin
|
|
|
361
429
|
|
|
362
430
|
ext_result = compress(
|
|
363
431
|
state_ptr,
|
|
364
|
-
source_file,
|
|
365
|
-
|
|
432
|
+
source_file,
|
|
433
|
+
source_buffer,
|
|
434
|
+
source_buffer_length,
|
|
435
|
+
destination_file,
|
|
436
|
+
destination_buffer,
|
|
437
|
+
destination_buffer_length,
|
|
438
|
+
gvl);
|
|
366
439
|
|
|
367
440
|
free(source_buffer);
|
|
368
441
|
free(destination_buffer);
|
|
@@ -378,41 +451,68 @@ VALUE brs_ext_compress_io(VALUE BRS_EXT_UNUSED(self), VALUE source, VALUE destin
|
|
|
378
451
|
return Qnil;
|
|
379
452
|
}
|
|
380
453
|
|
|
381
|
-
// -- decompress --
|
|
454
|
+
// -- buffered decompress --
|
|
455
|
+
|
|
456
|
+
typedef struct
|
|
457
|
+
{
|
|
458
|
+
BrotliDecoderState* state_ptr;
|
|
459
|
+
const brs_ext_byte_t** source_ptr;
|
|
460
|
+
size_t* source_length_ptr;
|
|
461
|
+
brs_ext_byte_t* remaining_destination_buffer;
|
|
462
|
+
size_t* remaining_destination_buffer_length_ptr;
|
|
463
|
+
BrotliDecoderResult result;
|
|
464
|
+
} decompress_args_t;
|
|
465
|
+
|
|
466
|
+
static inline void* decompress_wrapper(void* data)
|
|
467
|
+
{
|
|
468
|
+
decompress_args_t* args = data;
|
|
469
|
+
|
|
470
|
+
args->result = BrotliDecoderDecompressStream(
|
|
471
|
+
args->state_ptr,
|
|
472
|
+
args->source_length_ptr,
|
|
473
|
+
args->source_ptr,
|
|
474
|
+
args->remaining_destination_buffer_length_ptr,
|
|
475
|
+
&args->remaining_destination_buffer,
|
|
476
|
+
NULL);
|
|
477
|
+
|
|
478
|
+
return NULL;
|
|
479
|
+
}
|
|
382
480
|
|
|
383
481
|
static inline brs_ext_result_t buffered_decompress(
|
|
384
|
-
BrotliDecoderState*
|
|
385
|
-
const
|
|
386
|
-
|
|
482
|
+
BrotliDecoderState* state_ptr,
|
|
483
|
+
const brs_ext_byte_t** source_ptr,
|
|
484
|
+
size_t* source_length_ptr,
|
|
485
|
+
FILE* destination_file,
|
|
486
|
+
brs_ext_byte_t* destination_buffer,
|
|
487
|
+
size_t* destination_length_ptr,
|
|
488
|
+
size_t destination_buffer_length,
|
|
489
|
+
bool gvl)
|
|
387
490
|
{
|
|
388
|
-
|
|
389
|
-
|
|
491
|
+
brs_ext_result_t ext_result;
|
|
492
|
+
decompress_args_t args = {.state_ptr = state_ptr, .source_ptr = source_ptr, .source_length_ptr = source_length_ptr};
|
|
390
493
|
|
|
391
494
|
while (true) {
|
|
392
|
-
|
|
393
|
-
size_t
|
|
394
|
-
size_t
|
|
495
|
+
brs_ext_byte_t* remaining_destination_buffer = destination_buffer + *destination_length_ptr;
|
|
496
|
+
size_t remaining_destination_buffer_length = destination_buffer_length - *destination_length_ptr;
|
|
497
|
+
size_t prev_remaining_destination_buffer_length = remaining_destination_buffer_length;
|
|
498
|
+
|
|
499
|
+
args.remaining_destination_buffer = remaining_destination_buffer;
|
|
500
|
+
args.remaining_destination_buffer_length_ptr = &remaining_destination_buffer_length;
|
|
395
501
|
|
|
396
|
-
|
|
397
|
-
state_ptr,
|
|
398
|
-
source_length_ptr, source_ptr,
|
|
399
|
-
&remaining_destination_buffer_length, &remaining_destination_buffer,
|
|
400
|
-
NULL);
|
|
502
|
+
BRS_EXT_GVL_WRAP(gvl, decompress_wrapper, &args);
|
|
401
503
|
|
|
402
504
|
if (
|
|
403
|
-
result != BROTLI_DECODER_RESULT_SUCCESS &&
|
|
404
|
-
result !=
|
|
405
|
-
result != BROTLI_DECODER_RESULT_NEEDS_MORE_OUTPUT) {
|
|
505
|
+
args.result != BROTLI_DECODER_RESULT_SUCCESS && args.result != BROTLI_DECODER_RESULT_NEEDS_MORE_INPUT &&
|
|
506
|
+
args.result != BROTLI_DECODER_RESULT_NEEDS_MORE_OUTPUT) {
|
|
406
507
|
BrotliDecoderErrorCode error_code = BrotliDecoderGetErrorCode(state_ptr);
|
|
407
508
|
return brs_ext_get_decompressor_error(error_code);
|
|
408
509
|
}
|
|
409
510
|
|
|
410
511
|
*destination_length_ptr += prev_remaining_destination_buffer_length - remaining_destination_buffer_length;
|
|
411
512
|
|
|
412
|
-
if (result == BROTLI_DECODER_RESULT_NEEDS_MORE_OUTPUT) {
|
|
513
|
+
if (args.result == BROTLI_DECODER_RESULT_NEEDS_MORE_OUTPUT) {
|
|
413
514
|
ext_result = flush_destination_buffer(
|
|
414
|
-
destination_file,
|
|
415
|
-
destination_buffer, destination_length_ptr, destination_buffer_length);
|
|
515
|
+
destination_file, destination_buffer, destination_length_ptr, destination_buffer_length);
|
|
416
516
|
|
|
417
517
|
if (ext_result != 0) {
|
|
418
518
|
return ext_result;
|
|
@@ -427,22 +527,33 @@ static inline brs_ext_result_t buffered_decompress(
|
|
|
427
527
|
return 0;
|
|
428
528
|
}
|
|
429
529
|
|
|
530
|
+
// -- decompress --
|
|
531
|
+
|
|
430
532
|
static inline brs_ext_result_t decompress(
|
|
431
533
|
BrotliDecoderState* state_ptr,
|
|
432
|
-
FILE*
|
|
433
|
-
|
|
534
|
+
FILE* source_file,
|
|
535
|
+
brs_ext_byte_t* source_buffer,
|
|
536
|
+
size_t source_buffer_length,
|
|
537
|
+
FILE* destination_file,
|
|
538
|
+
brs_ext_byte_t* destination_buffer,
|
|
539
|
+
size_t destination_buffer_length,
|
|
540
|
+
bool gvl)
|
|
434
541
|
{
|
|
435
|
-
brs_ext_result_t
|
|
436
|
-
|
|
437
|
-
|
|
438
|
-
size_t
|
|
439
|
-
size_t destination_length = 0;
|
|
542
|
+
brs_ext_result_t ext_result;
|
|
543
|
+
const brs_ext_byte_t* source = source_buffer;
|
|
544
|
+
size_t source_length = 0;
|
|
545
|
+
size_t destination_length = 0;
|
|
440
546
|
|
|
441
547
|
BUFFERED_READ_SOURCE(
|
|
442
548
|
buffered_decompress,
|
|
443
549
|
state_ptr,
|
|
444
|
-
&source,
|
|
445
|
-
|
|
550
|
+
&source,
|
|
551
|
+
&source_length,
|
|
552
|
+
destination_file,
|
|
553
|
+
destination_buffer,
|
|
554
|
+
&destination_length,
|
|
555
|
+
destination_buffer_length,
|
|
556
|
+
gvl);
|
|
446
557
|
|
|
447
558
|
return write_remaining_destination(destination_file, destination_buffer, destination_length);
|
|
448
559
|
}
|
|
@@ -452,9 +563,10 @@ VALUE brs_ext_decompress_io(VALUE BRS_EXT_UNUSED(self), VALUE source, VALUE dest
|
|
|
452
563
|
GET_FILE(source);
|
|
453
564
|
GET_FILE(destination);
|
|
454
565
|
Check_Type(options, T_HASH);
|
|
566
|
+
BRS_EXT_GET_SIZE_OPTION(options, source_buffer_length);
|
|
567
|
+
BRS_EXT_GET_SIZE_OPTION(options, destination_buffer_length);
|
|
568
|
+
BRS_EXT_GET_BOOL_OPTION(options, gvl);
|
|
455
569
|
BRS_EXT_GET_DECOMPRESSOR_OPTIONS(options);
|
|
456
|
-
BRS_EXT_GET_BUFFER_LENGTH_OPTION(options, source_buffer_length);
|
|
457
|
-
BRS_EXT_GET_BUFFER_LENGTH_OPTION(options, destination_buffer_length);
|
|
458
570
|
|
|
459
571
|
BrotliDecoderState* state_ptr = BrotliDecoderCreateInstance(NULL, NULL, NULL);
|
|
460
572
|
if (state_ptr == NULL) {
|
|
@@ -474,13 +586,10 @@ VALUE brs_ext_decompress_io(VALUE BRS_EXT_UNUSED(self), VALUE source, VALUE dest
|
|
|
474
586
|
destination_buffer_length = BRS_DEFAULT_DESTINATION_BUFFER_LENGTH_FOR_DECOMPRESSOR;
|
|
475
587
|
}
|
|
476
588
|
|
|
477
|
-
|
|
478
|
-
|
|
479
|
-
|
|
480
|
-
ext_result = create_buffers(
|
|
481
|
-
&source_buffer, source_buffer_length,
|
|
482
|
-
&destination_buffer, destination_buffer_length);
|
|
589
|
+
brs_ext_byte_t* source_buffer;
|
|
590
|
+
brs_ext_byte_t* destination_buffer;
|
|
483
591
|
|
|
592
|
+
ext_result = create_buffers(&source_buffer, source_buffer_length, &destination_buffer, destination_buffer_length);
|
|
484
593
|
if (ext_result != 0) {
|
|
485
594
|
BrotliDecoderDestroyInstance(state_ptr);
|
|
486
595
|
brs_ext_raise_error(ext_result);
|
|
@@ -488,8 +597,13 @@ VALUE brs_ext_decompress_io(VALUE BRS_EXT_UNUSED(self), VALUE source, VALUE dest
|
|
|
488
597
|
|
|
489
598
|
ext_result = decompress(
|
|
490
599
|
state_ptr,
|
|
491
|
-
source_file,
|
|
492
|
-
|
|
600
|
+
source_file,
|
|
601
|
+
source_buffer,
|
|
602
|
+
source_buffer_length,
|
|
603
|
+
destination_file,
|
|
604
|
+
destination_buffer,
|
|
605
|
+
destination_buffer_length,
|
|
606
|
+
gvl);
|
|
493
607
|
|
|
494
608
|
free(source_buffer);
|
|
495
609
|
free(destination_buffer);
|
|
@@ -505,6 +619,8 @@ VALUE brs_ext_decompress_io(VALUE BRS_EXT_UNUSED(self), VALUE source, VALUE dest
|
|
|
505
619
|
return Qnil;
|
|
506
620
|
}
|
|
507
621
|
|
|
622
|
+
// -- exports --
|
|
623
|
+
|
|
508
624
|
void brs_ext_io_exports(VALUE root_module)
|
|
509
625
|
{
|
|
510
626
|
rb_define_module_function(root_module, "_native_compress_io", RUBY_METHOD_FUNC(brs_ext_compress_io), 3);
|