src/print/rfc2483_print.c

   1 /* quvi
   2  * Copyright (C) 2012,2013  Toni Gundogdu <legatvs@gmail.com>
   3  *
   4  * This file is part of quvi <http://quvi.sourceforge.net/>.
   5  *
   6  * This program 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 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 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 program.  If not, see
  18  * <http://www.gnu.org/licenses/>.
  19  */
  20
  21 /*
  22  * An URI list conforming to the text/uri-list mime type defined in
  23  * RFC2483 into individual URIs.
  24  *
  25  * media: default/selected stream URL only
  26  *  streams: all media stream URLs
  27  * scan: embedded media URLs only
  28  * subtitle: language URLs only
  29  * playlist: media URLs only
  30  *
  31  * This module prints directory to std{out,err}, and reuses the
  32  * lprint_enum_errmsg function from the enum module.
  33  */
  34
  35 #include "config.h"
  36
  37 #include <stdlib.h>
  38 #include <glib/gprintf.h>
  39 #include <glib/gi18n.h>
  40 #include <quvi.h>
  41
  42 #include "lprint.h"
  43 #include "lutil.h"
  44
  45 struct rfc2483_s
  46 {
  47   quvi_media_t qm;
  48   quvi_t q;
  49 };
  50
  51 typedef struct rfc2483_s *rfc2483_t;
  52
  53 static gint _rfc2483_handle_new(quvi_t q, quvi_media_t qm, gpointer *dst)
  54 {
  55   rfc2483_t n;
  56
  57   g_assert(dst != NULL);
  58
  59   n = g_new0(struct rfc2483_s, 1);
  60   n->qm = qm;
  61   n->q = q;
  62   *dst = n;
  63
  64   return (EXIT_SUCCESS);
  65 }
  66
  67 static gint _rfc2483_handle_free(gpointer data, const gint r)
  68 {
  69   g_free(data);
  70   return (r);
  71 }
  72
  73 extern const gchar *reserved_chars;
  74
  75 static gint _print(const rfc2483_t p, const lutilPropertyType pt,
  76                    const gchar *n, const gchar *s, const gdouble d,
  77                    const gboolean comment_out, const gboolean escape)
  78 {
  79   const gchar *h;
  80   gint r;
  81
  82   r = lutil_chk_property_ok(p->q, pt, n, lprint_enum_errmsg);
  83   if (r != EXIT_SUCCESS) /* Reuse the lprint_enum_errmsg. */
  84     return (EXIT_FAILURE);
  85
  86   h = (comment_out == TRUE) ? "# ":"";
  87
  88   if (s != NULL)
  89     {
  90       if (escape == TRUE)
  91         {
  92           gchar *e = g_uri_escape_string(s, reserved_chars, FALSE);
  93           g_print("%s%s\n", h, e);
  94           g_free(e);
  95         }
  96       else
  97         g_print("%s%s\n", h, s);
  98     }
  99   else
 100     g_print("%s%.0f\n", h, d);
 101
 102   return (EXIT_SUCCESS);
 103 }
 104
 105 /* media */
 106
 107 gint lprint_rfc2483_media_new(quvi_t q, quvi_media_t qm, gpointer *dst)
 108 {
 109   return (_rfc2483_handle_new(q, qm, dst));
 110 }
 111
 112 void lprint_rfc2483_media_free(gpointer data)
 113 {
 114   _rfc2483_handle_free(data, -1);
 115 }
 116
 117 gint lprint_rfc2483_media_print_buffer(gpointer data)
 118 {
 119   /* Nothing to buffer: everything gets printed to stdout immediately */
 120   return (EXIT_SUCCESS);
 121 }
 122
 123 typedef lprint_cb_errmsg cem;
 124
 125 static gint _mp_s(const rfc2483_t p, const QuviMediaProperty qmp,
 126                   const gchar *n, const gboolean c, const gboolean e)
 127 {
 128   gchar *s = NULL;
 129   quvi_media_get(p->qm, qmp, &s);
 130   return (_print(p, UTIL_PROPERTY_TYPE_MEDIA, n, s, -1, c, e));
 131 }
 132
 133 #define _print_mp_s(n,c,e) /* c=commented-out, e=escaped */ \
 134   do {\
 135     if (_mp_s(p, n, #n, c, e) != EXIT_SUCCESS)\
 136       return (EXIT_FAILURE);\
 137   } while (0)
 138
 139 gint
 140 lprint_rfc2483_media_stream_properties(quvi_http_metainfo_t qmi,
 141                                        gpointer data)
 142 {
 143   rfc2483_t p = (rfc2483_t) data;
 144
 145   g_assert(data != NULL);
 146
 147   _print_mp_s(QUVI_MEDIA_STREAM_PROPERTY_ID, TRUE, FALSE);
 148   _print_mp_s(QUVI_MEDIA_STREAM_PROPERTY_URL, FALSE, TRUE);
 149
 150   return (EXIT_SUCCESS);
 151 }
 152
 153 gint lprint_rfc2483_media_streams_available(quvi_t q, quvi_media_t qm)
 154 {
 155   rfc2483_t p;
 156   gint r;
 157
 158   if (_rfc2483_handle_new(q, qm, (gpointer*) &p) != EXIT_SUCCESS)
 159     return (EXIT_FAILURE);
 160
 161   g_print(_("# Media streams\n#\n"));
 162
 163   r = EXIT_SUCCESS;
 164   while (quvi_media_stream_next(qm) == QUVI_TRUE && r ==EXIT_SUCCESS)
 165     r = lprint_rfc2483_media_stream_properties(NULL, p);
 166
 167   return (_rfc2483_handle_free(p, r));
 168 }
 169
 170 #undef _print_mp_s
 171
 172 gint lprint_rfc2483_media_properties(gpointer data)
 173 {
 174   return (EXIT_SUCCESS);
 175 }
 176
 177 /* playlist */
 178
 179 gint lprint_rfc2483_playlist_new(quvi_t q, gpointer *dst)
 180 {
 181   return (_rfc2483_handle_new(q, NULL, dst));
 182 }
 183
 184 void lprint_rfc2483_playlist_free(gpointer data)
 185 {
 186   /* Nothing to release. */
 187 }
 188
 189 gint lprint_rfc2483_playlist_print_buffer(gpointer data)
 190 {
 191   /* Nothing to buffer: everything gets printed to stdout immediately */
 192   return (EXIT_SUCCESS);
 193 }
 194
 195 static gint _pp_s(const rfc2483_t p, const quvi_playlist_t qp,
 196                   const QuviPlaylistProperty qpp, const gchar *n,
 197                   const gboolean c, const gboolean e)
 198 {
 199   gchar *s = NULL;
 200   quvi_playlist_get(qp, qpp, &s);
 201   return (_print(p, UTIL_PROPERTY_TYPE_PLAYLIST, n, s, -1, c, e));
 202 }
 203
 204 #define _print_pp_s(n,c,e) /* c=commented-out, e=escaped */ \
 205   do {\
 206     if (_pp_s(p, qp, n, #n, c, e) != EXIT_SUCCESS)\
 207       return (EXIT_FAILURE);\
 208   } while (0)
 209
 210 static gint _pp_d(const rfc2483_t p, const quvi_playlist_t qp,
 211                   const QuviPlaylistProperty qpp, const gchar *n,
 212                   const gboolean c)
 213 {
 214   gdouble d = 0;
 215   quvi_playlist_get(qp, qpp, &d);
 216   return (_print(p, UTIL_PROPERTY_TYPE_PLAYLIST, n, NULL, d, c, FALSE));
 217 }
 218
 219 #define _print_pp_d(n,c) /* c=commented-out */ \
 220   do {\
 221     if (_pp_d(p, qp, n, #n, c) != EXIT_SUCCESS)\
 222       return (EXIT_FAILURE);\
 223   } while (0)
 224
 225 gint lprint_rfc2483_playlist_properties(quvi_playlist_t qp, gpointer data)
 226 {
 227   rfc2483_t p = (rfc2483_t) data;
 228
 229   g_assert(data != NULL);
 230   g_assert(qp != NULL);
 231
 232   g_print(_("# Playlist media URLs\n#\n"));
 233
 234   _print_pp_s(QUVI_PLAYLIST_PROPERTY_TITLE, TRUE, FALSE);
 235   _print_pp_s(QUVI_PLAYLIST_PROPERTY_ID, TRUE, FALSE);
 236   _print_pp_s(QUVI_PLAYLIST_PROPERTY_THUMBNAIL_URL, TRUE, FALSE);
 237
 238   g_print("#\n");
 239
 240   while (quvi_playlist_media_next(qp) == QUVI_TRUE)
 241     {
 242       _print_pp_s(QUVI_PLAYLIST_MEDIA_PROPERTY_TITLE, TRUE, FALSE);
 243       _print_pp_d(QUVI_PLAYLIST_MEDIA_PROPERTY_DURATION_MS, TRUE);
 244       _print_pp_s(QUVI_PLAYLIST_MEDIA_PROPERTY_URL, FALSE, TRUE);
 245     }
 246   return (EXIT_SUCCESS);
 247 }
 248
 249 #undef _print_pp_s
 250
 251 /* scan */
 252
 253 gint lprint_rfc2483_scan_new(quvi_t q, gpointer *dst)
 254 {
 255   return (_rfc2483_handle_new(q, NULL, dst));
 256 }
 257
 258 void lprint_rfc2483_scan_free(gpointer data)
 259 {
 260   _rfc2483_handle_free(data, -1);
 261 }
 262
 263 gint lprint_rfc2483_scan_print_buffer(gpointer data)
 264 {
 265   /* Nothing to buffer: everything gets printed to stdout immediately */
 266   return (EXIT_SUCCESS);
 267 }
 268
 269 gint lprint_rfc2483_scan_properties(quvi_scan_t qs, gpointer data)
 270 {
 271   const gchar *s;
 272
 273   g_assert(qs != NULL);
 274
 275   /* 'scan' interface does not have any properties. */
 276
 277   g_print(_("# Embedded media URLs\n#\n"));
 278   while ( (s = quvi_scan_next_media_url(qs)) != NULL)
 279     {
 280       gchar *e = g_uri_escape_string(s, reserved_chars, FALSE);
 281       g_print("%s\n", e);
 282       g_free(e);
 283     }
 284   return (EXIT_SUCCESS);
 285 }
 286
 287 /* subtitle */
 288
 289 gint lprint_rfc2483_subtitle_new(quvi_t q, gpointer *dst)
 290 {
 291   return (_rfc2483_handle_new(q, NULL, dst));
 292 }
 293
 294 void lprint_rfc2483_subtitle_free(gpointer data)
 295 {
 296   _rfc2483_handle_free(data, -1);
 297 }
 298
 299 gint lprint_rfc2483_subtitle_print_buffer(gpointer data)
 300 {
 301   /* Nothing to buffer: everything gets printed to stdout immediately */
 302   return (EXIT_SUCCESS);
 303 }
 304
 305 static gint _slp_s(const rfc2483_t p, const quvi_subtitle_lang_t qsl,
 306                    const QuviSubtitleLangProperty qslp, const gchar *n,
 307                    const gboolean c, const gboolean e)
 308 {
 309   gchar *s = NULL;
 310   quvi_subtitle_lang_get(qsl, qslp, &s);
 311   return (_print(p, UTIL_PROPERTY_TYPE_SUBTITLE_LANGUAGE, n, s, -1, c, e));
 312 }
 313
 314 #define _print_slp_s(n,c,e) /* c=commented-out, e=escaped */ \
 315   do {\
 316     if (_slp_s(p, l, n, #n, c, e) != EXIT_SUCCESS)\
 317       return (EXIT_FAILURE);\
 318   } while (0)
 319
 320 gint
 321 lprint_rfc2483_subtitle_lang_properties(quvi_subtitle_lang_t l,
 322                                         gpointer data)
 323 {
 324   rfc2483_t p;
 325
 326   g_assert(data != NULL);
 327   p = (rfc2483_t) data;
 328
 329   _print_slp_s(QUVI_SUBTITLE_LANG_PROPERTY_ID, TRUE, FALSE);
 330   _print_slp_s(QUVI_SUBTITLE_LANG_PROPERTY_URL, FALSE, TRUE);
 331
 332   return (EXIT_SUCCESS);
 333 }
 334
 335 gint lprint_rfc2483_subtitles_available(quvi_t q, quvi_subtitle_t qsub)
 336 {
 337   quvi_subtitle_type_t t;
 338   quvi_subtitle_lang_t l;
 339   rfc2483_t p;
 340   gint r;
 341
 342   if (_rfc2483_handle_new(q, NULL, (gpointer*) &p) != EXIT_SUCCESS)
 343     return (EXIT_FAILURE);
 344
 345   g_print(_("# Subtitles\n#\n"));
 346
 347   r = EXIT_SUCCESS;
 348   while ( (t = quvi_subtitle_type_next(qsub)) != NULL && r ==EXIT_SUCCESS)
 349     {
 350       while ( (l = quvi_subtitle_lang_next(t)) != NULL && r ==EXIT_SUCCESS)
 351         r = lprint_rfc2483_subtitle_lang_properties(l, p);
 352     }
 353   return (_rfc2483_handle_free(p, r));
 354 }
 355
 356 #undef _print_slp_s
 357
 358 /* vim: set ts=2 sw=2 tw=72 expandtab: */