input: accept const sdi in feed queue API
[libsigrok.git] / src / input / feed_queue.c
1 /*
2  * This file is part of the libsigrok project.
3  *
4  * Copyright (C) 2020 Gerhard Sittig <gerhard.sittig@gmx.net>
5  *
6  * This program is free software: you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License as published by
8  * the Free Software Foundation, either version 3 of the License, or
9  * (at your option) any later version.
10  *
11  * This program is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
18  */
19
20 #include <libsigrok/libsigrok.h>
21 #include "libsigrok-internal.h"
22 #include <string.h>
23
24 struct feed_queue_logic {
25         const struct sr_dev_inst *sdi;
26         size_t unit_size;
27         size_t alloc_count;
28         size_t fill_count;
29         uint8_t *data_bytes;
30         struct sr_datafeed_packet packet;
31         struct sr_datafeed_logic logic;
32 };
33
34 SR_API struct feed_queue_logic *feed_queue_logic_alloc(
35         const struct sr_dev_inst *sdi,
36         size_t sample_count, size_t unit_size)
37 {
38         struct feed_queue_logic *q;
39
40         q = g_malloc0(sizeof(*q));
41         q->sdi = sdi;
42         q->unit_size = unit_size;
43         q->alloc_count = sample_count;
44         q->data_bytes = g_try_malloc(q->alloc_count * q->unit_size);
45         if (!q->data_bytes) {
46                 g_free(q);
47                 return NULL;
48         }
49
50         memset(&q->packet, 0, sizeof(q->packet));
51         memset(&q->logic, 0, sizeof(q->logic));
52         q->packet.type = SR_DF_LOGIC;
53         q->packet.payload = &q->logic;
54         q->logic.unitsize = q->unit_size;
55         q->logic.data = q->data_bytes;
56
57         return q;
58 }
59
60 SR_API int feed_queue_logic_submit(struct feed_queue_logic *q,
61         const uint8_t *data, size_t count)
62 {
63         uint8_t *wrptr;
64         int ret;
65
66         wrptr = &q->data_bytes[q->fill_count * q->unit_size];
67         while (count--) {
68                 memcpy(wrptr, data, q->unit_size);
69                 wrptr += q->unit_size;
70                 q->fill_count++;
71                 if (q->fill_count == q->alloc_count) {
72                         ret = feed_queue_logic_flush(q);
73                         if (ret != SR_OK)
74                                 return ret;
75                         wrptr = &q->data_bytes[0];
76                 }
77         }
78
79         return SR_OK;
80 }
81
82 SR_API int feed_queue_logic_flush(struct feed_queue_logic *q)
83 {
84         int ret;
85
86         if (!q->fill_count)
87                 return SR_OK;
88
89         q->logic.length = q->fill_count * q->unit_size;
90         ret = sr_session_send(q->sdi, &q->packet);
91         if (ret != SR_OK)
92                 return ret;
93         q->fill_count = 0;
94
95         return SR_OK;
96 }
97
98 SR_API void feed_queue_logic_free(struct feed_queue_logic *q)
99 {
100
101         if (!q)
102                 return;
103
104         g_free(q->data_bytes);
105         g_free(q);
106 }
107
108 struct feed_queue_analog {
109         const struct sr_dev_inst *sdi;
110         size_t alloc_count;
111         size_t fill_count;
112         float *data_values;
113         int digits;
114         struct sr_datafeed_packet packet;
115         struct sr_datafeed_analog analog;
116         struct sr_analog_encoding encoding;
117         struct sr_analog_meaning meaning;
118         struct sr_analog_spec spec;
119         GSList *channels;
120 };
121
122 SR_API struct feed_queue_analog *feed_queue_analog_alloc(
123         const struct sr_dev_inst *sdi,
124         size_t sample_count, int digits, struct sr_channel *ch)
125 {
126         struct feed_queue_analog *q;
127
128         q = g_malloc0(sizeof(*q));
129         q->sdi = sdi;
130         q->alloc_count = sample_count;
131         q->data_values = g_try_malloc(q->alloc_count * sizeof(float));
132         if (!q->data_values) {
133                 g_free(q);
134                 return NULL;
135         }
136         q->digits = digits;
137         q->channels = g_slist_append(NULL, ch);
138
139         memset(&q->packet, 0, sizeof(q->packet));
140         sr_analog_init(&q->analog, &q->encoding, &q->meaning, &q->spec, digits);
141         q->packet.type = SR_DF_ANALOG;
142         q->packet.payload = &q->analog;
143         q->encoding.is_signed = TRUE;
144         q->meaning.channels = q->channels;
145         q->analog.data = q->data_values;
146
147         return q;
148 }
149
150 SR_API int feed_queue_analog_submit(struct feed_queue_analog *q,
151         float data, size_t count)
152 {
153         int ret;
154
155         while (count--) {
156                 q->data_values[q->fill_count++] = data;
157                 if (q->fill_count == q->alloc_count) {
158                         ret = feed_queue_analog_flush(q);
159                         if (ret != SR_OK)
160                                 return ret;
161                 }
162         }
163
164         return SR_OK;
165 }
166
167 SR_API int feed_queue_analog_flush(struct feed_queue_analog *q)
168 {
169         int ret;
170
171         if (!q->fill_count)
172                 return SR_OK;
173
174         q->analog.num_samples = q->fill_count;
175         ret = sr_session_send(q->sdi, &q->packet);
176         if (ret != SR_OK)
177                 return ret;
178         q->fill_count = 0;
179
180         return SR_OK;
181 }
182
183 SR_API void feed_queue_analog_free(struct feed_queue_analog *q)
184 {
185
186         if (!q)
187                 return;
188
189         g_free(q->data_values);
190         g_slist_free(q->channels);
191         g_free(q);
192 }