fix transcode's performance problem (#87)

Author: bicycle1885

src/stream.jl

@@ -636,12 +636,13 @@ function callprocess(stream::TranscodingStream, inbuf::Buffer, outbuf::Buffer)
     makemargin!(outbuf, minoutsize(stream.codec, input))
     Δin, Δout, state.code = process(stream.codec, input, marginmem(outbuf), state.error)
     @debug(
-       "called process()",
+        "called process()",
+        code = state.code,
         input_size = buffersize(inbuf),
         output_size = marginsize(outbuf),
         input_delta = Δin,
         output_delta = Δout,
-   )
+    )
     consumed!(inbuf, Δin, transcode = true)
     supplied!(outbuf, Δout, transcode = true)
     if state.code == :error
@@ -709,8 +710,7 @@ function changemode!(stream::TranscodingStream, newmode::Symbol)
         return
     elseif newmode == :panic
         if !haserror(state.error)
-            # set a default error
-            state.error[] = ErrorException("unknown error happened while processing data")
+            set_default_error!(state.error)
         end
         state.mode = newmode
         finalize_codec(stream.codec, state.error)
@@ -767,6 +767,11 @@ function throw_panic_error()
     throw(ArgumentError("stream is in unrecoverable error; only isopen and close are callable"))
 end
 
+# Set a defualt error.
+function set_default_error!(error::Error)
+    error[] = ErrorException("unknown error happened while processing data")
+end
+
 # Call the finalize method of the codec.
 function finalize_codec(codec::Codec, error::Error)
     try

src/transcode.jl

@@ -77,11 +77,53 @@ julia> String(decompressed)
 ```
 """
 function Base.transcode(codec::Codec, data::ByteData)
-    # Add `minoutsize` because `transcode` will be called at least two times.
-    buffer2 = Buffer(
-        expectedsize(codec, Memory(data)) + minoutsize(codec, Memory(C_NULL, 0)))
-    mark!(buffer2)
-    stream = TranscodingStream(codec, devnull, State(Buffer(data), buffer2); initialized=true)
-    write(stream, TOKEN_END)
-    return takemarked!(buffer2)
+    input = Buffer(data)
+    output = Buffer(initial_output_size(codec, buffermem(input)))
+    error = Error()
+    code = startproc(codec, :write, error)
+    if code === :error
+        @goto error
+    end
+    n = minoutsize(codec, buffermem(input))
+    while code !== :end || buffersize(input) > 0
+        makemargin!(output, n)
+        Δin, Δout, code = process(codec, buffermem(input), marginmem(output), error)
+        @debug(
+            "called process()",
+            code = code,
+            input_size = buffersize(input),
+            output_size = marginsize(output),
+            input_delta = Δin,
+            output_delta = Δout,
+        )
+        consumed!(input, Δin)
+        supplied!(output, Δout)
+        if code === :error
+            @goto error
+        elseif code === :end && buffersize(input) > 0
+            if startproc(codec, :write, error) === :error
+                @goto error
+            end
+        end
+        n = max(Δout, minoutsize(codec, buffermem(input)))
+    end
+    if marginsize(output) == 0
+        return output.data
+    else
+        return output.data[1:output.marginpos-1]
+    end
+    @label error
+    if !haserror(error)
+        set_default_error!(error)
+    end
+    throw(error[])
+end
+
+# Return the initial output buffer size.
+function initial_output_size(codec::Codec, input::Memory)
+    return max(
+        minoutsize(codec, input),
+        expectedsize(codec, input),
+        8,  # just in case where both minoutsize and expectedsize are foolish
+    )
 end