gstoggmux.c 53.4 KB
Newer Older
Wim Taymans's avatar
Wim Taymans committed
1
2
/* OGG muxer plugin for GStreamer
 * Copyright (C) 2004 Wim Taymans <wim@fluendo.com>
3
 * Copyright (C) 2006 Thomas Vander Stichele <thomas at apestaart dot org>
Wim Taymans's avatar
Wim Taymans committed
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Library General Public
 * License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Library General Public License for more details.
 *
 * You should have received a copy of the GNU Library General Public
 * License along with this library; if not, write to the
 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
 * Boston, MA 02111-1307, USA.
 */

21
22
/**
 * SECTION:element-oggmux
Stefan Kost's avatar
Stefan Kost committed
23
 * @see_also: <link linkend="gst-plugins-base-plugins-oggdemux">oggdemux</link>
24
25
 *
 * This element merges streams (audio and video) into ogg files.
26
27
 *
 * <refsect2>
28
 * <title>Example pipelines</title>
29
 * |[
30
 * gst-launch v4l2src num-buffers=500 ! video/x-raw-yuv,width=320,height=240 ! ffmpegcolorspace ! theoraenc ! oggmux ! filesink location=video.ogg
31
 * ]| Encodes a video stream captured from a v4l2-compatible camera to Ogg/Theora
32
 * (the encoding will stop automatically after 500 frames)
33
34
35
36
37
 * </refsect2>
 *
 * Last reviewed on 2008-02-06 (0.10.17)
 */

Wim Taymans's avatar
Wim Taymans committed
38
39
40
41
42
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif

#include <gst/gst.h>
Wim Taymans's avatar
Wim Taymans committed
43
#include <gst/base/gstcollectpads.h>
44
#include <gst/tag/tag.h>
Wim Taymans's avatar
Wim Taymans committed
45

46
47
#include "gstoggmux.h"

Thomas Vander Stichele's avatar
Thomas Vander Stichele committed
48
/* memcpy - if someone knows a way to get rid of it, please speak up
Wim Taymans's avatar
Wim Taymans committed
49
50
51
 * note: the ogg docs even say you need this... */
#include <string.h>
#include <time.h>
Thomas Vander Stichele's avatar
Thomas Vander Stichele committed
52
#include <stdlib.h>             /* rand, srand, atoi */
Wim Taymans's avatar
Wim Taymans committed
53
54
55
56

GST_DEBUG_CATEGORY_STATIC (gst_ogg_mux_debug);
#define GST_CAT_DEFAULT gst_ogg_mux_debug

57
58
59
60
61
62
63
64
/* This isn't generally what you'd want with an end-time macro, because
   technically the end time of a buffer with invalid duration is invalid. But
   for sorting ogg pages this is what we want. */
#define GST_BUFFER_END_TIME(buf) \
    (GST_BUFFER_DURATION_IS_VALID (buf) \
    ? GST_BUFFER_TIMESTAMP (buf) + GST_BUFFER_DURATION (buf) \
    : GST_BUFFER_TIMESTAMP (buf))

65
#define GST_GP_FORMAT "[gp %8" G_GINT64_FORMAT "]"
66
#define GST_GP_CAST(_gp) ((gint64) _gp)
67

Wim Taymans's avatar
Wim Taymans committed
68
69
70
71
72
73
74
75
76
77
78
79
80
81
typedef enum
{
  GST_OGG_FLAG_BOS = GST_ELEMENT_FLAG_LAST,
  GST_OGG_FLAG_EOS
}
GstOggFlag;

/* OggMux signals and args */
enum
{
  /* FILL ME */
  LAST_SIGNAL
};

Wim Taymans's avatar
Wim Taymans committed
82
/* set to 0.5 seconds by default */
Thomas Vander Stichele's avatar
Thomas Vander Stichele committed
83
84
#define DEFAULT_MAX_DELAY       G_GINT64_CONSTANT(500000000)
#define DEFAULT_MAX_PAGE_DELAY  G_GINT64_CONSTANT(500000000)
Wim Taymans's avatar
Wim Taymans committed
85
86
enum
{
87
88
  ARG_0,
  ARG_MAX_DELAY,
89
  ARG_MAX_PAGE_DELAY,
Wim Taymans's avatar
Wim Taymans committed
90
91
92
93
94
95
96
97
98
99
100
};

static GstStaticPadTemplate src_factory = GST_STATIC_PAD_TEMPLATE ("src",
    GST_PAD_SRC,
    GST_PAD_ALWAYS,
    GST_STATIC_CAPS ("application/ogg")
    );

static GstStaticPadTemplate sink_factory = GST_STATIC_PAD_TEMPLATE ("sink_%d",
    GST_PAD_SINK,
    GST_PAD_REQUEST,
101
    GST_STATIC_CAPS ("video/x-theora; "
102
        "audio/x-vorbis; audio/x-flac; audio/x-speex; audio/x-celt; "
103
        "application/x-ogm-video; application/x-ogm-audio; video/x-dirac; "
104
        "video/x-smoke; video/x-vp8; text/x-cmml, encoded = (boolean) TRUE; "
105
        "subtitle/x-kate; application/x-kate")
Wim Taymans's avatar
Wim Taymans committed
106
107
108
109
110
    );

static void gst_ogg_mux_base_init (gpointer g_class);
static void gst_ogg_mux_class_init (GstOggMuxClass * klass);
static void gst_ogg_mux_init (GstOggMux * ogg_mux);
111
static void gst_ogg_mux_finalize (GObject * object);
Wim Taymans's avatar
Wim Taymans committed
112

Wim Taymans's avatar
Wim Taymans committed
113
114
static GstFlowReturn
gst_ogg_mux_collected (GstCollectPads * pads, GstOggMux * ogg_mux);
Wim Taymans's avatar
Wim Taymans committed
115
116
117
static gboolean gst_ogg_mux_handle_src_event (GstPad * pad, GstEvent * event);
static GstPad *gst_ogg_mux_request_new_pad (GstElement * element,
    GstPadTemplate * templ, const gchar * name);
118
119
static void gst_ogg_mux_release_pad (GstElement * element, GstPad * pad);

Wim Taymans's avatar
Wim Taymans committed
120
121
122
123
static void gst_ogg_mux_set_property (GObject * object,
    guint prop_id, const GValue * value, GParamSpec * pspec);
static void gst_ogg_mux_get_property (GObject * object,
    guint prop_id, GValue * value, GParamSpec * pspec);
124
125
static GstStateChangeReturn gst_ogg_mux_change_state (GstElement * element,
    GstStateChange transition);
Wim Taymans's avatar
Wim Taymans committed
126
127
128
129
130
131
132
133
134
135

static GstElementClass *parent_class = NULL;

/*static guint gst_ogg_mux_signals[LAST_SIGNAL] = { 0 }; */

GType
gst_ogg_mux_get_type (void)
{
  static GType ogg_mux_type = 0;

136
  if (G_UNLIKELY (ogg_mux_type == 0)) {
Wim Taymans's avatar
Wim Taymans committed
137
138
139
140
141
142
143
144
145
146
147
    static const GTypeInfo ogg_mux_info = {
      sizeof (GstOggMuxClass),
      gst_ogg_mux_base_init,
      NULL,
      (GClassInitFunc) gst_ogg_mux_class_init,
      NULL,
      NULL,
      sizeof (GstOggMux),
      0,
      (GInstanceInitFunc) gst_ogg_mux_init,
    };
148
149
150
151
152
    static const GInterfaceInfo preset_info = {
      NULL,
      NULL,
      NULL
    };
Wim Taymans's avatar
Wim Taymans committed
153
154
155
156

    ogg_mux_type =
        g_type_register_static (GST_TYPE_ELEMENT, "GstOggMux", &ogg_mux_info,
        0);
157
158

    g_type_add_interface_static (ogg_mux_type, GST_TYPE_PRESET, &preset_info);
Wim Taymans's avatar
Wim Taymans committed
159
160
161
162
163
164
165
166
167
168
169
170
171
172
  }
  return ogg_mux_type;
}

static void
gst_ogg_mux_base_init (gpointer g_class)
{
  GstElementClass *element_class = GST_ELEMENT_CLASS (g_class);

  gst_element_class_add_pad_template (element_class,
      gst_static_pad_template_get (&src_factory));
  gst_element_class_add_pad_template (element_class,
      gst_static_pad_template_get (&sink_factory));

173
174
175
176
  gst_element_class_set_details_simple (element_class,
      "Ogg muxer", "Codec/Muxer",
      "mux ogg streams (info about ogg: http://xiph.org)",
      "Wim Taymans <wim@fluendo.com>");
Wim Taymans's avatar
Wim Taymans committed
177
178
179
180
181
182
183
184
185
186
187
}

static void
gst_ogg_mux_class_init (GstOggMuxClass * klass)
{
  GObjectClass *gobject_class;
  GstElementClass *gstelement_class;

  gobject_class = (GObjectClass *) klass;
  gstelement_class = (GstElementClass *) klass;

188
  parent_class = g_type_class_peek_parent (klass);
Wim Taymans's avatar
Wim Taymans committed
189

190
  gobject_class->finalize = gst_ogg_mux_finalize;
191
192
193
  gobject_class->get_property = gst_ogg_mux_get_property;
  gobject_class->set_property = gst_ogg_mux_set_property;

Wim Taymans's avatar
Wim Taymans committed
194
  gstelement_class->request_new_pad = gst_ogg_mux_request_new_pad;
195
  gstelement_class->release_pad = gst_ogg_mux_release_pad;
Wim Taymans's avatar
Wim Taymans committed
196

197
198
199
  g_object_class_install_property (gobject_class, ARG_MAX_DELAY,
      g_param_spec_uint64 ("max-delay", "Max delay",
          "Maximum delay in multiplexing streams", 0, G_MAXUINT64,
200
201
          DEFAULT_MAX_DELAY,
          (GParamFlags) G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
202
203
204
  g_object_class_install_property (gobject_class, ARG_MAX_PAGE_DELAY,
      g_param_spec_uint64 ("max-page-delay", "Max page delay",
          "Maximum delay for sending out a page", 0, G_MAXUINT64,
205
206
          DEFAULT_MAX_PAGE_DELAY,
          (GParamFlags) G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
207

Wim Taymans's avatar
Wim Taymans committed
208
209
210
211
  gstelement_class->change_state = gst_ogg_mux_change_state;

}

Wim Taymans's avatar
Wim Taymans committed
212
#if 0
Wim Taymans's avatar
Wim Taymans committed
213
214
215
216
217
static const GstEventMask *
gst_ogg_mux_get_sink_event_masks (GstPad * pad)
{
  static const GstEventMask gst_ogg_mux_sink_event_masks[] = {
    {GST_EVENT_EOS, 0},
Thomas Vander Stichele's avatar
Thomas Vander Stichele committed
218
    {GST_EVENT_DISCONTINUOUS, 0},
Wim Taymans's avatar
Wim Taymans committed
219
220
221
222
223
    {0,}
  };

  return gst_ogg_mux_sink_event_masks;
}
Wim Taymans's avatar
Wim Taymans committed
224
#endif
Wim Taymans's avatar
Wim Taymans committed
225

226
227
228
229
230
231
static void
gst_ogg_mux_clear (GstOggMux * ogg_mux)
{
  ogg_mux->pulling = NULL;
  ogg_mux->need_headers = TRUE;
  ogg_mux->delta_pad = NULL;
232
233
  ogg_mux->offset = 0;
  ogg_mux->next_ts = 0;
234
  ogg_mux->last_ts = GST_CLOCK_TIME_NONE;
235
236
}

Wim Taymans's avatar
Wim Taymans committed
237
238
239
240
241
242
243
244
245
246
247
static void
gst_ogg_mux_init (GstOggMux * ogg_mux)
{
  GstElementClass *klass = GST_ELEMENT_GET_CLASS (ogg_mux);

  ogg_mux->srcpad =
      gst_pad_new_from_template (gst_element_class_get_pad_template (klass,
          "src"), "src");
  gst_pad_set_event_function (ogg_mux->srcpad, gst_ogg_mux_handle_src_event);
  gst_element_add_pad (GST_ELEMENT (ogg_mux), ogg_mux->srcpad);

248
  GST_OBJECT_FLAG_SET (GST_ELEMENT (ogg_mux), GST_OGG_FLAG_BOS);
Wim Taymans's avatar
Wim Taymans committed
249
250
251
252

  /* seed random number generator for creation of serial numbers */
  srand (time (NULL));

253
254
  ogg_mux->collect = gst_collect_pads_new ();
  gst_collect_pads_set_function (ogg_mux->collect,
255
256
      (GstCollectPadsFunction) GST_DEBUG_FUNCPTR (gst_ogg_mux_collected),
      ogg_mux);
257

258
259
260
  ogg_mux->max_delay = DEFAULT_MAX_DELAY;
  ogg_mux->max_page_delay = DEFAULT_MAX_PAGE_DELAY;

261
  gst_ogg_mux_clear (ogg_mux);
Wim Taymans's avatar
Wim Taymans committed
262
263
}

264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
static void
gst_ogg_mux_finalize (GObject * object)
{
  GstOggMux *ogg_mux;

  ogg_mux = GST_OGG_MUX (object);

  if (ogg_mux->collect) {
    gst_object_unref (ogg_mux->collect);
    ogg_mux->collect = NULL;
  }

  G_OBJECT_CLASS (parent_class)->finalize (object);
}

279
280
281
static void
gst_ogg_mux_ogg_pad_destroy_notify (GstCollectData * data)
{
282
  GstOggPadData *oggpad = (GstOggPadData *) data;
283
284
  GstBuffer *buf;

285
  ogg_stream_clear (&oggpad->map.stream);
286
287
288
289
290
291
292
293
294
295

  if (oggpad->pagebuffers) {
    while ((buf = g_queue_pop_head (oggpad->pagebuffers)) != NULL) {
      gst_buffer_unref (buf);
    }
    g_queue_free (oggpad->pagebuffers);
    oggpad->pagebuffers = NULL;
  }
}

Wim Taymans's avatar
Wim Taymans committed
296
static GstPadLinkReturn
297
gst_ogg_mux_sinkconnect (GstPad * pad, GstPad * peer)
Wim Taymans's avatar
Wim Taymans committed
298
299
300
301
302
{
  GstOggMux *ogg_mux;

  ogg_mux = GST_OGG_MUX (gst_pad_get_parent (pad));

303
  GST_DEBUG_OBJECT (ogg_mux, "sinkconnect triggered on %s", GST_PAD_NAME (pad));
304

305
  gst_object_unref (ogg_mux);
Wim Taymans's avatar
Wim Taymans committed
306
307
308
309

  return GST_PAD_LINK_OK;
}

310
311
312
313
static gboolean
gst_ogg_mux_sink_event (GstPad * pad, GstEvent * event)
{
  GstOggMux *ogg_mux = GST_OGG_MUX (gst_pad_get_parent (pad));
314
  GstOggPadData *ogg_pad = (GstOggPadData *) gst_pad_get_element_private (pad);
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
  gboolean ret;

  GST_DEBUG ("Got %s event on pad %s:%s", GST_EVENT_TYPE_NAME (event),
      GST_DEBUG_PAD_NAME (pad));

  switch (GST_EVENT_TYPE (event)) {
    case GST_EVENT_NEWSEGMENT:
      /* We don't support NEWSEGMENT events */
      gst_event_unref (event);
      ret = FALSE;
      break;
    default:
      ret = TRUE;
      break;
  }

  /* now GstCollectPads can take care of the rest, e.g. EOS */
  if (ret)
    ret = ogg_pad->collect_event (pad, event);

  gst_object_unref (ogg_mux);
  return ret;
}

Wim Taymans's avatar
Wim Taymans committed
339
340
341
342
343
344
static GstPad *
gst_ogg_mux_request_new_pad (GstElement * element,
    GstPadTemplate * templ, const gchar * req_name)
{
  GstOggMux *ogg_mux;
  GstPad *newpad;
Wim Taymans's avatar
Wim Taymans committed
345
  GstElementClass *klass;
Wim Taymans's avatar
Wim Taymans committed
346
347
348

  g_return_val_if_fail (templ != NULL, NULL);

Wim Taymans's avatar
Wim Taymans committed
349
350
  if (templ->direction != GST_PAD_SINK)
    goto wrong_direction;
Wim Taymans's avatar
Wim Taymans committed
351
352
353
354

  g_return_val_if_fail (GST_IS_OGG_MUX (element), NULL);
  ogg_mux = GST_OGG_MUX (element);

Wim Taymans's avatar
Wim Taymans committed
355
356
357
358
359
360
  klass = GST_ELEMENT_GET_CLASS (element);

  if (templ != gst_element_class_get_pad_template (klass, "sink_%d"))
    goto wrong_template;

  {
Wim Taymans's avatar
Wim Taymans committed
361
362
363
364
365
366
367
368
369
370
371
    gint serial;
    gchar *name;

    if (req_name == NULL || strlen (req_name) < 6) {
      /* no name given when requesting the pad, use random serial number */
      serial = rand ();
    } else {
      /* parse serial number from requested padname */
      serial = atoi (&req_name[5]);
    }
    /* create new pad with the name */
Thomas Vander Stichele's avatar
Thomas Vander Stichele committed
372
    GST_DEBUG_OBJECT (ogg_mux, "Creating new pad for serial %d", serial);
Wim Taymans's avatar
Wim Taymans committed
373
374
375
376
377
378
379
    name = g_strdup_printf ("sink_%d", serial);
    newpad = gst_pad_new_from_template (templ, name);
    g_free (name);

    /* construct our own wrapper data structure for the pad to
     * keep track of its status */
    {
380
      GstOggPadData *oggpad;
Wim Taymans's avatar
Wim Taymans committed
381

382
      oggpad = (GstOggPadData *)
383
          gst_collect_pads_add_pad_full (ogg_mux->collect, newpad,
384
          sizeof (GstOggPadData), gst_ogg_mux_ogg_pad_destroy_notify);
385
      ogg_mux->active_pads++;
Wim Taymans's avatar
Wim Taymans committed
386

387
388
      oggpad->map.serialno = serial;
      ogg_stream_init (&oggpad->map.stream, oggpad->map.serialno);
Wim Taymans's avatar
Wim Taymans committed
389
390
391
392
393
      oggpad->packetno = 0;
      oggpad->pageno = 0;
      oggpad->eos = FALSE;
      /* we assume there will be some control data first for this pad */
      oggpad->state = GST_OGG_PAD_STATE_CONTROL;
394
395
396
      oggpad->new_page = TRUE;
      oggpad->first_delta = FALSE;
      oggpad->prev_delta = FALSE;
397
      oggpad->data_pushed = FALSE;
398
      oggpad->pagebuffers = g_queue_new ();
399
400
      oggpad->map.headers = NULL;
      oggpad->map.queued = NULL;
401
402
403
404

      oggpad->collect_event = (GstPadEventFunction) GST_PAD_EVENTFUNC (newpad);
      gst_pad_set_event_function (newpad,
          GST_DEBUG_FUNCPTR (gst_ogg_mux_sink_event));
Wim Taymans's avatar
Wim Taymans committed
405
406
407
408
409
    }
  }

  /* setup some pad functions */
  gst_pad_set_link_function (newpad, gst_ogg_mux_sinkconnect);
410

Wim Taymans's avatar
Wim Taymans committed
411
412
413
414
  /* dd the pad to the element */
  gst_element_add_pad (element, newpad);

  return newpad;
Wim Taymans's avatar
Wim Taymans committed
415
416
417
418
419
420
421
422
423
424
425
426

  /* ERRORS */
wrong_direction:
  {
    g_warning ("ogg_mux: request pad that is not a SINK pad\n");
    return NULL;
  }
wrong_template:
  {
    g_warning ("ogg_mux: this is not our template!\n");
    return NULL;
  }
Wim Taymans's avatar
Wim Taymans committed
427
428
}

429
430
431
432
433
434
435
436
static void
gst_ogg_mux_release_pad (GstElement * element, GstPad * pad)
{
  GstOggMux *ogg_mux;

  ogg_mux = GST_OGG_MUX (gst_pad_get_parent (pad));

  gst_collect_pads_remove_pad (ogg_mux->collect, pad);
437
  gst_element_remove_pad (element, pad);
438
439

  gst_object_unref (ogg_mux);
440
441
}

Wim Taymans's avatar
Wim Taymans committed
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
/* handle events */
static gboolean
gst_ogg_mux_handle_src_event (GstPad * pad, GstEvent * event)
{
  GstEventType type;

  type = event ? GST_EVENT_TYPE (event) : GST_EVENT_UNKNOWN;

  switch (type) {
    case GST_EVENT_SEEK:
      /* disable seeking for now */
      return FALSE;
    default:
      break;
  }

  return gst_pad_event_default (pad, event);
}

461
static GstBuffer *
462
gst_ogg_mux_buffer_from_page (GstOggMux * mux, ogg_page * page, gboolean delta)
Wim Taymans's avatar
Wim Taymans committed
463
464
465
466
{
  GstBuffer *buffer;

  /* allocate space for header and body */
Wim Taymans's avatar
Wim Taymans committed
467
  buffer = gst_buffer_new_and_alloc (page->header_len + page->body_len);
Wim Taymans's avatar
Wim Taymans committed
468
469
470
471
  memcpy (GST_BUFFER_DATA (buffer), page->header, page->header_len);
  memcpy (GST_BUFFER_DATA (buffer) + page->header_len,
      page->body, page->body_len);

472
473
474
475
  /* Here we set granulepos as our OFFSET_END to give easy direct access to
   * this value later. Before we push it, we reset this to OFFSET + SIZE
   * (see gst_ogg_mux_push_buffer). */
  GST_BUFFER_OFFSET_END (buffer) = ogg_page_granulepos (page);
476
  if (delta)
477
    GST_BUFFER_FLAG_SET (buffer, GST_BUFFER_FLAG_DELTA_UNIT);
Wim Taymans's avatar
Wim Taymans committed
478

479
  GST_LOG_OBJECT (mux, GST_GP_FORMAT
480
481
      " created buffer %p from ogg page",
      GST_GP_CAST (ogg_page_granulepos (page)), buffer);
482

483
484
485
  return buffer;
}

Wim Taymans's avatar
Wim Taymans committed
486
static GstFlowReturn
487
gst_ogg_mux_push_buffer (GstOggMux * mux, GstBuffer * buffer)
488
{
489
490
  GstCaps *caps;

491
492
493
494
  /* fix up OFFSET and OFFSET_END again */
  GST_BUFFER_OFFSET (buffer) = mux->offset;
  mux->offset += GST_BUFFER_SIZE (buffer);
  GST_BUFFER_OFFSET_END (buffer) = mux->offset;
495

496
497
  /* Ensure we have monotonically increasing timestamps in the output. */
  if (GST_BUFFER_TIMESTAMP_IS_VALID (buffer)) {
498
499
    if (mux->last_ts != GST_CLOCK_TIME_NONE &&
        GST_BUFFER_TIMESTAMP (buffer) < mux->last_ts)
500
501
502
503
504
      GST_BUFFER_TIMESTAMP (buffer) = mux->last_ts;
    else
      mux->last_ts = GST_BUFFER_TIMESTAMP (buffer);
  }

505
  caps = gst_pad_get_negotiated_caps (mux->srcpad);
506
  gst_buffer_set_caps (buffer, caps);
507
508
  if (caps)
    gst_caps_unref (caps);
509

510
511
512
513
514
515
516
517
518
  return gst_pad_push (mux->srcpad, buffer);
}

/* if all queues have at least one page, dequeue the page with the lowest
 * timestamp */
static gboolean
gst_ogg_mux_dequeue_page (GstOggMux * mux, GstFlowReturn * flowret)
{
  GSList *walk;
519
  GstOggPadData *opad = NULL;   /* "oldest" pad */
520
521
522
523
524
525
526
527
  GstClockTime oldest = GST_CLOCK_TIME_NONE;
  GstBuffer *buf = NULL;
  gboolean ret = FALSE;

  *flowret = GST_FLOW_OK;

  walk = mux->collect->data;
  while (walk) {
528
    GstOggPadData *pad = (GstOggPadData *) walk->data;
529
530
531
532
533
534
535

    /* We need each queue to either be at EOS, or have one or more pages
     * available with a set granulepos (i.e. not -1), otherwise we don't have
     * enough data yet to determine which stream needs to go next for correct
     * time ordering. */
    if (pad->pagebuffers->length == 0) {
      if (pad->eos) {
536
537
        GST_LOG_OBJECT (pad->collect.pad,
            "pad is EOS, skipping for dequeue decision");
538
      } else {
539
540
        GST_LOG_OBJECT (pad->collect.pad,
            "no pages in this queue, can't dequeue");
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
        return FALSE;
      }
    } else {
      /* We then need to check for a non-negative granulepos */
      int i;
      gboolean valid = FALSE;

      for (i = 0; i < pad->pagebuffers->length; i++) {
        buf = g_queue_peek_nth (pad->pagebuffers, i);
        /* Here we check the OFFSET_END, which is actually temporarily the
         * granulepos value for this buffer */
        if (GST_BUFFER_OFFSET_END (buf) != -1) {
          valid = TRUE;
          break;
        }
      }
      if (!valid) {
558
559
        GST_LOG_OBJECT (pad->collect.pad,
            "No page timestamps in queue, can't dequeue");
560
561
562
563
564
565
566
567
568
        return FALSE;
      }
    }

    walk = g_slist_next (walk);
  }

  walk = mux->collect->data;
  while (walk) {
569
    GstOggPadData *pad = (GstOggPadData *) walk->data;
570

571
    /* any page with a granulepos of -1 can be pushed immediately.
572
573
574
     * TODO: it CAN be, but it seems silly to do so? */
    buf = g_queue_peek_head (pad->pagebuffers);
    while (buf && GST_BUFFER_OFFSET_END (buf) == -1) {
Thomas Vander Stichele's avatar
Thomas Vander Stichele committed
575
      GST_LOG_OBJECT (pad->collect.pad, "[gp        -1] pushing page");
576
577
578
579
580
581
582
583
584
      g_queue_pop_head (pad->pagebuffers);
      *flowret = gst_ogg_mux_push_buffer (mux, buf);
      buf = g_queue_peek_head (pad->pagebuffers);
      ret = TRUE;
    }

    if (buf) {
      /* if no oldest buffer yet, take this one */
      if (oldest == GST_CLOCK_TIME_NONE) {
585
586
587
588
        GST_LOG_OBJECT (mux, "no oldest yet, taking buffer %p from pad %"
            GST_PTR_FORMAT " with gp time %" GST_TIME_FORMAT,
            buf, pad->collect.pad, GST_TIME_ARGS (GST_BUFFER_OFFSET (buf)));
        oldest = GST_BUFFER_OFFSET (buf);
589
590
591
        opad = pad;
      } else {
        /* if we have an oldest, compare with this one */
592
593
594
595
596
        if (GST_BUFFER_OFFSET (buf) < oldest) {
          GST_LOG_OBJECT (mux, "older buffer %p, taking from pad %"
              GST_PTR_FORMAT " with gp time %" GST_TIME_FORMAT,
              buf, pad->collect.pad, GST_TIME_ARGS (GST_BUFFER_OFFSET (buf)));
          oldest = GST_BUFFER_OFFSET (buf);
597
598
599
600
601
602
603
604
605
606
          opad = pad;
        }
      }
    }
    walk = g_slist_next (walk);
  }

  if (oldest != GST_CLOCK_TIME_NONE) {
    g_assert (opad);
    buf = g_queue_pop_head (opad->pagebuffers);
Thomas Vander Stichele's avatar
Thomas Vander Stichele committed
607
    GST_LOG_OBJECT (opad->collect.pad,
608
609
610
        GST_GP_FORMAT " pushing oldest page buffer %p (granulepos time %"
        GST_TIME_FORMAT ")", GST_BUFFER_OFFSET_END (buf), buf,
        GST_TIME_ARGS (GST_BUFFER_OFFSET (buf)));
611
612
613
614
615
616
617
    *flowret = gst_ogg_mux_push_buffer (mux, buf);
    ret = TRUE;
  }

  return ret;
}

618
619
620
621
622
623
624
625
626
627
628
629
630
/* put the given ogg page on a per-pad queue, timestamping it correctly.
 * after that, dequeue and push as many pages as possible.
 * Caller should make sure:
 * pad->timestamp     was set with the timestamp of the first packet put
 *                    on the page
 * pad->timestamp_end was set with the timestamp + duration of the last packet
 *                    put on the page
 * pad->gp_time       was set with the time matching the gp of the last
 *                    packet put on the page
 *
 * will also reset timestamp and timestamp_end, so caller func can restart
 * counting.
 */
631
static GstFlowReturn
632
633
gst_ogg_mux_pad_queue_page (GstOggMux * mux, GstOggPadData * pad,
    ogg_page * page, gboolean delta)
634
{
Wim Taymans's avatar
Wim Taymans committed
635
  GstFlowReturn ret;
636
  GstBuffer *buffer = gst_ogg_mux_buffer_from_page (mux, page, delta);
637

638
  /* take the timestamp of the first packet on this page */
639
  GST_BUFFER_TIMESTAMP (buffer) = pad->timestamp;
640
  GST_BUFFER_DURATION (buffer) = pad->timestamp_end - pad->timestamp;
641
642
  /* take the gp time of the last completed packet on this page */
  GST_BUFFER_OFFSET (buffer) = pad->gp_time;
643

644
  /* the next page will start where the current page's end time leaves off */
645
646
  pad->timestamp = pad->timestamp_end;

647
  g_queue_push_tail (pad->pagebuffers, buffer);
648
649
650
  GST_LOG_OBJECT (pad->collect.pad, GST_GP_FORMAT
      " queued buffer page %p (gp time %"
      GST_TIME_FORMAT ", timestamp %" GST_TIME_FORMAT
651
      "), %d page buffers queued", GST_GP_CAST (ogg_page_granulepos (page)),
652
      buffer, GST_TIME_ARGS (GST_BUFFER_OFFSET (buffer)),
653
654
      GST_TIME_ARGS (GST_BUFFER_TIMESTAMP (buffer)),
      g_queue_get_length (pad->pagebuffers));
Wim Taymans's avatar
Wim Taymans committed
655

656
657
658
659
  while (gst_ogg_mux_dequeue_page (mux, &ret)) {
    if (ret != GST_FLOW_OK)
      break;
  }
Wim Taymans's avatar
Wim Taymans committed
660
661

  return ret;
Wim Taymans's avatar
Wim Taymans committed
662
663
664
}

/*
665
666
667
668
669
670
671
 * Given two pads, compare the buffers queued on it.
 * Returns:
 *  0 if they have an equal priority
 * -1 if the first is better
 *  1 if the second is better
 * Priority decided by: a) validity, b) older timestamp, c) smaller number
 * of muxed pages
Wim Taymans's avatar
Wim Taymans committed
672
673
 */
static gint
674
675
gst_ogg_mux_compare_pads (GstOggMux * ogg_mux, GstOggPadData * first,
    GstOggPadData * second)
Wim Taymans's avatar
Wim Taymans committed
676
{
677
  guint64 firsttime, secondtime;
Wim Taymans's avatar
Wim Taymans committed
678

679
680
  /* if the first pad doesn't contain anything or is even NULL, return
   * the second pad as best candidate and vice versa */
681
  if (first == NULL || (first->buffer == NULL && first->next_buffer == NULL))
Wim Taymans's avatar
Wim Taymans committed
682
    return 1;
683
  if (second == NULL || (second->buffer == NULL && second->next_buffer == NULL))
Wim Taymans's avatar
Wim Taymans committed
684
685
    return -1;

686
  /* no timestamp on first buffer, it must go first */
687
688
689
690
  if (first->buffer)
    firsttime = GST_BUFFER_TIMESTAMP (first->buffer);
  else
    firsttime = GST_BUFFER_TIMESTAMP (first->next_buffer);
691
  if (firsttime == GST_CLOCK_TIME_NONE)
Wim Taymans's avatar
Wim Taymans committed
692
693
    return -1;

694
  /* no timestamp on second buffer, it must go first */
695
696
697
698
  if (second->buffer)
    secondtime = GST_BUFFER_TIMESTAMP (second->buffer);
  else
    secondtime = GST_BUFFER_TIMESTAMP (second->next_buffer);
699
  if (secondtime == GST_CLOCK_TIME_NONE)
Wim Taymans's avatar
Wim Taymans committed
700
701
    return 1;

702
703
  /* first buffer has higher timestamp, second one should go first */
  if (secondtime < firsttime)
Wim Taymans's avatar
Wim Taymans committed
704
    return 1;
705
706
  /* second buffer has higher timestamp, first one should go first */
  else if (secondtime > firsttime)
Wim Taymans's avatar
Wim Taymans committed
707
708
709
710
    return -1;
  else {
    /* buffers with equal timestamps, prefer the pad that has the
     * least number of pages muxed */
711
    if (second->pageno < first->pageno)
Wim Taymans's avatar
Wim Taymans committed
712
      return 1;
713
    else if (second->pageno > first->pageno)
Wim Taymans's avatar
Wim Taymans committed
714
715
716
717
718
719
720
      return -1;
  }

  /* same priority if all of the above failed */
  return 0;
}

721
722
723
724
725
726
727
728
729
730
731
732
733
/* make sure at least one buffer is queued on all pads, two if possible
 * 
 * if pad->buffer == NULL, pad->next_buffer !=  NULL, then
 *   we do not know if the buffer is the last or not
 * if pad->buffer != NULL, pad->next_buffer != NULL, then
 *   pad->buffer is not the last buffer for the pad
 * if pad->buffer != NULL, pad->next_buffer == NULL, then
 *   pad->buffer if the last buffer for the pad
 * 
 * returns a pointer to an oggpad that holds the best buffer, or
 * NULL when no pad was usable. "best" means the buffer marked
 * with the lowest timestamp. If best->buffer == NULL then nothing
 * should be done until more data arrives */
734
static GstOggPadData *
Wim Taymans's avatar
Wim Taymans committed
735
gst_ogg_mux_queue_pads (GstOggMux * ogg_mux)
Wim Taymans's avatar
Wim Taymans committed
736
{
737
  GstOggPadData *bestpad = NULL, *still_hungry = NULL;
Wim Taymans's avatar
Wim Taymans committed
738
739
740
  GSList *walk;

  /* try to make sure we have a buffer from each usable pad first */
Wim Taymans's avatar
Wim Taymans committed
741
  walk = ogg_mux->collect->data;
Wim Taymans's avatar
Wim Taymans committed
742
  while (walk) {
743
    GstOggPadData *pad;
Wim Taymans's avatar
Wim Taymans committed
744
    GstCollectData *data;
Wim Taymans's avatar
Wim Taymans committed
745

Wim Taymans's avatar
Wim Taymans committed
746
    data = (GstCollectData *) walk->data;
747
    pad = (GstOggPadData *) data;
Wim Taymans's avatar
Wim Taymans committed
748

Wim Taymans's avatar
Wim Taymans committed
749
750
    walk = g_slist_next (walk);

751
    GST_LOG_OBJECT (data->pad, "looking at pad for buffer");
752

Wim Taymans's avatar
Wim Taymans committed
753
    /* try to get a new buffer for this pad if needed and possible */
Wim Taymans's avatar
Wim Taymans committed
754
755
    if (pad->buffer == NULL) {
      GstBuffer *buf;
Wim Taymans's avatar
Wim Taymans committed
756

757
758
759
760
761
762
763
764
      /* shift the buffer along if needed (it's okay if next_buffer is NULL) */
      if (pad->buffer == NULL) {
        GST_LOG_OBJECT (data->pad, "shifting buffer %" GST_PTR_FORMAT,
            pad->next_buffer);
        pad->buffer = pad->next_buffer;
        pad->next_buffer = NULL;
      }

765
      buf = gst_collect_pads_pop (ogg_mux->collect, data);
766
      GST_LOG_OBJECT (data->pad, "popped buffer %" GST_PTR_FORMAT, buf);
Wim Taymans's avatar
Wim Taymans committed
767

768
769
      /* On EOS we get a NULL buffer */
      if (buf != NULL) {
770
771
772
773
        if (ogg_mux->delta_pad == NULL &&
            GST_BUFFER_FLAG_IS_SET (buf, GST_BUFFER_FLAG_DELTA_UNIT))
          ogg_mux->delta_pad = pad;

774
775
776
        /* if we need headers */
        if (pad->state == GST_OGG_PAD_STATE_CONTROL) {
          /* and we have one */
777
          ogg_packet packet;
778
779
          gboolean is_header;

780
781
          packet.packet = GST_BUFFER_DATA (buf);
          packet.bytes = GST_BUFFER_SIZE (buf);
782
783
784
785

          if (GST_BUFFER_OFFSET_END_IS_VALID (buf))
            packet.granulepos = GST_BUFFER_OFFSET_END (buf);
          else
786
787
788
789
790
791
            packet.granulepos = 0;

          /* if we're not yet in data mode, ensure we're setup on the first packet */
          if (!pad->have_type) {
            pad->have_type = gst_ogg_stream_setup_map (&pad->map, &packet);
            if (!pad->have_type) {
792
793
794
795
796
              GST_ERROR_OBJECT (pad, "mapper didn't recognise input stream "
                  "(pad caps: %" GST_PTR_FORMAT ")", GST_PAD_CAPS (pad));
            } else {
              GST_DEBUG_OBJECT (pad, "caps detected: %" GST_PTR_FORMAT,
                  pad->map.caps);
797
798
799
            }
          }

800
801
802
803
          if (pad->have_type)
            is_header = gst_ogg_stream_packet_is_header (&pad->map, &packet);
          else                  /* fallback (FIXME 0.11: remove IN_CAPS hack) */
            is_header = GST_BUFFER_FLAG_IS_SET (buf, GST_BUFFER_FLAG_IN_CAPS);
804

805
          if (is_header) {
806
            GST_DEBUG_OBJECT (ogg_mux,
807
                "got header buffer in control state, ignoring");
808
809
810
811
            /* just ignore */
            gst_buffer_unref (buf);
            buf = NULL;
          } else {
812
            GST_DEBUG_OBJECT (ogg_mux,
Vincent Penquerc'h's avatar
Vincent Penquerc'h committed
813
                "got data buffer in control state, switching to data mode");
814
815
816
            /* this is a data buffer so switch to data state */
            pad->state = GST_OGG_PAD_STATE_DATA;
          }
Wim Taymans's avatar
Wim Taymans committed
817
        }
818
      } else {
819
        GST_DEBUG_OBJECT (data->pad, "EOS on pad");
820
821
822
823
        if (!pad->eos) {
          ogg_page page;
          GstFlowReturn ret;

824
825
826
          /* it's no longer active */
          ogg_mux->active_pads--;

827
828
829
          /* Just gone to EOS. Flush existing page(s) */
          pad->eos = TRUE;

830
          while (ogg_stream_flush (&pad->map.stream, &page)) {
831
832
833
834
835
836
837
838
839
            /* Place page into the per-pad queue */
            ret = gst_ogg_mux_pad_queue_page (ogg_mux, pad, &page,
                pad->first_delta);
            /* increment the page number counter */
            pad->pageno++;
            /* mark other pages as delta */
            pad->first_delta = TRUE;
          }
        }
Wim Taymans's avatar
Wim Taymans committed
840
      }
841

842
      pad->next_buffer = buf;
Wim Taymans's avatar
Wim Taymans committed
843
    }
Wim Taymans's avatar
Wim Taymans committed
844
845
846

    /* we should have a buffer now, see if it is the best pad to
     * pull on */
847
    if (pad->buffer || pad->next_buffer) {
848
      if (gst_ogg_mux_compare_pads (ogg_mux, bestpad, pad) > 0) {
849
850
851
        GST_LOG_OBJECT (data->pad,
            "new best pad, with buffers %" GST_PTR_FORMAT
            " and %" GST_PTR_FORMAT, pad->buffer, pad->next_buffer);
852

Wim Taymans's avatar
Wim Taymans committed
853
        bestpad = pad;
854
      }
855
    } else if (!pad->eos) {
856
      GST_LOG_OBJECT (data->pad, "hungry pad");
857
      still_hungry = pad;
Wim Taymans's avatar
Wim Taymans committed
858
859
    }
  }
860
861
862
863
864
865

  if (still_hungry)
    /* drop back into collectpads... */
    return still_hungry;
  else
    return bestpad;
Wim Taymans's avatar
Wim Taymans committed
866
867
}

868
static GList *
869
gst_ogg_mux_get_headers (GstOggPadData * pad)
870
871
872
{
  GList *res = NULL;
  GstStructure *structure;
873
  GstCaps *caps;
Wim Taymans's avatar
Wim Taymans committed
874
  GstPad *thepad;
875

Wim Taymans's avatar
Wim Taymans committed
876
  thepad = pad->collect.pad;
877

878
  GST_LOG_OBJECT (thepad, "getting headers");
Wim Taymans's avatar
Wim Taymans committed
879
880

  caps = gst_pad_get_negotiated_caps (thepad);
881
882
883
884
  if (caps != NULL) {
    const GValue *streamheader;

    structure = gst_caps_get_structure (caps, 0);
885
886
887
888
889
890
    streamheader = gst_structure_get_value (structure, "streamheader");
    if (streamheader != NULL) {
      GST_LOG_OBJECT (thepad, "got header");
      if (G_VALUE_TYPE (streamheader) == GST_TYPE_ARRAY) {
        GArray *bufarr = g_value_peek_pointer (streamheader);
        gint i;
891

892
        GST_LOG_OBJECT (thepad, "got fixed list");
Wim Taymans's avatar
Wim Taymans committed
893

894
895
        for (i = 0; i < bufarr->len; i++) {
          GValue *bufval = &g_array_index (bufarr, GValue, i);
896

897
898
899
          GST_LOG_OBJECT (thepad, "item %d", i);
          if (G_VALUE_TYPE (bufval) == GST_TYPE_BUFFER) {
            GstBuffer *buf = g_value_peek_pointer (bufval);
900

901
            GST_LOG_OBJECT (thepad, "adding item %d to header list", i);
Wim Taymans's avatar
Wim Taymans committed
902

903
904
            gst_buffer_ref (buf);
            res = g_list_append (res, buf);
905
906
          }
        }
Wim Taymans's avatar
Wim Taymans committed
907
      } else {
908
        GST_LOG_OBJECT (thepad, "streamheader is not fixed list");
909
      }
910
911
912
913

      /* Start a new page for every CMML buffer */
      if (gst_structure_has_name (structure, "text/x-cmml"))
        pad->always_flush_page = TRUE;
914
915
916
917
    } else if (gst_structure_has_name (structure, "video/x-dirac")) {
      res = g_list_append (res, pad->buffer);
      pad->buffer = pad->next_buffer;
      pad->next_buffer = NULL;
918
      pad->always_flush_page = TRUE;
919
920
    } else {
      GST_LOG_OBJECT (thepad, "caps don't have streamheader");
921
    }
922
    gst_caps_unref (caps);
Wim Taymans's avatar
Wim Taymans committed
923
  } else {
924
    GST_LOG_OBJECT (thepad, "got empty caps as negotiated format");
925
926
927
928
  }
  return res;
}

Wim Taymans's avatar
Wim Taymans committed
929
static GstCaps *
930
931
gst_ogg_mux_set_header_on_caps (GstCaps * caps, GList * buffers)
{
Wim Taymans's avatar
Wim Taymans committed
932
  GstStructure *structure;
933
  GValue array = { 0 };
934
935
  GList *walk = buffers;

Wim Taymans's avatar
Wim Taymans committed
936
937
938
939
  caps = gst_caps_make_writable (caps);

  structure = gst_caps_get_structure (caps, 0);

940
  /* put buffers in a fixed list */
941
  g_value_init (&array, GST_TYPE_ARRAY);
942
943
944

  while (walk) {
    GstBuffer *buf = GST_BUFFER (walk->data);
945
    GstBuffer *copy;
946
947
948
949
950
    GValue value = { 0 };

    walk = walk->next;

    /* mark buffer */
951
    GST_LOG ("Setting IN_CAPS on buffer of length %d", GST_BUFFER_SIZE (buf));
952
    GST_BUFFER_FLAG_SET (buf, GST_BUFFER_FLAG_IN_CAPS);
953
954

    g_value_init (&value, GST_TYPE_BUFFER);
955
956
957
    copy = gst_buffer_copy (buf);
    gst_value_set_buffer (&value, copy);
    gst_buffer_unref (copy);
958
    gst_value_array_append_value (&array, &value);
959
960
    g_value_unset (&value);
  }
961
962
  gst_structure_set_value (structure, "streamheader", &array);
  g_value_unset (&array);
Wim Taymans's avatar
Wim Taymans committed
963
964

  return caps;
965
966
}

967
/*
968
969
970
971
972
973
974
 * For each pad we need to write out one (small) header in one
 * page that allows decoders to identify the type of the stream.
 * After that we need to write out all extra info for the decoders.
 * In the case of a codec that also needs data as configuration, we can
 * find that info in the streamcaps. 
 * After writing the headers we must start a new page for the data.
 */
Wim Taymans's avatar
Wim Taymans committed
975
static GstFlowReturn
976
977
978
979
980
gst_ogg_mux_send_headers (GstOggMux * mux)
{
  GSList *walk;
  GList *hbufs, *hwalk;
  GstCaps *caps;
Wim Taymans's avatar
Wim Taymans committed
981
  GstFlowReturn ret;
982
983

  hbufs = NULL;
Wim Taymans's avatar
Wim Taymans committed
984
  ret = GST_FLOW_OK;
985

986
  GST_LOG_OBJECT (mux, "collecting headers");
987

Wim Taymans's avatar
Wim Taymans committed
988
  walk = mux->collect->data;
989
  while (walk) {
990
    GstOggPadData *pad;
Wim Taymans's avatar
Wim Taymans committed
991
    GstPad *thepad;
992

993
    pad = (GstOggPadData *) walk->data;
Wim Taymans's avatar
Wim Taymans committed
994
    thepad = pad->collect.pad;
995

Wim Taymans's avatar
Wim Taymans committed
996
997
    walk = g_slist_next (walk);

998
    GST_LOG_OBJECT (mux, "looking at pad %s:%s", GST_DEBUG_PAD_NAME (thepad));
999
1000

    /* if the pad has no buffer, we don't care */
1001
    if (pad->buffer == NULL && pad->next_buffer == NULL)
1002
1003
1004
      continue;

    /* now figure out the headers */
1005
    pad->map.headers = gst_ogg_mux_get_headers (pad);
1006
1007
  }

1008
  GST_LOG_OBJECT (mux, "creating BOS pages");
Wim Taymans's avatar
Wim Taymans committed
1009
  walk = mux->collect->data;
1010
  while (walk) {
1011
    GstOggPadData *pad;
1012
1013
1014
    GstBuffer *buf;
    ogg_packet packet;
    ogg_page page;
Wim Taymans's avatar
Wim Taymans committed
1015
    GstPad *thepad;
1016
1017
1018
    GstCaps *caps;
    GstStructure *structure;
    GstBuffer *hbuf;
Wim Taymans's avatar
Wim Taymans committed
1019

1020
    pad = (GstOggPadData *) walk->data;
Wim Taymans's avatar
Wim Taymans committed
1021
    thepad = pad->collect.pad;
1022
1023
    caps = gst_pad_get_negotiated_caps (thepad);
    structure = gst_caps_get_structure (caps, 0);
1024
1025
1026
1027
1028

    walk = walk->next;

    pad->packetno = 0;

1029
    GST_LOG_OBJECT (thepad, "looping over headers");
1030

1031
1032
1033
    if (pad->map.headers) {
      buf = GST_BUFFER (pad->map.headers->data);
      pad->map.headers = g_list_remove (pad->map.headers, buf);
1034
    } else if (pad->buffer) {
1035
1036
      buf = pad->buffer;
      gst_buffer_ref (buf);
1037
1038
1039
    } else if (pad->next_buffer) {
      buf = pad->next_buffer;
      gst_buffer_ref (buf);
1040
    } else {
1041
      /* fixme -- should be caught in the previous list traversal. */
1042
      GST_OBJECT_LOCK (pad);
1043
1044
      g_critical ("No headers or buffers on pad %s:%s",
          GST_DEBUG_PAD_NAME (pad));
1045
      GST_OBJECT_UNLOCK (pad);
1046
      continue;
1047
1048
1049
1050
1051
1052
    }

    /* create a packet from the buffer */
    packet.packet = GST_BUFFER_DATA (buf);
    packet.bytes = GST_BUFFER_SIZE (buf);
    packet.granulepos = GST_BUFFER_OFFSET_END (buf);
1053
1054
    if (packet.granulepos == -1)
      packet.granulepos = 0;
1055
1056
1057
1058
1059
1060
1061
    /* mark BOS and packet number */
    packet.b_o_s = (pad->packetno == 0);
    packet.packetno = pad->packetno++;
    /* mark EOS */
    packet.e_o_s = 0;

    /* swap the packet in */
1062
    ogg_stream_packetin (&pad->map.stream, &packet);
1063
1064
    gst_buffer_unref (buf);

1065
    GST_LOG_OBJECT (thepad, "flushing out BOS page");
1066
    if (!ogg_stream_flush (&pad->map.stream, &page))
1067
1068
1069
      g_critical ("Could not flush BOS page");

    hbuf = gst_ogg_mux_buffer_from_page (mux, &page, FALSE);
1070

1071
1072
1073
    GST_LOG_OBJECT (mux, "swapped out page with mime type %s",
        gst_structure_get_name (structure));

1074
    /* quick hack: put Theora, VP8 and Dirac video pages at the front.
1075
     * Ideally, we would have a settable enum for which Ogg
1076
1077
1078
1079
1080
1081
1082
1083
1084
     * profile we work with, and order based on that.
     * (FIXME: if there is more than one video stream, shouldn't we only put
     * one's BOS into the first page, followed by an audio stream's BOS, and
     * only then followed by the remaining video and audio streams?) */
    if (gst_structure_has_name (structure, "video/x-theora")) {
      GST_DEBUG_OBJECT (thepad, "putting %s page at the front", "Theora");
      hbufs = g_list_prepend (hbufs, hbuf);
    } else if (gst_structure_has_name (structure, "video/x-dirac")) {
      GST_DEBUG_OBJECT (thepad, "putting %s page at the front", "Dirac");
1085
      hbufs = g_list_prepend (hbufs, hbuf);
1086
      pad->always_flush_page = TRUE;
1087
1088
1089
    } else if (gst_structure_has_name (structure, "video/x-vp8")) {
      GST_DEBUG_OBJECT (thepad, "putting %s page at the front", "VP8");
      hbufs = g_list_prepend (h