← Back to branch summary

~ubuntu-branches/ubuntu/raring/rygel/raring

« back to all changes in this revision

Viewing changes to src/librygel-server/rygel-http-byte-seek.c

  • Committer: Package Import Robot
  • Author(s): Andreas Henriksson
  • Date: 2012-09-26 22:34:15 UTC
  • mfrom: (11.1.19 experimental)
  • Revision ID: package-import@ubuntu.com-20120926223415-9day2s783n9td4e8
Tags: 0.16.0-1
Imported Upstream version 0.16.0

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/librygel-server/rygel-http-byte-seek.c
 
1
/* rygel-http-byte-seek.c generated by valac 0.16.1, the Vala compiler
 
2
 * generated from rygel-http-byte-seek.vala, do not modify */
 
3
 
 
4
/*
 
5
 * Copyright (C) 2009 Nokia Corporation.
 
6
 *
 
7
 * Author: Zeeshan Ali (Khattak) <zeeshanak@gnome.org>
 
8
 *                               <zeeshan.ali@nokia.com>
 
9
 *
 
10
 * This file is part of Rygel.
 
11
 *
 
12
 * Rygel is free software; you can redistribute it and/or modify
 
13
 * it under the terms of the GNU Lesser General Public License as published by
 
14
 * the Free Software Foundation; either version 2 of the License, or
 
15
 * (at your option) any later version.
 
16
 *
 
17
 * Rygel is distributed in the hope that it will be useful,
 
18
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 
19
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
20
 * GNU Lesser General Public License for more details.
 
21
 *
 
22
 * You should have received a copy of the GNU Lesser General Public License
 
23
 * along with this program; if not, write to the Free Software Foundation,
 
24
 * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
 
25
 */
 
26
 
 
27
#include <glib.h>
 
28
#include <glib-object.h>
 
29
#include <libsoup/soup.h>
 
30
#include <rygel-core.h>
 
31
#include <gio/gio.h>
 
32
#include <stdlib.h>
 
33
#include <string.h>
 
34
#include <glib/gi18n-lib.h>
 
35
 
 
36
 
 
37
#define RYGEL_TYPE_HTTP_SEEK (rygel_http_seek_get_type ())
 
38
#define RYGEL_HTTP_SEEK(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), RYGEL_TYPE_HTTP_SEEK, RygelHTTPSeek))
 
39
#define RYGEL_HTTP_SEEK_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), RYGEL_TYPE_HTTP_SEEK, RygelHTTPSeekClass))
 
40
#define RYGEL_IS_HTTP_SEEK(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), RYGEL_TYPE_HTTP_SEEK))
 
41
#define RYGEL_IS_HTTP_SEEK_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), RYGEL_TYPE_HTTP_SEEK))
 
42
#define RYGEL_HTTP_SEEK_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), RYGEL_TYPE_HTTP_SEEK, RygelHTTPSeekClass))
 
43
 
 
44
typedef struct _RygelHTTPSeek RygelHTTPSeek;
 
45
typedef struct _RygelHTTPSeekClass RygelHTTPSeekClass;
 
46
typedef struct _RygelHTTPSeekPrivate RygelHTTPSeekPrivate;
 
47
 
 
48
#define RYGEL_TYPE_HTTP_BYTE_SEEK (rygel_http_byte_seek_get_type ())
 
49
#define RYGEL_HTTP_BYTE_SEEK(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), RYGEL_TYPE_HTTP_BYTE_SEEK, RygelHTTPByteSeek))
 
50
#define RYGEL_HTTP_BYTE_SEEK_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), RYGEL_TYPE_HTTP_BYTE_SEEK, RygelHTTPByteSeekClass))
 
51
#define RYGEL_IS_HTTP_BYTE_SEEK(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), RYGEL_TYPE_HTTP_BYTE_SEEK))
 
52
#define RYGEL_IS_HTTP_BYTE_SEEK_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), RYGEL_TYPE_HTTP_BYTE_SEEK))
 
53
#define RYGEL_HTTP_BYTE_SEEK_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), RYGEL_TYPE_HTTP_BYTE_SEEK, RygelHTTPByteSeekClass))
 
54
 
 
55
typedef struct _RygelHTTPByteSeek RygelHTTPByteSeek;
 
56
typedef struct _RygelHTTPByteSeekClass RygelHTTPByteSeekClass;
 
57
typedef struct _RygelHTTPByteSeekPrivate RygelHTTPByteSeekPrivate;
 
58
 
 
59
#define RYGEL_TYPE_HTTP_REQUEST (rygel_http_request_get_type ())
 
60
#define RYGEL_HTTP_REQUEST(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), RYGEL_TYPE_HTTP_REQUEST, RygelHTTPRequest))
 
61
#define RYGEL_HTTP_REQUEST_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), RYGEL_TYPE_HTTP_REQUEST, RygelHTTPRequestClass))
 
62
#define RYGEL_IS_HTTP_REQUEST(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), RYGEL_TYPE_HTTP_REQUEST))
 
63
#define RYGEL_IS_HTTP_REQUEST_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), RYGEL_TYPE_HTTP_REQUEST))
 
64
#define RYGEL_HTTP_REQUEST_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), RYGEL_TYPE_HTTP_REQUEST, RygelHTTPRequestClass))
 
65
 
 
66
typedef struct _RygelHTTPRequest RygelHTTPRequest;
 
67
typedef struct _RygelHTTPRequestClass RygelHTTPRequestClass;
 
68
 
 
69
#define RYGEL_TYPE_HTTP_GET (rygel_http_get_get_type ())
 
70
#define RYGEL_HTTP_GET(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), RYGEL_TYPE_HTTP_GET, RygelHTTPGet))
 
71
#define RYGEL_HTTP_GET_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), RYGEL_TYPE_HTTP_GET, RygelHTTPGetClass))
 
72
#define RYGEL_IS_HTTP_GET(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), RYGEL_TYPE_HTTP_GET))
 
73
#define RYGEL_IS_HTTP_GET_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), RYGEL_TYPE_HTTP_GET))
 
74
#define RYGEL_HTTP_GET_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), RYGEL_TYPE_HTTP_GET, RygelHTTPGetClass))
 
75
 
 
76
typedef struct _RygelHTTPGet RygelHTTPGet;
 
77
typedef struct _RygelHTTPGetClass RygelHTTPGetClass;
 
78
typedef struct _RygelHTTPRequestPrivate RygelHTTPRequestPrivate;
 
79
 
 
80
#define RYGEL_TYPE_TRANSCODE_MANAGER (rygel_transcode_manager_get_type ())
 
81
#define RYGEL_TRANSCODE_MANAGER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), RYGEL_TYPE_TRANSCODE_MANAGER, RygelTranscodeManager))
 
82
#define RYGEL_TRANSCODE_MANAGER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), RYGEL_TYPE_TRANSCODE_MANAGER, RygelTranscodeManagerClass))
 
83
#define RYGEL_IS_TRANSCODE_MANAGER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), RYGEL_TYPE_TRANSCODE_MANAGER))
 
84
#define RYGEL_IS_TRANSCODE_MANAGER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), RYGEL_TYPE_TRANSCODE_MANAGER))
 
85
#define RYGEL_TRANSCODE_MANAGER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), RYGEL_TYPE_TRANSCODE_MANAGER, RygelTranscodeManagerClass))
 
86
 
 
87
typedef struct _RygelTranscodeManager RygelTranscodeManager;
 
88
typedef struct _RygelTranscodeManagerClass RygelTranscodeManagerClass;
 
89
 
 
90
#define RYGEL_TYPE_HTTP_SERVER (rygel_http_server_get_type ())
 
91
#define RYGEL_HTTP_SERVER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), RYGEL_TYPE_HTTP_SERVER, RygelHTTPServer))
 
92
#define RYGEL_HTTP_SERVER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), RYGEL_TYPE_HTTP_SERVER, RygelHTTPServerClass))
 
93
#define RYGEL_IS_HTTP_SERVER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), RYGEL_TYPE_HTTP_SERVER))
 
94
#define RYGEL_IS_HTTP_SERVER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), RYGEL_TYPE_HTTP_SERVER))
 
95
#define RYGEL_HTTP_SERVER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), RYGEL_TYPE_HTTP_SERVER, RygelHTTPServerClass))
 
96
 
 
97
typedef struct _RygelHTTPServer RygelHTTPServer;
 
98
typedef struct _RygelHTTPServerClass RygelHTTPServerClass;
 
99
 
 
100
#define RYGEL_TYPE_HTTP_ITEM_URI (rygel_http_item_uri_get_type ())
 
101
#define RYGEL_HTTP_ITEM_URI(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), RYGEL_TYPE_HTTP_ITEM_URI, RygelHTTPItemURI))
 
102
#define RYGEL_HTTP_ITEM_URI_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), RYGEL_TYPE_HTTP_ITEM_URI, RygelHTTPItemURIClass))
 
103
#define RYGEL_IS_HTTP_ITEM_URI(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), RYGEL_TYPE_HTTP_ITEM_URI))
 
104
#define RYGEL_IS_HTTP_ITEM_URI_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), RYGEL_TYPE_HTTP_ITEM_URI))
 
105
#define RYGEL_HTTP_ITEM_URI_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), RYGEL_TYPE_HTTP_ITEM_URI, RygelHTTPItemURIClass))
 
106
 
 
107
typedef struct _RygelHTTPItemURI RygelHTTPItemURI;
 
108
typedef struct _RygelHTTPItemURIClass RygelHTTPItemURIClass;
 
109
 
 
110
#define RYGEL_TYPE_MEDIA_OBJECT (rygel_media_object_get_type ())
 
111
#define RYGEL_MEDIA_OBJECT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), RYGEL_TYPE_MEDIA_OBJECT, RygelMediaObject))
 
112
#define RYGEL_MEDIA_OBJECT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), RYGEL_TYPE_MEDIA_OBJECT, RygelMediaObjectClass))
 
113
#define RYGEL_IS_MEDIA_OBJECT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), RYGEL_TYPE_MEDIA_OBJECT))
 
114
#define RYGEL_IS_MEDIA_OBJECT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), RYGEL_TYPE_MEDIA_OBJECT))
 
115
#define RYGEL_MEDIA_OBJECT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), RYGEL_TYPE_MEDIA_OBJECT, RygelMediaObjectClass))
 
116
 
 
117
typedef struct _RygelMediaObject RygelMediaObject;
 
118
typedef struct _RygelMediaObjectClass RygelMediaObjectClass;
 
119
 
 
120
#define RYGEL_TYPE_MEDIA_ITEM (rygel_media_item_get_type ())
 
121
#define RYGEL_MEDIA_ITEM(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), RYGEL_TYPE_MEDIA_ITEM, RygelMediaItem))
 
122
#define RYGEL_MEDIA_ITEM_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), RYGEL_TYPE_MEDIA_ITEM, RygelMediaItemClass))
 
123
#define RYGEL_IS_MEDIA_ITEM(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), RYGEL_TYPE_MEDIA_ITEM))
 
124
#define RYGEL_IS_MEDIA_ITEM_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), RYGEL_TYPE_MEDIA_ITEM))
 
125
#define RYGEL_MEDIA_ITEM_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), RYGEL_TYPE_MEDIA_ITEM, RygelMediaItemClass))
 
126
 
 
127
typedef struct _RygelMediaItem RygelMediaItem;
 
128
typedef struct _RygelMediaItemClass RygelMediaItemClass;
 
129
 
 
130
#define RYGEL_TYPE_CLIENT_HACKS (rygel_client_hacks_get_type ())
 
131
#define RYGEL_CLIENT_HACKS(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), RYGEL_TYPE_CLIENT_HACKS, RygelClientHacks))
 
132
#define RYGEL_CLIENT_HACKS_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), RYGEL_TYPE_CLIENT_HACKS, RygelClientHacksClass))
 
133
#define RYGEL_IS_CLIENT_HACKS(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), RYGEL_TYPE_CLIENT_HACKS))
 
134
#define RYGEL_IS_CLIENT_HACKS_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), RYGEL_TYPE_CLIENT_HACKS))
 
135
#define RYGEL_CLIENT_HACKS_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), RYGEL_TYPE_CLIENT_HACKS, RygelClientHacksClass))
 
136
 
 
137
typedef struct _RygelClientHacks RygelClientHacks;
 
138
typedef struct _RygelClientHacksClass RygelClientHacksClass;
 
139
typedef struct _RygelHTTPGetPrivate RygelHTTPGetPrivate;
 
140
 
 
141
#define RYGEL_TYPE_THUMBNAIL (rygel_thumbnail_get_type ())
 
142
#define RYGEL_THUMBNAIL(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), RYGEL_TYPE_THUMBNAIL, RygelThumbnail))
 
143
#define RYGEL_THUMBNAIL_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), RYGEL_TYPE_THUMBNAIL, RygelThumbnailClass))
 
144
#define RYGEL_IS_THUMBNAIL(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), RYGEL_TYPE_THUMBNAIL))
 
145
#define RYGEL_IS_THUMBNAIL_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), RYGEL_TYPE_THUMBNAIL))
 
146
#define RYGEL_THUMBNAIL_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), RYGEL_TYPE_THUMBNAIL, RygelThumbnailClass))
 
147
 
 
148
typedef struct _RygelThumbnail RygelThumbnail;
 
149
typedef struct _RygelThumbnailClass RygelThumbnailClass;
 
150
 
 
151
#define RYGEL_TYPE_SUBTITLE (rygel_subtitle_get_type ())
 
152
#define RYGEL_SUBTITLE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), RYGEL_TYPE_SUBTITLE, RygelSubtitle))
 
153
#define RYGEL_SUBTITLE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), RYGEL_TYPE_SUBTITLE, RygelSubtitleClass))
 
154
#define RYGEL_IS_SUBTITLE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), RYGEL_TYPE_SUBTITLE))
 
155
#define RYGEL_IS_SUBTITLE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), RYGEL_TYPE_SUBTITLE))
 
156
#define RYGEL_SUBTITLE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), RYGEL_TYPE_SUBTITLE, RygelSubtitleClass))
 
157
 
 
158
typedef struct _RygelSubtitle RygelSubtitle;
 
159
typedef struct _RygelSubtitleClass RygelSubtitleClass;
 
160
 
 
161
#define RYGEL_TYPE_HTTP_GET_HANDLER (rygel_http_get_handler_get_type ())
 
162
#define RYGEL_HTTP_GET_HANDLER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), RYGEL_TYPE_HTTP_GET_HANDLER, RygelHTTPGetHandler))
 
163
#define RYGEL_HTTP_GET_HANDLER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), RYGEL_TYPE_HTTP_GET_HANDLER, RygelHTTPGetHandlerClass))
 
164
#define RYGEL_IS_HTTP_GET_HANDLER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), RYGEL_TYPE_HTTP_GET_HANDLER))
 
165
#define RYGEL_IS_HTTP_GET_HANDLER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), RYGEL_TYPE_HTTP_GET_HANDLER))
 
166
#define RYGEL_HTTP_GET_HANDLER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), RYGEL_TYPE_HTTP_GET_HANDLER, RygelHTTPGetHandlerClass))
 
167
 
 
168
typedef struct _RygelHTTPGetHandler RygelHTTPGetHandler;
 
169
typedef struct _RygelHTTPGetHandlerClass RygelHTTPGetHandlerClass;
 
170
typedef struct _RygelSubtitlePrivate RygelSubtitlePrivate;
 
171
#define _g_object_unref0(var) ((var == NULL) ? NULL : (var = (g_object_unref (var), NULL)))
 
172
 
 
173
#define RYGEL_TYPE_HTTP_IDENTITY_HANDLER (rygel_http_identity_handler_get_type ())
 
174
#define RYGEL_HTTP_IDENTITY_HANDLER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), RYGEL_TYPE_HTTP_IDENTITY_HANDLER, RygelHTTPIdentityHandler))
 
175
#define RYGEL_HTTP_IDENTITY_HANDLER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), RYGEL_TYPE_HTTP_IDENTITY_HANDLER, RygelHTTPIdentityHandlerClass))
 
176
#define RYGEL_IS_HTTP_IDENTITY_HANDLER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), RYGEL_TYPE_HTTP_IDENTITY_HANDLER))
 
177
#define RYGEL_IS_HTTP_IDENTITY_HANDLER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), RYGEL_TYPE_HTTP_IDENTITY_HANDLER))
 
178
#define RYGEL_HTTP_IDENTITY_HANDLER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), RYGEL_TYPE_HTTP_IDENTITY_HANDLER, RygelHTTPIdentityHandlerClass))
 
179
 
 
180
typedef struct _RygelHTTPIdentityHandler RygelHTTPIdentityHandler;
 
181
typedef struct _RygelHTTPIdentityHandlerClass RygelHTTPIdentityHandlerClass;
 
182
#define _g_free0(var) (var = (g_free (var), NULL))
 
183
 
 
184
struct _RygelHTTPSeek {
 
185
        GObject parent_instance;
 
186
        RygelHTTPSeekPrivate * priv;
 
187
};
 
188
 
 
189
struct _RygelHTTPSeekClass {
 
190
        GObjectClass parent_class;
 
191
        void (*add_response_headers) (RygelHTTPSeek* self);
 
192
};
 
193
 
 
194
struct _RygelHTTPByteSeek {
 
195
        RygelHTTPSeek parent_instance;
 
196
        RygelHTTPByteSeekPrivate * priv;
 
197
};
 
198
 
 
199
struct _RygelHTTPByteSeekClass {
 
200
        RygelHTTPSeekClass parent_class;
 
201
};
 
202
 
 
203
typedef enum  {
 
204
        RYGEL_HTTP_SEEK_ERROR_INVALID_RANGE = SOUP_STATUS_BAD_REQUEST,
 
205
        RYGEL_HTTP_SEEK_ERROR_OUT_OF_RANGE = SOUP_STATUS_REQUESTED_RANGE_NOT_SATISFIABLE
 
206
} RygelHTTPSeekError;
 
207
#define RYGEL_HTTP_SEEK_ERROR rygel_http_seek_error_quark ()
 
208
struct _RygelHTTPRequest {
 
209
        GObject parent_instance;
 
210
        RygelHTTPRequestPrivate * priv;
 
211
        RygelHTTPServer* http_server;
 
212
        SoupServer* server;
 
213
        SoupMessage* msg;
 
214
        RygelHTTPItemURI* uri;
 
215
        RygelMediaItem* item;
 
216
        RygelClientHacks* hack;
 
217
};
 
218
 
 
219
struct _RygelHTTPRequestClass {
 
220
        GObjectClass parent_class;
 
221
        void (*handle) (RygelHTTPRequest* self, GAsyncReadyCallback _callback_, gpointer _user_data_);
 
222
        void (*handle_finish) (RygelHTTPRequest* self, GAsyncResult* _res_, GError** error);
 
223
        void (*find_item) (RygelHTTPRequest* self, GAsyncReadyCallback _callback_, gpointer _user_data_);
 
224
        void (*find_item_finish) (RygelHTTPRequest* self, GAsyncResult* _res_, GError** error);
 
225
};
 
226
 
 
227
struct _RygelHTTPGet {
 
228
        RygelHTTPRequest parent_instance;
 
229
        RygelHTTPGetPrivate * priv;
 
230
        RygelThumbnail* thumbnail;
 
231
        RygelSubtitle* subtitle;
 
232
        RygelHTTPSeek* seek;
 
233
        RygelHTTPGetHandler* handler;
 
234
};
 
235
 
 
236
struct _RygelHTTPGetClass {
 
237
        RygelHTTPRequestClass parent_class;
 
238
};
 
239
 
 
240
struct _RygelSubtitle {
 
241
        GTypeInstance parent_instance;
 
242
        volatile int ref_count;
 
243
        RygelSubtitlePrivate * priv;
 
244
        gchar* uri;
 
245
        gchar* mime_type;
 
246
        gchar* caption_type;
 
247
        gint64 size;
 
248
};
 
249
 
 
250
struct _RygelSubtitleClass {
 
251
        GTypeClass parent_class;
 
252
        void (*finalize) (RygelSubtitle *self);
 
253
};
 
254
 
 
255
 
 
256
static gpointer rygel_http_byte_seek_parent_class = NULL;
 
257
 
 
258
GType rygel_http_seek_get_type (void) G_GNUC_CONST;
 
259
GType rygel_http_byte_seek_get_type (void) G_GNUC_CONST;
 
260
enum  {
 
261
        RYGEL_HTTP_BYTE_SEEK_DUMMY_PROPERTY
 
262
};
 
263
GType rygel_http_request_get_type (void) G_GNUC_CONST;
 
264
GType rygel_http_get_get_type (void) G_GNUC_CONST;
 
265
GQuark rygel_http_seek_error_quark (void);
 
266
RygelHTTPByteSeek* rygel_http_byte_seek_new (RygelHTTPGet* request, GError** error);
 
267
RygelHTTPByteSeek* rygel_http_byte_seek_construct (GType object_type, RygelHTTPGet* request, GError** error);
 
268
GType rygel_transcode_manager_get_type (void) G_GNUC_CONST;
 
269
GType rygel_http_server_get_type (void) G_GNUC_CONST;
 
270
GType rygel_http_item_uri_get_type (void) G_GNUC_CONST;
 
271
GType rygel_media_object_get_type (void) G_GNUC_CONST;
 
272
GType rygel_media_item_get_type (void) G_GNUC_CONST;
 
273
GType rygel_client_hacks_get_type (void) G_GNUC_CONST;
 
274
GType rygel_thumbnail_get_type (void) G_GNUC_CONST;
 
275
gpointer rygel_subtitle_ref (gpointer instance);
 
276
void rygel_subtitle_unref (gpointer instance);
 
277
GParamSpec* rygel_param_spec_subtitle (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags);
 
278
void rygel_value_set_subtitle (GValue* value, gpointer v_object);
 
279
void rygel_value_take_subtitle (GValue* value, gpointer v_object);
 
280
gpointer rygel_value_get_subtitle (const GValue* value);
 
281
GType rygel_subtitle_get_type (void) G_GNUC_CONST;
 
282
GType rygel_http_get_handler_get_type (void) G_GNUC_CONST;
 
283
gint64 rygel_media_item_get_size (RygelMediaItem* self);
 
284
RygelHTTPSeek* rygel_http_seek_construct (GType object_type, SoupMessage* msg, gint64 start, gint64 stop, gint64 step, gint64 total_length, GError** error);
 
285
gboolean rygel_http_byte_seek_needed (RygelHTTPGet* request);
 
286
GType rygel_http_identity_handler_get_type (void) G_GNUC_CONST;
 
287
gboolean rygel_http_byte_seek_requested (RygelHTTPGet* request);
 
288
static void rygel_http_byte_seek_real_add_response_headers (RygelHTTPSeek* base);
 
289
SoupMessage* rygel_http_seek_get_msg (RygelHTTPSeek* self);
 
290
gint64 rygel_http_seek_get_start (RygelHTTPSeek* self);
 
291
gint64 rygel_http_seek_get_stop (RygelHTTPSeek* self);
 
292
gint64 rygel_http_seek_get_total_length (RygelHTTPSeek* self);
 
293
gint64 rygel_http_seek_get_length (RygelHTTPSeek* self);
 
294
 
 
295
 
 
296
RygelHTTPByteSeek* rygel_http_byte_seek_construct (GType object_type, RygelHTTPGet* request, GError** error) {
 
297
        RygelHTTPByteSeek * self = NULL;
 
298
        SoupRange* ranges = NULL;
 
299
        gint ranges_length1 = 0;
 
300
        gint _ranges_size_ = 0;
 
301
        gint64 start;
 
302
        gint64 total_length = 0LL;
 
303
        RygelHTTPGet* _tmp0_;
 
304
        SoupMessage* _tmp1_;
 
305
        SoupMessageHeaders* _tmp2_;
 
306
        const gchar* _tmp3_ = NULL;
 
307
        const gchar* range;
 
308
        RygelHTTPGet* _tmp4_;
 
309
        RygelThumbnail* _tmp5_;
 
310
        gint64 _tmp18_;
 
311
        gint64 stop;
 
312
        const gchar* _tmp19_;
 
313
        RygelHTTPGet* _tmp41_;
 
314
        SoupMessage* _tmp42_;
 
315
        gint64 _tmp43_;
 
316
        gint64 _tmp44_;
 
317
        gint64 _tmp45_;
 
318
        GError * _inner_error_ = NULL;
 
319
        g_return_val_if_fail (request != NULL, NULL);
 
320
        start = (gint64) 0;
 
321
        _tmp0_ = request;
 
322
        _tmp1_ = ((RygelHTTPRequest*) _tmp0_)->msg;
 
323
        _tmp2_ = _tmp1_->request_headers;
 
324
        _tmp3_ = soup_message_headers_get_one (_tmp2_, "Range");
 
325
        range = _tmp3_;
 
326
        _tmp4_ = request;
 
327
        _tmp5_ = _tmp4_->thumbnail;
 
328
        if (_tmp5_ != NULL) {
 
329
                RygelHTTPGet* _tmp6_;
 
330
                RygelThumbnail* _tmp7_;
 
331
                gint64 _tmp8_;
 
332
                _tmp6_ = request;
 
333
                _tmp7_ = _tmp6_->thumbnail;
 
334
                _tmp8_ = ((RygelIconInfo*) _tmp7_)->size;
 
335
                total_length = _tmp8_;
 
336
        } else {
 
337
                RygelHTTPGet* _tmp9_;
 
338
                RygelSubtitle* _tmp10_;
 
339
                _tmp9_ = request;
 
340
                _tmp10_ = _tmp9_->subtitle;
 
341
                if (_tmp10_ != NULL) {
 
342
                        RygelHTTPGet* _tmp11_;
 
343
                        RygelSubtitle* _tmp12_;
 
344
                        gint64 _tmp13_;
 
345
                        _tmp11_ = request;
 
346
                        _tmp12_ = _tmp11_->subtitle;
 
347
                        _tmp13_ = _tmp12_->size;
 
348
                        total_length = _tmp13_;
 
349
                } else {
 
350
                        RygelHTTPGet* _tmp14_;
 
351
                        RygelMediaItem* _tmp15_;
 
352
                        gint64 _tmp16_;
 
353
                        gint64 _tmp17_;
 
354
                        _tmp14_ = request;
 
355
                        _tmp15_ = ((RygelHTTPRequest*) _tmp14_)->item;
 
356
                        _tmp16_ = rygel_media_item_get_size (_tmp15_);
 
357
                        _tmp17_ = _tmp16_;
 
358
                        total_length = _tmp17_;
 
359
                }
 
360
        }
 
361
        _tmp18_ = total_length;
 
362
        stop = _tmp18_ - 1;
 
363
        _tmp19_ = range;
 
364
        if (_tmp19_ != NULL) {
 
365
                RygelHTTPGet* _tmp20_;
 
366
                SoupMessage* _tmp21_;
 
367
                SoupMessageHeaders* _tmp22_;
 
368
                gint64 _tmp23_;
 
369
                SoupRange* _tmp24_ = NULL;
 
370
                gint _tmp25_ = 0;
 
371
                gboolean _tmp26_ = FALSE;
 
372
                gint64 _tmp36_;
 
373
                gint64 _tmp37_;
 
374
                _tmp20_ = request;
 
375
                _tmp21_ = ((RygelHTTPRequest*) _tmp20_)->msg;
 
376
                _tmp22_ = _tmp21_->request_headers;
 
377
                _tmp23_ = total_length;
 
378
                _tmp26_ = soup_message_headers_get_ranges (_tmp22_, _tmp23_, (SoupRange**) (&_tmp24_), &_tmp25_);
 
379
                ranges = (g_free (ranges), NULL);
 
380
                ranges = _tmp24_;
 
381
                ranges_length1 = _tmp25_;
 
382
                _ranges_size_ = ranges_length1;
 
383
                if (_tmp26_) {
 
384
                        SoupRange* _tmp27_;
 
385
                        gint _tmp27__length1;
 
386
                        SoupRange _tmp28_;
 
387
                        gint64 _tmp29_;
 
388
                        SoupRange* _tmp30_;
 
389
                        gint _tmp30__length1;
 
390
                        SoupRange _tmp31_;
 
391
                        gint64 _tmp32_;
 
392
                        _tmp27_ = ranges;
 
393
                        _tmp27__length1 = ranges_length1;
 
394
                        _tmp28_ = _tmp27_[0];
 
395
                        _tmp29_ = _tmp28_.start;
 
396
                        start = _tmp29_;
 
397
                        _tmp30_ = ranges;
 
398
                        _tmp30__length1 = ranges_length1;
 
399
                        _tmp31_ = _tmp30_[0];
 
400
                        _tmp32_ = _tmp31_.end;
 
401
                        stop = _tmp32_;
 
402
                } else {
 
403
                        const gchar* _tmp33_ = NULL;
 
404
                        const gchar* _tmp34_;
 
405
                        GError* _tmp35_;
 
406
                        _tmp33_ = _ ("Invalid Range '%s'");
 
407
                        _tmp34_ = range;
 
408
                        _tmp35_ = g_error_new (RYGEL_HTTP_SEEK_ERROR, RYGEL_HTTP_SEEK_ERROR_INVALID_RANGE, _tmp33_, _tmp34_);
 
409
                        _inner_error_ = _tmp35_;
 
410
                        if (_inner_error_->domain == RYGEL_HTTP_SEEK_ERROR) {
 
411
                                g_propagate_error (error, _inner_error_);
 
412
                                ranges = (g_free (ranges), NULL);
 
413
                                _g_object_unref0 (self);
 
414
                                return NULL;
 
415
                        } else {
 
416
                                ranges = (g_free (ranges), NULL);
 
417
                                g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
 
418
                                g_clear_error (&_inner_error_);
 
419
                                return NULL;
 
420
                        }
 
421
                }
 
422
                _tmp36_ = start;
 
423
                _tmp37_ = stop;
 
424
                if (_tmp36_ > _tmp37_) {
 
425
                        const gchar* _tmp38_ = NULL;
 
426
                        const gchar* _tmp39_;
 
427
                        GError* _tmp40_;
 
428
                        _tmp38_ = _ ("Invalid Range '%s'");
 
429
                        _tmp39_ = range;
 
430
                        _tmp40_ = g_error_new (RYGEL_HTTP_SEEK_ERROR, RYGEL_HTTP_SEEK_ERROR_INVALID_RANGE, _tmp38_, _tmp39_);
 
431
                        _inner_error_ = _tmp40_;
 
432
                        if (_inner_error_->domain == RYGEL_HTTP_SEEK_ERROR) {
 
433
                                g_propagate_error (error, _inner_error_);
 
434
                                ranges = (g_free (ranges), NULL);
 
435
                                _g_object_unref0 (self);
 
436
                                return NULL;
 
437
                        } else {
 
438
                                ranges = (g_free (ranges), NULL);
 
439
                                g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
 
440
                                g_clear_error (&_inner_error_);
 
441
                                return NULL;
 
442
                        }
 
443
                }
 
444
        }
 
445
        _tmp41_ = request;
 
446
        _tmp42_ = ((RygelHTTPRequest*) _tmp41_)->msg;
 
447
        _tmp43_ = start;
 
448
        _tmp44_ = stop;
 
449
        _tmp45_ = total_length;
 
450
        self = (RygelHTTPByteSeek*) rygel_http_seek_construct (object_type, _tmp42_, _tmp43_, _tmp44_, (gint64) 1, _tmp45_, &_inner_error_);
 
451
        if (_inner_error_ != NULL) {
 
452
                if (_inner_error_->domain == RYGEL_HTTP_SEEK_ERROR) {
 
453
                        g_propagate_error (error, _inner_error_);
 
454
                        ranges = (g_free (ranges), NULL);
 
455
                        _g_object_unref0 (self);
 
456
                        return NULL;
 
457
                } else {
 
458
                        ranges = (g_free (ranges), NULL);
 
459
                        g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
 
460
                        g_clear_error (&_inner_error_);
 
461
                        return NULL;
 
462
                }
 
463
        }
 
464
        ranges = (g_free (ranges), NULL);
 
465
        return self;
 
466
}
 
467
 
 
468
 
 
469
RygelHTTPByteSeek* rygel_http_byte_seek_new (RygelHTTPGet* request, GError** error) {
 
470
        return rygel_http_byte_seek_construct (RYGEL_TYPE_HTTP_BYTE_SEEK, request, error);
 
471
}
 
472
 
 
473
 
 
474
gboolean rygel_http_byte_seek_needed (RygelHTTPGet* request) {
 
475
        gboolean result = FALSE;
 
476
        gboolean _tmp0_ = FALSE;
 
477
        gboolean _tmp1_ = FALSE;
 
478
        gboolean _tmp2_ = FALSE;
 
479
        gboolean _tmp3_ = FALSE;
 
480
        RygelHTTPGet* _tmp4_;
 
481
        RygelMediaItem* _tmp5_;
 
482
        gint64 _tmp6_;
 
483
        gint64 _tmp7_;
 
484
        gboolean _tmp10_;
 
485
        gboolean _tmp18_;
 
486
        gboolean _tmp26_;
 
487
        gboolean _tmp31_;
 
488
        g_return_val_if_fail (request != NULL, FALSE);
 
489
        _tmp4_ = request;
 
490
        _tmp5_ = ((RygelHTTPRequest*) _tmp4_)->item;
 
491
        _tmp6_ = rygel_media_item_get_size (_tmp5_);
 
492
        _tmp7_ = _tmp6_;
 
493
        if (_tmp7_ > ((gint64) 0)) {
 
494
                RygelHTTPGet* _tmp8_;
 
495
                RygelHTTPGetHandler* _tmp9_;
 
496
                _tmp8_ = request;
 
497
                _tmp9_ = _tmp8_->handler;
 
498
                _tmp3_ = RYGEL_IS_HTTP_IDENTITY_HANDLER (_tmp9_);
 
499
        } else {
 
500
                _tmp3_ = FALSE;
 
501
        }
 
502
        _tmp10_ = _tmp3_;
 
503
        if (_tmp10_) {
 
504
                _tmp2_ = TRUE;
 
505
        } else {
 
506
                gboolean _tmp11_ = FALSE;
 
507
                RygelHTTPGet* _tmp12_;
 
508
                RygelThumbnail* _tmp13_;
 
509
                gboolean _tmp17_;
 
510
                _tmp12_ = request;
 
511
                _tmp13_ = _tmp12_->thumbnail;
 
512
                if (_tmp13_ != NULL) {
 
513
                        RygelHTTPGet* _tmp14_;
 
514
                        RygelThumbnail* _tmp15_;
 
515
                        gint64 _tmp16_;
 
516
                        _tmp14_ = request;
 
517
                        _tmp15_ = _tmp14_->thumbnail;
 
518
                        _tmp16_ = ((RygelIconInfo*) _tmp15_)->size;
 
519
                        _tmp11_ = _tmp16_ > ((gint64) 0);
 
520
                } else {
 
521
                        _tmp11_ = FALSE;
 
522
                }
 
523
                _tmp17_ = _tmp11_;
 
524
                _tmp2_ = _tmp17_;
 
525
        }
 
526
        _tmp18_ = _tmp2_;
 
527
        if (_tmp18_) {
 
528
                _tmp1_ = TRUE;
 
529
        } else {
 
530
                gboolean _tmp19_ = FALSE;
 
531
                RygelHTTPGet* _tmp20_;
 
532
                RygelSubtitle* _tmp21_;
 
533
                gboolean _tmp25_;
 
534
                _tmp20_ = request;
 
535
                _tmp21_ = _tmp20_->subtitle;
 
536
                if (_tmp21_ != NULL) {
 
537
                        RygelHTTPGet* _tmp22_;
 
538
                        RygelSubtitle* _tmp23_;
 
539
                        gint64 _tmp24_;
 
540
                        _tmp22_ = request;
 
541
                        _tmp23_ = _tmp22_->subtitle;
 
542
                        _tmp24_ = _tmp23_->size;
 
543
                        _tmp19_ = _tmp24_ > ((gint64) 0);
 
544
                } else {
 
545
                        _tmp19_ = FALSE;
 
546
                }
 
547
                _tmp25_ = _tmp19_;
 
548
                _tmp1_ = _tmp25_;
 
549
        }
 
550
        _tmp26_ = _tmp1_;
 
551
        if (_tmp26_) {
 
552
                _tmp0_ = TRUE;
 
553
        } else {
 
554
                RygelHTTPGet* _tmp27_;
 
555
                SoupMessage* _tmp28_;
 
556
                SoupMessageHeaders* _tmp29_;
 
557
                const gchar* _tmp30_ = NULL;
 
558
                _tmp27_ = request;
 
559
                _tmp28_ = ((RygelHTTPRequest*) _tmp27_)->msg;
 
560
                _tmp29_ = _tmp28_->request_headers;
 
561
                _tmp30_ = soup_message_headers_get_one (_tmp29_, "User-Agent");
 
562
                _tmp0_ = g_strcmp0 (_tmp30_, "PLAYSTATION 3") == 0;
 
563
        }
 
564
        _tmp31_ = _tmp0_;
 
565
        result = _tmp31_;
 
566
        return result;
 
567
}
 
568
 
 
569
 
 
570
gboolean rygel_http_byte_seek_requested (RygelHTTPGet* request) {
 
571
        gboolean result = FALSE;
 
572
        RygelHTTPGet* _tmp0_;
 
573
        SoupMessage* _tmp1_;
 
574
        SoupMessageHeaders* _tmp2_;
 
575
        const gchar* _tmp3_ = NULL;
 
576
        g_return_val_if_fail (request != NULL, FALSE);
 
577
        _tmp0_ = request;
 
578
        _tmp1_ = ((RygelHTTPRequest*) _tmp0_)->msg;
 
579
        _tmp2_ = _tmp1_->request_headers;
 
580
        _tmp3_ = soup_message_headers_get_one (_tmp2_, "Range");
 
581
        result = _tmp3_ != NULL;
 
582
        return result;
 
583
}
 
584
 
 
585
 
 
586
static void rygel_http_byte_seek_real_add_response_headers (RygelHTTPSeek* base) {
 
587
        RygelHTTPByteSeek * self;
 
588
        gchar* _tmp0_;
 
589
        gchar* range;
 
590
        SoupMessage* _tmp1_;
 
591
        SoupMessage* _tmp2_;
 
592
        SoupMessageHeaders* _tmp3_;
 
593
        SoupMessageHeaders* headers;
 
594
        SoupMessage* _tmp4_;
 
595
        SoupMessage* _tmp5_;
 
596
        SoupMessageHeaders* _tmp6_;
 
597
        const gchar* _tmp7_ = NULL;
 
598
        SoupMessageHeaders* _tmp33_;
 
599
        gint64 _tmp34_;
 
600
        gint64 _tmp35_;
 
601
        self = (RygelHTTPByteSeek*) base;
 
602
        _tmp0_ = g_strdup ("bytes ");
 
603
        range = _tmp0_;
 
604
        _tmp1_ = rygel_http_seek_get_msg ((RygelHTTPSeek*) self);
 
605
        _tmp2_ = _tmp1_;
 
606
        _tmp3_ = _tmp2_->response_headers;
 
607
        headers = _tmp3_;
 
608
        _tmp4_ = rygel_http_seek_get_msg ((RygelHTTPSeek*) self);
 
609
        _tmp5_ = _tmp4_;
 
610
        _tmp6_ = _tmp5_->request_headers;
 
611
        _tmp7_ = soup_message_headers_get_one (_tmp6_, "Range");
 
612
        if (_tmp7_ != NULL) {
 
613
                SoupMessageHeaders* _tmp8_;
 
614
                const gchar* _tmp9_;
 
615
                gint64 _tmp10_;
 
616
                gint64 _tmp11_;
 
617
                gchar* _tmp12_ = NULL;
 
618
                gchar* _tmp13_;
 
619
                gchar* _tmp14_;
 
620
                gchar* _tmp15_;
 
621
                gint64 _tmp16_;
 
622
                gint64 _tmp17_;
 
623
                gchar* _tmp18_ = NULL;
 
624
                gchar* _tmp19_;
 
625
                gchar* _tmp20_;
 
626
                gchar* _tmp21_;
 
627
                gchar* _tmp22_;
 
628
                gchar* _tmp23_;
 
629
                gint64 _tmp24_;
 
630
                gint64 _tmp25_;
 
631
                gchar* _tmp26_ = NULL;
 
632
                gchar* _tmp27_;
 
633
                gchar* _tmp28_;
 
634
                gchar* _tmp29_;
 
635
                gchar* _tmp30_;
 
636
                SoupMessageHeaders* _tmp31_;
 
637
                const gchar* _tmp32_;
 
638
                _tmp8_ = headers;
 
639
                soup_message_headers_append (_tmp8_, "Accept-Ranges", "bytes");
 
640
                _tmp9_ = range;
 
641
                _tmp10_ = rygel_http_seek_get_start ((RygelHTTPSeek*) self);
 
642
                _tmp11_ = _tmp10_;
 
643
                _tmp12_ = g_strdup_printf ("%" G_GINT64_FORMAT, _tmp11_);
 
644
                _tmp13_ = _tmp12_;
 
645
                _tmp14_ = g_strconcat (_tmp13_, "-", NULL);
 
646
                _tmp15_ = _tmp14_;
 
647
                _tmp16_ = rygel_http_seek_get_stop ((RygelHTTPSeek*) self);
 
648
                _tmp17_ = _tmp16_;
 
649
                _tmp18_ = g_strdup_printf ("%" G_GINT64_FORMAT, _tmp17_);
 
650
                _tmp19_ = _tmp18_;
 
651
                _tmp20_ = g_strconcat (_tmp15_, _tmp19_, NULL);
 
652
                _tmp21_ = _tmp20_;
 
653
                _tmp22_ = g_strconcat (_tmp21_, "/", NULL);
 
654
                _tmp23_ = _tmp22_;
 
655
                _tmp24_ = rygel_http_seek_get_total_length ((RygelHTTPSeek*) self);
 
656
                _tmp25_ = _tmp24_;
 
657
                _tmp26_ = g_strdup_printf ("%" G_GINT64_FORMAT, _tmp25_);
 
658
                _tmp27_ = _tmp26_;
 
659
                _tmp28_ = g_strconcat (_tmp23_, _tmp27_, NULL);
 
660
                _tmp29_ = _tmp28_;
 
661
                _tmp30_ = g_strconcat (_tmp9_, _tmp29_, NULL);
 
662
                _g_free0 (range);
 
663
                range = _tmp30_;
 
664
                _g_free0 (_tmp29_);
 
665
                _g_free0 (_tmp27_);
 
666
                _g_free0 (_tmp23_);
 
667
                _g_free0 (_tmp21_);
 
668
                _g_free0 (_tmp19_);
 
669
                _g_free0 (_tmp15_);
 
670
                _g_free0 (_tmp13_);
 
671
                _tmp31_ = headers;
 
672
                _tmp32_ = range;
 
673
                soup_message_headers_append (_tmp31_, "Content-Range", _tmp32_);
 
674
        }
 
675
        _tmp33_ = headers;
 
676
        _tmp34_ = rygel_http_seek_get_length ((RygelHTTPSeek*) self);
 
677
        _tmp35_ = _tmp34_;
 
678
        soup_message_headers_set_content_length (_tmp33_, _tmp35_);
 
679
        _g_free0 (range);
 
680
}
 
681
 
 
682
 
 
683
static void rygel_http_byte_seek_class_init (RygelHTTPByteSeekClass * klass) {
 
684
        rygel_http_byte_seek_parent_class = g_type_class_peek_parent (klass);
 
685
        RYGEL_HTTP_SEEK_CLASS (klass)->add_response_headers = rygel_http_byte_seek_real_add_response_headers;
 
686
}
 
687
 
 
688
 
 
689
static void rygel_http_byte_seek_instance_init (RygelHTTPByteSeek * self) {
 
690
}
 
691
 
 
692
 
 
693
GType rygel_http_byte_seek_get_type (void) {
 
694
        static volatile gsize rygel_http_byte_seek_type_id__volatile = 0;
 
695
        if (g_once_init_enter (&rygel_http_byte_seek_type_id__volatile)) {
 
696
                static const GTypeInfo g_define_type_info = { sizeof (RygelHTTPByteSeekClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) rygel_http_byte_seek_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (RygelHTTPByteSeek), 0, (GInstanceInitFunc) rygel_http_byte_seek_instance_init, NULL };
 
697
                GType rygel_http_byte_seek_type_id;
 
698
                rygel_http_byte_seek_type_id = g_type_register_static (RYGEL_TYPE_HTTP_SEEK, "RygelHTTPByteSeek", &g_define_type_info, 0);
 
699
                g_once_init_leave (&rygel_http_byte_seek_type_id__volatile, rygel_http_byte_seek_type_id);
 
700
        }
 
701
        return rygel_http_byte_seek_type_id__volatile;
 
702
}
 
703
 
 
704
 
 
705