← Back to branch summary

~ubuntu-branches/ubuntu/precise/rygel/precise

« back to all changes in this revision

Viewing changes to src/rygel/rygel-http-transcode-handler.c

  • Committer: Bazaar Package Importer
  • Author(s): Andreas Henriksson
  • Date: 2009-09-26 14:04:05 UTC
  • Revision ID: james.westby@ubuntu.com-20090926140405-d5x3j13k10psa1gu
Tags: upstream-0.4.1
Import upstream version 0.4.1

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/rygel/rygel-http-transcode-handler.c
 
1
/*
 
2
 * Copyright (C) 2009 Nokia Corporation.
 
3
 *
 
4
 * Author: Zeeshan Ali (Khattak) <zeeshanak@gnome.org>
 
5
 *                               <zeeshan.ali@nokia.com>
 
6
 *
 
7
 * This file is part of Rygel.
 
8
 *
 
9
 * Rygel is free software; you can redistribute it and/or modify
 
10
 * it under the terms of the GNU Lesser General Public License as published by
 
11
 * the Free Software Foundation; either version 2 of the License, or
 
12
 * (at your option) any later version.
 
13
 *
 
14
 * Rygel is distributed in the hope that it will be useful,
 
15
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 
16
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
17
 * GNU Lesser General Public License for more details.
 
18
 *
 
19
 * You should have received a copy of the GNU Lesser General Public License
 
20
 * along with this program; if not, write to the Free Software Foundation,
 
21
 * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
 
22
 */
 
23
 
 
24
#include <glib.h>
 
25
#include <glib-object.h>
 
26
#include <libsoup/soup.h>
 
27
#include <libgupnp-av/gupnp-av.h>
 
28
#include <gio/gio.h>
 
29
#include <stdlib.h>
 
30
#include <string.h>
 
31
#include <gst/gst.h>
 
32
 
 
33
 
 
34
#define RYGEL_TYPE_HTTP_REQUEST_HANDLER (rygel_http_request_handler_get_type ())
 
35
#define RYGEL_HTTP_REQUEST_HANDLER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), RYGEL_TYPE_HTTP_REQUEST_HANDLER, RygelHTTPRequestHandler))
 
36
#define RYGEL_HTTP_REQUEST_HANDLER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), RYGEL_TYPE_HTTP_REQUEST_HANDLER, RygelHTTPRequestHandlerClass))
 
37
#define RYGEL_IS_HTTP_REQUEST_HANDLER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), RYGEL_TYPE_HTTP_REQUEST_HANDLER))
 
38
#define RYGEL_IS_HTTP_REQUEST_HANDLER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), RYGEL_TYPE_HTTP_REQUEST_HANDLER))
 
39
#define RYGEL_HTTP_REQUEST_HANDLER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), RYGEL_TYPE_HTTP_REQUEST_HANDLER, RygelHTTPRequestHandlerClass))
 
40
 
 
41
typedef struct _RygelHTTPRequestHandler RygelHTTPRequestHandler;
 
42
typedef struct _RygelHTTPRequestHandlerClass RygelHTTPRequestHandlerClass;
 
43
typedef struct _RygelHTTPRequestHandlerPrivate RygelHTTPRequestHandlerPrivate;
 
44
 
 
45
#define RYGEL_TYPE_HTTP_REQUEST (rygel_http_request_get_type ())
 
46
#define RYGEL_HTTP_REQUEST(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), RYGEL_TYPE_HTTP_REQUEST, RygelHTTPRequest))
 
47
#define RYGEL_HTTP_REQUEST_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), RYGEL_TYPE_HTTP_REQUEST, RygelHTTPRequestClass))
 
48
#define RYGEL_IS_HTTP_REQUEST(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), RYGEL_TYPE_HTTP_REQUEST))
 
49
#define RYGEL_IS_HTTP_REQUEST_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), RYGEL_TYPE_HTTP_REQUEST))
 
50
#define RYGEL_HTTP_REQUEST_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), RYGEL_TYPE_HTTP_REQUEST, RygelHTTPRequestClass))
 
51
 
 
52
typedef struct _RygelHTTPRequest RygelHTTPRequest;
 
53
typedef struct _RygelHTTPRequestClass RygelHTTPRequestClass;
 
54
 
 
55
#define RYGEL_TYPE_HTTP_RESPONSE (rygel_http_response_get_type ())
 
56
#define RYGEL_HTTP_RESPONSE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), RYGEL_TYPE_HTTP_RESPONSE, RygelHTTPResponse))
 
57
#define RYGEL_HTTP_RESPONSE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), RYGEL_TYPE_HTTP_RESPONSE, RygelHTTPResponseClass))
 
58
#define RYGEL_IS_HTTP_RESPONSE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), RYGEL_TYPE_HTTP_RESPONSE))
 
59
#define RYGEL_IS_HTTP_RESPONSE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), RYGEL_TYPE_HTTP_RESPONSE))
 
60
#define RYGEL_HTTP_RESPONSE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), RYGEL_TYPE_HTTP_RESPONSE, RygelHTTPResponseClass))
 
61
 
 
62
typedef struct _RygelHTTPResponse RygelHTTPResponse;
 
63
typedef struct _RygelHTTPResponseClass RygelHTTPResponseClass;
 
64
 
 
65
#define RYGEL_TYPE_HTTP_TRANSCODE_HANDLER (rygel_http_transcode_handler_get_type ())
 
66
#define RYGEL_HTTP_TRANSCODE_HANDLER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), RYGEL_TYPE_HTTP_TRANSCODE_HANDLER, RygelHTTPTranscodeHandler))
 
67
#define RYGEL_HTTP_TRANSCODE_HANDLER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), RYGEL_TYPE_HTTP_TRANSCODE_HANDLER, RygelHTTPTranscodeHandlerClass))
 
68
#define RYGEL_IS_HTTP_TRANSCODE_HANDLER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), RYGEL_TYPE_HTTP_TRANSCODE_HANDLER))
 
69
#define RYGEL_IS_HTTP_TRANSCODE_HANDLER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), RYGEL_TYPE_HTTP_TRANSCODE_HANDLER))
 
70
#define RYGEL_HTTP_TRANSCODE_HANDLER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), RYGEL_TYPE_HTTP_TRANSCODE_HANDLER, RygelHTTPTranscodeHandlerClass))
 
71
 
 
72
typedef struct _RygelHTTPTranscodeHandler RygelHTTPTranscodeHandler;
 
73
typedef struct _RygelHTTPTranscodeHandlerClass RygelHTTPTranscodeHandlerClass;
 
74
typedef struct _RygelHTTPTranscodeHandlerPrivate RygelHTTPTranscodeHandlerPrivate;
 
75
 
 
76
#define RYGEL_TYPE_TRANSCODER (rygel_transcoder_get_type ())
 
77
#define RYGEL_TRANSCODER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), RYGEL_TYPE_TRANSCODER, RygelTranscoder))
 
78
#define RYGEL_TRANSCODER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), RYGEL_TYPE_TRANSCODER, RygelTranscoderClass))
 
79
#define RYGEL_IS_TRANSCODER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), RYGEL_TYPE_TRANSCODER))
 
80
#define RYGEL_IS_TRANSCODER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), RYGEL_TYPE_TRANSCODER))
 
81
#define RYGEL_TRANSCODER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), RYGEL_TYPE_TRANSCODER, RygelTranscoderClass))
 
82
 
 
83
typedef struct _RygelTranscoder RygelTranscoder;
 
84
typedef struct _RygelTranscoderClass RygelTranscoderClass;
 
85
#define _g_object_unref0(var) ((var == NULL) ? NULL : (var = (g_object_unref (var), NULL)))
 
86
 
 
87
#define RYGEL_TYPE_STATE_MACHINE (rygel_state_machine_get_type ())
 
88
#define RYGEL_STATE_MACHINE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), RYGEL_TYPE_STATE_MACHINE, RygelStateMachine))
 
89
#define RYGEL_IS_STATE_MACHINE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), RYGEL_TYPE_STATE_MACHINE))
 
90
#define RYGEL_STATE_MACHINE_GET_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), RYGEL_TYPE_STATE_MACHINE, RygelStateMachineIface))
 
91
 
 
92
typedef struct _RygelStateMachine RygelStateMachine;
 
93
typedef struct _RygelStateMachineIface RygelStateMachineIface;
 
94
typedef struct _RygelHTTPRequestPrivate RygelHTTPRequestPrivate;
 
95
 
 
96
#define RYGEL_TYPE_TRANSCODE_MANAGER (rygel_transcode_manager_get_type ())
 
97
#define RYGEL_TRANSCODE_MANAGER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), RYGEL_TYPE_TRANSCODE_MANAGER, RygelTranscodeManager))
 
98
#define RYGEL_TRANSCODE_MANAGER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), RYGEL_TYPE_TRANSCODE_MANAGER, RygelTranscodeManagerClass))
 
99
#define RYGEL_IS_TRANSCODE_MANAGER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), RYGEL_TYPE_TRANSCODE_MANAGER))
 
100
#define RYGEL_IS_TRANSCODE_MANAGER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), RYGEL_TYPE_TRANSCODE_MANAGER))
 
101
#define RYGEL_TRANSCODE_MANAGER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), RYGEL_TYPE_TRANSCODE_MANAGER, RygelTranscodeManagerClass))
 
102
 
 
103
typedef struct _RygelTranscodeManager RygelTranscodeManager;
 
104
typedef struct _RygelTranscodeManagerClass RygelTranscodeManagerClass;
 
105
 
 
106
#define RYGEL_TYPE_HTTP_SERVER (rygel_http_server_get_type ())
 
107
#define RYGEL_HTTP_SERVER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), RYGEL_TYPE_HTTP_SERVER, RygelHTTPServer))
 
108
#define RYGEL_HTTP_SERVER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), RYGEL_TYPE_HTTP_SERVER, RygelHTTPServerClass))
 
109
#define RYGEL_IS_HTTP_SERVER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), RYGEL_TYPE_HTTP_SERVER))
 
110
#define RYGEL_IS_HTTP_SERVER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), RYGEL_TYPE_HTTP_SERVER))
 
111
#define RYGEL_HTTP_SERVER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), RYGEL_TYPE_HTTP_SERVER, RygelHTTPServerClass))
 
112
 
 
113
typedef struct _RygelHTTPServer RygelHTTPServer;
 
114
typedef struct _RygelHTTPServerClass RygelHTTPServerClass;
 
115
 
 
116
#define RYGEL_TYPE_MEDIA_OBJECT (rygel_media_object_get_type ())
 
117
#define RYGEL_MEDIA_OBJECT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), RYGEL_TYPE_MEDIA_OBJECT, RygelMediaObject))
 
118
#define RYGEL_MEDIA_OBJECT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), RYGEL_TYPE_MEDIA_OBJECT, RygelMediaObjectClass))
 
119
#define RYGEL_IS_MEDIA_OBJECT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), RYGEL_TYPE_MEDIA_OBJECT))
 
120
#define RYGEL_IS_MEDIA_OBJECT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), RYGEL_TYPE_MEDIA_OBJECT))
 
121
#define RYGEL_MEDIA_OBJECT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), RYGEL_TYPE_MEDIA_OBJECT, RygelMediaObjectClass))
 
122
 
 
123
typedef struct _RygelMediaObject RygelMediaObject;
 
124
typedef struct _RygelMediaObjectClass RygelMediaObjectClass;
 
125
 
 
126
#define RYGEL_TYPE_MEDIA_ITEM (rygel_media_item_get_type ())
 
127
#define RYGEL_MEDIA_ITEM(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), RYGEL_TYPE_MEDIA_ITEM, RygelMediaItem))
 
128
#define RYGEL_MEDIA_ITEM_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), RYGEL_TYPE_MEDIA_ITEM, RygelMediaItemClass))
 
129
#define RYGEL_IS_MEDIA_ITEM(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), RYGEL_TYPE_MEDIA_ITEM))
 
130
#define RYGEL_IS_MEDIA_ITEM_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), RYGEL_TYPE_MEDIA_ITEM))
 
131
#define RYGEL_MEDIA_ITEM_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), RYGEL_TYPE_MEDIA_ITEM, RygelMediaItemClass))
 
132
 
 
133
typedef struct _RygelMediaItem RygelMediaItem;
 
134
typedef struct _RygelMediaItemClass RygelMediaItemClass;
 
135
 
 
136
#define RYGEL_TYPE_ICON_INFO (rygel_icon_info_get_type ())
 
137
#define RYGEL_ICON_INFO(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), RYGEL_TYPE_ICON_INFO, RygelIconInfo))
 
138
#define RYGEL_ICON_INFO_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), RYGEL_TYPE_ICON_INFO, RygelIconInfoClass))
 
139
#define RYGEL_IS_ICON_INFO(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), RYGEL_TYPE_ICON_INFO))
 
140
#define RYGEL_IS_ICON_INFO_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), RYGEL_TYPE_ICON_INFO))
 
141
#define RYGEL_ICON_INFO_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), RYGEL_TYPE_ICON_INFO, RygelIconInfoClass))
 
142
 
 
143
typedef struct _RygelIconInfo RygelIconInfo;
 
144
typedef struct _RygelIconInfoClass RygelIconInfoClass;
 
145
 
 
146
#define RYGEL_TYPE_THUMBNAIL (rygel_thumbnail_get_type ())
 
147
#define RYGEL_THUMBNAIL(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), RYGEL_TYPE_THUMBNAIL, RygelThumbnail))
 
148
#define RYGEL_THUMBNAIL_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), RYGEL_TYPE_THUMBNAIL, RygelThumbnailClass))
 
149
#define RYGEL_IS_THUMBNAIL(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), RYGEL_TYPE_THUMBNAIL))
 
150
#define RYGEL_IS_THUMBNAIL_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), RYGEL_TYPE_THUMBNAIL))
 
151
#define RYGEL_THUMBNAIL_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), RYGEL_TYPE_THUMBNAIL, RygelThumbnailClass))
 
152
 
 
153
typedef struct _RygelThumbnail RygelThumbnail;
 
154
typedef struct _RygelThumbnailClass RygelThumbnailClass;
 
155
 
 
156
#define RYGEL_TYPE_HTTP_SEEK (rygel_http_seek_get_type ())
 
157
#define RYGEL_HTTP_SEEK(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), RYGEL_TYPE_HTTP_SEEK, RygelHTTPSeek))
 
158
#define RYGEL_HTTP_SEEK_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), RYGEL_TYPE_HTTP_SEEK, RygelHTTPSeekClass))
 
159
#define RYGEL_IS_HTTP_SEEK(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), RYGEL_TYPE_HTTP_SEEK))
 
160
#define RYGEL_IS_HTTP_SEEK_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), RYGEL_TYPE_HTTP_SEEK))
 
161
#define RYGEL_HTTP_SEEK_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), RYGEL_TYPE_HTTP_SEEK, RygelHTTPSeekClass))
 
162
 
 
163
typedef struct _RygelHTTPSeek RygelHTTPSeek;
 
164
typedef struct _RygelHTTPSeekClass RygelHTTPSeekClass;
 
165
#define _gst_object_unref0(var) ((var == NULL) ? NULL : (var = (gst_object_unref (var), NULL)))
 
166
 
 
167
#define RYGEL_TYPE_LIVE_RESPONSE (rygel_live_response_get_type ())
 
168
#define RYGEL_LIVE_RESPONSE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), RYGEL_TYPE_LIVE_RESPONSE, RygelLiveResponse))
 
169
#define RYGEL_LIVE_RESPONSE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), RYGEL_TYPE_LIVE_RESPONSE, RygelLiveResponseClass))
 
170
#define RYGEL_IS_LIVE_RESPONSE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), RYGEL_TYPE_LIVE_RESPONSE))
 
171
#define RYGEL_IS_LIVE_RESPONSE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), RYGEL_TYPE_LIVE_RESPONSE))
 
172
#define RYGEL_LIVE_RESPONSE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), RYGEL_TYPE_LIVE_RESPONSE, RygelLiveResponseClass))
 
173
 
 
174
typedef struct _RygelLiveResponse RygelLiveResponse;
 
175
typedef struct _RygelLiveResponseClass RygelLiveResponseClass;
 
176
 
 
177
typedef enum  {
 
178
        RYGEL_HTTP_REQUEST_ERROR_UNACCEPTABLE = SOUP_STATUS_NOT_ACCEPTABLE,
 
179
        RYGEL_HTTP_REQUEST_ERROR_BAD_REQUEST = SOUP_STATUS_BAD_REQUEST,
 
180
        RYGEL_HTTP_REQUEST_ERROR_NOT_FOUND = SOUP_STATUS_NOT_FOUND
 
181
} RygelHTTPRequestError;
 
182
#define RYGEL_HTTP_REQUEST_ERROR rygel_http_request_error_quark ()
 
183
struct _RygelHTTPRequestHandler {
 
184
        GObject parent_instance;
 
185
        RygelHTTPRequestHandlerPrivate * priv;
 
186
};
 
187
 
 
188
struct _RygelHTTPRequestHandlerClass {
 
189
        GObjectClass parent_class;
 
190
        void (*add_response_headers) (RygelHTTPRequestHandler* self, RygelHTTPRequest* request, GError** error);
 
191
        RygelHTTPResponse* (*render_body) (RygelHTTPRequestHandler* self, RygelHTTPRequest* request, GError** error);
 
192
        GUPnPDIDLLiteResource* (*add_resource) (RygelHTTPRequestHandler* self, GUPnPDIDLLiteItem* didl_item, RygelHTTPRequest* request, GError** error);
 
193
};
 
194
 
 
195
struct _RygelHTTPTranscodeHandler {
 
196
        RygelHTTPRequestHandler parent_instance;
 
197
        RygelHTTPTranscodeHandlerPrivate * priv;
 
198
};
 
199
 
 
200
struct _RygelHTTPTranscodeHandlerClass {
 
201
        RygelHTTPRequestHandlerClass parent_class;
 
202
};
 
203
 
 
204
struct _RygelHTTPTranscodeHandlerPrivate {
 
205
        RygelTranscoder* transcoder;
 
206
};
 
207
 
 
208
struct _RygelStateMachineIface {
 
209
        GTypeInterface parent_iface;
 
210
        void (*run) (RygelStateMachine* self);
 
211
        GCancellable* (*get_cancellable) (RygelStateMachine* self);
 
212
        void (*set_cancellable) (RygelStateMachine* self, GCancellable* value);
 
213
};
 
214
 
 
215
struct _RygelHTTPRequest {
 
216
        GObject parent_instance;
 
217
        RygelHTTPRequestPrivate * priv;
 
218
        RygelHTTPServer* http_server;
 
219
        SoupServer* server;
 
220
        SoupMessage* msg;
 
221
        RygelMediaItem* item;
 
222
        RygelThumbnail* thumbnail;
 
223
        RygelHTTPSeek* byte_range;
 
224
        RygelHTTPSeek* time_range;
 
225
};
 
226
 
 
227
struct _RygelHTTPRequestClass {
 
228
        GObjectClass parent_class;
 
229
};
 
230
 
 
231
 
 
232
static gpointer rygel_http_transcode_handler_parent_class = NULL;
 
233
 
 
234
GType rygel_http_request_handler_get_type (void);
 
235
GType rygel_http_request_get_type (void);
 
236
GQuark rygel_http_request_error_quark (void);
 
237
GType rygel_http_response_get_type (void);
 
238
GType rygel_http_transcode_handler_get_type (void);
 
239
GType rygel_transcoder_get_type (void);
 
240
#define RYGEL_HTTP_TRANSCODE_HANDLER_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), RYGEL_TYPE_HTTP_TRANSCODE_HANDLER, RygelHTTPTranscodeHandlerPrivate))
 
241
enum  {
 
242
        RYGEL_HTTP_TRANSCODE_HANDLER_DUMMY_PROPERTY
 
243
};
 
244
RygelHTTPRequestHandler* rygel_http_request_handler_construct (GType object_type);
 
245
void rygel_http_request_handler_set_cancellable (RygelHTTPRequestHandler* self, GCancellable* value);
 
246
RygelHTTPTranscodeHandler* rygel_http_transcode_handler_new (RygelTranscoder* transcoder, GCancellable* cancellable);
 
247
RygelHTTPTranscodeHandler* rygel_http_transcode_handler_construct (GType object_type, RygelTranscoder* transcoder, GCancellable* cancellable);
 
248
GType rygel_state_machine_get_type (void);
 
249
GType rygel_transcode_manager_get_type (void);
 
250
GType rygel_http_server_get_type (void);
 
251
GType rygel_media_object_get_type (void);
 
252
GType rygel_media_item_get_type (void);
 
253
gpointer rygel_icon_info_ref (gpointer instance);
 
254
void rygel_icon_info_unref (gpointer instance);
 
255
GParamSpec* rygel_param_spec_icon_info (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags);
 
256
void rygel_value_set_icon_info (GValue* value, gpointer v_object);
 
257
gpointer rygel_value_get_icon_info (const GValue* value);
 
258
GType rygel_icon_info_get_type (void);
 
259
GType rygel_thumbnail_get_type (void);
 
260
GType rygel_http_seek_get_type (void);
 
261
const char* rygel_transcoder_get_mime_type (RygelTranscoder* self);
 
262
void rygel_http_seek_add_response_header (RygelHTTPSeek* self, SoupMessage* msg, gint64 length);
 
263
void rygel_http_request_handler_add_response_headers (RygelHTTPRequestHandler* self, RygelHTTPRequest* request, GError** error);
 
264
static void rygel_http_transcode_handler_real_add_response_headers (RygelHTTPRequestHandler* base, RygelHTTPRequest* request, GError** error);
 
265
GstElement* rygel_media_item_create_stream_source (RygelMediaItem* self);
 
266
GstElement* rygel_transcoder_create_source (RygelTranscoder* self, RygelMediaItem* item, GstElement* src, GError** error);
 
267
GCancellable* rygel_http_request_handler_get_cancellable (RygelHTTPRequestHandler* self);
 
268
RygelLiveResponse* rygel_live_response_new (SoupServer* server, SoupMessage* msg, const char* name, GstElement* src, RygelHTTPSeek* time_range, GCancellable* cancellable, GError** error);
 
269
RygelLiveResponse* rygel_live_response_construct (GType object_type, SoupServer* server, SoupMessage* msg, const char* name, GstElement* src, RygelHTTPSeek* time_range, GCancellable* cancellable, GError** error);
 
270
GType rygel_live_response_get_type (void);
 
271
static RygelHTTPResponse* rygel_http_transcode_handler_real_render_body (RygelHTTPRequestHandler* base, RygelHTTPRequest* request, GError** error);
 
272
GUPnPDIDLLiteResource* rygel_transcoder_add_resource (RygelTranscoder* self, GUPnPDIDLLiteItem* didl_item, RygelMediaItem* item, RygelTranscodeManager* manager, GError** error);
 
273
static GUPnPDIDLLiteResource* rygel_http_transcode_handler_real_add_resource (RygelHTTPRequestHandler* base, GUPnPDIDLLiteItem* didl_item, RygelHTTPRequest* request, GError** error);
 
274
static void rygel_http_transcode_handler_finalize (GObject* obj);
 
275
 
 
276
 
 
277
 
 
278
static gpointer _g_object_ref0 (gpointer self) {
 
279
        return self ? g_object_ref (self) : NULL;
 
280
}
 
281
 
 
282
 
 
283
RygelHTTPTranscodeHandler* rygel_http_transcode_handler_construct (GType object_type, RygelTranscoder* transcoder, GCancellable* cancellable) {
 
284
        RygelHTTPTranscodeHandler * self;
 
285
        RygelTranscoder* _tmp0_;
 
286
        g_return_val_if_fail (transcoder != NULL, NULL);
 
287
        self = (RygelHTTPTranscodeHandler*) rygel_http_request_handler_construct (object_type);
 
288
        self->priv->transcoder = (_tmp0_ = _g_object_ref0 (transcoder), _g_object_unref0 (self->priv->transcoder), _tmp0_);
 
289
        rygel_http_request_handler_set_cancellable ((RygelHTTPRequestHandler*) self, cancellable);
 
290
        return self;
 
291
}
 
292
 
 
293
 
 
294
RygelHTTPTranscodeHandler* rygel_http_transcode_handler_new (RygelTranscoder* transcoder, GCancellable* cancellable) {
 
295
        return rygel_http_transcode_handler_construct (RYGEL_TYPE_HTTP_TRANSCODE_HANDLER, transcoder, cancellable);
 
296
}
 
297
 
 
298
 
 
299
static void rygel_http_transcode_handler_real_add_response_headers (RygelHTTPRequestHandler* base, RygelHTTPRequest* request, GError** error) {
 
300
        RygelHTTPTranscodeHandler * self;
 
301
        GError * _inner_error_;
 
302
        self = (RygelHTTPTranscodeHandler*) base;
 
303
        g_return_if_fail (request != NULL);
 
304
        _inner_error_ = NULL;
 
305
        soup_message_headers_append (request->msg->response_headers, "Content-Type", rygel_transcoder_get_mime_type (self->priv->transcoder));
 
306
        if (request->time_range != NULL) {
 
307
                rygel_http_seek_add_response_header (request->time_range, request->msg, -1);
 
308
        }
 
309
        RYGEL_HTTP_REQUEST_HANDLER_CLASS (rygel_http_transcode_handler_parent_class)->add_response_headers (RYGEL_HTTP_REQUEST_HANDLER (self), request, &_inner_error_);
 
310
        if (_inner_error_ != NULL) {
 
311
                if (_inner_error_->domain == RYGEL_HTTP_REQUEST_ERROR) {
 
312
                        g_propagate_error (error, _inner_error_);
 
313
                        return;
 
314
                } else {
 
315
                        g_critical ("file %s: line %d: uncaught error: %s", __FILE__, __LINE__, _inner_error_->message);
 
316
                        g_clear_error (&_inner_error_);
 
317
                        return;
 
318
                }
 
319
        }
 
320
}
 
321
 
 
322
 
 
323
static RygelHTTPResponse* rygel_http_transcode_handler_real_render_body (RygelHTTPRequestHandler* base, RygelHTTPRequest* request, GError** error) {
 
324
        RygelHTTPTranscodeHandler * self;
 
325
        RygelHTTPResponse* result;
 
326
        GError * _inner_error_;
 
327
        RygelMediaItem* item;
 
328
        GstElement* src;
 
329
        GstElement* _tmp0_;
 
330
        GstElement* _tmp1_;
 
331
        RygelLiveResponse* _tmp2_;
 
332
        self = (RygelHTTPTranscodeHandler*) base;
 
333
        g_return_val_if_fail (request != NULL, NULL);
 
334
        _inner_error_ = NULL;
 
335
        item = _g_object_ref0 (request->item);
 
336
        src = rygel_media_item_create_stream_source (item);
 
337
        if (src == NULL) {
 
338
                _inner_error_ = g_error_new_literal (RYGEL_HTTP_REQUEST_ERROR, RYGEL_HTTP_REQUEST_ERROR_NOT_FOUND, "Not found");
 
339
                if (_inner_error_ != NULL) {
 
340
                        if (_inner_error_->domain == RYGEL_HTTP_REQUEST_ERROR) {
 
341
                                g_propagate_error (error, _inner_error_);
 
342
                                _g_object_unref0 (item);
 
343
                                _gst_object_unref0 (src);
 
344
                                return NULL;
 
345
                        } else {
 
346
                                _g_object_unref0 (item);
 
347
                                _gst_object_unref0 (src);
 
348
                                g_critical ("file %s: line %d: uncaught error: %s", __FILE__, __LINE__, _inner_error_->message);
 
349
                                g_clear_error (&_inner_error_);
 
350
                                return NULL;
 
351
                        }
 
352
                }
 
353
        }
 
354
        _tmp0_ = rygel_transcoder_create_source (self->priv->transcoder, item, src, &_inner_error_);
 
355
        if (_inner_error_ != NULL) {
 
356
                if (_inner_error_->domain == RYGEL_HTTP_REQUEST_ERROR) {
 
357
                        g_propagate_error (error, _inner_error_);
 
358
                        _g_object_unref0 (item);
 
359
                        _gst_object_unref0 (src);
 
360
                        return NULL;
 
361
                } else {
 
362
                        _g_object_unref0 (item);
 
363
                        _gst_object_unref0 (src);
 
364
                        g_critical ("file %s: line %d: uncaught error: %s", __FILE__, __LINE__, _inner_error_->message);
 
365
                        g_clear_error (&_inner_error_);
 
366
                        return NULL;
 
367
                }
 
368
        }
 
369
        src = (_tmp1_ = _tmp0_, _gst_object_unref0 (src), _tmp1_);
 
370
        _tmp2_ = rygel_live_response_new (request->server, request->msg, "RygelLiveResponse", src, request->time_range, rygel_http_request_handler_get_cancellable ((RygelHTTPRequestHandler*) self), &_inner_error_);
 
371
        if (_inner_error_ != NULL) {
 
372
                if (_inner_error_->domain == RYGEL_HTTP_REQUEST_ERROR) {
 
373
                        g_propagate_error (error, _inner_error_);
 
374
                        _g_object_unref0 (item);
 
375
                        _gst_object_unref0 (src);
 
376
                        return NULL;
 
377
                } else {
 
378
                        _g_object_unref0 (item);
 
379
                        _gst_object_unref0 (src);
 
380
                        g_critical ("file %s: line %d: uncaught error: %s", __FILE__, __LINE__, _inner_error_->message);
 
381
                        g_clear_error (&_inner_error_);
 
382
                        return NULL;
 
383
                }
 
384
        }
 
385
        result = (RygelHTTPResponse*) _tmp2_;
 
386
        _g_object_unref0 (item);
 
387
        _gst_object_unref0 (src);
 
388
        return result;
 
389
}
 
390
 
 
391
 
 
392
static GUPnPDIDLLiteResource* rygel_http_transcode_handler_real_add_resource (RygelHTTPRequestHandler* base, GUPnPDIDLLiteItem* didl_item, RygelHTTPRequest* request, GError** error) {
 
393
        RygelHTTPTranscodeHandler * self;
 
394
        GUPnPDIDLLiteResource* result;
 
395
        GError * _inner_error_;
 
396
        GUPnPDIDLLiteResource* _tmp0_;
 
397
        self = (RygelHTTPTranscodeHandler*) base;
 
398
        g_return_val_if_fail (didl_item != NULL, NULL);
 
399
        g_return_val_if_fail (request != NULL, NULL);
 
400
        _inner_error_ = NULL;
 
401
        _tmp0_ = rygel_transcoder_add_resource (self->priv->transcoder, didl_item, request->item, (RygelTranscodeManager*) request->http_server, &_inner_error_);
 
402
        if (_inner_error_ != NULL) {
 
403
                if (_inner_error_->domain == RYGEL_HTTP_REQUEST_ERROR) {
 
404
                        g_propagate_error (error, _inner_error_);
 
405
                        return NULL;
 
406
                } else {
 
407
                        g_critical ("file %s: line %d: uncaught error: %s", __FILE__, __LINE__, _inner_error_->message);
 
408
                        g_clear_error (&_inner_error_);
 
409
                        return NULL;
 
410
                }
 
411
        }
 
412
        result = _tmp0_;
 
413
        return result;
 
414
}
 
415
 
 
416
 
 
417
static void rygel_http_transcode_handler_class_init (RygelHTTPTranscodeHandlerClass * klass) {
 
418
        rygel_http_transcode_handler_parent_class = g_type_class_peek_parent (klass);
 
419
        g_type_class_add_private (klass, sizeof (RygelHTTPTranscodeHandlerPrivate));
 
420
        RYGEL_HTTP_REQUEST_HANDLER_CLASS (klass)->add_response_headers = rygel_http_transcode_handler_real_add_response_headers;
 
421
        RYGEL_HTTP_REQUEST_HANDLER_CLASS (klass)->render_body = rygel_http_transcode_handler_real_render_body;
 
422
        RYGEL_HTTP_REQUEST_HANDLER_CLASS (klass)->add_resource = rygel_http_transcode_handler_real_add_resource;
 
423
        G_OBJECT_CLASS (klass)->finalize = rygel_http_transcode_handler_finalize;
 
424
}
 
425
 
 
426
 
 
427
static void rygel_http_transcode_handler_instance_init (RygelHTTPTranscodeHandler * self) {
 
428
        self->priv = RYGEL_HTTP_TRANSCODE_HANDLER_GET_PRIVATE (self);
 
429
}
 
430
 
 
431
 
 
432
static void rygel_http_transcode_handler_finalize (GObject* obj) {
 
433
        RygelHTTPTranscodeHandler * self;
 
434
        self = RYGEL_HTTP_TRANSCODE_HANDLER (obj);
 
435
        _g_object_unref0 (self->priv->transcoder);
 
436
        G_OBJECT_CLASS (rygel_http_transcode_handler_parent_class)->finalize (obj);
 
437
}
 
438
 
 
439
 
 
440
GType rygel_http_transcode_handler_get_type (void) {
 
441
        static GType rygel_http_transcode_handler_type_id = 0;
 
442
        if (rygel_http_transcode_handler_type_id == 0) {
 
443
                static const GTypeInfo g_define_type_info = { sizeof (RygelHTTPTranscodeHandlerClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) rygel_http_transcode_handler_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (RygelHTTPTranscodeHandler), 0, (GInstanceInitFunc) rygel_http_transcode_handler_instance_init, NULL };
 
444
                rygel_http_transcode_handler_type_id = g_type_register_static (RYGEL_TYPE_HTTP_REQUEST_HANDLER, "RygelHTTPTranscodeHandler", &g_define_type_info, 0);
 
445
        }
 
446
        return rygel_http_transcode_handler_type_id;
 
447
}
 
448
 
 
449
 
 
450
 
 
451