src/lua/exec_subtitle_script_parse.c

   1 /* libquvi
   2  * Copyright (C) 2013  Toni Gundogdu <legatvs@gmail.com>
   3  *
   4  * This file is part of libquvi <http://quvi.sourceforge.net/>.
   5  *
   6  * This library is free software: you can redistribute it and/or
   7  * modify it under the terms of the GNU Affero General Public
   8  * License as published by the Free Software Foundation, either
   9  * version 3 of the License, or (at your option) any later version.
  10  *
  11  * This library 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 Affero General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Affero General
  17  * Public License along with this library.  If not, see
  18  * <http://www.gnu.org/licenses/>.
  19  */
  20
  21 /*
  22  * NOTE: The error messages produced in these functions are intended for
  23  *       developers. They would typically be seen when a new script is
  24  *       being developed or an old one is being maintained.
  25  *
  26  *       These messages should be clear, indicating the actual error,
  27  *       minimizing the time spent on locating the problem in the script.
  28  */
  29
  30 #include "config.h"
  31
  32 #include <lauxlib.h>
  33 #include <glib.h>
  34
  35 #include "quvi.h"
  36 /* -- */
  37 #include "_quvi_s.h"
  38 #include "_quvi_subtitle_s.h"
  39 #include "_quvi_script_s.h"
  40 /* -- */
  41 #include "misc/subtitle.h"
  42 #include "lua/setfield.h"
  43 #include "lua/chk.h"
  44 #include "lua/def.h"
  45
  46 static const gchar script_func[] = "parse";
  47
  48 /* Verify that the language has an ID (if there are >1 languages). */
  49 static void _chk_lang_id(lua_State *l, _quvi_subtitle_type_t qst,
  50                          _quvi_subtitle_lang_t qsl, const gchar *script_path,
  51                          const gint i)
  52 {
  53   if (g_slist_length(qst->languages) <2)
  54     return;
  55
  56   if (qsl->id->len ==0)
  57     {
  58       g_warning("%s: %s: `qargs.%s[%d].%s' should not be empty; "
  59                 "each language should have an ID when there are >1 languages",
  60                 script_path, script_func, SUS_SUBTITLES, i, SUSSL_ID);
  61     }
  62 }
  63
  64 typedef void (*foreach_cb)(lua_State*, _quvi_subtitle_type_t,
  65                            const gchar*, const gint);
  66
  67 /* Process a "sublevel" of a dictionary, e.g. qargs.subtitles.lang */
  68 static void _chk_subtitle_sublevel(lua_State *l, const gchar *level,
  69                                    _quvi_subtitle_type_t qst,
  70                                    const gchar *script_path,
  71                                    const foreach_cb cb, const gint i)
  72 {
  73   if (lua_isstring(l, LI_KEY) && lua_istable(l, LI_VALUE))
  74     {
  75       if (g_strcmp0(lua_tostring(l, LI_KEY), level) ==0)
  76         cb(l, qst, script_path, i);
  77     }
  78 }
  79
  80 /* Return a new language handle. */
  81 static gpointer _subtitle_lang_new(_quvi_subtitle_type_t qst)
  82 {
  83   _quvi_subtitle_lang_t qsl = g_new0(struct _quvi_subtitle_lang_s, 1);
  84   /* Handle. */
  85   qsl->handle.quvi = qst->handle.quvi;
  86   /* Strings. */
  87   qsl->translated = g_string_new(NULL);
  88   qsl->original = g_string_new(NULL);
  89   qsl->code = g_string_new(NULL);
  90   qsl->url = g_string_new(NULL);
  91   qsl->id = g_string_new(NULL);
  92   /* double */
  93   qsl->format = qst->format;
  94   return (qsl);
  95 }
  96
  97 /* Return a new data handle. */
  98 static gpointer _subtitle_type_new(const _quvi_subtitle_t qsub)
  99 {
 100   _quvi_subtitle_type_t qst = g_new0(struct _quvi_subtitle_type_s, 1);
 101   /* Handle. */
 102   qst->handle.quvi = qsub->handle.quvi;
 103   /* double. */
 104   qst->format = -1;
 105   qst->type = -1;
 106   return (qst);
 107 }
 108
 109 /* Must have at least one language URL. */
 110 static _quvi_subtitle_lang_t _chk_url(lua_State *l, const gchar *script_path,
 111                                       _quvi_subtitle_lang_t qsl, gint i)
 112 {
 113   if (qsl->url->len ==0)
 114     {
 115       m_subtitle_lang_free(qsl);
 116
 117       luaL_error(l, "%s: %s: must return `qargs.%s[%d].%s[1].%s'",
 118                  script_path, script_func, SUS_SUBTITLES, i,
 119                  SUSS_LANG, SUSSL_URL);
 120     }
 121   return (qsl);
 122 }
 123
 124 /* Return a new lang handle. */
 125 static _quvi_subtitle_lang_t _new_lang(lua_State *l, const gchar *script_path,
 126                                        const _quvi_subtitle_type_t qst,
 127                                        const gint i)
 128 {
 129   _quvi_subtitle_lang_t qsl = _subtitle_lang_new(qst);
 130   lua_pushnil(l);
 131   while (lua_next(l, LI_KEY))
 132     {
 133       l_chk_assign_s(l, SUSSL_TRANSLATED, qsl->translated, TRUE);
 134       l_chk_assign_s(l, SUSSL_ORIGINAL, qsl->original, TRUE);
 135       l_chk_assign_s(l, SUSSL_CODE, qsl->code, TRUE);
 136       l_chk_assign_s(l, SUSSL_URL, qsl->url, TRUE);
 137       l_chk_assign_s(l, SUSSL_ID, qsl->id, TRUE);
 138       lua_pop(l, 1);
 139     }
 140   return (_chk_url(l, script_path, qsl, i));
 141 }
 142
 143 /* For each qargs.subtitles.lang property. */
 144 static void _foreach_lang_property(lua_State *l, _quvi_subtitle_type_t qst,
 145                                    const gchar *script_path, const gint i)
 146 {
 147   _quvi_subtitle_lang_t qsl;
 148   gint j;
 149
 150   lua_pushnil(l);
 151   j = 0;
 152
 153   while (lua_next(l, LI_KEY))
 154     {
 155       if (lua_istable(l, LI_VALUE))
 156         {
 157           qsl = _new_lang(l, script_path, qst, ++j);
 158           _chk_lang_id(l, qst, qsl, script_path, j);
 159           qst->languages = g_slist_prepend(qst->languages, qsl);
 160         }
 161       lua_pop(l, 1);
 162     }
 163 }
 164
 165 /* Verify required subtitle data properties. */
 166 static gpointer _chk_req_type(lua_State *l, _quvi_subtitle_type_t qst,
 167                               const gint i, const gchar *script_path)
 168 {
 169   static const gchar *_E = "%s: %s: must return `qargs.%s[%d].%s'";
 170
 171   if (qst->format <0)
 172     {
 173       luaL_error(l, _E, script_path, script_func,
 174                  SUS_SUBTITLES, i, SUSS_FORMAT);
 175     }
 176
 177   if (qst->type <0)
 178     {
 179       luaL_error(l, _E, script_path, script_func,
 180                  SUS_SUBTITLES, i, SUSS_TYPE);
 181     }
 182
 183   /* Not all videos have subtitles of any kind. */
 184   if (g_slist_length(qst->languages) ==0)
 185     {
 186       m_subtitle_type_free(qst);
 187       return (NULL);
 188     }
 189
 190 #ifdef _1
 191   if (g_slist_length(qst->languages) ==0)
 192     {
 193       luaL_error(l, "%s: %s: qargs.%s[%d].%s must not be empty",
 194                  script_path, script_func, SUS_SUBTITLES, i, SUSS_LANG);
 195     }
 196 #endif
 197
 198   qst->languages = g_slist_reverse(qst->languages);
 199   return (qst);
 200 }
 201
 202 /* Return a new data handle. */
 203 static _quvi_subtitle_type_t _new_type(lua_State *l, _quvi_subtitle_t qsub,
 204                                        const gchar *script_path, const gint i)
 205 {
 206   _quvi_subtitle_type_t qst = _subtitle_type_new(qsub);
 207   lua_pushnil(l);
 208   while (lua_next(l, LI_KEY))
 209     {
 210       _chk_subtitle_sublevel(l, SUSS_LANG, qst, script_path,
 211                              _foreach_lang_property, i);
 212       l_chk_assign_n(l, SUSS_FORMAT, &qst->format);
 213       l_chk_assign_n(l, SUSS_TYPE, &qst->type);
 214       lua_pop(l, 1);
 215     }
 216   return (_chk_req_type(l, qst, i, script_path));
 217 }
 218
 219 /* For each qargs.subtitle */
 220 static void _foreach_subtitle(lua_State *l, _quvi_subtitle_t qsub,
 221                               const gchar *script_path)
 222 {
 223   _quvi_subtitle_type_t qst;
 224   gint i;
 225
 226   lua_pushnil(l);
 227   i = 0;
 228
 229   while (lua_next(l, LI_KEY))
 230     {
 231       if (lua_istable(l, LI_VALUE))
 232         {
 233           qst = _new_type(l, qsub, script_path, ++i);
 234           if (qst != NULL)
 235             qsub->types = g_slist_prepend(qsub->types, qst);
 236         }
 237       lua_pop(l, 1);
 238     }
 239   qsub->types = g_slist_reverse(qsub->types);
 240 }
 241
 242 static void _chk_subtitles(lua_State *l, _quvi_subtitle_t qsub,
 243                            const gchar *script_path)
 244 {
 245   lua_pushstring(l, SUS_SUBTITLES);
 246   lua_gettable(l, LI_KEY);
 247
 248   if (lua_istable(l, LI_VALUE))
 249     _foreach_subtitle(l, qsub, script_path);
 250   else
 251     {
 252       static const gchar *_E =
 253         "%s: %s: must return a dictionary containing the `qargs.%s'";
 254
 255       luaL_error(l, _E, script_path, script_func, SUS_SUBTITLES);
 256     }
 257   lua_pop(l, 1);
 258 }
 259
 260 extern gint c_reset(_quvi_t);
 261
 262 QuviError l_exec_subtitle_script_parse(gpointer p, GSList *sl)
 263 {
 264   _quvi_subtitle_t qsub;
 265   _quvi_script_t qs;
 266   lua_State *l;
 267
 268   qsub = (_quvi_subtitle_t) p;
 269   l = qsub->handle.quvi->handle.lua;
 270
 271   c_reset(qsub->handle.quvi);
 272
 273   qs = (_quvi_script_t) sl->data;
 274   lua_getglobal(l, script_func);
 275
 276   if (!lua_isfunction(l, -1))
 277     {
 278       luaL_error(l, "%s: the function `%s' was not found",
 279                  qs->fpath->str, script_func);
 280     }
 281
 282   lua_newtable(l);
 283   l_set_reg_userdata(l, USERDATA_QUVI_T, (gpointer) qsub->handle.quvi);
 284   l_setfield_s(l, SUS_INPUT_URL, qsub->url.input->str, -1);
 285
 286   if (lua_pcall(l, 1, 1, 0))
 287     {
 288       g_string_assign(qsub->handle.quvi->status.errmsg, lua_tostring(l, -1));
 289       return (QUVI_ERROR_SCRIPT);
 290     }
 291
 292   if (!lua_istable(l, -1))
 293     {
 294       static const gchar *_E =
 295         "%s: %s: must return a dictionary, this is typically the `qargs'";
 296
 297       luaL_error(l, _E, qs->fpath->str, script_func);
 298     }
 299
 300   _chk_subtitles(l, qsub, qs->fpath->str);
 301   lua_pop(l, 1);
 302
 303   return (QUVI_OK);
 304 }
 305
 306 /* vim: set ts=2 sw=2 tw=72 expandtab: */