1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17 package io.netty.handler.codec.compression;
18
19 import com.aayushatharva.brotli4j.decoder.DecoderJNI;
20 import io.netty.buffer.ByteBuf;
21 import io.netty.channel.ChannelHandlerContext;
22 import io.netty.handler.codec.ByteToMessageDecoder;
23 import io.netty.util.internal.ObjectUtil;
24
25 import java.nio.ByteBuffer;
26 import java.util.List;
27
28
29
30
31
32
33 public final class BrotliDecoder extends ByteToMessageDecoder {
34
35 private enum State {
36 DONE, NEEDS_MORE_INPUT, ERROR
37 }
38
39 static {
40 try {
41 Brotli.ensureAvailability();
42 } catch (Throwable throwable) {
43 throw new ExceptionInInitializerError(throwable);
44 }
45 }
46
47 private final int inputBufferSize;
48 private DecoderJNI.Wrapper decoder;
49 private boolean destroyed;
50 private boolean needsRead;
51
52
53
54
55 public BrotliDecoder() {
56 this(8 * 1024);
57 }
58
59
60
61
62
63 public BrotliDecoder(int inputBufferSize) {
64 this.inputBufferSize = ObjectUtil.checkPositive(inputBufferSize, "inputBufferSize");
65 }
66
67 private void forwardOutput(ChannelHandlerContext ctx) {
68 ByteBuffer nativeBuffer = decoder.pull();
69
70 ByteBuf copy = ctx.alloc().buffer(nativeBuffer.remaining());
71 copy.writeBytes(nativeBuffer);
72 needsRead = false;
73 ctx.fireChannelRead(copy);
74 }
75
76 private State decompress(ChannelHandlerContext ctx, ByteBuf input) {
77 for (;;) {
78 switch (decoder.getStatus()) {
79 case DONE:
80 return State.DONE;
81
82 case OK:
83 decoder.push(0);
84 break;
85
86 case NEEDS_MORE_INPUT:
87 if (decoder.hasOutput()) {
88 forwardOutput(ctx);
89 }
90
91 if (!input.isReadable()) {
92 return State.NEEDS_MORE_INPUT;
93 }
94
95 ByteBuffer decoderInputBuffer = decoder.getInputBuffer();
96 decoderInputBuffer.clear();
97 int readBytes = readBytes(input, decoderInputBuffer);
98 decoder.push(readBytes);
99 break;
100
101 case NEEDS_MORE_OUTPUT:
102 forwardOutput(ctx);
103 break;
104
105 default:
106 return State.ERROR;
107 }
108 }
109 }
110
111 private static int readBytes(ByteBuf in, ByteBuffer dest) {
112 int limit = Math.min(in.readableBytes(), dest.remaining());
113 ByteBuffer slice = dest.slice();
114 slice.limit(limit);
115 in.readBytes(slice);
116 dest.position(dest.position() + limit);
117 return limit;
118 }
119
120 @Override
121 public void handlerAdded(ChannelHandlerContext ctx) throws Exception {
122 decoder = new DecoderJNI.Wrapper(inputBufferSize);
123 }
124
125 @Override
126 protected void decode(ChannelHandlerContext ctx, ByteBuf in, List<Object> out) throws Exception {
127 needsRead = true;
128 if (destroyed) {
129
130 in.skipBytes(in.readableBytes());
131 return;
132 }
133
134 if (!in.isReadable()) {
135 return;
136 }
137
138 try {
139 State state = decompress(ctx, in);
140 if (state == State.DONE) {
141 destroy();
142 } else if (state == State.ERROR) {
143 throw new DecompressionException("Brotli stream corrupted");
144 }
145 } catch (Exception e) {
146 destroy();
147 throw e;
148 }
149 }
150
151 private void destroy() {
152 if (!destroyed) {
153 destroyed = true;
154 decoder.destroy();
155 }
156 }
157
158 @Override
159 protected void handlerRemoved0(ChannelHandlerContext ctx) throws Exception {
160 try {
161 destroy();
162 } finally {
163 super.handlerRemoved0(ctx);
164 }
165 }
166
167 @Override
168 public void channelInactive(ChannelHandlerContext ctx) throws Exception {
169 try {
170 destroy();
171 } finally {
172 super.channelInactive(ctx);
173 }
174 }
175
176 @Override
177 public void channelReadComplete(ChannelHandlerContext ctx) throws Exception {
178
179 discardSomeReadBytes();
180
181 if (needsRead && !ctx.channel().config().isAutoRead()) {
182 ctx.read();
183 }
184 ctx.fireChannelReadComplete();
185 }
186 }