src/output/srzip.c

   1 /*
   2  * This file is part of the libsigrok project.
   3  *
   4  * Copyright (C) 2014 Bert Vermeulen <bert@biot.com>
   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 <config.h>
  21 #include <stdlib.h>
  22 #include <string.h>
  23 #include <errno.h>
  24 #include <glib.h>
  25 #include <glib/gstdio.h>
  26 #include <zip.h>
  27 #include <libsigrok/libsigrok.h>
  28 #include "libsigrok-internal.h"
  29
  30 #define LOG_PREFIX "output/srzip"
  31
  32 struct out_context {
  33         gboolean zip_created;
  34         uint64_t samplerate;
  35         char *filename;
  36         gint first_analog_index;
  37         gint *analog_index_map;
  38 };
  39
  40 static int init(struct sr_output *o, GHashTable *options)
  41 {
  42         struct out_context *outc;
  43
  44         (void)options;
  45
  46         if (!o->filename || o->filename[0] == '\0') {
  47                 sr_info("srzip output module requires a file name, cannot save.");
  48                 return SR_ERR_ARG;
  49         }
  50
  51         outc = g_malloc0(sizeof(struct out_context));
  52         outc->filename = g_strdup(o->filename);
  53         o->priv = outc;
  54
  55         return SR_OK;
  56 }
  57
  58 static int zip_create(const struct sr_output *o)
  59 {
  60         struct out_context *outc;
  61         struct zip *zipfile;
  62         struct zip_source *versrc, *metasrc;
  63         struct sr_channel *ch;
  64         GVariant *gvar;
  65         GKeyFile *meta;
  66         GSList *l;
  67         const char *devgroup;
  68         char *s, *metabuf;
  69         gsize metalen;
  70         guint logic_channels = 0, enabled_logic_channels = 0;
  71         guint enabled_analog_channels = 0;
  72         guint index;
  73
  74         outc = o->priv;
  75
  76         if (outc->samplerate == 0 && sr_config_get(o->sdi->driver, o->sdi, NULL,
  77                                         SR_CONF_SAMPLERATE, &gvar) == SR_OK) {
  78                 outc->samplerate = g_variant_get_uint64(gvar);
  79                 g_variant_unref(gvar);
  80         }
  81
  82         /* Quietly delete it first, libzip wants replace ops otherwise. */
  83         g_unlink(outc->filename);
  84         zipfile = zip_open(outc->filename, ZIP_CREATE, NULL);
  85         if (!zipfile)
  86                 return SR_ERR;
  87
  88         /* "version" */
  89         versrc = zip_source_buffer(zipfile, "2", 1, FALSE);
  90         if (zip_add(zipfile, "version", versrc) < 0) {
  91                 sr_err("Error saving version into zipfile: %s",
  92                         zip_strerror(zipfile));
  93                 zip_source_free(versrc);
  94                 zip_discard(zipfile);
  95                 return SR_ERR;
  96         }
  97
  98         /* init "metadata" */
  99         meta = g_key_file_new();
 100
 101         g_key_file_set_string(meta, "global", "sigrok version",
 102                         SR_PACKAGE_VERSION_STRING);
 103
 104         devgroup = "device 1";
 105
 106         for (l = o->sdi->channels; l; l = l->next) {
 107                 ch = l->data;
 108
 109                 switch (ch->type) {
 110                 case SR_CHANNEL_LOGIC:
 111                         if (ch->enabled)
 112                                 enabled_logic_channels++;
 113                         logic_channels++;
 114                         break;
 115                 case SR_CHANNEL_ANALOG:
 116                         if (ch->enabled)
 117                                 enabled_analog_channels++;
 118                         break;
 119                 }
 120         }
 121
 122         /* When reading the file, the first index of the analog channels
 123          * can only be deduced through the "total probes" count, so the
 124          * first analog index must follow the last logic one, enabled or not. */
 125         if (enabled_logic_channels > 0)
 126                 outc->first_analog_index = logic_channels + 1;
 127         else
 128                 outc->first_analog_index = 1;
 129
 130         /* Only set capturefile and probes if we will actually save logic data. */
 131         if (enabled_logic_channels > 0) {
 132                 g_key_file_set_string(meta, devgroup, "capturefile", "logic-1");
 133                 g_key_file_set_integer(meta, devgroup, "total probes", logic_channels);
 134         }
 135
 136         s = sr_samplerate_string(outc->samplerate);
 137         g_key_file_set_string(meta, devgroup, "samplerate", s);
 138         g_free(s);
 139
 140         g_key_file_set_integer(meta, devgroup, "total analog", enabled_analog_channels);
 141
 142         /* Make the array one entry larger than needed so we can use the final
 143          * entry as terminator, which is set to -1. */
 144         outc->analog_index_map = g_malloc0(sizeof(gint) * (enabled_analog_channels + 1));
 145         outc->analog_index_map[enabled_analog_channels] = -1;
 146
 147         index = 0;
 148         for (l = o->sdi->channels; l; l = l->next) {
 149                 ch = l->data;
 150                 if (!ch->enabled)
 151                         continue;
 152
 153                 switch (ch->type) {
 154                 case SR_CHANNEL_LOGIC:
 155                         s = g_strdup_printf("probe%d", ch->index + 1);
 156                         break;
 157                 case SR_CHANNEL_ANALOG:
 158                         outc->analog_index_map[index] = ch->index;
 159                         s = g_strdup_printf("analog%d", outc->first_analog_index + index);
 160                         index++;
 161                         break;
 162                 }
 163                 g_key_file_set_string(meta, devgroup, s, ch->name);
 164                 g_free(s);
 165         }
 166
 167         metabuf = g_key_file_to_data(meta, &metalen, NULL);
 168         g_key_file_free(meta);
 169
 170         metasrc = zip_source_buffer(zipfile, metabuf, metalen, FALSE);
 171         if (zip_add(zipfile, "metadata", metasrc) < 0) {
 172                 sr_err("Error saving metadata into zipfile: %s",
 173                         zip_strerror(zipfile));
 174                 zip_source_free(metasrc);
 175                 zip_discard(zipfile);
 176                 g_free(metabuf);
 177                 return SR_ERR;
 178         }
 179
 180         if (zip_close(zipfile) < 0) {
 181                 sr_err("Error saving zipfile: %s", zip_strerror(zipfile));
 182                 zip_discard(zipfile);
 183                 g_free(metabuf);
 184                 return SR_ERR;
 185         }
 186         g_free(metabuf);
 187
 188         return SR_OK;
 189 }
 190
 191 static int zip_append(const struct sr_output *o, unsigned char *buf,
 192                 int unitsize, int length)
 193 {
 194         struct out_context *outc;
 195         struct zip *archive;
 196         struct zip_source *logicsrc;
 197         int64_t i, num_files;
 198         struct zip_stat zs;
 199         struct zip_source *metasrc;
 200         GKeyFile *kf;
 201         GError *error;
 202         uint64_t chunk_num;
 203         const char *entry_name;
 204         char *metabuf;
 205         gsize metalen;
 206         char *chunkname;
 207         unsigned int next_chunk_num;
 208
 209         outc = o->priv;
 210         if (!(archive = zip_open(outc->filename, 0, NULL)))
 211                 return SR_ERR;
 212
 213         if (zip_stat(archive, "metadata", 0, &zs) < 0) {
 214                 sr_err("Failed to open metadata: %s", zip_strerror(archive));
 215                 zip_discard(archive);
 216                 return SR_ERR;
 217         }
 218         kf = sr_sessionfile_read_metadata(archive, &zs);
 219         if (!kf) {
 220                 zip_discard(archive);
 221                 return SR_ERR_DATA;
 222         }
 223         /*
 224          * If the file was only initialized but doesn't yet have any
 225          * data it in, it won't have a unitsize field in metadata yet.
 226          */
 227         error = NULL;
 228         metabuf = NULL;
 229         if (!g_key_file_has_key(kf, "device 1", "unitsize", &error)) {
 230                 if (error && error->code != G_KEY_FILE_ERROR_KEY_NOT_FOUND) {
 231                         sr_err("Failed to check unitsize key: %s", error->message);
 232                         g_error_free(error);
 233                         g_key_file_free(kf);
 234                         zip_discard(archive);
 235                         return SR_ERR;
 236                 }
 237                 g_clear_error(&error);
 238
 239                 /* Add unitsize field. */
 240                 g_key_file_set_integer(kf, "device 1", "unitsize", unitsize);
 241                 metabuf = g_key_file_to_data(kf, &metalen, NULL);
 242                 metasrc = zip_source_buffer(archive, metabuf, metalen, FALSE);
 243
 244                 if (zip_replace(archive, zs.index, metasrc) < 0) {
 245                         sr_err("Failed to replace metadata: %s",
 246                                 zip_strerror(archive));
 247                         g_key_file_free(kf);
 248                         zip_source_free(metasrc);
 249                         zip_discard(archive);
 250                         g_free(metabuf);
 251                         return SR_ERR;
 252                 }
 253         }
 254         g_key_file_free(kf);
 255
 256         next_chunk_num = 1;
 257         num_files = zip_get_num_entries(archive, 0);
 258         for (i = 0; i < num_files; i++) {
 259                 entry_name = zip_get_name(archive, i, 0);
 260                 if (!entry_name || strncmp(entry_name, "logic-1", 7) != 0)
 261                         continue;
 262                 if (entry_name[7] == '\0') {
 263                         /*
 264                          * This file has no extra chunks, just a single
 265                          * "logic-1". Rename it to "logic-1-1" and continue
 266                          * with chunk 2.
 267                          */
 268                         if (zip_rename(archive, i, "logic-1-1") < 0) {
 269                                 sr_err("Failed to rename 'logic-1' to 'logic-1-1': %s",
 270                                         zip_strerror(archive));
 271                                 zip_discard(archive);
 272                                 g_free(metabuf);
 273                                 return SR_ERR;
 274                         }
 275                         next_chunk_num = 2;
 276                         break;
 277                 } else if (entry_name[7] == '-') {
 278                         chunk_num = g_ascii_strtoull(entry_name + 8, NULL, 10);
 279                         if (chunk_num < G_MAXINT && chunk_num >= next_chunk_num)
 280                                 next_chunk_num = chunk_num + 1;
 281                 }
 282         }
 283
 284         if (length % unitsize != 0) {
 285                 sr_warn("Chunk size %d not a multiple of the"
 286                         " unit size %d.", length, unitsize);
 287         }
 288         logicsrc = zip_source_buffer(archive, buf, length, FALSE);
 289         chunkname = g_strdup_printf("logic-1-%u", next_chunk_num);
 290         i = zip_add(archive, chunkname, logicsrc);
 291         g_free(chunkname);
 292         if (i < 0) {
 293                 sr_err("Failed to add chunk 'logic-1-%u': %s",
 294                         next_chunk_num, zip_strerror(archive));
 295                 zip_source_free(logicsrc);
 296                 zip_discard(archive);
 297                 g_free(metabuf);
 298                 return SR_ERR;
 299         }
 300         if (zip_close(archive) < 0) {
 301                 sr_err("Error saving session file: %s", zip_strerror(archive));
 302                 zip_discard(archive);
 303                 g_free(metabuf);
 304                 return SR_ERR;
 305         }
 306         g_free(metabuf);
 307
 308         return SR_OK;
 309 }
 310
 311 static int zip_append_analog(const struct sr_output *o,
 312                 const struct sr_datafeed_analog *analog)
 313 {
 314         struct out_context *outc;
 315         struct zip *archive;
 316         struct zip_source *analogsrc;
 317         int64_t i, num_files;
 318         struct zip_stat zs;
 319         uint64_t chunk_num;
 320         const char *entry_name;
 321         char *basename;
 322         gsize baselen;
 323         struct sr_channel *channel;
 324         float *chunkbuf;
 325         gsize chunksize;
 326         char *chunkname;
 327         unsigned int next_chunk_num, index;
 328
 329         outc = o->priv;
 330
 331         /* TODO: support packets covering multiple channels */
 332         if (g_slist_length(analog->meaning->channels) != 1) {
 333                 sr_err("Analog packets covering multiple channels not supported yet");
 334                 return SR_ERR;
 335         }
 336         channel = analog->meaning->channels->data;
 337
 338         /* When reading the file, analog channels must be consecutive.
 339          * Thus we need a global channel index map as we don't know in
 340          * which order the channel data comes in. */
 341         for (index = 0; outc->analog_index_map[index] != -1; index++)
 342                 if (outc->analog_index_map[index] == channel->index)
 343                         break;
 344         if (outc->analog_index_map[index] == -1)
 345                 return SR_ERR_ARG; /* Channel index was not in the list */
 346
 347         index += outc->first_analog_index;
 348
 349         if (!(archive = zip_open(outc->filename, 0, NULL)))
 350                 return SR_ERR;
 351
 352         if (zip_stat(archive, "metadata", 0, &zs) < 0) {
 353                 sr_err("Failed to open metadata: %s", zip_strerror(archive));
 354                 goto err_zip_discard;
 355         }
 356
 357         basename = g_strdup_printf("analog-1-%u", index);
 358         baselen = strlen(basename);
 359         next_chunk_num = 1;
 360         num_files = zip_get_num_entries(archive, 0);
 361         for (i = 0; i < num_files; i++) {
 362                 entry_name = zip_get_name(archive, i, 0);
 363                 if (!entry_name || strncmp(entry_name, basename, baselen) != 0) {
 364                         continue;
 365                 } else if (entry_name[baselen] == '-') {
 366                         chunk_num = g_ascii_strtoull(entry_name + baselen + 1, NULL, 10);
 367                         if (chunk_num < G_MAXINT && chunk_num >= next_chunk_num)
 368                                 next_chunk_num = chunk_num + 1;
 369                 }
 370         }
 371
 372         chunksize = sizeof(float) * analog->num_samples;
 373         if (!(chunkbuf = g_try_malloc(chunksize)))
 374                 goto err_free_basename;
 375
 376         if (sr_analog_to_float(analog, chunkbuf) != SR_OK)
 377                 goto err_free_chunkbuf;
 378
 379         analogsrc = zip_source_buffer(archive, chunkbuf, chunksize, FALSE);
 380         chunkname = g_strdup_printf("%s-%u", basename, next_chunk_num);
 381         i = zip_add(archive, chunkname, analogsrc);
 382         g_free(chunkname);
 383         if (i < 0) {
 384                 sr_err("Failed to add chunk '%s': %s", chunkname, zip_strerror(archive));
 385                 zip_source_free(analogsrc);
 386                 goto err_free_chunkbuf;
 387         }
 388         if (zip_close(archive) < 0) {
 389                 sr_err("Error saving session file: %s", zip_strerror(archive));
 390                 goto err_free_chunkbuf;
 391         }
 392
 393         g_free(basename);
 394         g_free(chunkbuf);
 395
 396         return SR_OK;
 397
 398 err_free_chunkbuf:
 399         g_free(chunkbuf);
 400 err_free_basename:
 401         g_free(basename);
 402 err_zip_discard:
 403         zip_discard(archive);
 404
 405         return SR_ERR;
 406 }
 407
 408 static int receive(const struct sr_output *o, const struct sr_datafeed_packet *packet,
 409                 GString **out)
 410 {
 411         struct out_context *outc;
 412         const struct sr_datafeed_meta *meta;
 413         const struct sr_datafeed_logic *logic;
 414         const struct sr_datafeed_analog *analog;
 415         const struct sr_config *src;
 416         GSList *l;
 417
 418         int ret;
 419
 420         *out = NULL;
 421         if (!o || !o->sdi || !(outc = o->priv))
 422                 return SR_ERR_ARG;
 423
 424         switch (packet->type) {
 425         case SR_DF_META:
 426                 meta = packet->payload;
 427                 for (l = meta->config; l; l = l->next) {
 428                         src = l->data;
 429                         if (src->key != SR_CONF_SAMPLERATE)
 430                                 continue;
 431                         outc->samplerate = g_variant_get_uint64(src->data);
 432                 }
 433                 break;
 434         case SR_DF_LOGIC:
 435                 if (!outc->zip_created) {
 436                         if ((ret = zip_create(o)) != SR_OK)
 437                                 return ret;
 438                         outc->zip_created = TRUE;
 439                 }
 440                 logic = packet->payload;
 441                 ret = zip_append(o, logic->data, logic->unitsize, logic->length);
 442                 if (ret != SR_OK)
 443                         return ret;
 444                 break;
 445         case SR_DF_ANALOG:
 446                 if (!outc->zip_created) {
 447                         if ((ret = zip_create(o)) != SR_OK)
 448                                 return ret;
 449                         outc->zip_created = TRUE;
 450                 }
 451                 analog = packet->payload;
 452                 ret = zip_append_analog(o, analog);
 453                 if (ret != SR_OK)
 454                         return ret;
 455                 break;
 456         }
 457
 458         return SR_OK;
 459 }
 460
 461 static struct sr_option options[] = {
 462         ALL_ZERO
 463 };
 464
 465 static const struct sr_option *get_options(void)
 466 {
 467         if (!options[0].def)
 468                 options[0].def = g_variant_ref_sink(g_variant_new_string(""));
 469
 470         return options;
 471 }
 472
 473 static int cleanup(struct sr_output *o)
 474 {
 475         struct out_context *outc;
 476
 477         outc = o->priv;
 478         g_variant_unref(options[0].def);
 479         g_free(outc->analog_index_map);
 480         g_free(outc->filename);
 481         g_free(outc);
 482         o->priv = NULL;
 483
 484         return SR_OK;
 485 }
 486
 487 SR_PRIV struct sr_output_module output_srzip = {
 488         .id = "srzip",
 489         .name = "srzip",
 490         .desc = "srzip session file",
 491         .exts = (const char*[]){"sr", NULL},
 492         .flags = SR_OUTPUT_INTERNAL_IO_HANDLING,
 493         .options = get_options,
 494         .init = init,
 495         .receive = receive,
 496         .cleanup = cleanup,
 497 };