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 static gint _print(const rfc2483_t p, const lutilPropertyType pt,
  74                    const gchar *n, const gchar *s, const gdouble d,
  75                    const gboolean comment_out, const gboolean escape)
  76 {
  77   const gchar *h;
  78   gint r;
  79
  80   r = lutil_chk_property_ok(p->q, pt, n, lprint_enum_errmsg);
  81   if (r != EXIT_SUCCESS) /* Reuse the lprint_enum_errmsg. */
  82     return (EXIT_FAILURE);
  83
  84   h = (comment_out == TRUE) ? "# ":"";
  85
  86   if (s != NULL)
  87     {
  88       if (escape == TRUE)
  89         {
  90           gchar *e = g_uri_escape_string(s, NULL, TRUE);
  91           g_print("%s%s\n", h, e);
  92           g_free(e);
  93         }
  94       else
  95         g_print("%s%s\n", h, s);
  96     }
  97   else
  98     g_print("%s%.0f\n", h, d);
  99
 100   return (EXIT_SUCCESS);
 101 }
 102
 103 /* media */
 104
 105 gint lprint_rfc2483_media_new(quvi_t q, quvi_media_t qm, gpointer *dst)
 106 {
 107   return (_rfc2483_handle_new(q, qm, dst));
 108 }
 109
 110 void lprint_rfc2483_media_free(gpointer data)
 111 {
 112   _rfc2483_handle_free(data, -1);
 113 }
 114
 115 gint lprint_rfc2483_media_print_buffer(gpointer data)
 116 {
 117   /* Nothing to buffer: everything gets printed to stdout immediately */
 118   return (EXIT_SUCCESS);
 119 }
 120
 121 typedef lprint_cb_errmsg cem;
 122
 123 static gint _mp_s(const rfc2483_t p, const QuviMediaProperty qmp,
 124                   const gchar *n, const gboolean c, const gboolean e)
 125 {
 126   gchar *s = NULL;
 127   quvi_media_get(p->qm, qmp, &s);
 128   return (_print(p, UTIL_PROPERTY_TYPE_MEDIA, n, s, -1, c, e));
 129 }
 130
 131 #define _print_mp_s(n,c,e) /* c=commented-out, e=escaped */ \
 132   do {\
 133     if (_mp_s(p, n, #n, c, e) != EXIT_SUCCESS)\
 134       return (EXIT_FAILURE);\
 135   } while (0)
 136
 137 gint
 138 lprint_rfc2483_media_stream_properties(quvi_http_metainfo_t qmi,
 139                                        gpointer data)
 140 {
 141   rfc2483_t p = (rfc2483_t) data;
 142
 143   g_assert(data != NULL);
 144
 145   _print_mp_s(QUVI_MEDIA_STREAM_PROPERTY_ID, TRUE, FALSE);
 146   _print_mp_s(QUVI_MEDIA_STREAM_PROPERTY_URL, FALSE, TRUE);
 147
 148   return (EXIT_SUCCESS);
 149 }
 150
 151 gint lprint_rfc2483_media_streams_available(quvi_t q, quvi_media_t qm)
 152 {
 153   rfc2483_t p;
 154   gint r;
 155
 156   if (_rfc2483_handle_new(q, qm, (gpointer*) &p) != EXIT_SUCCESS)
 157     return (EXIT_FAILURE);
 158
 159   g_print(_("# Media streams\n#\n"));
 160
 161   r = EXIT_SUCCESS;
 162   while (quvi_media_stream_next(qm) == QUVI_TRUE && r ==EXIT_SUCCESS)
 163     r = lprint_rfc2483_media_stream_properties(NULL, p);
 164
 165   return (_rfc2483_handle_free(p, r));
 166 }
 167
 168 #undef _print_mp_s
 169
 170 gint lprint_rfc2483_media_properties(gpointer data)
 171 {
 172   return (EXIT_SUCCESS);
 173 }
 174
 175 /* playlist */
 176
 177 gint lprint_rfc2483_playlist_new(quvi_t q, gpointer *dst)
 178 {
 179   return (_rfc2483_handle_new(q, NULL, dst));
 180 }
 181
 182 void lprint_rfc2483_playlist_free(gpointer data)
 183 {
 184   /* Nothing to release. */
 185 }
 186
 187 gint lprint_rfc2483_playlist_print_buffer(gpointer data)
 188 {
 189   /* Nothing to buffer: everything gets printed to stdout immediately */
 190   return (EXIT_SUCCESS);
 191 }
 192
 193 static gint _pp_s(const rfc2483_t p, const quvi_playlist_t qp,
 194                   const QuviPlaylistProperty qpp, const gchar *n,
 195                   const gboolean c, const gboolean e)
 196 {
 197   gchar *s = NULL;
 198   quvi_playlist_get(qp, qpp, &s);
 199   return (_print(p, UTIL_PROPERTY_TYPE_PLAYLIST, n, s, -1, c, e));
 200 }
 201
 202 #define _print_pp_s(n,c,e) /* c=commented-out, e=escaped */ \
 203   do {\
 204     if (_pp_s(p, qp, n, #n, c, e) != EXIT_SUCCESS)\
 205       return (EXIT_FAILURE);\
 206   } while (0)
 207
 208 static gint _pp_d(const rfc2483_t p, const quvi_playlist_t qp,
 209                   const QuviPlaylistProperty qpp, const gchar *n,
 210                   const gboolean c)
 211 {
 212   gdouble d = 0;
 213   quvi_playlist_get(qp, qpp, &d);
 214   return (_print(p, UTIL_PROPERTY_TYPE_PLAYLIST, n, NULL, d, c, FALSE));
 215 }
 216
 217 #define _print_pp_d(n,c) /* c=commented-out */ \
 218   do {\
 219     if (_pp_d(p, qp, n, #n, c) != EXIT_SUCCESS)\
 220       return (EXIT_FAILURE);\
 221   } while (0)
 222
 223 gint lprint_rfc2483_playlist_properties(quvi_playlist_t qp, gpointer data)
 224 {
 225   rfc2483_t p = (rfc2483_t) data;
 226
 227   g_assert(data != NULL);
 228   g_assert(qp != NULL);
 229
 230   g_print(_("# Playlist media URLs\n#\n"));
 231
 232   _print_pp_s(QUVI_PLAYLIST_PROPERTY_TITLE, TRUE, FALSE);
 233   _print_pp_s(QUVI_PLAYLIST_PROPERTY_ID, TRUE, FALSE);
 234   _print_pp_s(QUVI_PLAYLIST_PROPERTY_THUMBNAIL_URL, TRUE, FALSE);
 235
 236   g_print("#\n");
 237
 238   while (quvi_playlist_media_next(qp) == QUVI_TRUE)
 239     {
 240       _print_pp_s(QUVI_PLAYLIST_MEDIA_PROPERTY_TITLE, TRUE, FALSE);
 241       _print_pp_d(QUVI_PLAYLIST_MEDIA_PROPERTY_DURATION_MS, TRUE);
 242       _print_pp_s(QUVI_PLAYLIST_MEDIA_PROPERTY_URL, FALSE, TRUE);
 243     }
 244   return (EXIT_SUCCESS);
 245 }
 246
 247 #undef _print_pp_s
 248
 249 /* scan */
 250
 251 gint lprint_rfc2483_scan_new(quvi_t q, gpointer *dst)
 252 {
 253   return (_rfc2483_handle_new(q, NULL, dst));
 254 }
 255
 256 void lprint_rfc2483_scan_free(gpointer data)
 257 {
 258   _rfc2483_handle_free(data, -1);
 259 }
 260
 261 gint lprint_rfc2483_scan_print_buffer(gpointer data)
 262 {
 263   /* Nothing to buffer: everything gets printed to stdout immediately */
 264   return (EXIT_SUCCESS);
 265 }
 266
 267 gint lprint_rfc2483_scan_properties(quvi_scan_t qs, gpointer data)
 268 {
 269   const gchar *s;
 270
 271   g_assert(qs != NULL);
 272
 273   /* 'scan' interface does not have any properties. */
 274
 275   g_print(_("# Embedded media URLs\n#\n"));
 276   while ( (s = quvi_scan_next_media_url(qs)) != NULL)
 277     {
 278       gchar *e = g_uri_escape_string(s, NULL, TRUE);
 279       g_print("%s\n", e);
 280       g_free(e);
 281     }
 282   return (EXIT_SUCCESS);
 283 }
 284
 285 /* subtitle */
 286
 287 gint lprint_rfc2483_subtitle_new(quvi_t q, gpointer *dst)
 288 {
 289   return (_rfc2483_handle_new(q, NULL, dst));
 290 }
 291
 292 void lprint_rfc2483_subtitle_free(gpointer data)
 293 {
 294   _rfc2483_handle_free(data, -1);
 295 }
 296
 297 gint lprint_rfc2483_subtitle_print_buffer(gpointer data)
 298 {
 299   /* Nothing to buffer: everything gets printed to stdout immediately */
 300   return (EXIT_SUCCESS);
 301 }
 302
 303 static gint _slp_s(const rfc2483_t p, const quvi_subtitle_lang_t qsl,
 304                    const QuviSubtitleLangProperty qslp, const gchar *n,
 305                    const gboolean c, const gboolean e)
 306 {
 307   gchar *s = NULL;
 308   quvi_subtitle_lang_get(qsl, qslp, &s);
 309   return (_print(p, UTIL_PROPERTY_TYPE_SUBTITLE_LANGUAGE, n, s, -1, c, e));
 310 }
 311
 312 #define _print_slp_s(n,c,e) /* c=commented-out, e=escaped */ \
 313   do {\
 314     if (_slp_s(p, l, n, #n, c, e) != EXIT_SUCCESS)\
 315       return (EXIT_FAILURE);\
 316   } while (0)
 317
 318 gint
 319 lprint_rfc2483_subtitle_lang_properties(quvi_subtitle_lang_t l,
 320                                         gpointer data)
 321 {
 322   rfc2483_t p;
 323
 324   g_assert(data != NULL);
 325   p = (rfc2483_t) data;
 326
 327   _print_slp_s(QUVI_SUBTITLE_LANG_PROPERTY_ID, TRUE, FALSE);
 328   _print_slp_s(QUVI_SUBTITLE_LANG_PROPERTY_URL, FALSE, TRUE);
 329
 330   return (EXIT_SUCCESS);
 331 }
 332
 333 gint lprint_rfc2483_subtitles_available(quvi_t q, quvi_subtitle_t qsub)
 334 {
 335   quvi_subtitle_type_t t;
 336   quvi_subtitle_lang_t l;
 337   rfc2483_t p;
 338   gint r;
 339
 340   if (_rfc2483_handle_new(q, NULL, (gpointer*) &p) != EXIT_SUCCESS)
 341     return (EXIT_FAILURE);
 342
 343   g_print(_("# Subtitles\n#\n"));
 344
 345   r = EXIT_SUCCESS;
 346   while ( (t = quvi_subtitle_type_next(qsub)) != NULL && r ==EXIT_SUCCESS)
 347     {
 348       while ( (l = quvi_subtitle_lang_next(t)) != NULL && r ==EXIT_SUCCESS)
 349         r = lprint_rfc2483_subtitle_lang_properties(l, p);
 350     }
 351   return (_rfc2483_handle_free(p, r));
 352 }
 353
 354 #undef _print_slp_s
 355
 356 /* vim: set ts=2 sw=2 tw=72 expandtab: */