pans

2017-08-30 71c92f101b6c8b4a678a8c3cfe2d8edbf488efa4

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
144
145
146
147
148
149
150
151
152
153
#include "PL_Gainer.h" 
#include "MaterialBuffer.h" 
#include "logger.h" 
 
#include <string.h> // for memcpy 
 
struct PL_Gainer_Internal 
{ 
    PL_Gainer_Config config; 
    PipeMaterial lastPm; 
    MB_Frame lastFrame; 
 
    PL_Gainer_Internal() :  
        config(), lastPm(), lastFrame() 
    { 
    } 
     
    ~PL_Gainer_Internal() 
    { 
    } 
     
    void reset() 
    { 
        PL_Gainer_Config _config; 
        config = _config; 
         
        PipeMaterial _lastPm; 
        lastPm = _lastPm; 
         
        MB_Frame _lastFrame; 
        lastFrame = _lastFrame; 
    } 
}; 
 
PipeLineElem* create_PL_Gainer() 
{ 
    return new PL_Gainer; 
} 
 
PL_Gainer::PL_Gainer() : internal(new PL_Gainer_Internal) 
{ 
} 
 
PL_Gainer::~PL_Gainer() 
{ 
    delete (PL_Gainer_Internal*)internal; 
    internal= nullptr; 
} 
 
bool PL_Gainer::init(void* args) 
{ 
    PL_Gainer_Internal* in = (PL_Gainer_Internal*)internal; 
    in->reset(); 
     
    if (args != nullptr) 
    { 
        PL_Gainer_Config* config = (PL_Gainer_Config*)args; 
        in->config = *config; 
    } 
 
    return true; 
} 
 
void PL_Gainer::finit() 
{ 
    PL_Gainer_Internal* in = (PL_Gainer_Internal*)internal; 
     
} 
 
void pl_gainer_deleter_func(PipeMaterial* pm, bool lastRet) 
{ 
    PL_Gainer_Internal* in = (PL_Gainer_Internal*)(pm->args); 
 
    if (in->config.copyData) 
    { 
        switch(pm->type) 
        { 
        case PipeMaterial::PMT_BYTES: 
        { 
            delete[] (uint8_t*)pm->buffer; 
        } 
        break; 
        case PipeMaterial::PMT_FRAME: 
        { 
            MB_Frame* pmFrame = (MB_Frame*)(pm->buffer); 
            delete[] (uint8_t*)pmFrame->buffer; 
        } 
        break; 
        default: 
            //#todo support list or pm::copier operator 
            LOG_ERROR << "Only support PMT_BYTES / PMT_FRAME" << std::endl; 
            return; 
        } 
    } 
     
    PipeMaterial _pm; 
    *pm = _pm; 
} 
 
bool PL_Gainer::pay(const PipeMaterial& pm) 
{ 
    return false; 
} 
 
bool PL_Gainer::gain(PipeMaterial& pm) 
{ 
    PL_Gainer_Internal* in = (PL_Gainer_Internal*)internal; 
 
    if (in->config.copyData) 
    { 
        PipeMaterial newPm = pm; 
 
        switch(pm.type) 
        { 
        case PipeMaterial::PMT_BYTES: 
        { 
            newPm.buffer = new uint8_t[pm.buffSize]; 
            memcpy(newPm.buffer, pm.buffer, pm.buffSize); 
        } 
        break; 
        case PipeMaterial::PMT_FRAME: 
        { 
            MB_Frame* pmFrame = (MB_Frame*)(pm.buffer); 
            in->lastFrame = *pmFrame; 
            in->lastFrame.buffer = new uint8_t[pmFrame->buffSize]; 
            memcpy(in->lastFrame.buffer, pmFrame->buffer, pmFrame->buffSize); 
             
            newPm.buffer = &(in->lastFrame); 
        } 
        break; 
        default: 
            //#todo support list or pm::copier operator 
            LOG_ERROR << "Only support PMT_BYTES / PMT_FRAME" << std::endl; 
            return false; 
        } 
         
        newPm.args = in; 
        newPm.deleter = pl_gainer_deleter_func; 
         
        newPm.former = this; 
         
        if (pm.deleter != nullptr) 
            (pm.deleter)(&pm, false);//#todo 
         
        pm = newPm; 
        return true; 
    } 
    else 
    { 
        pm.former = this; 
        return true; 
    } 
}