Bert Vermeulen | b2c1961 | 2011-12-04 10:33:02 +0100 | [diff] [blame] | 1 | /* |
Uwe Hermann | 50bd5d2 | 2013-04-23 22:27:20 +0200 | [diff] [blame] | 2 | * This file is part of the libsigrokdecode project. |
Bert Vermeulen | b2c1961 | 2011-12-04 10:33:02 +0100 | [diff] [blame] | 3 | * |
| 4 | * Copyright (C) 2010 Uwe Hermann <uwe@hermann-uwe.de> |
Bert Vermeulen | bc5f5a4 | 2012-01-05 03:31:36 +0100 | [diff] [blame] | 5 | * Copyright (C) 2012 Bert Vermeulen <bert@biot.com> |
Bert Vermeulen | b2c1961 | 2011-12-04 10:33:02 +0100 | [diff] [blame] | 6 | * |
| 7 | * This program is free software: you can redistribute it and/or modify |
| 8 | * it under the terms of the GNU General Public License as published by |
| 9 | * the Free Software Foundation, either version 3 of the License, or |
| 10 | * (at your option) any later version. |
| 11 | * |
| 12 | * This program is distributed in the hope that it will be useful, |
| 13 | * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| 14 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| 15 | * GNU General Public License for more details. |
| 16 | * |
| 17 | * You should have received a copy of the GNU General Public License |
| 18 | * along with this program. If not, see <http://www.gnu.org/licenses/>. |
| 19 | */ |
| 20 | |
Uwe Hermann | c1f86f0 | 2013-05-03 14:49:21 +0200 | [diff] [blame] | 21 | #include "libsigrokdecode.h" /* First, so we avoid a _POSIX_C_SOURCE warning. */ |
| 22 | #include "libsigrokdecode-internal.h" |
Bert Vermeulen | 7ce7775 | 2012-01-10 00:25:16 +0100 | [diff] [blame] | 23 | #include "config.h" |
Bert Vermeulen | b2c1961 | 2011-12-04 10:33:02 +0100 | [diff] [blame] | 24 | #include <glib.h> |
Bert Vermeulen | 1aef2f9 | 2011-12-15 03:31:31 +0100 | [diff] [blame] | 25 | #include <inttypes.h> |
Bert Vermeulen | 0bdadba | 2012-01-17 03:37:34 +0100 | [diff] [blame] | 26 | #include <stdlib.h> |
Bert Vermeulen | 32cfb92 | 2013-09-12 23:54:43 +0200 | [diff] [blame] | 27 | #include <stdint.h> |
Bert Vermeulen | b2c1961 | 2011-12-04 10:33:02 +0100 | [diff] [blame] | 28 | |
Uwe Hermann | d7dae84 | 2013-02-09 21:32:31 +0100 | [diff] [blame] | 29 | /** |
| 30 | * @mainpage libsigrokdecode API |
| 31 | * |
| 32 | * @section sec_intro Introduction |
| 33 | * |
| 34 | * The <a href="http://sigrok.org">sigrok</a> project aims at creating a |
| 35 | * portable, cross-platform, Free/Libre/Open-Source signal analysis software |
| 36 | * suite that supports various device types (such as logic analyzers, |
| 37 | * oscilloscopes, multimeters, and more). |
| 38 | * |
| 39 | * <a href="http://sigrok.org/wiki/Libsigrokdecode">libsigrokdecode</a> is a |
| 40 | * shared library written in C which provides the basic API for (streaming) |
| 41 | * protocol decoding functionality. |
| 42 | * |
| 43 | * The <a href="http://sigrok.org/wiki/Protocol_decoders">protocol decoders</a> |
| 44 | * are written in Python (>= 3.0). |
| 45 | * |
| 46 | * @section sec_api API reference |
| 47 | * |
| 48 | * See the "Modules" page for an introduction to various libsigrokdecode |
| 49 | * related topics and the detailed API documentation of the respective |
| 50 | * functions. |
| 51 | * |
| 52 | * You can also browse the API documentation by file, or review all |
| 53 | * data structures. |
| 54 | * |
| 55 | * @section sec_mailinglists Mailing lists |
| 56 | * |
| 57 | * There are two mailing lists for sigrok/libsigrokdecode: <a href="https://lists.sourceforge.net/lists/listinfo/sigrok-devel">sigrok-devel</a> and <a href="https://lists.sourceforge.net/lists/listinfo/sigrok-commits">sigrok-commits</a>. |
| 58 | * |
| 59 | * @section sec_irc IRC |
| 60 | * |
| 61 | * You can find the sigrok developers in the |
| 62 | * <a href="irc://chat.freenode.net/sigrok">\#sigrok</a> |
| 63 | * IRC channel on Freenode. |
| 64 | * |
| 65 | * @section sec_website Website |
| 66 | * |
| 67 | * <a href="http://sigrok.org/wiki/Libsigrokdecode">sigrok.org/wiki/Libsigrokdecode</a> |
| 68 | */ |
| 69 | |
| 70 | /** |
| 71 | * @file |
| 72 | * |
| 73 | * Initializing and shutting down libsigrokdecode. |
| 74 | */ |
| 75 | |
| 76 | /** |
| 77 | * @defgroup grp_init Initialization |
| 78 | * |
| 79 | * Initializing and shutting down libsigrokdecode. |
| 80 | * |
| 81 | * Before using any of the libsigrokdecode functionality, srd_init() must |
| 82 | * be called to initialize the library. |
| 83 | * |
| 84 | * When libsigrokdecode functionality is no longer needed, srd_exit() should |
| 85 | * be called. |
| 86 | * |
| 87 | * @{ |
| 88 | */ |
| 89 | |
Uwe Hermann | 57790bc | 2013-02-09 21:44:11 +0100 | [diff] [blame] | 90 | /** @cond PRIVATE */ |
| 91 | |
Bert Vermeulen | fe9d91a | 2013-11-16 23:14:50 +0100 | [diff] [blame^] | 92 | extern GSList *sessions; |
| 93 | extern int max_session_id; |
Bert Vermeulen | 32cfb92 | 2013-09-12 23:54:43 +0200 | [diff] [blame] | 94 | |
Uwe Hermann | c9bfccc | 2012-02-08 22:39:30 +0100 | [diff] [blame] | 95 | /* decoder.c */ |
Uwe Hermann | 55c3c5f | 2012-02-09 19:11:53 +0100 | [diff] [blame] | 96 | extern SRD_PRIV GSList *pd_list; |
Bert Vermeulen | b2c1961 | 2011-12-04 10:33:02 +0100 | [diff] [blame] | 97 | |
Uwe Hermann | c9bfccc | 2012-02-08 22:39:30 +0100 | [diff] [blame] | 98 | /* module_sigrokdecode.c */ |
Uwe Hermann | 53a07a6 | 2012-04-16 23:10:26 +0200 | [diff] [blame] | 99 | extern PyMODINIT_FUNC PyInit_sigrokdecode(void); |
Bert Vermeulen | b2c1961 | 2011-12-04 10:33:02 +0100 | [diff] [blame] | 100 | |
Uwe Hermann | c9bfccc | 2012-02-08 22:39:30 +0100 | [diff] [blame] | 101 | /* type_logic.c */ |
Uwe Hermann | 55c3c5f | 2012-02-09 19:11:53 +0100 | [diff] [blame] | 102 | extern SRD_PRIV PyTypeObject srd_logic_type; |
Bert Vermeulen | b2c1961 | 2011-12-04 10:33:02 +0100 | [diff] [blame] | 103 | |
Uwe Hermann | 57790bc | 2013-02-09 21:44:11 +0100 | [diff] [blame] | 104 | /** @endcond */ |
| 105 | |
Bert Vermeulen | b2c1961 | 2011-12-04 10:33:02 +0100 | [diff] [blame] | 106 | /** |
| 107 | * Initialize libsigrokdecode. |
| 108 | * |
| 109 | * This initializes the Python interpreter, and creates and initializes |
Uwe Hermann | 361fdca | 2012-03-15 22:00:24 +0100 | [diff] [blame] | 110 | * a "sigrokdecode" Python module. |
Bert Vermeulen | b2c1961 | 2011-12-04 10:33:02 +0100 | [diff] [blame] | 111 | * |
Uwe Hermann | 4cc0d9f | 2013-05-03 21:21:30 +0200 | [diff] [blame] | 112 | * Then, it searches for sigrok protocol decoders in the "decoders" |
| 113 | * subdirectory of the the libsigrokdecode installation directory. |
Bert Vermeulen | b2c1961 | 2011-12-04 10:33:02 +0100 | [diff] [blame] | 114 | * All decoders that are found are loaded into memory and added to an |
Uwe Hermann | 4cc0d9f | 2013-05-03 21:21:30 +0200 | [diff] [blame] | 115 | * internal list of decoders, which can be queried via srd_decoder_list(). |
Bert Vermeulen | b2c1961 | 2011-12-04 10:33:02 +0100 | [diff] [blame] | 116 | * |
| 117 | * The caller is responsible for calling the clean-up function srd_exit(), |
| 118 | * which will properly shut down libsigrokdecode and free its allocated memory. |
| 119 | * |
Bert Vermeulen | 7ce7775 | 2012-01-10 00:25:16 +0100 | [diff] [blame] | 120 | * Multiple calls to srd_init(), without calling srd_exit() in between, |
Bert Vermeulen | b2c1961 | 2011-12-04 10:33:02 +0100 | [diff] [blame] | 121 | * are not allowed. |
| 122 | * |
Bert Vermeulen | 65e1c7d | 2012-02-12 04:07:22 +0100 | [diff] [blame] | 123 | * @param path Path to an extra directory containing protocol decoders |
Uwe Hermann | 4cc0d9f | 2013-05-03 21:21:30 +0200 | [diff] [blame] | 124 | * which will be added to the Python sys.path. May be NULL. |
Bert Vermeulen | 65e1c7d | 2012-02-12 04:07:22 +0100 | [diff] [blame] | 125 | * |
Bert Vermeulen | b2c1961 | 2011-12-04 10:33:02 +0100 | [diff] [blame] | 126 | * @return SRD_OK upon success, a (negative) error code otherwise. |
Uwe Hermann | 4cc0d9f | 2013-05-03 21:21:30 +0200 | [diff] [blame] | 127 | * Upon Python errors, SRD_ERR_PYTHON is returned. If the decoders |
| 128 | * directory cannot be accessed, SRD_ERR_DECODERS_DIR is returned. |
| 129 | * If not enough memory could be allocated, SRD_ERR_MALLOC is returned. |
Uwe Hermann | 8c664ca | 2013-05-03 14:45:49 +0200 | [diff] [blame] | 130 | * |
| 131 | * @since 0.1.0 |
Bert Vermeulen | b2c1961 | 2011-12-04 10:33:02 +0100 | [diff] [blame] | 132 | */ |
Uwe Hermann | abeeed8 | 2012-03-16 15:12:54 +0100 | [diff] [blame] | 133 | SRD_API int srd_init(const char *path) |
Bert Vermeulen | b2c1961 | 2011-12-04 10:33:02 +0100 | [diff] [blame] | 134 | { |
| 135 | int ret; |
Bert Vermeulen | 65e1c7d | 2012-02-12 04:07:22 +0100 | [diff] [blame] | 136 | char *env_path; |
Bert Vermeulen | b2c1961 | 2011-12-04 10:33:02 +0100 | [diff] [blame] | 137 | |
Bert Vermeulen | 32cfb92 | 2013-09-12 23:54:43 +0200 | [diff] [blame] | 138 | if (max_session_id != -1) { |
| 139 | srd_err("libsigrokdecode is already initialized."); |
| 140 | return SRD_ERR; |
| 141 | } |
| 142 | |
Uwe Hermann | 7a1712c | 2012-01-26 01:15:10 +0100 | [diff] [blame] | 143 | srd_dbg("Initializing libsigrokdecode."); |
Bert Vermeulen | d906d3f | 2012-01-22 02:51:49 +0100 | [diff] [blame] | 144 | |
| 145 | /* Add our own module to the list of built-in modules. */ |
Bert Vermeulen | bc5f5a4 | 2012-01-05 03:31:36 +0100 | [diff] [blame] | 146 | PyImport_AppendInittab("sigrokdecode", PyInit_sigrokdecode); |
Bert Vermeulen | 5f802ec | 2011-12-27 22:15:53 +0100 | [diff] [blame] | 147 | |
Uwe Hermann | 511e212 | 2012-02-10 09:29:38 +0100 | [diff] [blame] | 148 | /* Initialize the Python interpreter. */ |
Bert Vermeulen | b2c1961 | 2011-12-04 10:33:02 +0100 | [diff] [blame] | 149 | Py_Initialize(); |
| 150 | |
Bert Vermeulen | 65e1c7d | 2012-02-12 04:07:22 +0100 | [diff] [blame] | 151 | /* Installed decoders. */ |
Uwe Hermann | aafeeae | 2012-03-25 15:08:16 +0200 | [diff] [blame] | 152 | if ((ret = srd_decoder_searchpath_add(DECODERS_DIR)) != SRD_OK) { |
Bert Vermeulen | b2c1961 | 2011-12-04 10:33:02 +0100 | [diff] [blame] | 153 | Py_Finalize(); |
| 154 | return ret; |
| 155 | } |
| 156 | |
Bert Vermeulen | 65e1c7d | 2012-02-12 04:07:22 +0100 | [diff] [blame] | 157 | /* Path specified by the user. */ |
| 158 | if (path) { |
Uwe Hermann | aafeeae | 2012-03-25 15:08:16 +0200 | [diff] [blame] | 159 | if ((ret = srd_decoder_searchpath_add(path)) != SRD_OK) { |
Bert Vermeulen | 65e1c7d | 2012-02-12 04:07:22 +0100 | [diff] [blame] | 160 | Py_Finalize(); |
| 161 | return ret; |
| 162 | } |
| 163 | } |
| 164 | |
| 165 | /* Environment variable overrides everything, for debugging. */ |
| 166 | if ((env_path = getenv("SIGROKDECODE_DIR"))) { |
Uwe Hermann | aafeeae | 2012-03-25 15:08:16 +0200 | [diff] [blame] | 167 | if ((ret = srd_decoder_searchpath_add(env_path)) != SRD_OK) { |
Bert Vermeulen | 65e1c7d | 2012-02-12 04:07:22 +0100 | [diff] [blame] | 168 | Py_Finalize(); |
| 169 | return ret; |
| 170 | } |
| 171 | } |
| 172 | |
Bert Vermeulen | 32cfb92 | 2013-09-12 23:54:43 +0200 | [diff] [blame] | 173 | max_session_id = 0; |
| 174 | |
Bert Vermeulen | b2c1961 | 2011-12-04 10:33:02 +0100 | [diff] [blame] | 175 | return SRD_OK; |
| 176 | } |
| 177 | |
Bert Vermeulen | b2c1961 | 2011-12-04 10:33:02 +0100 | [diff] [blame] | 178 | /** |
| 179 | * Shutdown libsigrokdecode. |
| 180 | * |
| 181 | * This frees all the memory allocated for protocol decoders and shuts down |
| 182 | * the Python interpreter. |
| 183 | * |
| 184 | * This function should only be called if there was a (successful!) invocation |
| 185 | * of srd_init() before. Calling this function multiple times in a row, without |
Bert Vermeulen | 7ce7775 | 2012-01-10 00:25:16 +0100 | [diff] [blame] | 186 | * any successful srd_init() calls in between, is not allowed. |
Bert Vermeulen | b2c1961 | 2011-12-04 10:33:02 +0100 | [diff] [blame] | 187 | * |
| 188 | * @return SRD_OK upon success, a (negative) error code otherwise. |
Uwe Hermann | 8c664ca | 2013-05-03 14:45:49 +0200 | [diff] [blame] | 189 | * |
| 190 | * @since 0.1.0 |
Bert Vermeulen | b2c1961 | 2011-12-04 10:33:02 +0100 | [diff] [blame] | 191 | */ |
Uwe Hermann | 55c3c5f | 2012-02-09 19:11:53 +0100 | [diff] [blame] | 192 | SRD_API int srd_exit(void) |
Bert Vermeulen | b2c1961 | 2011-12-04 10:33:02 +0100 | [diff] [blame] | 193 | { |
Bert Vermeulen | 32cfb92 | 2013-09-12 23:54:43 +0200 | [diff] [blame] | 194 | GSList *l; |
| 195 | |
Uwe Hermann | 7a1712c | 2012-01-26 01:15:10 +0100 | [diff] [blame] | 196 | srd_dbg("Exiting libsigrokdecode."); |
Bert Vermeulen | d906d3f | 2012-01-22 02:51:49 +0100 | [diff] [blame] | 197 | |
Bert Vermeulen | 32cfb92 | 2013-09-12 23:54:43 +0200 | [diff] [blame] | 198 | for (l = sessions; l; l = l->next) |
| 199 | srd_session_destroy((struct srd_session *)l->data); |
| 200 | |
Uwe Hermann | 8ad6e50 | 2012-03-16 15:25:53 +0100 | [diff] [blame] | 201 | srd_decoder_unload_all(); |
Bert Vermeulen | e508088 | 2011-12-07 09:56:49 +0100 | [diff] [blame] | 202 | g_slist_free(pd_list); |
Uwe Hermann | 96c5259 | 2012-03-20 18:02:45 +0100 | [diff] [blame] | 203 | pd_list = NULL; |
Bert Vermeulen | b2c1961 | 2011-12-04 10:33:02 +0100 | [diff] [blame] | 204 | |
| 205 | /* Py_Finalize() returns void, any finalization errors are ignored. */ |
| 206 | Py_Finalize(); |
| 207 | |
Bert Vermeulen | 32cfb92 | 2013-09-12 23:54:43 +0200 | [diff] [blame] | 208 | max_session_id = -1; |
| 209 | |
Bert Vermeulen | b2c1961 | 2011-12-04 10:33:02 +0100 | [diff] [blame] | 210 | return SRD_OK; |
| 211 | } |
| 212 | |
Bert Vermeulen | b2c1961 | 2011-12-04 10:33:02 +0100 | [diff] [blame] | 213 | /** |
Uwe Hermann | 9d9fcb3 | 2012-01-23 19:58:06 +0100 | [diff] [blame] | 214 | * Add an additional search directory for the protocol decoders. |
| 215 | * |
| 216 | * The specified directory is prepended (not appended!) to Python's sys.path, |
| 217 | * in order to search for sigrok protocol decoders in the specified |
| 218 | * directories first, and in the generic Python module directories (and in |
| 219 | * the current working directory) last. This avoids conflicts if there are |
| 220 | * Python modules which have the same name as a sigrok protocol decoder in |
| 221 | * sys.path or in the current working directory. |
Bert Vermeulen | b2c1961 | 2011-12-04 10:33:02 +0100 | [diff] [blame] | 222 | * |
Uwe Hermann | 361fdca | 2012-03-15 22:00:24 +0100 | [diff] [blame] | 223 | * @param path Path to the directory containing protocol decoders which shall |
| 224 | * be added to the Python sys.path, or NULL. |
Uwe Hermann | 9d9fcb3 | 2012-01-23 19:58:06 +0100 | [diff] [blame] | 225 | * |
Bert Vermeulen | 65e1c7d | 2012-02-12 04:07:22 +0100 | [diff] [blame] | 226 | * @return SRD_OK upon success, a (negative) error code otherwise. |
Uwe Hermann | 57790bc | 2013-02-09 21:44:11 +0100 | [diff] [blame] | 227 | * |
| 228 | * @private |
Uwe Hermann | 8c664ca | 2013-05-03 14:45:49 +0200 | [diff] [blame] | 229 | * |
| 230 | * @since 0.1.0 |
Bert Vermeulen | b2c1961 | 2011-12-04 10:33:02 +0100 | [diff] [blame] | 231 | */ |
Uwe Hermann | aafeeae | 2012-03-25 15:08:16 +0200 | [diff] [blame] | 232 | SRD_PRIV int srd_decoder_searchpath_add(const char *path) |
Bert Vermeulen | b2c1961 | 2011-12-04 10:33:02 +0100 | [diff] [blame] | 233 | { |
Bert Vermeulen | 65e1c7d | 2012-02-12 04:07:22 +0100 | [diff] [blame] | 234 | PyObject *py_cur_path, *py_item; |
| 235 | GString *new_path; |
| 236 | int wc_len, i; |
| 237 | wchar_t *wc_new_path; |
| 238 | char *item; |
Bert Vermeulen | b2c1961 | 2011-12-04 10:33:02 +0100 | [diff] [blame] | 239 | |
Uwe Hermann | 8ad6e50 | 2012-03-16 15:25:53 +0100 | [diff] [blame] | 240 | srd_dbg("Adding '%s' to module path.", path); |
Uwe Hermann | 639c568 | 2012-01-19 00:21:00 +0100 | [diff] [blame] | 241 | |
Bert Vermeulen | 65e1c7d | 2012-02-12 04:07:22 +0100 | [diff] [blame] | 242 | new_path = g_string_sized_new(256); |
Bert Vermeulen | e592ac8 | 2013-05-05 17:20:13 +0200 | [diff] [blame] | 243 | g_string_assign(new_path, path); |
Bert Vermeulen | 65e1c7d | 2012-02-12 04:07:22 +0100 | [diff] [blame] | 244 | py_cur_path = PySys_GetObject("path"); |
| 245 | for (i = 0; i < PyList_Size(py_cur_path); i++) { |
Bert Vermeulen | e592ac8 | 2013-05-05 17:20:13 +0200 | [diff] [blame] | 246 | g_string_append(new_path, G_SEARCHPATH_SEPARATOR_S); |
Bert Vermeulen | 65e1c7d | 2012-02-12 04:07:22 +0100 | [diff] [blame] | 247 | py_item = PyList_GetItem(py_cur_path, i); |
| 248 | if (!PyUnicode_Check(py_item)) |
| 249 | /* Shouldn't happen. */ |
| 250 | continue; |
| 251 | if (py_str_as_str(py_item, &item) != SRD_OK) |
| 252 | continue; |
| 253 | g_string_append(new_path, item); |
Bert Vermeulen | e592ac8 | 2013-05-05 17:20:13 +0200 | [diff] [blame] | 254 | g_free(item); |
Bert Vermeulen | 65e1c7d | 2012-02-12 04:07:22 +0100 | [diff] [blame] | 255 | } |
Uwe Hermann | 639c568 | 2012-01-19 00:21:00 +0100 | [diff] [blame] | 256 | |
Bert Vermeulen | 65e1c7d | 2012-02-12 04:07:22 +0100 | [diff] [blame] | 257 | /* Convert to wide chars. */ |
| 258 | wc_len = sizeof(wchar_t) * (new_path->len + 1); |
| 259 | if (!(wc_new_path = g_try_malloc(wc_len))) { |
| 260 | srd_dbg("malloc failed"); |
| 261 | return SRD_ERR_MALLOC; |
| 262 | } |
| 263 | mbstowcs(wc_new_path, new_path->str, wc_len); |
| 264 | PySys_SetPath(wc_new_path); |
| 265 | g_string_free(new_path, TRUE); |
| 266 | g_free(wc_new_path); |
Uwe Hermann | 639c568 | 2012-01-19 00:21:00 +0100 | [diff] [blame] | 267 | |
Bert Vermeulen | 65e1c7d | 2012-02-12 04:07:22 +0100 | [diff] [blame] | 268 | return SRD_OK; |
Bert Vermeulen | b2c1961 | 2011-12-04 10:33:02 +0100 | [diff] [blame] | 269 | } |
| 270 | |
Uwe Hermann | 4895418 | 2013-02-09 22:25:15 +0100 | [diff] [blame] | 271 | /** @} */ |
| 272 | |
| 273 | /** |
| 274 | * @defgroup grp_instances Decoder instances |
| 275 | * |
| 276 | * Decoder instance handling. |
| 277 | * |
| 278 | * @{ |
| 279 | */ |
| 280 | |
Bert Vermeulen | 7ce7775 | 2012-01-10 00:25:16 +0100 | [diff] [blame] | 281 | /** |
Uwe Hermann | b33b8aa | 2012-03-25 14:49:11 +0200 | [diff] [blame] | 282 | * Set one or more options in a decoder instance. |
Bert Vermeulen | 0bdadba | 2012-01-17 03:37:34 +0100 | [diff] [blame] | 283 | * |
Uwe Hermann | 361fdca | 2012-03-15 22:00:24 +0100 | [diff] [blame] | 284 | * Handled options are removed from the hash. |
| 285 | * |
Bert Vermeulen | 0bdadba | 2012-01-17 03:37:34 +0100 | [diff] [blame] | 286 | * @param di Decoder instance. |
| 287 | * @param options A GHashTable of options to set. |
| 288 | * |
Bert Vermeulen | 0bdadba | 2012-01-17 03:37:34 +0100 | [diff] [blame] | 289 | * @return SRD_OK upon success, a (negative) error code otherwise. |
Uwe Hermann | 8c664ca | 2013-05-03 14:45:49 +0200 | [diff] [blame] | 290 | * |
| 291 | * @since 0.1.0 |
Bert Vermeulen | 0bdadba | 2012-01-17 03:37:34 +0100 | [diff] [blame] | 292 | */ |
Uwe Hermann | b33b8aa | 2012-03-25 14:49:11 +0200 | [diff] [blame] | 293 | SRD_API int srd_inst_option_set(struct srd_decoder_inst *di, |
Bert Vermeulen | 0ff2d19 | 2013-03-19 01:01:25 +0100 | [diff] [blame] | 294 | GHashTable *options) |
Bert Vermeulen | 0bdadba | 2012-01-17 03:37:34 +0100 | [diff] [blame] | 295 | { |
| 296 | PyObject *py_dec_options, *py_dec_optkeys, *py_di_options, *py_optval; |
| 297 | PyObject *py_optlist, *py_classval; |
| 298 | Py_UNICODE *py_ustr; |
Bert Vermeulen | 2f395bf | 2013-03-19 01:47:53 +0100 | [diff] [blame] | 299 | GVariant *value; |
Bert Vermeulen | 0bdadba | 2012-01-17 03:37:34 +0100 | [diff] [blame] | 300 | unsigned long long int val_ull; |
Bert Vermeulen | 2f395bf | 2013-03-19 01:47:53 +0100 | [diff] [blame] | 301 | gint64 val_int; |
Bert Vermeulen | 0bdadba | 2012-01-17 03:37:34 +0100 | [diff] [blame] | 302 | int num_optkeys, ret, size, i; |
Bert Vermeulen | 2f395bf | 2013-03-19 01:47:53 +0100 | [diff] [blame] | 303 | const char *val_str; |
| 304 | char *dbg, *key; |
Bert Vermeulen | 0bdadba | 2012-01-17 03:37:34 +0100 | [diff] [blame] | 305 | |
Uwe Hermann | 3af0e34 | 2013-10-23 19:23:40 +0200 | [diff] [blame] | 306 | if (!di) { |
| 307 | srd_err("Invalid decoder instance."); |
| 308 | return SRD_ERR_ARG; |
| 309 | } |
| 310 | |
| 311 | if (!options) { |
| 312 | srd_err("Invalid options GHashTable."); |
| 313 | return SRD_ERR_ARG; |
| 314 | } |
| 315 | |
Uwe Hermann | c9bfccc | 2012-02-08 22:39:30 +0100 | [diff] [blame] | 316 | if (!PyObject_HasAttrString(di->decoder->py_dec, "options")) { |
Bert Vermeulen | 0bdadba | 2012-01-17 03:37:34 +0100 | [diff] [blame] | 317 | /* Decoder has no options. */ |
Bert Vermeulen | e431d9c | 2012-01-18 22:59:14 +0100 | [diff] [blame] | 318 | if (g_hash_table_size(options) == 0) { |
| 319 | /* No options provided. */ |
| 320 | return SRD_OK; |
| 321 | } else { |
| 322 | srd_err("Protocol decoder has no options."); |
| 323 | return SRD_ERR_ARG; |
| 324 | } |
Bert Vermeulen | 0bdadba | 2012-01-17 03:37:34 +0100 | [diff] [blame] | 325 | return SRD_OK; |
Bert Vermeulen | e431d9c | 2012-01-18 22:59:14 +0100 | [diff] [blame] | 326 | } |
Bert Vermeulen | 0bdadba | 2012-01-17 03:37:34 +0100 | [diff] [blame] | 327 | |
| 328 | ret = SRD_ERR_PYTHON; |
| 329 | key = NULL; |
| 330 | py_dec_options = py_dec_optkeys = py_di_options = py_optval = NULL; |
| 331 | py_optlist = py_classval = NULL; |
| 332 | py_dec_options = PyObject_GetAttrString(di->decoder->py_dec, "options"); |
Bert Vermeulen | 0bdadba | 2012-01-17 03:37:34 +0100 | [diff] [blame] | 333 | |
| 334 | /* All of these are synthesized objects, so they're good. */ |
| 335 | py_dec_optkeys = PyDict_Keys(py_dec_options); |
| 336 | num_optkeys = PyList_Size(py_dec_optkeys); |
Bert Vermeulen | 119d625 | 2013-10-17 16:27:54 +0200 | [diff] [blame] | 337 | |
| 338 | /* |
| 339 | * The 'options' dictionary is a class variable, but we need to |
| 340 | * change it. Changing it directly will affect the entire class, |
| 341 | * so we need to create a new object for it, and populate that |
| 342 | * instead. |
| 343 | */ |
Bert Vermeulen | a8b72b0 | 2012-02-11 18:06:56 +0100 | [diff] [blame] | 344 | if (!(py_di_options = PyObject_GetAttrString(di->py_inst, "options"))) |
Bert Vermeulen | 0bdadba | 2012-01-17 03:37:34 +0100 | [diff] [blame] | 345 | goto err_out; |
Bert Vermeulen | 119d625 | 2013-10-17 16:27:54 +0200 | [diff] [blame] | 346 | Py_DECREF(py_di_options); |
| 347 | py_di_options = PyDict_New(); |
| 348 | PyObject_SetAttrString(di->py_inst, "options", py_di_options); |
Bert Vermeulen | 0bdadba | 2012-01-17 03:37:34 +0100 | [diff] [blame] | 349 | for (i = 0; i < num_optkeys; i++) { |
| 350 | /* Get the default class value for this option. */ |
| 351 | py_str_as_str(PyList_GetItem(py_dec_optkeys, i), &key); |
| 352 | if (!(py_optlist = PyDict_GetItemString(py_dec_options, key))) |
| 353 | goto err_out; |
| 354 | if (!(py_classval = PyList_GetItem(py_optlist, 1))) |
| 355 | goto err_out; |
Bert Vermeulen | 130ef08 | 2012-01-19 00:00:02 +0100 | [diff] [blame] | 356 | if (!PyUnicode_Check(py_classval) && !PyLong_Check(py_classval)) { |
Uwe Hermann | c9bfccc | 2012-02-08 22:39:30 +0100 | [diff] [blame] | 357 | srd_err("Options of type %s are not yet supported.", |
| 358 | Py_TYPE(py_classval)->tp_name); |
Bert Vermeulen | 130ef08 | 2012-01-19 00:00:02 +0100 | [diff] [blame] | 359 | goto err_out; |
| 360 | } |
Bert Vermeulen | 0bdadba | 2012-01-17 03:37:34 +0100 | [diff] [blame] | 361 | |
| 362 | if ((value = g_hash_table_lookup(options, key))) { |
Bert Vermeulen | 2f395bf | 2013-03-19 01:47:53 +0100 | [diff] [blame] | 363 | dbg = g_variant_print(value, TRUE); |
| 364 | srd_dbg("got option '%s' = %s", key, dbg); |
| 365 | g_free(dbg); |
Bert Vermeulen | 0bdadba | 2012-01-17 03:37:34 +0100 | [diff] [blame] | 366 | /* An override for this option was provided. */ |
| 367 | if (PyUnicode_Check(py_classval)) { |
Bert Vermeulen | 2f395bf | 2013-03-19 01:47:53 +0100 | [diff] [blame] | 368 | if (!g_variant_is_of_type(value, G_VARIANT_TYPE_STRING)) { |
| 369 | srd_err("Option '%s' requires a string value.", key); |
| 370 | goto err_out; |
| 371 | } |
| 372 | val_str = g_variant_get_string(value, NULL); |
| 373 | if (!(py_optval = PyUnicode_FromString(val_str))) { |
Bert Vermeulen | 0bdadba | 2012-01-17 03:37:34 +0100 | [diff] [blame] | 374 | /* Some UTF-8 encoding error. */ |
| 375 | PyErr_Clear(); |
Bert Vermeulen | 2f395bf | 2013-03-19 01:47:53 +0100 | [diff] [blame] | 376 | srd_err("Option '%s' requires a UTF-8 string value.", key); |
Bert Vermeulen | 0bdadba | 2012-01-17 03:37:34 +0100 | [diff] [blame] | 377 | goto err_out; |
| 378 | } |
| 379 | } else if (PyLong_Check(py_classval)) { |
Bert Vermeulen | 2f395bf | 2013-03-19 01:47:53 +0100 | [diff] [blame] | 380 | if (!g_variant_is_of_type(value, G_VARIANT_TYPE_INT64)) { |
| 381 | srd_err("Option '%s' requires an integer value.", key); |
| 382 | goto err_out; |
| 383 | } |
| 384 | val_int = g_variant_get_int64(value); |
| 385 | if (!(py_optval = PyLong_FromLong(val_int))) { |
Bert Vermeulen | 0bdadba | 2012-01-17 03:37:34 +0100 | [diff] [blame] | 386 | /* ValueError Exception */ |
| 387 | PyErr_Clear(); |
Bert Vermeulen | 2f395bf | 2013-03-19 01:47:53 +0100 | [diff] [blame] | 388 | srd_err("Option '%s' has invalid integer value.", key); |
Bert Vermeulen | 0bdadba | 2012-01-17 03:37:34 +0100 | [diff] [blame] | 389 | goto err_out; |
| 390 | } |
| 391 | } |
| 392 | g_hash_table_remove(options, key); |
| 393 | } else { |
| 394 | /* Use the class default for this option. */ |
| 395 | if (PyUnicode_Check(py_classval)) { |
| 396 | /* Make a brand new copy of the string. */ |
| 397 | py_ustr = PyUnicode_AS_UNICODE(py_classval); |
| 398 | size = PyUnicode_GET_SIZE(py_classval); |
| 399 | py_optval = PyUnicode_FromUnicode(py_ustr, size); |
| 400 | } else if (PyLong_Check(py_classval)) { |
| 401 | /* Make a brand new copy of the integer. */ |
| 402 | val_ull = PyLong_AsUnsignedLongLong(py_classval); |
| 403 | if (val_ull == (unsigned long long)-1) { |
| 404 | /* OverFlowError exception */ |
| 405 | PyErr_Clear(); |
Uwe Hermann | c9bfccc | 2012-02-08 22:39:30 +0100 | [diff] [blame] | 406 | srd_err("Invalid integer value for %s: " |
| 407 | "expected integer.", key); |
Bert Vermeulen | 0bdadba | 2012-01-17 03:37:34 +0100 | [diff] [blame] | 408 | goto err_out; |
| 409 | } |
| 410 | if (!(py_optval = PyLong_FromUnsignedLongLong(val_ull))) |
| 411 | goto err_out; |
| 412 | } |
| 413 | } |
| 414 | |
Uwe Hermann | 361fdca | 2012-03-15 22:00:24 +0100 | [diff] [blame] | 415 | /* |
| 416 | * If we got here, py_optval holds a known good new reference |
Bert Vermeulen | 0bdadba | 2012-01-17 03:37:34 +0100 | [diff] [blame] | 417 | * to the instance option to set. |
| 418 | */ |
| 419 | if (PyDict_SetItemString(py_di_options, key, py_optval) == -1) |
| 420 | goto err_out; |
Bert Vermeulen | e592ac8 | 2013-05-05 17:20:13 +0200 | [diff] [blame] | 421 | g_free(key); |
Bert Vermeulen | b88e336 | 2013-05-23 11:24:25 +0200 | [diff] [blame] | 422 | key = NULL; |
Bert Vermeulen | 0bdadba | 2012-01-17 03:37:34 +0100 | [diff] [blame] | 423 | } |
| 424 | |
| 425 | ret = SRD_OK; |
| 426 | |
| 427 | err_out: |
Bert Vermeulen | 0bdadba | 2012-01-17 03:37:34 +0100 | [diff] [blame] | 428 | Py_XDECREF(py_di_options); |
| 429 | Py_XDECREF(py_dec_optkeys); |
| 430 | Py_XDECREF(py_dec_options); |
Uwe Hermann | 6f85831 | 2012-01-28 21:26:26 +0100 | [diff] [blame] | 431 | g_free(key); |
Bert Vermeulen | 7fc7bde | 2013-10-16 11:10:27 +0200 | [diff] [blame] | 432 | if (PyErr_Occurred()) { |
Uwe Hermann | aafeeae | 2012-03-25 15:08:16 +0200 | [diff] [blame] | 433 | srd_exception_catch("Stray exception in srd_inst_option_set()."); |
Bert Vermeulen | 7fc7bde | 2013-10-16 11:10:27 +0200 | [diff] [blame] | 434 | ret = SRD_ERR_PYTHON; |
| 435 | } |
Bert Vermeulen | 0bdadba | 2012-01-17 03:37:34 +0100 | [diff] [blame] | 436 | |
| 437 | return ret; |
| 438 | } |
| 439 | |
Uwe Hermann | b33b8aa | 2012-03-25 14:49:11 +0200 | [diff] [blame] | 440 | /* Helper GComparefunc for g_slist_find_custom() in srd_inst_probe_set_all() */ |
Uwe Hermann | abeeed8 | 2012-03-16 15:12:54 +0100 | [diff] [blame] | 441 | static gint compare_probe_id(const struct srd_probe *a, const char *probe_id) |
Bert Vermeulen | f38ec28 | 2012-01-20 22:25:42 +0100 | [diff] [blame] | 442 | { |
Bert Vermeulen | f38ec28 | 2012-01-20 22:25:42 +0100 | [diff] [blame] | 443 | return strcmp(a->id, probe_id); |
| 444 | } |
| 445 | |
Bert Vermeulen | 0bdadba | 2012-01-17 03:37:34 +0100 | [diff] [blame] | 446 | /** |
Uwe Hermann | b33b8aa | 2012-03-25 14:49:11 +0200 | [diff] [blame] | 447 | * Set all probes in a decoder instance. |
| 448 | * |
| 449 | * This function sets _all_ probes for the specified decoder instance, i.e., |
| 450 | * it overwrites any probes that were already defined (if any). |
Bert Vermeulen | 0bdadba | 2012-01-17 03:37:34 +0100 | [diff] [blame] | 451 | * |
| 452 | * @param di Decoder instance. |
Uwe Hermann | 38ff504 | 2013-02-02 12:18:29 +0100 | [diff] [blame] | 453 | * @param new_probes A GHashTable of probes to set. Key is probe name, value is |
| 454 | * the probe number. Samples passed to this instance will be |
| 455 | * arranged in this order. |
Bert Vermeulen | 12243c2 | 2012-02-12 14:18:32 +0100 | [diff] [blame] | 456 | * |
Bert Vermeulen | 0bdadba | 2012-01-17 03:37:34 +0100 | [diff] [blame] | 457 | * @return SRD_OK upon success, a (negative) error code otherwise. |
Uwe Hermann | 8c664ca | 2013-05-03 14:45:49 +0200 | [diff] [blame] | 458 | * |
| 459 | * @since 0.1.0 |
Bert Vermeulen | 0bdadba | 2012-01-17 03:37:34 +0100 | [diff] [blame] | 460 | */ |
Uwe Hermann | b33b8aa | 2012-03-25 14:49:11 +0200 | [diff] [blame] | 461 | SRD_API int srd_inst_probe_set_all(struct srd_decoder_inst *di, |
Bert Vermeulen | 0ff2d19 | 2013-03-19 01:01:25 +0100 | [diff] [blame] | 462 | GHashTable *new_probes) |
Bert Vermeulen | 0bdadba | 2012-01-17 03:37:34 +0100 | [diff] [blame] | 463 | { |
Bert Vermeulen | 2f395bf | 2013-03-19 01:47:53 +0100 | [diff] [blame] | 464 | GVariant *probe_val; |
Bert Vermeulen | f38ec28 | 2012-01-20 22:25:42 +0100 | [diff] [blame] | 465 | GList *l; |
| 466 | GSList *sl; |
| 467 | struct srd_probe *p; |
Bert Vermeulen | ed41649 | 2013-10-30 16:30:05 +0100 | [diff] [blame] | 468 | int *new_probemap, new_probenum, num_required_probes, num_probes, i; |
Bert Vermeulen | 2f395bf | 2013-03-19 01:47:53 +0100 | [diff] [blame] | 469 | char *probe_id; |
Bert Vermeulen | 0bdadba | 2012-01-17 03:37:34 +0100 | [diff] [blame] | 470 | |
Bert Vermeulen | ce46bee | 2012-01-27 08:21:58 +0100 | [diff] [blame] | 471 | srd_dbg("set probes called for instance %s with list of %d probes", |
Bert Vermeulen | a8b72b0 | 2012-02-11 18:06:56 +0100 | [diff] [blame] | 472 | di->inst_id, g_hash_table_size(new_probes)); |
Bert Vermeulen | ce46bee | 2012-01-27 08:21:58 +0100 | [diff] [blame] | 473 | |
Bert Vermeulen | f38ec28 | 2012-01-20 22:25:42 +0100 | [diff] [blame] | 474 | if (g_hash_table_size(new_probes) == 0) |
Bert Vermeulen | 0bdadba | 2012-01-17 03:37:34 +0100 | [diff] [blame] | 475 | /* No probes provided. */ |
| 476 | return SRD_OK; |
| 477 | |
Uwe Hermann | c9bfccc | 2012-02-08 22:39:30 +0100 | [diff] [blame] | 478 | if (di->dec_num_probes == 0) { |
Bert Vermeulen | 0bdadba | 2012-01-17 03:37:34 +0100 | [diff] [blame] | 479 | /* Decoder has no probes. */ |
Bert Vermeulen | f38ec28 | 2012-01-20 22:25:42 +0100 | [diff] [blame] | 480 | srd_err("Protocol decoder %s has no probes to define.", |
Uwe Hermann | c9bfccc | 2012-02-08 22:39:30 +0100 | [diff] [blame] | 481 | di->decoder->name); |
Bert Vermeulen | f38ec28 | 2012-01-20 22:25:42 +0100 | [diff] [blame] | 482 | return SRD_ERR_ARG; |
Bert Vermeulen | 0bdadba | 2012-01-17 03:37:34 +0100 | [diff] [blame] | 483 | } |
| 484 | |
Bert Vermeulen | f38ec28 | 2012-01-20 22:25:42 +0100 | [diff] [blame] | 485 | new_probemap = NULL; |
Bert Vermeulen | 0bdadba | 2012-01-17 03:37:34 +0100 | [diff] [blame] | 486 | |
Bert Vermeulen | f38ec28 | 2012-01-20 22:25:42 +0100 | [diff] [blame] | 487 | if (!(new_probemap = g_try_malloc(sizeof(int) * di->dec_num_probes))) { |
Uwe Hermann | a61ece2 | 2012-02-10 00:06:58 +0100 | [diff] [blame] | 488 | srd_err("Failed to g_malloc() new probe map."); |
Bert Vermeulen | f38ec28 | 2012-01-20 22:25:42 +0100 | [diff] [blame] | 489 | return SRD_ERR_MALLOC; |
| 490 | } |
| 491 | |
Uwe Hermann | 38ff504 | 2013-02-02 12:18:29 +0100 | [diff] [blame] | 492 | /* |
| 493 | * For now, map all indexes to probe -1 (can be overridden later). |
| 494 | * This -1 is interpreted as an unspecified probe later. |
| 495 | */ |
| 496 | for (i = 0; i < di->dec_num_probes; i++) |
| 497 | new_probemap[i] = -1; |
| 498 | |
Bert Vermeulen | ed41649 | 2013-10-30 16:30:05 +0100 | [diff] [blame] | 499 | num_probes = 0; |
Bert Vermeulen | f38ec28 | 2012-01-20 22:25:42 +0100 | [diff] [blame] | 500 | for (l = g_hash_table_get_keys(new_probes); l; l = l->next) { |
| 501 | probe_id = l->data; |
Bert Vermeulen | 6907581 | 2013-10-30 15:22:10 +0100 | [diff] [blame] | 502 | probe_val = g_hash_table_lookup(new_probes, probe_id); |
Bert Vermeulen | 2f395bf | 2013-03-19 01:47:53 +0100 | [diff] [blame] | 503 | if (!g_variant_is_of_type(probe_val, G_VARIANT_TYPE_INT32)) { |
Bert Vermeulen | be87326 | 2012-01-23 19:34:23 +0100 | [diff] [blame] | 504 | /* Probe name was specified without a value. */ |
Uwe Hermann | c9bfccc | 2012-02-08 22:39:30 +0100 | [diff] [blame] | 505 | srd_err("No probe number was specified for %s.", |
Bert Vermeulen | 2f395bf | 2013-03-19 01:47:53 +0100 | [diff] [blame] | 506 | probe_id); |
Bert Vermeulen | be87326 | 2012-01-23 19:34:23 +0100 | [diff] [blame] | 507 | g_free(new_probemap); |
| 508 | return SRD_ERR_ARG; |
| 509 | } |
Bert Vermeulen | 2f395bf | 2013-03-19 01:47:53 +0100 | [diff] [blame] | 510 | new_probenum = g_variant_get_int32(probe_val); |
Bert Vermeulen | f38ec28 | 2012-01-20 22:25:42 +0100 | [diff] [blame] | 511 | if (!(sl = g_slist_find_custom(di->decoder->probes, probe_id, |
| 512 | (GCompareFunc)compare_probe_id))) { |
| 513 | /* Fall back on optional probes. */ |
Bert Vermeulen | dcdf488 | 2012-02-01 00:07:55 +0100 | [diff] [blame] | 514 | if (!(sl = g_slist_find_custom(di->decoder->opt_probes, |
Uwe Hermann | c9bfccc | 2012-02-08 22:39:30 +0100 | [diff] [blame] | 515 | probe_id, (GCompareFunc) compare_probe_id))) { |
| 516 | srd_err("Protocol decoder %s has no probe " |
Bert Vermeulen | 2f395bf | 2013-03-19 01:47:53 +0100 | [diff] [blame] | 517 | "'%s'.", di->decoder->name, probe_id); |
Bert Vermeulen | f38ec28 | 2012-01-20 22:25:42 +0100 | [diff] [blame] | 518 | g_free(new_probemap); |
| 519 | return SRD_ERR_ARG; |
| 520 | } |
| 521 | } |
| 522 | p = sl->data; |
| 523 | new_probemap[p->order] = new_probenum; |
Uwe Hermann | 38ff504 | 2013-02-02 12:18:29 +0100 | [diff] [blame] | 524 | srd_dbg("Setting probe mapping: %s (index %d) = probe %d.", |
| 525 | p->id, p->order, new_probenum); |
Bert Vermeulen | ed41649 | 2013-10-30 16:30:05 +0100 | [diff] [blame] | 526 | num_probes++; |
Bert Vermeulen | f38ec28 | 2012-01-20 22:25:42 +0100 | [diff] [blame] | 527 | } |
Bert Vermeulen | ed41649 | 2013-10-30 16:30:05 +0100 | [diff] [blame] | 528 | di->data_unitsize = (num_probes + 7) / 8; |
Uwe Hermann | 38ff504 | 2013-02-02 12:18:29 +0100 | [diff] [blame] | 529 | |
| 530 | srd_dbg("Final probe map:"); |
| 531 | num_required_probes = g_slist_length(di->decoder->probes); |
| 532 | for (i = 0; i < di->dec_num_probes; i++) { |
| 533 | srd_dbg(" - index %d = probe %d (%s)", i, new_probemap[i], |
| 534 | (i < num_required_probes) ? "required" : "optional"); |
| 535 | } |
| 536 | |
Bert Vermeulen | f38ec28 | 2012-01-20 22:25:42 +0100 | [diff] [blame] | 537 | g_free(di->dec_probemap); |
| 538 | di->dec_probemap = new_probemap; |
| 539 | |
| 540 | return SRD_OK; |
Bert Vermeulen | 0bdadba | 2012-01-17 03:37:34 +0100 | [diff] [blame] | 541 | } |
| 542 | |
| 543 | /** |
Bert Vermeulen | 7ce7775 | 2012-01-10 00:25:16 +0100 | [diff] [blame] | 544 | * Create a new protocol decoder instance. |
| 545 | * |
Bert Vermeulen | 32cfb92 | 2013-09-12 23:54:43 +0200 | [diff] [blame] | 546 | * @param sess The session holding the protocol decoder instance. |
Uwe Hermann | 38ff504 | 2013-02-02 12:18:29 +0100 | [diff] [blame] | 547 | * @param decoder_id Decoder 'id' field. |
Bert Vermeulen | 0bdadba | 2012-01-17 03:37:34 +0100 | [diff] [blame] | 548 | * @param options GHashtable of options which override the defaults set in |
Uwe Hermann | 38ff504 | 2013-02-02 12:18:29 +0100 | [diff] [blame] | 549 | * the decoder class. May be NULL. |
Bert Vermeulen | 12243c2 | 2012-02-12 14:18:32 +0100 | [diff] [blame] | 550 | * |
Bert Vermeulen | a8b72b0 | 2012-02-11 18:06:56 +0100 | [diff] [blame] | 551 | * @return Pointer to a newly allocated struct srd_decoder_inst, or |
Uwe Hermann | c9bfccc | 2012-02-08 22:39:30 +0100 | [diff] [blame] | 552 | * NULL in case of failure. |
Uwe Hermann | 8c664ca | 2013-05-03 14:45:49 +0200 | [diff] [blame] | 553 | * |
Bert Vermeulen | 6907581 | 2013-10-30 15:22:10 +0100 | [diff] [blame] | 554 | * @since 0.3.0 |
Bert Vermeulen | 7ce7775 | 2012-01-10 00:25:16 +0100 | [diff] [blame] | 555 | */ |
Bert Vermeulen | 32cfb92 | 2013-09-12 23:54:43 +0200 | [diff] [blame] | 556 | SRD_API struct srd_decoder_inst *srd_inst_new(struct srd_session *sess, |
| 557 | const char *decoder_id, GHashTable *options) |
Bert Vermeulen | b2c1961 | 2011-12-04 10:33:02 +0100 | [diff] [blame] | 558 | { |
Uwe Hermann | c9bfccc | 2012-02-08 22:39:30 +0100 | [diff] [blame] | 559 | int i; |
Bert Vermeulen | b2c1961 | 2011-12-04 10:33:02 +0100 | [diff] [blame] | 560 | struct srd_decoder *dec; |
Bert Vermeulen | a8b72b0 | 2012-02-11 18:06:56 +0100 | [diff] [blame] | 561 | struct srd_decoder_inst *di; |
| 562 | char *inst_id; |
Bert Vermeulen | b2c1961 | 2011-12-04 10:33:02 +0100 | [diff] [blame] | 563 | |
Uwe Hermann | 7a1712c | 2012-01-26 01:15:10 +0100 | [diff] [blame] | 564 | srd_dbg("Creating new %s instance.", decoder_id); |
Bert Vermeulen | 7ce7775 | 2012-01-10 00:25:16 +0100 | [diff] [blame] | 565 | |
Bert Vermeulen | 32cfb92 | 2013-09-12 23:54:43 +0200 | [diff] [blame] | 566 | if (session_is_valid(sess) != SRD_OK) { |
| 567 | srd_err("Invalid session."); |
| 568 | return NULL; |
| 569 | } |
| 570 | |
Bert Vermeulen | 9d122fd | 2012-02-14 03:43:28 +0100 | [diff] [blame] | 571 | if (!(dec = srd_decoder_get_by_id(decoder_id))) { |
Bert Vermeulen | 0bdadba | 2012-01-17 03:37:34 +0100 | [diff] [blame] | 572 | srd_err("Protocol decoder %s not found.", decoder_id); |
Bert Vermeulen | 7ce7775 | 2012-01-10 00:25:16 +0100 | [diff] [blame] | 573 | return NULL; |
| 574 | } |
Bert Vermeulen | 0bdadba | 2012-01-17 03:37:34 +0100 | [diff] [blame] | 575 | |
Bert Vermeulen | a8b72b0 | 2012-02-11 18:06:56 +0100 | [diff] [blame] | 576 | if (!(di = g_try_malloc0(sizeof(struct srd_decoder_inst)))) { |
Uwe Hermann | a61ece2 | 2012-02-10 00:06:58 +0100 | [diff] [blame] | 577 | srd_err("Failed to g_malloc() instance."); |
Bert Vermeulen | 0bdadba | 2012-01-17 03:37:34 +0100 | [diff] [blame] | 578 | return NULL; |
| 579 | } |
| 580 | |
Bert Vermeulen | b2c1961 | 2011-12-04 10:33:02 +0100 | [diff] [blame] | 581 | di->decoder = dec; |
Bert Vermeulen | 32cfb92 | 2013-09-12 23:54:43 +0200 | [diff] [blame] | 582 | di->sess = sess; |
Uwe Hermann | 38ff504 | 2013-02-02 12:18:29 +0100 | [diff] [blame] | 583 | if (options) { |
| 584 | inst_id = g_hash_table_lookup(options, "id"); |
| 585 | di->inst_id = g_strdup(inst_id ? inst_id : decoder_id); |
| 586 | g_hash_table_remove(options, "id"); |
| 587 | } else |
| 588 | di->inst_id = g_strdup(decoder_id); |
Bert Vermeulen | b2c1961 | 2011-12-04 10:33:02 +0100 | [diff] [blame] | 589 | |
Uwe Hermann | 361fdca | 2012-03-15 22:00:24 +0100 | [diff] [blame] | 590 | /* |
| 591 | * Prepare a default probe map, where samples come in the |
Bert Vermeulen | f38ec28 | 2012-01-20 22:25:42 +0100 | [diff] [blame] | 592 | * order in which the decoder class defined them. |
| 593 | */ |
| 594 | di->dec_num_probes = g_slist_length(di->decoder->probes) + |
Bert Vermeulen | 6907581 | 2013-10-30 15:22:10 +0100 | [diff] [blame] | 595 | g_slist_length(di->decoder->opt_probes); |
Bert Vermeulen | 19a90ba | 2012-01-21 19:45:04 +0100 | [diff] [blame] | 596 | if (di->dec_num_probes) { |
Uwe Hermann | c9bfccc | 2012-02-08 22:39:30 +0100 | [diff] [blame] | 597 | if (!(di->dec_probemap = |
Bert Vermeulen | 6907581 | 2013-10-30 15:22:10 +0100 | [diff] [blame] | 598 | g_try_malloc(sizeof(int) * di->dec_num_probes))) { |
Uwe Hermann | a61ece2 | 2012-02-10 00:06:58 +0100 | [diff] [blame] | 599 | srd_err("Failed to g_malloc() probe map."); |
Bert Vermeulen | 19a90ba | 2012-01-21 19:45:04 +0100 | [diff] [blame] | 600 | g_free(di); |
| 601 | return NULL; |
| 602 | } |
| 603 | for (i = 0; i < di->dec_num_probes; i++) |
| 604 | di->dec_probemap[i] = i; |
Bert Vermeulen | f38ec28 | 2012-01-20 22:25:42 +0100 | [diff] [blame] | 605 | } |
Bert Vermeulen | ed41649 | 2013-10-30 16:30:05 +0100 | [diff] [blame] | 606 | di->data_unitsize = (di->dec_num_probes + 7) / 8; |
Bert Vermeulen | f38ec28 | 2012-01-20 22:25:42 +0100 | [diff] [blame] | 607 | |
Bert Vermeulen | 0bdadba | 2012-01-17 03:37:34 +0100 | [diff] [blame] | 608 | /* Create a new instance of this decoder class. */ |
Bert Vermeulen | a8b72b0 | 2012-02-11 18:06:56 +0100 | [diff] [blame] | 609 | if (!(di->py_inst = PyObject_CallObject(dec->py_dec, NULL))) { |
Bert Vermeulen | b2c1961 | 2011-12-04 10:33:02 +0100 | [diff] [blame] | 610 | if (PyErr_Occurred()) |
Uwe Hermann | aafeeae | 2012-03-25 15:08:16 +0200 | [diff] [blame] | 611 | srd_exception_catch("failed to create %s instance: ", |
Bert Vermeulen | 6907581 | 2013-10-30 15:22:10 +0100 | [diff] [blame] | 612 | decoder_id); |
Bert Vermeulen | f38ec28 | 2012-01-20 22:25:42 +0100 | [diff] [blame] | 613 | g_free(di->dec_probemap); |
| 614 | g_free(di); |
| 615 | return NULL; |
| 616 | } |
| 617 | |
Uwe Hermann | 38ff504 | 2013-02-02 12:18:29 +0100 | [diff] [blame] | 618 | if (options && srd_inst_option_set(di, options) != SRD_OK) { |
Bert Vermeulen | f38ec28 | 2012-01-20 22:25:42 +0100 | [diff] [blame] | 619 | g_free(di->dec_probemap); |
Bert Vermeulen | 0bdadba | 2012-01-17 03:37:34 +0100 | [diff] [blame] | 620 | g_free(di); |
Bert Vermeulen | 7ce7775 | 2012-01-10 00:25:16 +0100 | [diff] [blame] | 621 | return NULL; |
Bert Vermeulen | b2c1961 | 2011-12-04 10:33:02 +0100 | [diff] [blame] | 622 | } |
Bert Vermeulen | 7ce7775 | 2012-01-10 00:25:16 +0100 | [diff] [blame] | 623 | |
| 624 | /* Instance takes input from a frontend by default. */ |
Bert Vermeulen | 32cfb92 | 2013-09-12 23:54:43 +0200 | [diff] [blame] | 625 | sess->di_list = g_slist_append(sess->di_list, di); |
Bert Vermeulen | b2c1961 | 2011-12-04 10:33:02 +0100 | [diff] [blame] | 626 | |
Bert Vermeulen | b2c1961 | 2011-12-04 10:33:02 +0100 | [diff] [blame] | 627 | return di; |
| 628 | } |
| 629 | |
Bert Vermeulen | 582c847 | 2012-02-12 14:55:20 +0100 | [diff] [blame] | 630 | /** |
| 631 | * Stack a decoder instance on top of another. |
| 632 | * |
Bert Vermeulen | 32cfb92 | 2013-09-12 23:54:43 +0200 | [diff] [blame] | 633 | * @param sess The session holding the protocol decoder instances. |
Bert Vermeulen | 582c847 | 2012-02-12 14:55:20 +0100 | [diff] [blame] | 634 | * @param di_from The instance to move. |
| 635 | * @param di_to The instance on top of which di_from will be stacked. |
| 636 | * |
| 637 | * @return SRD_OK upon success, a (negative) error code otherwise. |
Uwe Hermann | 8c664ca | 2013-05-03 14:45:49 +0200 | [diff] [blame] | 638 | * |
Bert Vermeulen | 6907581 | 2013-10-30 15:22:10 +0100 | [diff] [blame] | 639 | * @since 0.3.0 |
Bert Vermeulen | 582c847 | 2012-02-12 14:55:20 +0100 | [diff] [blame] | 640 | */ |
Bert Vermeulen | 32cfb92 | 2013-09-12 23:54:43 +0200 | [diff] [blame] | 641 | SRD_API int srd_inst_stack(struct srd_session *sess, |
| 642 | struct srd_decoder_inst *di_from, struct srd_decoder_inst *di_to) |
Bert Vermeulen | 7ce7775 | 2012-01-10 00:25:16 +0100 | [diff] [blame] | 643 | { |
Bert Vermeulen | 32cfb92 | 2013-09-12 23:54:43 +0200 | [diff] [blame] | 644 | |
| 645 | if (session_is_valid(sess) != SRD_OK) { |
| 646 | srd_err("Invalid session."); |
| 647 | return SRD_ERR_ARG; |
| 648 | } |
| 649 | |
Bert Vermeulen | 7ce7775 | 2012-01-10 00:25:16 +0100 | [diff] [blame] | 650 | if (!di_from || !di_to) { |
Bert Vermeulen | d906d3f | 2012-01-22 02:51:49 +0100 | [diff] [blame] | 651 | srd_err("Invalid from/to instance pair."); |
Bert Vermeulen | 7ce7775 | 2012-01-10 00:25:16 +0100 | [diff] [blame] | 652 | return SRD_ERR_ARG; |
| 653 | } |
| 654 | |
Bert Vermeulen | 32cfb92 | 2013-09-12 23:54:43 +0200 | [diff] [blame] | 655 | if (g_slist_find(sess->di_list, di_to)) { |
Bert Vermeulen | 2072ae0 | 2012-01-25 01:49:35 +0100 | [diff] [blame] | 656 | /* Remove from the unstacked list. */ |
Bert Vermeulen | 32cfb92 | 2013-09-12 23:54:43 +0200 | [diff] [blame] | 657 | sess->di_list = g_slist_remove(sess->di_list, di_to); |
Bert Vermeulen | 7ce7775 | 2012-01-10 00:25:16 +0100 | [diff] [blame] | 658 | } |
| 659 | |
Bert Vermeulen | 7ce7775 | 2012-01-10 00:25:16 +0100 | [diff] [blame] | 660 | /* Stack on top of source di. */ |
| 661 | di_from->next_di = g_slist_append(di_from->next_di, di_to); |
| 662 | |
| 663 | return SRD_OK; |
| 664 | } |
| 665 | |
Bert Vermeulen | 2072ae0 | 2012-01-25 01:49:35 +0100 | [diff] [blame] | 666 | /** |
Uwe Hermann | 361fdca | 2012-03-15 22:00:24 +0100 | [diff] [blame] | 667 | * Find a decoder instance by its instance ID. |
| 668 | * |
| 669 | * Only the bottom level of instances are searched -- instances already stacked |
| 670 | * on top of another one will not be found. |
Bert Vermeulen | 2072ae0 | 2012-01-25 01:49:35 +0100 | [diff] [blame] | 671 | * |
Bert Vermeulen | 32cfb92 | 2013-09-12 23:54:43 +0200 | [diff] [blame] | 672 | * @param sess The session holding the protocol decoder instance. |
Uwe Hermann | ed2306a | 2012-03-18 14:16:50 +0100 | [diff] [blame] | 673 | * @param inst_id The instance ID to be found. |
Bert Vermeulen | 2072ae0 | 2012-01-25 01:49:35 +0100 | [diff] [blame] | 674 | * |
Bert Vermeulen | a8b72b0 | 2012-02-11 18:06:56 +0100 | [diff] [blame] | 675 | * @return Pointer to struct srd_decoder_inst, or NULL if not found. |
Uwe Hermann | 8c664ca | 2013-05-03 14:45:49 +0200 | [diff] [blame] | 676 | * |
Bert Vermeulen | 6907581 | 2013-10-30 15:22:10 +0100 | [diff] [blame] | 677 | * @since 0.3.0 |
Bert Vermeulen | 2072ae0 | 2012-01-25 01:49:35 +0100 | [diff] [blame] | 678 | */ |
Bert Vermeulen | 32cfb92 | 2013-09-12 23:54:43 +0200 | [diff] [blame] | 679 | SRD_API struct srd_decoder_inst *srd_inst_find_by_id(struct srd_session *sess, |
| 680 | const char *inst_id) |
Bert Vermeulen | b2c1961 | 2011-12-04 10:33:02 +0100 | [diff] [blame] | 681 | { |
Bert Vermeulen | 7ce7775 | 2012-01-10 00:25:16 +0100 | [diff] [blame] | 682 | GSList *l; |
Bert Vermeulen | a8b72b0 | 2012-02-11 18:06:56 +0100 | [diff] [blame] | 683 | struct srd_decoder_inst *tmp, *di; |
Bert Vermeulen | b2c1961 | 2011-12-04 10:33:02 +0100 | [diff] [blame] | 684 | |
Bert Vermeulen | 32cfb92 | 2013-09-12 23:54:43 +0200 | [diff] [blame] | 685 | if (session_is_valid(sess) != SRD_OK) { |
| 686 | srd_err("Invalid session."); |
| 687 | return NULL; |
| 688 | } |
| 689 | |
Bert Vermeulen | 7ce7775 | 2012-01-10 00:25:16 +0100 | [diff] [blame] | 690 | di = NULL; |
Bert Vermeulen | 32cfb92 | 2013-09-12 23:54:43 +0200 | [diff] [blame] | 691 | for (l = sess->di_list; l; l = l->next) { |
Bert Vermeulen | 7ce7775 | 2012-01-10 00:25:16 +0100 | [diff] [blame] | 692 | tmp = l->data; |
Bert Vermeulen | a8b72b0 | 2012-02-11 18:06:56 +0100 | [diff] [blame] | 693 | if (!strcmp(tmp->inst_id, inst_id)) { |
Bert Vermeulen | 7ce7775 | 2012-01-10 00:25:16 +0100 | [diff] [blame] | 694 | di = tmp; |
| 695 | break; |
Bert Vermeulen | b2c1961 | 2011-12-04 10:33:02 +0100 | [diff] [blame] | 696 | } |
Bert Vermeulen | b2c1961 | 2011-12-04 10:33:02 +0100 | [diff] [blame] | 697 | } |
| 698 | |
Bert Vermeulen | 7ce7775 | 2012-01-10 00:25:16 +0100 | [diff] [blame] | 699 | return di; |
| 700 | } |
| 701 | |
Bert Vermeulen | 32cfb92 | 2013-09-12 23:54:43 +0200 | [diff] [blame] | 702 | static struct srd_decoder_inst *srd_sess_inst_find_by_obj( |
| 703 | struct srd_session *sess, const GSList *stack, |
| 704 | const PyObject *obj) |
| 705 | { |
| 706 | const GSList *l; |
| 707 | struct srd_decoder_inst *tmp, *di; |
| 708 | |
| 709 | if (session_is_valid(sess) != SRD_OK) { |
| 710 | srd_err("Invalid session."); |
| 711 | return NULL; |
| 712 | } |
| 713 | |
| 714 | di = NULL; |
| 715 | for (l = stack ? stack : sess->di_list; di == NULL && l != NULL; l = l->next) { |
| 716 | tmp = l->data; |
| 717 | if (tmp->py_inst == obj) |
| 718 | di = tmp; |
| 719 | else if (tmp->next_di) |
| 720 | di = srd_sess_inst_find_by_obj(sess, tmp->next_di, obj); |
| 721 | } |
| 722 | |
| 723 | return di; |
| 724 | } |
| 725 | |
Bert Vermeulen | 2072ae0 | 2012-01-25 01:49:35 +0100 | [diff] [blame] | 726 | /** |
Uwe Hermann | 361fdca | 2012-03-15 22:00:24 +0100 | [diff] [blame] | 727 | * Find a decoder instance by its Python object. |
Bert Vermeulen | 2072ae0 | 2012-01-25 01:49:35 +0100 | [diff] [blame] | 728 | * |
Uwe Hermann | 361fdca | 2012-03-15 22:00:24 +0100 | [diff] [blame] | 729 | * I.e. find that instance's instantiation of the sigrokdecode.Decoder class. |
Bert Vermeulen | 32cfb92 | 2013-09-12 23:54:43 +0200 | [diff] [blame] | 730 | * This will recurse to find the instance anywhere in the stack tree of all |
| 731 | * sessions. |
Uwe Hermann | 361fdca | 2012-03-15 22:00:24 +0100 | [diff] [blame] | 732 | * |
| 733 | * @param stack Pointer to a GSList of struct srd_decoder_inst, indicating the |
| 734 | * stack to search. To start searching at the bottom level of |
| 735 | * decoder instances, pass NULL. |
Uwe Hermann | 511e212 | 2012-02-10 09:29:38 +0100 | [diff] [blame] | 736 | * @param obj The Python class instantiation. |
Bert Vermeulen | 2072ae0 | 2012-01-25 01:49:35 +0100 | [diff] [blame] | 737 | * |
Bert Vermeulen | a8b72b0 | 2012-02-11 18:06:56 +0100 | [diff] [blame] | 738 | * @return Pointer to struct srd_decoder_inst, or NULL if not found. |
Uwe Hermann | 57790bc | 2013-02-09 21:44:11 +0100 | [diff] [blame] | 739 | * |
| 740 | * @private |
Uwe Hermann | 8c664ca | 2013-05-03 14:45:49 +0200 | [diff] [blame] | 741 | * |
| 742 | * @since 0.1.0 |
Bert Vermeulen | 2072ae0 | 2012-01-25 01:49:35 +0100 | [diff] [blame] | 743 | */ |
Uwe Hermann | abeeed8 | 2012-03-16 15:12:54 +0100 | [diff] [blame] | 744 | SRD_PRIV struct srd_decoder_inst *srd_inst_find_by_obj(const GSList *stack, |
Bert Vermeulen | 0ff2d19 | 2013-03-19 01:01:25 +0100 | [diff] [blame] | 745 | const PyObject *obj) |
Bert Vermeulen | 2072ae0 | 2012-01-25 01:49:35 +0100 | [diff] [blame] | 746 | { |
Bert Vermeulen | 32cfb92 | 2013-09-12 23:54:43 +0200 | [diff] [blame] | 747 | struct srd_decoder_inst *di; |
| 748 | struct srd_session *sess; |
| 749 | GSList *l; |
Bert Vermeulen | 2072ae0 | 2012-01-25 01:49:35 +0100 | [diff] [blame] | 750 | |
| 751 | di = NULL; |
Bert Vermeulen | 32cfb92 | 2013-09-12 23:54:43 +0200 | [diff] [blame] | 752 | for (l = sessions; di == NULL && l != NULL; l = l->next) { |
| 753 | sess = l->data; |
| 754 | di = srd_sess_inst_find_by_obj(sess, stack, obj); |
Bert Vermeulen | 2072ae0 | 2012-01-25 01:49:35 +0100 | [diff] [blame] | 755 | } |
| 756 | |
| 757 | return di; |
| 758 | } |
| 759 | |
Uwe Hermann | 57790bc | 2013-02-09 21:44:11 +0100 | [diff] [blame] | 760 | /** @private */ |
Bert Vermeulen | ed41649 | 2013-10-30 16:30:05 +0100 | [diff] [blame] | 761 | SRD_PRIV int srd_inst_start(struct srd_decoder_inst *di) |
Bert Vermeulen | 7ce7775 | 2012-01-10 00:25:16 +0100 | [diff] [blame] | 762 | { |
Bert Vermeulen | ed41649 | 2013-10-30 16:30:05 +0100 | [diff] [blame] | 763 | PyObject *py_res; |
Bert Vermeulen | 2072ae0 | 2012-01-25 01:49:35 +0100 | [diff] [blame] | 764 | GSList *l; |
Bert Vermeulen | a8b72b0 | 2012-02-11 18:06:56 +0100 | [diff] [blame] | 765 | struct srd_decoder_inst *next_di; |
Bert Vermeulen | ed41649 | 2013-10-30 16:30:05 +0100 | [diff] [blame] | 766 | int ret; |
Bert Vermeulen | 7ce7775 | 2012-01-10 00:25:16 +0100 | [diff] [blame] | 767 | |
Uwe Hermann | 7a1712c | 2012-01-26 01:15:10 +0100 | [diff] [blame] | 768 | srd_dbg("Calling start() method on protocol decoder instance %s.", |
Bert Vermeulen | ed41649 | 2013-10-30 16:30:05 +0100 | [diff] [blame] | 769 | di->inst_id); |
Bert Vermeulen | 7ce7775 | 2012-01-10 00:25:16 +0100 | [diff] [blame] | 770 | |
Bert Vermeulen | ed41649 | 2013-10-30 16:30:05 +0100 | [diff] [blame] | 771 | if (!(py_res = PyObject_CallMethod(di->py_inst, "start", NULL))) { |
Uwe Hermann | aafeeae | 2012-03-25 15:08:16 +0200 | [diff] [blame] | 772 | srd_exception_catch("Protocol decoder instance %s: ", |
Bert Vermeulen | ed41649 | 2013-10-30 16:30:05 +0100 | [diff] [blame] | 773 | di->inst_id); |
Bert Vermeulen | 7ce7775 | 2012-01-10 00:25:16 +0100 | [diff] [blame] | 774 | return SRD_ERR_PYTHON; |
| 775 | } |
Bert Vermeulen | f38ec28 | 2012-01-20 22:25:42 +0100 | [diff] [blame] | 776 | Py_DecRef(py_res); |
Bert Vermeulen | 7ce7775 | 2012-01-10 00:25:16 +0100 | [diff] [blame] | 777 | |
Bert Vermeulen | ed41649 | 2013-10-30 16:30:05 +0100 | [diff] [blame] | 778 | /* Start all the PDs stacked on top of this one. */ |
Bert Vermeulen | 2072ae0 | 2012-01-25 01:49:35 +0100 | [diff] [blame] | 779 | for (l = di->next_di; l; l = l->next) { |
| 780 | next_di = l->data; |
Bert Vermeulen | ed41649 | 2013-10-30 16:30:05 +0100 | [diff] [blame] | 781 | if ((ret = srd_inst_start(next_di)) != SRD_OK) |
| 782 | return ret; |
Bert Vermeulen | 2072ae0 | 2012-01-25 01:49:35 +0100 | [diff] [blame] | 783 | } |
| 784 | |
Bert Vermeulen | b2c1961 | 2011-12-04 10:33:02 +0100 | [diff] [blame] | 785 | return SRD_OK; |
| 786 | } |
| 787 | |
Bert Vermeulen | b2c1961 | 2011-12-04 10:33:02 +0100 | [diff] [blame] | 788 | /** |
| 789 | * Run the specified decoder function. |
| 790 | * |
Bert Vermeulen | ed41649 | 2013-10-30 16:30:05 +0100 | [diff] [blame] | 791 | * @param di The decoder instance to call. Must not be NULL. |
Bert Vermeulen | d906d3f | 2012-01-22 02:51:49 +0100 | [diff] [blame] | 792 | * @param start_samplenum The starting sample number for the buffer's sample |
Uwe Hermann | 7a1712c | 2012-01-26 01:15:10 +0100 | [diff] [blame] | 793 | * set, relative to the start of capture. |
Bert Vermeulen | ed41649 | 2013-10-30 16:30:05 +0100 | [diff] [blame] | 794 | * @param end_samplenum The ending sample number for the buffer's sample |
| 795 | * set, relative to the start of capture. |
Uwe Hermann | 7a1712c | 2012-01-26 01:15:10 +0100 | [diff] [blame] | 796 | * @param inbuf The buffer to decode. Must not be NULL. |
| 797 | * @param inbuflen Length of the buffer. Must be > 0. |
Bert Vermeulen | b2c1961 | 2011-12-04 10:33:02 +0100 | [diff] [blame] | 798 | * |
| 799 | * @return SRD_OK upon success, a (negative) error code otherwise. |
Uwe Hermann | 57790bc | 2013-02-09 21:44:11 +0100 | [diff] [blame] | 800 | * |
| 801 | * @private |
Uwe Hermann | 8c664ca | 2013-05-03 14:45:49 +0200 | [diff] [blame] | 802 | * |
| 803 | * @since 0.1.0 |
Bert Vermeulen | b2c1961 | 2011-12-04 10:33:02 +0100 | [diff] [blame] | 804 | */ |
Bert Vermeulen | ed41649 | 2013-10-30 16:30:05 +0100 | [diff] [blame] | 805 | SRD_PRIV int srd_inst_decode(const struct srd_decoder_inst *di, |
| 806 | uint64_t start_samplenum, uint64_t end_samplenum, |
| 807 | const uint8_t *inbuf, uint64_t inbuflen) |
Bert Vermeulen | b2c1961 | 2011-12-04 10:33:02 +0100 | [diff] [blame] | 808 | { |
Bert Vermeulen | d906d3f | 2012-01-22 02:51:49 +0100 | [diff] [blame] | 809 | PyObject *py_res; |
Bert Vermeulen | bc5f5a4 | 2012-01-05 03:31:36 +0100 | [diff] [blame] | 810 | srd_logic *logic; |
Bert Vermeulen | b2c1961 | 2011-12-04 10:33:02 +0100 | [diff] [blame] | 811 | |
Uwe Hermann | 74bb0af | 2013-10-20 23:09:46 +0200 | [diff] [blame] | 812 | srd_dbg("Calling decode() on instance %s with %" PRIu64 " bytes " |
| 813 | "starting at sample %" PRIu64 ".", di->inst_id, inbuflen, |
| 814 | start_samplenum); |
Bert Vermeulen | d906d3f | 2012-01-22 02:51:49 +0100 | [diff] [blame] | 815 | |
Bert Vermeulen | b2c1961 | 2011-12-04 10:33:02 +0100 | [diff] [blame] | 816 | /* Return an error upon unusable input. */ |
Uwe Hermann | 7a1712c | 2012-01-26 01:15:10 +0100 | [diff] [blame] | 817 | if (!di) { |
| 818 | srd_dbg("empty decoder instance"); |
Bert Vermeulen | d906d3f | 2012-01-22 02:51:49 +0100 | [diff] [blame] | 819 | return SRD_ERR_ARG; |
| 820 | } |
Uwe Hermann | 7a1712c | 2012-01-26 01:15:10 +0100 | [diff] [blame] | 821 | if (!inbuf) { |
| 822 | srd_dbg("NULL buffer pointer"); |
Bert Vermeulen | d906d3f | 2012-01-22 02:51:49 +0100 | [diff] [blame] | 823 | return SRD_ERR_ARG; |
| 824 | } |
| 825 | if (inbuflen == 0) { |
Uwe Hermann | 7a1712c | 2012-01-26 01:15:10 +0100 | [diff] [blame] | 826 | srd_dbg("empty buffer"); |
Bert Vermeulen | d906d3f | 2012-01-22 02:51:49 +0100 | [diff] [blame] | 827 | return SRD_ERR_ARG; |
| 828 | } |
Bert Vermeulen | b2c1961 | 2011-12-04 10:33:02 +0100 | [diff] [blame] | 829 | |
Uwe Hermann | 361fdca | 2012-03-15 22:00:24 +0100 | [diff] [blame] | 830 | /* |
| 831 | * Create new srd_logic object. Each iteration around the PD's loop |
Bert Vermeulen | d906d3f | 2012-01-22 02:51:49 +0100 | [diff] [blame] | 832 | * will fill one sample into this object. |
| 833 | */ |
Bert Vermeulen | bc5f5a4 | 2012-01-05 03:31:36 +0100 | [diff] [blame] | 834 | logic = PyObject_New(srd_logic, &srd_logic_type); |
| 835 | Py_INCREF(logic); |
Uwe Hermann | abeeed8 | 2012-03-16 15:12:54 +0100 | [diff] [blame] | 836 | logic->di = (struct srd_decoder_inst *)di; |
Bert Vermeulen | 8652829 | 2012-01-15 23:20:39 +0100 | [diff] [blame] | 837 | logic->start_samplenum = start_samplenum; |
Bert Vermeulen | bc5f5a4 | 2012-01-05 03:31:36 +0100 | [diff] [blame] | 838 | logic->itercnt = 0; |
Uwe Hermann | abeeed8 | 2012-03-16 15:12:54 +0100 | [diff] [blame] | 839 | logic->inbuf = (uint8_t *)inbuf; |
Bert Vermeulen | bc5f5a4 | 2012-01-05 03:31:36 +0100 | [diff] [blame] | 840 | logic->inbuflen = inbuflen; |
| 841 | logic->sample = PyList_New(2); |
| 842 | Py_INCREF(logic->sample); |
| 843 | |
Bert Vermeulen | a8b72b0 | 2012-02-11 18:06:56 +0100 | [diff] [blame] | 844 | Py_IncRef(di->py_inst); |
Bert Vermeulen | a8b72b0 | 2012-02-11 18:06:56 +0100 | [diff] [blame] | 845 | if (!(py_res = PyObject_CallMethod(di->py_inst, "decode", |
Bert Vermeulen | ed41649 | 2013-10-30 16:30:05 +0100 | [diff] [blame] | 846 | "KKO", start_samplenum, end_samplenum, logic))) { |
| 847 | srd_exception_catch("Protocol decoder instance %s: ", di->inst_id); |
Bert Vermeulen | 0ff2d19 | 2013-03-19 01:01:25 +0100 | [diff] [blame] | 848 | return SRD_ERR_PYTHON; |
Bert Vermeulen | b2c1961 | 2011-12-04 10:33:02 +0100 | [diff] [blame] | 849 | } |
Bert Vermeulen | d906d3f | 2012-01-22 02:51:49 +0100 | [diff] [blame] | 850 | Py_DecRef(py_res); |
Bert Vermeulen | bc5f5a4 | 2012-01-05 03:31:36 +0100 | [diff] [blame] | 851 | |
Bert Vermeulen | b2c1961 | 2011-12-04 10:33:02 +0100 | [diff] [blame] | 852 | return SRD_OK; |
| 853 | } |
| 854 | |
Uwe Hermann | 57790bc | 2013-02-09 21:44:11 +0100 | [diff] [blame] | 855 | /** @private */ |
Bert Vermeulen | 12243c2 | 2012-02-12 14:18:32 +0100 | [diff] [blame] | 856 | SRD_PRIV void srd_inst_free(struct srd_decoder_inst *di) |
Bert Vermeulen | fa12a21 | 2012-01-31 23:48:10 +0100 | [diff] [blame] | 857 | { |
| 858 | GSList *l; |
| 859 | struct srd_pd_output *pdo; |
| 860 | |
Bert Vermeulen | a8b72b0 | 2012-02-11 18:06:56 +0100 | [diff] [blame] | 861 | srd_dbg("Freeing instance %s", di->inst_id); |
Bert Vermeulen | fa12a21 | 2012-01-31 23:48:10 +0100 | [diff] [blame] | 862 | |
Bert Vermeulen | a8b72b0 | 2012-02-11 18:06:56 +0100 | [diff] [blame] | 863 | Py_DecRef(di->py_inst); |
| 864 | g_free(di->inst_id); |
Bert Vermeulen | fa12a21 | 2012-01-31 23:48:10 +0100 | [diff] [blame] | 865 | g_free(di->dec_probemap); |
| 866 | g_slist_free(di->next_di); |
| 867 | for (l = di->pd_output; l; l = l->next) { |
| 868 | pdo = l->data; |
| 869 | g_free(pdo->proto_id); |
| 870 | g_free(pdo); |
| 871 | } |
| 872 | g_slist_free(di->pd_output); |
Bert Vermeulen | e592ac8 | 2013-05-05 17:20:13 +0200 | [diff] [blame] | 873 | g_free(di); |
Bert Vermeulen | fa12a21 | 2012-01-31 23:48:10 +0100 | [diff] [blame] | 874 | } |
| 875 | |
Uwe Hermann | 57790bc | 2013-02-09 21:44:11 +0100 | [diff] [blame] | 876 | /** @private */ |
Bert Vermeulen | 32cfb92 | 2013-09-12 23:54:43 +0200 | [diff] [blame] | 877 | SRD_PRIV void srd_inst_free_all(struct srd_session *sess, GSList *stack) |
Bert Vermeulen | fa12a21 | 2012-01-31 23:48:10 +0100 | [diff] [blame] | 878 | { |
| 879 | GSList *l; |
Bert Vermeulen | a8b72b0 | 2012-02-11 18:06:56 +0100 | [diff] [blame] | 880 | struct srd_decoder_inst *di; |
Bert Vermeulen | fa12a21 | 2012-01-31 23:48:10 +0100 | [diff] [blame] | 881 | |
Bert Vermeulen | 32cfb92 | 2013-09-12 23:54:43 +0200 | [diff] [blame] | 882 | if (session_is_valid(sess) != SRD_OK) { |
| 883 | srd_err("Invalid session."); |
| 884 | return; |
| 885 | } |
| 886 | |
Bert Vermeulen | fa12a21 | 2012-01-31 23:48:10 +0100 | [diff] [blame] | 887 | di = NULL; |
Bert Vermeulen | 32cfb92 | 2013-09-12 23:54:43 +0200 | [diff] [blame] | 888 | for (l = stack ? stack : sess->di_list; di == NULL && l != NULL; l = l->next) { |
Bert Vermeulen | fa12a21 | 2012-01-31 23:48:10 +0100 | [diff] [blame] | 889 | di = l->data; |
| 890 | if (di->next_di) |
Bert Vermeulen | 32cfb92 | 2013-09-12 23:54:43 +0200 | [diff] [blame] | 891 | srd_inst_free_all(sess, di->next_di); |
Bert Vermeulen | a8b72b0 | 2012-02-11 18:06:56 +0100 | [diff] [blame] | 892 | srd_inst_free(di); |
Bert Vermeulen | fa12a21 | 2012-01-31 23:48:10 +0100 | [diff] [blame] | 893 | } |
| 894 | if (!stack) { |
Bert Vermeulen | 32cfb92 | 2013-09-12 23:54:43 +0200 | [diff] [blame] | 895 | g_slist_free(sess->di_list); |
| 896 | sess->di_list = NULL; |
Bert Vermeulen | fa12a21 | 2012-01-31 23:48:10 +0100 | [diff] [blame] | 897 | } |
Bert Vermeulen | fa12a21 | 2012-01-31 23:48:10 +0100 | [diff] [blame] | 898 | } |
Bert Vermeulen | b2c1961 | 2011-12-04 10:33:02 +0100 | [diff] [blame] | 899 | |
Uwe Hermann | 4895418 | 2013-02-09 22:25:15 +0100 | [diff] [blame] | 900 | /** @} */ |
| 901 | |