Fail to redirect native library's output from console

The DLL is c++ wrapping a Fortran subroutine, and called via JNI in
the Java Application. I need to read the standard output from Fortran
code, and display it to a dialog in Java Dialog. But using I/O
redirection :
System.setOut(new PrintStream(nativeDLL.getOutputStream()) ) can only
read Java's standout output, -- it doesn't work on my DLL's output...
Could you pls help me? Thanks in advance.

We can't use Process.getInputStream() since this is a DLL rather an
executable and the library is loaded without using Process, and a
class LoopedStreams is used to implement input stream.

public void run()
{

            final LoopedStreams ls = new LoopedStreams();
            PrintStream ps = new PrintStream(ls.getOutputStream());
            System.setOut(ps);
            System.setErr(ps);
               try
               {
                   LoadNativeDll.Init(m_command);
                   new LoadNativeDll(m_workingDir+"\\").start();
                                  }
               catch (Exception ex)
               {//display ex
                   return;
               }
            final BufferedReader br = new BufferedReader(new
InputStreamReader(ls.getInputStream()));
               new Thread(new Runnable()
            {
                public void run()
                {
                    try
                    {
                        String line;
                        while ((line = br.readLine())!=null)
                        {
                            //feed the line to a dialog
                            sleep(10);
                                     }
                        fireStatusEvent(this,
RegressionStatusEvent.REGRESSSION_STOP);
                    }
                    catch (Exception ex)
                    {//display ex
                             return;
                    }

                }
            }).start();

}

// now the LoopedStreams wrapper
public class LoopedStreams {
    private PipedOutputStream pipedOS =
        new PipedOutputStream();

    private boolean keepRunning = true;

    private ByteArrayOutputStream byteArrayOS =
        new ByteArrayOutputStream() {
        public void close()
        {
            keepRunning = false;
            try {
                super.close();
                pipedOS.close();
            }
            catch(IOException e) {
                // record error and deal with it
                // here simply stop it
                   System.err.println("Fail to close
ByteArrayOutputStream!");
                return;

            }
        }
    };

    private PipedInputStream pipedIS = new PipedInputStream() {
        public void close() {
            keepRunning = false;
            try {
                super.close();
            }
            catch(IOException e) { return; }
        }
    };

    public LoopedStreams() throws IOException {
        pipedOS.connect(pipedIS);
        startByteArrayReaderThread();
    } // LoopedStreams()

    public InputStream getInputStream() {
        return pipedIS;
    } // getInputStream()

    public OutputStream getOutputStream() {
        return byteArrayOS;
    } // getOutputStream()

    private void startByteArrayReaderThread() {
        new Thread(new Runnable() {
            public void run() {
                while(keepRunning) {
                    // check the bytes size of the stream
                    if(byteArrayOS.size() > 0) {
                        byte[] buffer = null;
                        synchronized(byteArrayOS) {
                            buffer = byteArrayOS.toByteArray();
                            byteArrayOS.reset(); // flush the buffer
                        }
                        try {
                            // send data to PipedOutputStream
                            pipedOS.write(buffer, 0, buffer.length);
                        }
                        catch(IOException e) {
                            // record error and deal with it
                            // here simply stop it
                               System.err.println("Read thread
error!");
                            return;

                        }
                    }
                    else // no data and turn the thread to sleep
                        try {
                            // check the ByteArrayOutputStream for new
data every 1s
                            Thread.sleep(1000);
                        }
                        catch(InterruptedException e) {}
                    }
             }
        }).start();
    } // startByteArrayReaderThread()
} // LoopedStreams