zhangzengfei
2022-01-10 4496b59ab27d569df1da7ef634e02273b3a9618a
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
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
package com.basic.security.utils.yuv.pull.client;
 
import android.graphics.Bitmap;
 
import com.basic.security.utils.RenderScriptHelper;
import com.basic.security.utils.RotateUtil;
 
import java.io.ByteArrayOutputStream;
import java.util.LinkedList;
 
public class BufferManager extends Thread {
    private static final int MAX_BUFFER_COUNT = 4;
    private final int mFrameLength;
    ByteArrayOutputStream jpgBaos = new ByteArrayOutputStream();
    RotateUtil rotateUtil = new RotateUtil();
    byte[] jpgByteArray;
    RenderScriptHelper renderScriptHelper = new RenderScriptHelper();
    private ImageBuffer[] mBufferQueue;
    private int mFillCount = 0;
    private int mRemained = 0;
    private int mWidth, mHeight;
    private LinkedList<byte[]> mYUVQueue = new LinkedList<byte[]>();
    private DataListener mListener;
 
    public BufferManager(int frameLength, int width, int height) {
        mWidth = width;
        mHeight = height;
        mFrameLength = frameLength;
        mBufferQueue = new ImageBuffer[MAX_BUFFER_COUNT];
        for (int i = 0; i < MAX_BUFFER_COUNT; ++i) {
            mBufferQueue[i] = new ImageBuffer(mFrameLength, width, height);
        }
    }
 
    public void fillBuffer(byte[] data, int len) {
        mFillCount = mFillCount % MAX_BUFFER_COUNT;
        if (mRemained != 0) {
            if (mRemained < len) {
                mBufferQueue[mFillCount].fillBuffer(data, 0, mRemained, mYUVQueue);
                ++mFillCount;
                if (mFillCount == MAX_BUFFER_COUNT)
                    mFillCount = 0;
                mBufferQueue[mFillCount].fillBuffer(data, mRemained, len - mRemained, mYUVQueue);
                mRemained = mFrameLength - len + mRemained;
            } else if (mRemained == len) {
                mBufferQueue[mFillCount].fillBuffer(data, 0, mRemained, mYUVQueue);
                mRemained = 0;
                ++mFillCount;
                if (mFillCount == MAX_BUFFER_COUNT)
                    mFillCount = 0;
            } else {
                mBufferQueue[mFillCount].fillBuffer(data, 0, len, mYUVQueue);
                mRemained = mRemained - len;
            }
        } else {
            mBufferQueue[mFillCount].fillBuffer(data, 0, len, mYUVQueue);
 
            if (len < mFrameLength) {
                mRemained = mFrameLength - len;
            } else {
                ++mFillCount;
                if (mFillCount == MAX_BUFFER_COUNT)
                    mFillCount = 0;
            }
        }
    }
 
    public void setOnDataListener(DataListener listener) {
        mListener = listener;
        start();
    }
 
    public void close() {
        interrupt();
        try {
            join();
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
 
    @Override
    public void run() {
        // TODO Auto-generated method stub
        super.run();
        long lastTimeShowImage = System.currentTimeMillis();
        while (!Thread.currentThread().isInterrupted()) {
            byte[] data = null;
            synchronized (mYUVQueue) {
                data = mYUVQueue.poll();
 
                if (data != null) {
                    data = rotateUtil.rotateYUV420Degree90(data, mWidth, mHeight);
                    int mWidth1 = mHeight;
                    int mHeight1 = mWidth;
 
 
                    long begin = System.currentTimeMillis();
                    Bitmap bufferedImage = renderScriptHelper.getBitmapFromFrameData(data, mWidth1, mHeight1);
 
//                    YuvImage im = new YuvImage(data, ImageFormat.NV21, mWidth1,
//                            mHeight1, null);
//                    Rect r = new Rect(0,0,mWidth1,mHeight1);
//                    jpgBaos.reset();
//                    im.compressToJpeg(r, 100, jpgBaos);
//                    jpgByteArray = jpgBaos.toByteArray();
//
//                    long t = System.currentTimeMillis();
//                    Bitmap bufferedImage = null;
//                    bufferedImage = BitmapFactory.decodeByteArray(jpgByteArray, 0, jpgByteArray.length);
 
//                    System.out.println("taken="+(System.currentTimeMillis() - begin));
                    mListener.onDirty(bufferedImage);
                    System.out.println("上次显示图片的时间间隔:" + (System.currentTimeMillis() - lastTimeShowImage));
                    lastTimeShowImage = System.currentTimeMillis();
                }
 
            }
        }
    }
}