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
|
/*
* This file is part of the PulseView project.
*
* Copyright (C) 2012 Joel Holdsworth <joel@airwebreathe.org.uk>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, see <http://www.gnu.org/licenses/>.
*/
#ifndef PULSEVIEW_PV_DATA_LOGICSEGMENT_HPP
#define PULSEVIEW_PV_DATA_LOGICSEGMENT_HPP
#include "segment.hpp"
#include <utility>
#include <vector>
#include <QObject>
using std::pair;
using std::shared_ptr;
using std::vector;
namespace sigrok {
class Logic;
}
namespace LogicSegmentTest {
struct Pow2;
struct Basic;
struct LargeData;
struct Pulses;
struct LongPulses;
}
namespace pv {
namespace data {
class Logic;
class LogicSegment : public Segment
{
Q_OBJECT
public:
typedef pair<int64_t, bool> EdgePair;
static const unsigned int ScaleStepCount = 10;
static const int MipMapScalePower;
static const int MipMapScaleFactor;
static const float LogMipMapScaleFactor;
static const uint64_t MipMapDataUnit;
private:
struct MipMapLevel
{
uint64_t length;
uint64_t data_length;
void *data;
};
public:
LogicSegment(pv::data::Logic& owner, uint32_t segment_id,
unsigned int unit_size, uint64_t samplerate);
virtual ~LogicSegment();
void append_payload(shared_ptr<sigrok::Logic> logic);
void append_payload(void *data, uint64_t data_size);
void get_samples(int64_t start_sample, int64_t end_sample, uint8_t* dest) const;
/**
* Parses a logic data segment to generate a list of transitions
* in a time interval to a given level of detail.
* @param[out] edges The vector to place the edges into.
* @param[in] start The start sample index.
* @param[in] end The end sample index.
* @param[in] min_length The minimum number of samples that
* can be resolved at this level of detail.
* @param[in] sig_index The index of the signal.
*/
void get_subsampled_edges(vector<EdgePair> &edges,
uint64_t start, uint64_t end,
float min_length, int sig_index, bool first_change_only = false);
void get_surrounding_edges(vector<EdgePair> &dest,
uint64_t origin_sample, float min_length, int sig_index);
private:
uint64_t unpack_sample(const uint8_t *ptr) const;
void pack_sample(uint8_t *ptr, uint64_t value);
void reallocate_mipmap_level(MipMapLevel &m);
void append_payload_to_mipmap();
uint64_t get_unpacked_sample(uint64_t index) const;
template <class T> void downsampleTmain(const T*&in, T &acc, T &prev);
template <class T> void downsampleT(const uint8_t *in, uint8_t *&out, uint64_t len);
void downsampleGeneric(const uint8_t *in, uint8_t *&out, uint64_t len);
private:
uint64_t get_subsample(int level, uint64_t offset) const;
static uint64_t pow2_ceil(uint64_t x, unsigned int power);
private:
Logic& owner_;
struct MipMapLevel mip_map_[ScaleStepCount];
uint64_t last_append_sample_;
uint64_t last_append_accumulator_;
uint64_t last_append_extra_;
friend struct LogicSegmentTest::Pow2;
friend struct LogicSegmentTest::Basic;
friend struct LogicSegmentTest::LargeData;
friend struct LogicSegmentTest::Pulses;
friend struct LogicSegmentTest::LongPulses;
};
} // namespace data
} // namespace pv
#endif // PULSEVIEW_PV_DATA_LOGICSEGMENT_HPP
|
