houxiao
2016-12-29 633e76c1d533c3d9c257b92df7ebdfd36c9fd8a0
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
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
#include "PL_AVFrameBGRA.h"
#include "MaterialBuffer.h"
#include "logger.h"
 
extern "C"
{
    #include <libavcodec/avcodec.h>
    #include <libavutil/frame.h>
    #include <libavformat/avformat.h>
    
    #include <libyuv.h>
}
 
struct PL_AVFrameBGRA_Internal
{
    uint8_t buffer[1920*1080*4];//#todo
    size_t buffSize;
    size_t buffSizeMax;
    MB_Frame lastFrame;
 
    bool payError;
    
    PL_AVFrameBGRA_Internal() : 
        buffSize(0), buffSizeMax(sizeof(buffer)), lastFrame(), 
        payError(true)
    {
    }
    
    ~PL_AVFrameBGRA_Internal()
    {
    }
    
    void reset()
    {
        buffSize = 0;
        payError = true;
        
        MB_Frame _lastFrame;
        lastFrame = _lastFrame;
    }
};
 
PipeLineElem* create_PL_AVFrameBGRA()
{
    return new PL_AVFrameBGRA;
}
 
PL_AVFrameBGRA::PL_AVFrameBGRA() : internal(new PL_AVFrameBGRA_Internal)
{
}
 
PL_AVFrameBGRA::~PL_AVFrameBGRA()
{
    delete (PL_AVFrameBGRA_Internal*)internal;
    internal= nullptr;
}
 
bool PL_AVFrameBGRA::init(void* args)
{
    PL_AVFrameBGRA_Internal* in = (PL_AVFrameBGRA_Internal*)internal;
    in->reset();
 
    return true;
}
 
void PL_AVFrameBGRA::finit()
{
    PL_AVFrameBGRA_Internal* in = (PL_AVFrameBGRA_Internal*)internal;
    
}
 
#define SUBSAMPLE(v, a) ((((v) + (a) - 1)) / (a))
 
bool PL_AVFrameBGRA::pay(const PipeMaterial& pm)
{
    PL_AVFrameBGRA_Internal* in = (PL_AVFrameBGRA_Internal*)internal;
    
    if (pm.type != PipeMaterial::PMT_FRAME)
    {
        LOG(ERROR) << "PL_AVFrameBGRA::pay only support PMT_FRAME";
        return false;
    }
    
    if (pm.buffer == nullptr)
        return false;
    
    MB_Frame* frame = (MB_Frame*)pm.buffer;
    if (frame->type != MB_Frame::MBFT_PTR_AVFRAME)
    {
        LOG(ERROR) << "PL_AVFrameBGRA::pay only support MBFT_PTR_AVFRAME";
        return false;
    }
 
    AVFrame* pAVFrame = (AVFrame*)frame->buffer;
    if (pAVFrame == nullptr)
        return false;
 
    const int height = pAVFrame->height;
    const int width = pAVFrame->width;
 
//int I420ToBGRA(const uint8* src_y, int src_stride_y,
//               const uint8* src_u, int src_stride_u,
//               const uint8* src_v, int src_stride_v,
//               uint8* dst_argb, int dst_stride_argb,
//               int width, int height);
 
    libyuv::I420ToBGRA(pAVFrame->data[0], width, 
                        pAVFrame->data[1], SUBSAMPLE(width, 2), 
                        pAVFrame->data[2], SUBSAMPLE(width, 2), 
                        in->buffer, 4 * width, 
                        width, height);
 
    in->buffSize = in->buffSizeMax;
    //in->buffer readly
    
    in->lastFrame.type = MB_Frame::MBFT_BGRA;
    in->lastFrame.buffer = in->buffer;
    in->lastFrame.buffSize = in->buffSize;
    in->lastFrame.width = width;
    in->lastFrame.height = height;
    in->lastFrame.pts = frame->pts;
 
    //#test
    //static size_t f=0;
    //char fname[50];
    //sprintf(fname, "%u.bgra", ++f);
    //FILE * pFile = fopen (fname,"wb");
    //fwrite (in->buffer , sizeof(char), in->buffSize, pFile);
    //fclose(pFile);
 
    return true;
}
 
bool PL_AVFrameBGRA::gain(PipeMaterial& pm)
{
    PL_AVFrameBGRA_Internal* in = (PL_AVFrameBGRA_Internal*)internal;
 
    pm.type = PipeMaterial::PMT_FRAME;
    pm.buffer = &(in->lastFrame);
    pm.buffSize = 0;
    pm.former = this;
    return true;
}