segmenter/segmenter.cpp at master · drivextech/segmenter · GitHub

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
154
155
156
157
158
159
160
161
162
163
164
165
// Copyright 2020 DriveX.Tech. All rights reserved.
//
// Licensed under the License.

#include "segmenter.hpp"
#include "marshalling/packer.h"
#include <string.h>
#include <assert.h>

using namespace dxt_common;


Segmenter::Segmenter(WORD data_chunk_length)
{
    set_data_chunk_length(data_chunk_length);

    reset();
}

Segmenter::~Segmenter()
{
}

void Segmenter::reset()
{
    seger_ind = 0;
    seger_off = 0;
    seger_data.clear();
}

bool Segmenter::set_data_chunk_length(WORD data_chunk_length)
{
    max_seger_length = data_chunk_length;
    max_seger_payload_length = max_seger_length - SEGMENTER_HDER_LEN;

    return true;
}

bool Segmenter::test_is_started(const std::vector<BYTE>& seger)
{
    assert(seger.size() > 0);
    return (seger[0] >> 1) == 0;
}

bool Segmenter::test_is_finished(const std::vector<BYTE>& seger)
{
    assert(seger.size() > 0);
    return !(seger[0] & 1);
}

bool Segmenter::skip(WORD len)
{
    seger_ind++; // set next data segment ind
    seger_off += len; // next expected seger off
    assert(seger_off <= seger_data.size());

    return true;
}

Segmenter::Status Segmenter::try_pack(std::vector<BYTE>& seger)
{
    Status status = FAILED;

    bool is_last_seger = false;
    WORD data_seg_len =  max_seger_payload_length;

    if(seger_off + max_seger_payload_length >= seger_data.size()) { // last segment, set MS flag to 1
        is_last_seger = true;
        data_seg_len = (WORD)seger_data.size() - seger_off;
    }

    if(data_seg_len == 0) {
        return FAILED;
    }

    seger.resize(SEGMENTER_HDER_LEN + data_seg_len);

    int len = 0;

    BYTE MS_IND = 0; // more segment flag && segment index, bit-0: MS flag, bit-1:8, ind
    MS_IND = is_last_seger ? 0 : 1;
    MS_IND |= (seger_ind << 1); // set highest 7-bit to segment ind
    len = pack_BYTE(MS_IND, seger.data());

    len += pack_WORD(seger_off, seger.data() + len);
    len += pack_WORD(data_seg_len, seger.data() + len);

    memcpy(seger.data() + len, seger_data.data() + seger_off, data_seg_len);
    len += data_seg_len;

    status = is_last_seger ? SUCCESSFUL : CONTINUE;
    return status;
}

Segmenter::Status Segmenter::pack(std::vector<BYTE>& seger)
{
    Status status = try_pack(seger);
    if(status != FAILED) {
        bool ret = skip((WORD)seger.size() - SEGMENTER_HDER_LEN);
        if(ret) {
            ;
        }
    }

    return status;
}

Segmenter::Status Segmenter::try_unpack(const std::vector<BYTE>& seger)
{
    Status status = FAILED;

    bool is_last_seger = false;

    int len = 0;

    BYTE MS_IND; // more segment flag && segment index, bit-0: MS flag, bit-1:8, ind
    len = unpack_BYTE(seger.data(), &MS_IND);
    if(len > max_seger_length) {
        return FAILED;
    }

    BYTE ind = (MS_IND >> 1);
    // assert(ind == seger_ind);
    if(ind != seger_ind) {
        return FAILED;
    }
    is_last_seger = !(MS_IND & 1);

    WORD data_seg_len =  0, data_seg_off = 0;
    len += unpack_WORD(seger.data() + len, &data_seg_off);
    // assert(data_seg_off == seger_off);
    if(data_seg_off != seger_off) {
        return FAILED;
    }
    len += unpack_WORD(seger.data() + len, &data_seg_len);
    if(len > max_seger_length) {
        return FAILED;
    }
    if(data_seg_len + SEGMENTER_HDER_LEN != seger.size()) {
        return FAILED;
    }

    //seger_data.insert(seger_data.end(), seger.data() + len, seger.data() + len + data_seg_len);
    seger_data.insert(seger_data.begin() + seger_off, seger.data() + len, seger.data() + len + data_seg_len);
    len += data_seg_len;
    if(len > max_seger_length) {
        return FAILED;
    }

    status = is_last_seger ? SUCCESSFUL : CONTINUE;
    return status;
}

Segmenter::Status Segmenter::unpack(const std::vector<BYTE>& seger)
{
    Status status = try_unpack(seger);
    if(status != FAILED) {
        bool ret = skip((WORD)seger.size() - SEGMENTER_HDER_LEN);
        if(ret) {
            ;
        }
    }

    return status;
}