a

554325746@qq.com

2019-12-25 603cb36a5123e46656b06a5deb8d7ac7ff81307f

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
package com.basic.security.utils.socket;
 
import android.graphics.Bitmap;
 
import com.basic.security.utils.RenderScriptHelper;
import com.basic.security.utils.RotateUtil;
 
import java.io.ByteArrayOutputStream;
import java.util.LinkedList;
import java.util.Map;
 
public class YuvToJpgFrameBufferManager 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 YuvFrameQueue[] mBufferQueue;
    private int mFillCount = 0;
    private int mRemained = 0;
    private int mWidth, mHeight;
    private LinkedList<byte[]> mYUVQueue = new LinkedList<byte[]>();
    private BitmapListener mListener;
 
    public YuvToJpgFrameBufferManager(int frameLength, int width, int height) {
        mWidth = width;
        mHeight = height;
        mFrameLength = frameLength;
        mBufferQueue = new YuvFrameQueue[MAX_BUFFER_COUNT];
        for (int i = 0; i < MAX_BUFFER_COUNT; ++i) {
            mBufferQueue[i] = new YuvFrameQueue(mFrameLength, width, height);
        }
    }
 
    public YuvToJpgFrameBufferManager(int frameLength, int width, int height, BitmapListener listener) {
        this(frameLength, width, height);
        mListener = listener;
        start();
    }
 
    public void fillBuffer1(Map<String, Object> faceListMap, byte[] data, int len, boolean hasFaces) {
        data = rotateUtil.rotateYUV420Degree270(data, mWidth, mHeight);
        int mWidth1 = mHeight;
        int mHeight1 = mWidth;
        Bitmap bufferedImage = renderScriptHelper.getBitmapFromFrameData(data, mWidth1, mHeight1);
        if (hasFaces) {
            mListener.detectFace(faceListMap, data, mWidth1, mHeight1, bufferedImage, new byte[]{});
        }
        mListener.onBitmap(bufferedImage);
    }
 
    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(BitmapListener listener) {
        mListener = listener;
        start();
    }
 
    public void close() {
        interrupt();
        try {
            join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
 
    public void run() {
        super.run();
        long lastTimeShowImage = System.currentTimeMillis();
        while (!Thread.currentThread().isInterrupted()) {
            byte[] data;
            synchronized (mYUVQueue) {
                data = mYUVQueue.poll();
                if (data != null) {
                    data = rotateUtil.rotateYUV420Degree90(data, mWidth, mHeight);
                    int mWidth1 = mHeight;
                    int mHeight1 = mWidth;
                    Bitmap bufferedImage = renderScriptHelper.getBitmapFromFrameData(data, mWidth1, mHeight1);
                    mListener.onBitmap(bufferedImage);
                }
            }
        }
    }
}