libhb/hb_dict.c

   1 /* hb_dict.c
   2
   3    Copyright (c) 2003-2015 HandBrake Team
   4    This file is part of the HandBrake source code
   5    Homepage: <http://handbrake.fr/>.
   6    It may be used under the terms of the GNU General Public License v2.
   7    For full terms see the file COPYING file or visit http://www.gnu.org/licenses/gpl-2.0.html
   8  */
   9
  10 #include <stdio.h>
  11 #include "hb.h"
  12 #include "hb_dict.h"
  13
  14 hb_value_type_t hb_value_type(const hb_value_t *value)
  15 {
  16    if (value == NULL)
  17         return HB_VALUE_TYPE_NULL;
  18     hb_value_type_t type = json_typeof(value);
  19     if (type == JSON_TRUE || type == JSON_FALSE)
  20         return HB_VALUE_TYPE_BOOL;
  21     return type;
  22 }
  23
  24 int hb_value_is_number(const hb_value_t *value)
  25 {
  26     return json_is_number(value);
  27 }
  28
  29 hb_value_t * hb_value_dup(const hb_value_t *value)
  30 {
  31     if (value == NULL) return NULL;
  32     return json_deep_copy(value);
  33 }
  34
  35 hb_value_t* hb_value_incref(hb_value_t *value)
  36 {
  37     return json_incref(value);
  38 }
  39
  40 void hb_value_decref(hb_value_t *value)
  41 {
  42     if (value == NULL) return;
  43     json_decref(value);
  44 }
  45
  46 void hb_value_free(hb_value_t **_value)
  47 {
  48     hb_value_decref(*_value);
  49     *_value = NULL;
  50 }
  51
  52 hb_value_t * hb_value_string(const char * value)
  53 {
  54     // json_string does not create a value for NULL strings.
  55     // So create JSON_NULL in this case
  56     if (value == NULL)
  57         return json_null();
  58     return json_string(value);
  59 }
  60
  61 hb_value_t * hb_value_int(json_int_t value)
  62 {
  63     return json_integer(value);
  64 }
  65
  66 hb_value_t * hb_value_double(double value)
  67 {
  68     return json_real(value);
  69 }
  70
  71 hb_value_t * hb_value_bool(int value)
  72 {
  73     return json_boolean(value);
  74 }
  75
  76 hb_value_t * hb_value_json(const char *json)
  77 {
  78     json_error_t error;
  79     hb_value_t *val = json_loads(json, 0, &error);
  80     if (val == NULL)
  81     {
  82         hb_error("hb_value_json: Failed, error %s", error.text);
  83     }
  84     return val;
  85 }
  86
  87 hb_value_t * hb_value_read_json(const char *path)
  88 {
  89     json_error_t error;
  90     hb_value_t *val = json_load_file(path, 0, &error);
  91     return val;
  92 }
  93
  94 static hb_value_t* xform_null(hb_value_type_t type)
  95 {
  96     switch (type)
  97     {
  98         default:
  99         case HB_VALUE_TYPE_NULL:
 100             return json_null();
 101         case HB_VALUE_TYPE_BOOL:
 102             return json_false();
 103         case HB_VALUE_TYPE_INT:
 104             return json_integer(0);
 105         case HB_VALUE_TYPE_DOUBLE:
 106             return json_real(0.0);
 107         case HB_VALUE_TYPE_STRING:
 108             return json_null();
 109     }
 110 }
 111
 112 static hb_value_t* xform_bool(const hb_value_t *value, hb_value_type_t type)
 113 {
 114     json_int_t b = json_is_true(value);
 115     switch (type)
 116     {
 117         default:
 118         case HB_VALUE_TYPE_NULL:
 119             return json_null();
 120         case HB_VALUE_TYPE_BOOL:
 121             return json_boolean(b);
 122         case HB_VALUE_TYPE_INT:
 123             return json_integer(b);
 124         case HB_VALUE_TYPE_DOUBLE:
 125             return json_real(b);
 126         case HB_VALUE_TYPE_STRING:
 127         {
 128             char *s = hb_strdup_printf("%"JSON_INTEGER_FORMAT, b);
 129             hb_value_t *v = json_string(s);
 130             free(s);
 131             return v;
 132         }
 133     }
 134 }
 135
 136 static hb_value_t* xform_int(const hb_value_t *value, hb_value_type_t type)
 137 {
 138     json_int_t i = json_integer_value(value);
 139     switch (type)
 140     {
 141         default:
 142         case HB_VALUE_TYPE_NULL:
 143             return json_null();
 144         case HB_VALUE_TYPE_BOOL:
 145             return json_boolean(i);
 146         case HB_VALUE_TYPE_INT:
 147             return json_integer(i);
 148         case HB_VALUE_TYPE_DOUBLE:
 149             return json_real(i);
 150         case HB_VALUE_TYPE_STRING:
 151         {
 152             char *s = hb_strdup_printf("%"JSON_INTEGER_FORMAT, i);
 153             hb_value_t *v = json_string(s);
 154             free(s);
 155             return v;
 156         }
 157     }
 158 }
 159
 160 static hb_value_t* xform_double(const hb_value_t *value, hb_value_type_t type)
 161 {
 162     double d = json_real_value(value);
 163     switch (type)
 164     {
 165         default:
 166         case HB_VALUE_TYPE_NULL:
 167             return json_null();
 168         case HB_VALUE_TYPE_BOOL:
 169             return json_boolean((int)d != 0);
 170         case HB_VALUE_TYPE_INT:
 171             return json_integer(d);
 172         case HB_VALUE_TYPE_DOUBLE:
 173             return json_real(d);
 174         case HB_VALUE_TYPE_STRING:
 175         {
 176             char *s = hb_strdup_printf("%g", d);
 177             hb_value_t *v = json_string(s);
 178             free(s);
 179             return v;
 180         }
 181     }
 182 }
 183
 184 static hb_value_t* xform_string(const hb_value_t *value, hb_value_type_t type)
 185 {
 186     const char *s = json_string_value(value);
 187     switch (type)
 188     {
 189         default:
 190         case HB_VALUE_TYPE_NULL:
 191         {
 192             return json_null();
 193         }
 194         case HB_VALUE_TYPE_BOOL:
 195         {
 196             if (!strcasecmp(s, "true") ||
 197                 !strcasecmp(s, "yes")  ||
 198                 !strcasecmp(s, "1"))
 199             {
 200                 return json_true();
 201             }
 202             return json_false();
 203         }
 204         case HB_VALUE_TYPE_INT:
 205         {
 206             return json_integer(strtoll(s, NULL, 0));
 207         }
 208         case HB_VALUE_TYPE_DOUBLE:
 209         {
 210             return json_real(strtod(s, NULL));
 211         }
 212         case HB_VALUE_TYPE_STRING:
 213         {
 214             return json_string(s);
 215         }
 216     }
 217 }
 218
 219 static hb_value_t* xform_array(const hb_value_t *value, hb_value_type_t type)
 220 {
 221     hb_value_t *first = NULL;
 222     int count = hb_value_array_len(value);
 223
 224     if (count > 0)
 225         first = hb_value_array_get(value, 0);
 226     switch (type)
 227     {
 228         default:
 229         case HB_VALUE_TYPE_NULL:
 230         case HB_VALUE_TYPE_BOOL:
 231         case HB_VALUE_TYPE_INT:
 232         case HB_VALUE_TYPE_DOUBLE:
 233             return hb_value_xform(first, type);
 234         case HB_VALUE_TYPE_STRING:
 235         {
 236             char *r = strdup("");
 237             int ii;
 238             for (ii = 0; ii < count; ii++)
 239             {
 240                 hb_value_t *v = hb_value_array_get(value, ii);
 241                 hb_value_t *x = hb_value_xform(v, type);
 242                 const char *s = hb_value_get_string(x);
 243                 if (s != NULL)
 244                 {
 245                     char *tmp = r;
 246                     r = hb_strdup_printf("%s%s,", tmp, s);
 247                     free(tmp);
 248                 }
 249                 hb_value_free(&x);
 250             }
 251             int len = strlen(r);
 252             hb_value_t *v;
 253             if (len > 0)
 254             {
 255                 // Removing trailing ','
 256                 r[len - 1] = 0;
 257                 v = json_string(r);
 258             }
 259             else
 260             {
 261                 free(r);
 262                 r = NULL;
 263                 v = json_null();
 264             }
 265             free(r);
 266             return v;
 267         }
 268     }
 269 }
 270
 271 static hb_value_t* xform_dict(const hb_value_t *dict, hb_value_type_t type)
 272 {
 273     hb_value_t *first = NULL;
 274     hb_dict_iter_t iter = hb_dict_iter_init(dict);
 275
 276     if (iter != HB_DICT_ITER_DONE)
 277         first = hb_dict_iter_value(iter);
 278
 279     switch (type)
 280     {
 281         default:
 282         case HB_VALUE_TYPE_NULL:
 283         case HB_VALUE_TYPE_BOOL:
 284         case HB_VALUE_TYPE_INT:
 285         case HB_VALUE_TYPE_DOUBLE:
 286             return hb_value_xform(first, type);
 287         case HB_VALUE_TYPE_STRING:
 288         {
 289             char *r = strdup("");
 290             hb_dict_iter_t iter;
 291             for (iter  = hb_dict_iter_init(dict);
 292                  iter != HB_DICT_ITER_DONE;
 293                  iter  = hb_dict_iter_next(dict, iter))
 294             {
 295                 const char *k = hb_dict_iter_key(iter);
 296                 hb_value_t *v = hb_dict_iter_value(iter);
 297                 hb_value_t *x = hb_value_xform(v, type);
 298                 const char *s = hb_value_get_string(x);
 299
 300                 char *tmp = r;
 301                 r = hb_strdup_printf("%s%s%s%s:",
 302                                      r,
 303                                      k,
 304                                      s  ? "=" : "",
 305                                      s  ? s   : "");
 306                 free(tmp);
 307                 hb_value_free(&x);
 308             }
 309             int len = strlen(r);
 310             hb_value_t *v;
 311             if (len > 0)
 312             {
 313                 // Removing trailing ':'
 314                 r[len - 1] = 0;
 315                 v = json_string(r);
 316             }
 317             else
 318             {
 319                 free(r);
 320                 r = NULL;
 321                 v = json_null();
 322             }
 323             free(r);
 324             return v;
 325         }
 326     }
 327 }
 328
 329 hb_value_t* hb_value_xform(const hb_value_t *value, hb_value_type_t type)
 330 {
 331     hb_value_type_t src_type = hb_value_type(value);
 332     if (src_type == type && value != NULL)
 333     {
 334         json_incref((hb_value_t*)value);
 335         return (hb_value_t*)value;
 336     }
 337     switch (src_type)
 338     {
 339         default:
 340         case HB_VALUE_TYPE_NULL:
 341         {
 342             return xform_null(type);
 343         }
 344         case HB_VALUE_TYPE_BOOL:
 345         {
 346             return xform_bool(value, type);
 347         }
 348         case HB_VALUE_TYPE_INT:
 349         {
 350             return xform_int(value, type);
 351         }
 352         case HB_VALUE_TYPE_DOUBLE:
 353         {
 354             return xform_double(value, type);
 355         }
 356         case HB_VALUE_TYPE_STRING:
 357         {
 358             return xform_string(value, type);
 359         }
 360         case HB_VALUE_TYPE_ARRAY:
 361         {
 362             return xform_array(value, type);
 363         }
 364         case HB_VALUE_TYPE_DICT:
 365         {
 366             return xform_dict(value, type);
 367         }
 368     }
 369 }
 370
 371 const char * hb_value_get_string(const hb_value_t *value)
 372 {
 373     if (hb_value_type(value) != HB_VALUE_TYPE_STRING) return NULL;
 374     return json_string_value(value);
 375 }
 376
 377 json_int_t hb_value_get_int(const hb_value_t *value)
 378 {
 379     json_int_t result;
 380     hb_value_t *v = hb_value_xform(value, HB_VALUE_TYPE_INT);
 381     result = json_integer_value(v);
 382     json_decref(v);
 383     return result;
 384 }
 385
 386 double hb_value_get_double(const hb_value_t *value)
 387 {
 388     double result;
 389     hb_value_t *v = hb_value_xform(value, HB_VALUE_TYPE_DOUBLE);
 390     result = json_real_value(v);
 391     json_decref(v);
 392     return result;
 393 }
 394
 395 int hb_value_get_bool(const hb_value_t *value)
 396 {
 397     int result;
 398     hb_value_t *v = hb_value_xform(value, HB_VALUE_TYPE_BOOL);
 399     result = json_is_true(v);
 400     json_decref(v);
 401     return result;
 402 }
 403
 404 char*
 405 hb_value_get_string_xform(const hb_value_t *value)
 406 {
 407     char *result;
 408     if (hb_value_type(value) == HB_VALUE_TYPE_NULL)
 409         return NULL;
 410     hb_value_t *v = hb_value_xform(value, HB_VALUE_TYPE_STRING);
 411     if (hb_value_type(v) == HB_VALUE_TYPE_NULL)
 412         return NULL;
 413     result = strdup(json_string_value(v));
 414     json_decref(v);
 415     return result;
 416 }
 417
 418 char * hb_value_get_json(const hb_value_t *value)
 419 {
 420     return json_dumps(value, JSON_INDENT(4) | JSON_SORT_KEYS);
 421 }
 422
 423 int  hb_value_write_file_json(hb_value_t *value, FILE *file)
 424 {
 425     return json_dumpf(value, file, JSON_INDENT(4) | JSON_SORT_KEYS);
 426 }
 427
 428 int  hb_value_write_json(hb_value_t *value, const char *path)
 429 {
 430     return json_dump_file(value, path, JSON_INDENT(4) | JSON_SORT_KEYS);
 431 }
 432
 433 void hb_dict_free(hb_dict_t **_dict)
 434 {
 435     hb_value_free(_dict);
 436 }
 437
 438 hb_dict_t * hb_dict_init()
 439 {
 440     return json_object();
 441 }
 442
 443 void hb_dict_set(hb_dict_t * dict, const char *key, hb_value_t *value)
 444 {
 445     json_object_set_new(dict, key, value);
 446 }
 447
 448 int hb_dict_remove(hb_dict_t * dict, const char * key)
 449 {
 450     return json_object_del(dict, key) == 0;
 451 }
 452
 453 hb_value_t * hb_dict_get(const hb_dict_t * dict, const char * key)
 454 {
 455     return json_object_get(dict, key);
 456 }
 457
 458 hb_dict_iter_t hb_dict_iter_init(const hb_dict_t *dict)
 459 {
 460     if (dict == NULL)
 461         return HB_DICT_ITER_DONE;
 462     return json_object_iter((hb_dict_t*)dict);
 463 }
 464
 465 hb_dict_iter_t hb_dict_iter_next(const hb_dict_t *dict, hb_dict_iter_t iter)
 466 {
 467     return json_object_iter_next((hb_dict_t*)dict, iter);
 468 }
 469
 470 const char * hb_dict_iter_key(const hb_dict_iter_t iter)
 471 {
 472     return json_object_iter_key(iter);
 473 }
 474
 475 hb_value_t * hb_dict_iter_value(const hb_dict_iter_t iter)
 476 {
 477     return json_object_iter_value(iter);
 478 }
 479
 480 int
 481 hb_dict_iter_next_ex(const hb_dict_t *dict, hb_dict_iter_t *iter,
 482                      const char **key, hb_value_t **val)
 483 {
 484     if (*iter == NULL)
 485         return 0;
 486     if (key != NULL)
 487         *key = json_object_iter_key(*iter);
 488     if (val != NULL)
 489         *val = json_object_iter_value(*iter);
 490     *iter = json_object_iter_next((hb_dict_t*)dict, *iter);
 491     return 1;
 492 }
 493
 494 hb_value_array_t*
 495 hb_value_array_init()
 496 {
 497     return json_array();
 498 }
 499
 500 void
 501 hb_value_array_clear(hb_value_array_t *array)
 502 {
 503     json_array_clear(array);
 504 }
 505
 506 hb_value_t*
 507 hb_value_array_get(const hb_value_array_t *array, int index)
 508 {
 509     return json_array_get(array, index);
 510 }
 511
 512 void
 513 hb_value_array_set(hb_value_array_t *array, int index, hb_value_t *value)
 514 {
 515     if (index < 0 || index >= json_array_size(array))
 516     {
 517         hb_error("hb_value_array_set: invalid index %d size %zu",
 518                  index, json_array_size(array));
 519         return;
 520     }
 521     json_array_set_new(array, index, value);
 522 }
 523
 524 void
 525 hb_value_array_insert(hb_value_array_t *array, int index, hb_value_t *value)
 526 {
 527     json_array_insert_new(array, index, value);
 528 }
 529
 530 void
 531 hb_value_array_append(hb_value_array_t *array, hb_value_t *value)
 532 {
 533     json_array_append_new(array, value);
 534 }
 535
 536 void
 537 hb_value_array_remove(hb_value_array_t *array, int index)
 538 {
 539     json_array_remove(array, index);
 540 }
 541
 542 void
 543 hb_value_array_copy(hb_value_array_t *dst,
 544                     const hb_value_array_t *src, int count)
 545 {
 546     size_t len;
 547     int ii;
 548
 549     // empty the first array if it is not already empty
 550     json_array_clear(dst);
 551
 552     len = hb_value_array_len(src);
 553     count = MIN(count, len);
 554     for (ii = 0; ii < count; ii++)
 555         hb_value_array_append(dst, hb_value_dup(hb_value_array_get(src, ii)));
 556 }
 557
 558 size_t
 559 hb_value_array_len(const hb_value_array_t *array)
 560 {
 561     return json_array_size(array);
 562 }
 563
 564 hb_dict_t * hb_encopts_to_dict(const char * encopts, int encoder)
 565 {
 566     hb_dict_t * dict = NULL;
 567
 568     if (encopts && *encopts)
 569     {
 570         char *cur_opt, *opts_start, *value;
 571         const char *name;
 572         dict = hb_dict_init();
 573         if( !dict )
 574             return NULL;
 575         cur_opt = opts_start = strdup(encopts);
 576         if (opts_start)
 577         {
 578             while (*cur_opt)
 579             {
 580                 name = cur_opt;
 581                 cur_opt += strcspn(cur_opt, ":");
 582                 if (*cur_opt)
 583                 {
 584                     *cur_opt = 0;
 585                     cur_opt++;
 586                 }
 587                 value = strchr(name, '=');
 588                 if (value)
 589                 {
 590                     *value = 0;
 591                     value++;
 592                 }
 593                 // x264 has multiple names for some options
 594                 if (encoder == HB_VCODEC_X264)
 595                     name = hb_x264_encopt_name(name);
 596 #ifdef USE_X265
 597                 // x265 has multiple names for some options
 598                 if (encoder == HB_VCODEC_X265)
 599                     name = hb_x265_encopt_name(name);
 600 #endif
 601                 if (name != NULL)
 602                 {
 603                     hb_dict_set(dict, name, hb_value_string(value));
 604                 }
 605             }
 606         }
 607         free(opts_start);
 608     }
 609     return dict;
 610 }
 611
 612 char * hb_dict_to_encopts(const hb_dict_t * dict)
 613 {
 614     return hb_value_get_string_xform(dict);
 615 }