gstoggmux.c 51.6 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
23
24
25
/**
 * SECTION:element-oggmux
 * @see_also: <link linkend="gst-plugins-base-plugins-deoggmux">oggdemux</link>
 *
 * 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
44
#include <gst/base/gstcollectpads.h>

45
46
#include "gstoggmux.h"

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

GST_DEBUG_CATEGORY_STATIC (gst_ogg_mux_debug);
#define GST_CAT_DEFAULT gst_ogg_mux_debug

56
57
58
59
60
61
62
63
/* 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))

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

Wim Taymans's avatar
Wim Taymans committed
67
68
69
70
71
72
73
74
75
76
77
78
79
80
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
81
/* set to 0.5 seconds by default */
Thomas Vander Stichele's avatar
Thomas Vander Stichele committed
82
83
#define DEFAULT_MAX_DELAY       G_GINT64_CONSTANT(500000000)
#define DEFAULT_MAX_PAGE_DELAY  G_GINT64_CONSTANT(500000000)
Wim Taymans's avatar
Wim Taymans committed
84
85
enum
{
86
87
  ARG_0,
  ARG_MAX_DELAY,
88
  ARG_MAX_PAGE_DELAY,
Wim Taymans's avatar
Wim Taymans committed
89
90
91
92
93
94
95
96
97
98
99
};

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,
100
    GST_STATIC_CAPS ("video/x-theora; "
101
        "audio/x-vorbis; audio/x-flac; audio/x-speex; audio/x-celt; "
102
        "application/x-ogm-video; application/x-ogm-audio; video/x-dirac; "
103
104
        "video/x-smoke; text/x-cmml, encoded = (boolean) TRUE; "
        "subtitle/x-kate; application/x-kate")
Wim Taymans's avatar
Wim Taymans committed
105
106
107
108
109
    );

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);
110
static void gst_ogg_mux_finalize (GObject * object);
Wim Taymans's avatar
Wim Taymans committed
111

Wim Taymans's avatar
Wim Taymans committed
112
113
static GstFlowReturn
gst_ogg_mux_collected (GstCollectPads * pads, GstOggMux * ogg_mux);
Wim Taymans's avatar
Wim Taymans committed
114
115
116
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);
117
118
static void gst_ogg_mux_release_pad (GstElement * element, GstPad * pad);

Wim Taymans's avatar
Wim Taymans committed
119
120
121
122
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);
123
124
static GstStateChangeReturn gst_ogg_mux_change_state (GstElement * element,
    GstStateChange transition);
Wim Taymans's avatar
Wim Taymans committed
125
126
127
128
129
130
131
132
133
134

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;

135
  if (G_UNLIKELY (ogg_mux_type == 0)) {
Wim Taymans's avatar
Wim Taymans committed
136
137
138
139
140
141
142
143
144
145
146
    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,
    };
147
148
149
150
151
    static const GInterfaceInfo preset_info = {
      NULL,
      NULL,
      NULL
    };
Wim Taymans's avatar
Wim Taymans committed
152
153
154
155

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

    g_type_add_interface_static (ogg_mux_type, GST_TYPE_PRESET, &preset_info);
Wim Taymans's avatar
Wim Taymans committed
158
159
160
161
162
163
164
165
166
167
168
169
170
171
  }
  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));

172
173
174
175
  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
176
177
178
179
180
181
182
183
184
185
186
}

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

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

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

189
  gobject_class->finalize = gst_ogg_mux_finalize;
190
191
192
  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
193
  gstelement_class->request_new_pad = gst_ogg_mux_request_new_pad;
194
  gstelement_class->release_pad = gst_ogg_mux_release_pad;
Wim Taymans's avatar
Wim Taymans committed
195

196
197
198
  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,
199
200
          DEFAULT_MAX_DELAY,
          (GParamFlags) G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
201
202
203
  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,
204
205
          DEFAULT_MAX_PAGE_DELAY,
          (GParamFlags) G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
206

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

}

Wim Taymans's avatar
Wim Taymans committed
211
#if 0
Wim Taymans's avatar
Wim Taymans committed
212
213
214
215
216
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
217
    {GST_EVENT_DISCONTINUOUS, 0},
Wim Taymans's avatar
Wim Taymans committed
218
219
220
221
222
    {0,}
  };

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

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

Wim Taymans's avatar
Wim Taymans committed
236
237
238
239
240
241
242
243
244
245
246
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);

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

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

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

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

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

263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
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);
}

278
279
280
static void
gst_ogg_mux_ogg_pad_destroy_notify (GstCollectData * data)
{
281
  GstOggPadData *oggpad = (GstOggPadData *) data;
282
283
284
285
286
287
288
289
290
291
292
293
294
  GstBuffer *buf;

  ogg_stream_clear (&oggpad->stream);

  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
295
static GstPadLinkReturn
296
gst_ogg_mux_sinkconnect (GstPad * pad, GstPad * peer)
Wim Taymans's avatar
Wim Taymans committed
297
298
299
300
301
{
  GstOggMux *ogg_mux;

  ogg_mux = GST_OGG_MUX (gst_pad_get_parent (pad));

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

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

  return GST_PAD_LINK_OK;
}

309
310
311
312
static gboolean
gst_ogg_mux_sink_event (GstPad * pad, GstEvent * event)
{
  GstOggMux *ogg_mux = GST_OGG_MUX (gst_pad_get_parent (pad));
313
  GstOggPadData *ogg_pad = (GstOggPadData *) gst_pad_get_element_private (pad);
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
  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
338
339
340
341
342
343
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
344
  GstElementClass *klass;
Wim Taymans's avatar
Wim Taymans committed
345
346
347

  g_return_val_if_fail (templ != NULL, NULL);

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

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

Wim Taymans's avatar
Wim Taymans committed
354
355
356
357
358
359
  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
360
361
362
363
364
365
366
367
368
369
370
    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
371
    GST_DEBUG_OBJECT (ogg_mux, "Creating new pad for serial %d", serial);
Wim Taymans's avatar
Wim Taymans committed
372
373
374
375
376
377
378
    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 */
    {
379
      GstOggPadData *oggpad;
Wim Taymans's avatar
Wim Taymans committed
380

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

      oggpad->serial = serial;
      ogg_stream_init (&oggpad->stream, serial);
      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;
393
394
395
      oggpad->new_page = TRUE;
      oggpad->first_delta = FALSE;
      oggpad->prev_delta = FALSE;
396
      oggpad->pagebuffers = g_queue_new ();
397
398
399
400

      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
401
402
403
404
405
    }
  }

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

Wim Taymans's avatar
Wim Taymans committed
407
408
409
410
  /* dd the pad to the element */
  gst_element_add_pad (element, newpad);

  return newpad;
Wim Taymans's avatar
Wim Taymans committed
411
412
413
414
415
416
417
418
419
420
421
422

  /* 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
423
424
}

425
426
427
428
429
430
431
432
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);
433
  gst_element_remove_pad (element, pad);
434
435

  gst_object_unref (ogg_mux);
436
437
}

Wim Taymans's avatar
Wim Taymans committed
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
/* 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);
}

457
static GstBuffer *
458
gst_ogg_mux_buffer_from_page (GstOggMux * mux, ogg_page * page, gboolean delta)
Wim Taymans's avatar
Wim Taymans committed
459
460
461
462
{
  GstBuffer *buffer;

  /* allocate space for header and body */
Wim Taymans's avatar
Wim Taymans committed
463
  buffer = gst_buffer_new_and_alloc (page->header_len + page->body_len);
Wim Taymans's avatar
Wim Taymans committed
464
465
466
467
  memcpy (GST_BUFFER_DATA (buffer), page->header, page->header_len);
  memcpy (GST_BUFFER_DATA (buffer) + page->header_len,
      page->body, page->body_len);

468
469
470
471
  /* 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);
472
  if (delta)
473
    GST_BUFFER_FLAG_SET (buffer, GST_BUFFER_FLAG_DELTA_UNIT);
Wim Taymans's avatar
Wim Taymans committed
474

475
  GST_LOG_OBJECT (mux, GST_GP_FORMAT
476
477
      " created buffer %p from ogg page",
      GST_GP_CAST (ogg_page_granulepos (page)), buffer);
478

479
480
481
  return buffer;
}

Wim Taymans's avatar
Wim Taymans committed
482
static GstFlowReturn
483
gst_ogg_mux_push_buffer (GstOggMux * mux, GstBuffer * buffer)
484
{
485
486
  GstCaps *caps;

487
488
489
490
  /* 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;
491

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

501
  caps = gst_pad_get_negotiated_caps (mux->srcpad);
502
  gst_buffer_set_caps (buffer, caps);
503
504
  if (caps)
    gst_caps_unref (caps);
505

506
507
508
509
510
511
512
513
514
  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;
515
  GstOggPadData *opad = NULL;   /* "oldest" pad */
516
517
518
519
520
521
522
523
  GstClockTime oldest = GST_CLOCK_TIME_NONE;
  GstBuffer *buf = NULL;
  gboolean ret = FALSE;

  *flowret = GST_FLOW_OK;

  walk = mux->collect->data;
  while (walk) {
524
    GstOggPadData *pad = (GstOggPadData *) walk->data;
525
526
527
528
529
530
531

    /* 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) {
532
533
        GST_LOG_OBJECT (pad->collect.pad,
            "pad is EOS, skipping for dequeue decision");
534
      } else {
535
536
        GST_LOG_OBJECT (pad->collect.pad,
            "no pages in this queue, can't dequeue");
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
        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) {
554
555
        GST_LOG_OBJECT (pad->collect.pad,
            "No page timestamps in queue, can't dequeue");
556
557
558
559
560
561
562
563
564
        return FALSE;
      }
    }

    walk = g_slist_next (walk);
  }

  walk = mux->collect->data;
  while (walk) {
565
    GstOggPadData *pad = (GstOggPadData *) walk->data;
566

567
    /* any page with a granulepos of -1 can be pushed immediately.
568
569
570
     * 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
571
      GST_LOG_OBJECT (pad->collect.pad, "[gp        -1] pushing page");
572
573
574
575
576
577
578
579
580
      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) {
581
582
583
584
        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);
585
586
587
        opad = pad;
      } else {
        /* if we have an oldest, compare with this one */
588
589
590
591
592
        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);
593
594
595
596
597
598
599
600
601
602
          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
603
    GST_LOG_OBJECT (opad->collect.pad,
604
605
606
        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)));
607
608
609
610
611
612
613
    *flowret = gst_ogg_mux_push_buffer (mux, buf);
    ret = TRUE;
  }

  return ret;
}

614
615
616
617
618
619
620
621
622
623
624
625
626
/* 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.
 */
627
static GstFlowReturn
628
629
gst_ogg_mux_pad_queue_page (GstOggMux * mux, GstOggPadData * pad,
    ogg_page * page, gboolean delta)
630
{
Wim Taymans's avatar
Wim Taymans committed
631
  GstFlowReturn ret;
632
  GstBuffer *buffer = gst_ogg_mux_buffer_from_page (mux, page, delta);
633

634
  /* take the timestamp of the first packet on this page */
635
  GST_BUFFER_TIMESTAMP (buffer) = pad->timestamp;
636
  GST_BUFFER_DURATION (buffer) = pad->timestamp_end - pad->timestamp;
637
638
  /* take the gp time of the last completed packet on this page */
  GST_BUFFER_OFFSET (buffer) = pad->gp_time;
639

640
  /* the next page will start where the current page's end time leaves off */
641
642
  pad->timestamp = pad->timestamp_end;

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

652
653
654
655
  while (gst_ogg_mux_dequeue_page (mux, &ret)) {
    if (ret != GST_FLOW_OK)
      break;
  }
Wim Taymans's avatar
Wim Taymans committed
656
657

  return ret;
Wim Taymans's avatar
Wim Taymans committed
658
659
660
}

/*
661
662
663
664
665
666
667
 * 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
668
669
 */
static gint
670
671
gst_ogg_mux_compare_pads (GstOggMux * ogg_mux, GstOggPadData * first,
    GstOggPadData * second)
Wim Taymans's avatar
Wim Taymans committed
672
{
673
  guint64 firsttime, secondtime;
Wim Taymans's avatar
Wim Taymans committed
674

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

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

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

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

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

717
718
719
720
721
722
723
724
725
726
727
728
729
/* 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 */
730
static GstOggPadData *
Wim Taymans's avatar
Wim Taymans committed
731
gst_ogg_mux_queue_pads (GstOggMux * ogg_mux)
Wim Taymans's avatar
Wim Taymans committed
732
{
733
  GstOggPadData *bestpad = NULL, *still_hungry = NULL;
Wim Taymans's avatar
Wim Taymans committed
734
735
736
  GSList *walk;

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

Wim Taymans's avatar
Wim Taymans committed
742
    data = (GstCollectData *) walk->data;
743
    pad = (GstOggPadData *) data;
Wim Taymans's avatar
Wim Taymans committed
744

Wim Taymans's avatar
Wim Taymans committed
745
746
    walk = g_slist_next (walk);

747
    GST_LOG_OBJECT (data->pad, "looking at pad for buffer");
748

Wim Taymans's avatar
Wim Taymans committed
749
    /* try to get a new buffer for this pad if needed and possible */
Wim Taymans's avatar
Wim Taymans committed
750
751
752
    if (pad->buffer == NULL) {
      GstBuffer *buf;
      gboolean incaps;
Wim Taymans's avatar
Wim Taymans committed
753

754
755
756
757
758
759
760
761
      /* 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;
      }

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

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

771
772
773
774
775
        incaps = GST_BUFFER_FLAG_IS_SET (buf, GST_BUFFER_FLAG_IN_CAPS);
        /* if we need headers */
        if (pad->state == GST_OGG_PAD_STATE_CONTROL) {
          /* and we have one */
          if (incaps) {
776
777
            GST_DEBUG_OBJECT (ogg_mux,
                "got incaps buffer in control state, ignoring");
778
779
780
781
            /* just ignore */
            gst_buffer_unref (buf);
            buf = NULL;
          } else {
782
783
            GST_DEBUG_OBJECT (ogg_mux,
                "got data buffer in control state, switching " "to data mode");
784
785
786
            /* this is a data buffer so switch to data state */
            pad->state = GST_OGG_PAD_STATE_DATA;
          }
Wim Taymans's avatar
Wim Taymans committed
787
        }
788
      } else {
789
        GST_DEBUG_OBJECT (data->pad, "EOS on pad");
790
791
792
793
        if (!pad->eos) {
          ogg_page page;
          GstFlowReturn ret;

794
795
796
          /* it's no longer active */
          ogg_mux->active_pads--;

797
798
799
800
801
802
803
804
805
806
807
808
809
          /* Just gone to EOS. Flush existing page(s) */
          pad->eos = TRUE;

          while (ogg_stream_flush (&pad->stream, &page)) {
            /* 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
810
      }
811

812
      pad->next_buffer = buf;
Wim Taymans's avatar
Wim Taymans committed
813
    }
Wim Taymans's avatar
Wim Taymans committed
814
815
816

    /* we should have a buffer now, see if it is the best pad to
     * pull on */
817
    if (pad->buffer || pad->next_buffer) {
818
      if (gst_ogg_mux_compare_pads (ogg_mux, bestpad, pad) > 0) {
819
820
821
        GST_LOG_OBJECT (data->pad,
            "new best pad, with buffers %" GST_PTR_FORMAT
            " and %" GST_PTR_FORMAT, pad->buffer, pad->next_buffer);
822

Wim Taymans's avatar
Wim Taymans committed
823
        bestpad = pad;
824
      }
825
    } else if (!pad->eos) {
826
      GST_LOG_OBJECT (data->pad, "hungry pad");
827
      still_hungry = pad;
Wim Taymans's avatar
Wim Taymans committed
828
829
    }
  }
830
831
832
833
834
835

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

838
static GList *
839
gst_ogg_mux_get_headers (GstOggPadData * pad)
840
841
842
{
  GList *res = NULL;
  GstStructure *structure;
843
  GstCaps *caps;
Wim Taymans's avatar
Wim Taymans committed
844
  GstPad *thepad;
845

Wim Taymans's avatar
Wim Taymans committed
846
  thepad = pad->collect.pad;
847

848
  GST_LOG_OBJECT (thepad, "getting headers");
Wim Taymans's avatar
Wim Taymans committed
849
850

  caps = gst_pad_get_negotiated_caps (thepad);
851
852
853
854
  if (caps != NULL) {
    const GValue *streamheader;

    structure = gst_caps_get_structure (caps, 0);
855
856
857
858
859
860
    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;
861

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

864
865
        for (i = 0; i < bufarr->len; i++) {
          GValue *bufval = &g_array_index (bufarr, GValue, i);
866

867
868
869
          GST_LOG_OBJECT (thepad, "item %d", i);
          if (G_VALUE_TYPE (bufval) == GST_TYPE_BUFFER) {
            GstBuffer *buf = g_value_peek_pointer (bufval);
870

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

873
874
            gst_buffer_ref (buf);
            res = g_list_append (res, buf);
875
876
          }
        }
Wim Taymans's avatar
Wim Taymans committed
877
      } else {
878
        GST_LOG_OBJECT (thepad, "streamheader is not fixed list");
879
      }
880
881
882
883
    } 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;
884
      pad->always_flush_page = TRUE;
885
886
    } else {
      GST_LOG_OBJECT (thepad, "caps don't have streamheader");
887
    }
888
    gst_caps_unref (caps);
Wim Taymans's avatar
Wim Taymans committed
889
  } else {
890
    GST_LOG_OBJECT (thepad, "got empty caps as negotiated format");
891
892
893
894
  }
  return res;
}

Wim Taymans's avatar
Wim Taymans committed
895
static GstCaps *
896
897
gst_ogg_mux_set_header_on_caps (GstCaps * caps, GList * buffers)
{
Wim Taymans's avatar
Wim Taymans committed
898
  GstStructure *structure;
899
  GValue array = { 0 };
900
901
  GList *walk = buffers;

Wim Taymans's avatar
Wim Taymans committed
902
903
904
905
  caps = gst_caps_make_writable (caps);

  structure = gst_caps_get_structure (caps, 0);

906
  /* put buffers in a fixed list */
907
  g_value_init (&array, GST_TYPE_ARRAY);
908
909
910

  while (walk) {
    GstBuffer *buf = GST_BUFFER (walk->data);
911
    GstBuffer *copy;
912
913
914
915
916
    GValue value = { 0 };

    walk = walk->next;

    /* mark buffer */
917
    GST_LOG ("Setting IN_CAPS on buffer of length %d", GST_BUFFER_SIZE (buf));
918
    GST_BUFFER_FLAG_SET (buf, GST_BUFFER_FLAG_IN_CAPS);
919
920

    g_value_init (&value, GST_TYPE_BUFFER);
921
922
923
    copy = gst_buffer_copy (buf);
    gst_value_set_buffer (&value, copy);
    gst_buffer_unref (copy);
924
    gst_value_array_append_value (&array, &value);
925
926
    g_value_unset (&value);
  }
927
928
  gst_structure_set_value (structure, "streamheader", &array);
  g_value_unset (&array);
Wim Taymans's avatar
Wim Taymans committed
929
930

  return caps;
931
932
}

933
/*
934
935
936
937
938
939
940
 * 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
941
static GstFlowReturn
942
943
944
945
946
gst_ogg_mux_send_headers (GstOggMux * mux)
{
  GSList *walk;
  GList *hbufs, *hwalk;
  GstCaps *caps;
Wim Taymans's avatar
Wim Taymans committed
947
  GstFlowReturn ret;
948
949

  hbufs = NULL;
Wim Taymans's avatar
Wim Taymans committed
950
  ret = GST_FLOW_OK;
951

952
  GST_LOG_OBJECT (mux, "collecting headers");
953

Wim Taymans's avatar
Wim Taymans committed
954
  walk = mux->collect->data;
955
  while (walk) {
956
    GstOggPadData *pad;
Wim Taymans's avatar
Wim Taymans committed
957
    GstPad *thepad;
958

959
    pad = (GstOggPadData *) walk->data;
Wim Taymans's avatar
Wim Taymans committed
960
    thepad = pad->collect.pad;
961

Wim Taymans's avatar
Wim Taymans committed
962
963
    walk = g_slist_next (walk);

964
    GST_LOG_OBJECT (mux, "looking at pad %s:%s", GST_DEBUG_PAD_NAME (thepad));
965
966

    /* if the pad has no buffer, we don't care */
967
    if (pad->buffer == NULL && pad->next_buffer == NULL)
968
969
970
971
972
973
      continue;

    /* now figure out the headers */
    pad->headers = gst_ogg_mux_get_headers (pad);
  }

974
  GST_LOG_OBJECT (mux, "creating BOS pages");
Wim Taymans's avatar
Wim Taymans committed
975
  walk = mux->collect->data;
976
  while (walk) {
977
    GstOggPadData *pad;
978
979
980
    GstBuffer *buf;
    ogg_packet packet;
    ogg_page page;
Wim Taymans's avatar
Wim Taymans committed
981
    GstPad *thepad;
982
983
984
    GstCaps *caps;
    GstStructure *structure;
    GstBuffer *hbuf;
Wim Taymans's avatar
Wim Taymans committed
985

986
    pad = (GstOggPadData *) walk->data;
Wim Taymans's avatar
Wim Taymans committed
987
    thepad = pad->collect.pad;
988
989
    caps = gst_pad_get_negotiated_caps (thepad);
    structure = gst_caps_get_structure (caps, 0);
990
991
992
993
994

    walk = walk->next;

    pad->packetno = 0;

995
    GST_LOG_OBJECT (thepad, "looping over headers");
996
997
998
999

    if (pad->headers) {
      buf = GST_BUFFER (pad->headers->data);
      pad->headers = g_list_remove (pad->headers, buf);
1000
    } else if (pad->buffer) {
1001
1002
      buf = pad->buffer;
      gst_buffer_ref (buf);
1003
1004
1005
    } else if (pad->next_buffer) {
      buf = pad->next_buffer;
      gst_buffer_ref (buf);
1006
    } else {
1007
      /* fixme -- should be caught in the previous list traversal. */
1008
      GST_OBJECT_LOCK (pad);
1009
1010
      g_critical ("No headers or buffers on pad %s:%s",
          GST_DEBUG_PAD_NAME (pad));
1011
      GST_OBJECT_UNLOCK (pad);
1012
      continue;
1013
1014
1015
1016
1017
1018
    }

    /* 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);
1019
1020
    if (packet.granulepos == -1)
      packet.granulepos = 0;
1021
1022
1023
1024
1025
1026
1027
1028
1029
1030
    /* 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 */
    ogg_stream_packetin (&pad->stream, &packet);
    gst_buffer_unref (buf);

1031
1032
1033
1034
1035
    GST_LOG_OBJECT (thepad, "flushing out BOS page");
    if (!ogg_stream_flush (&pad->stream, &page))
      g_critical ("Could not flush BOS page");

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

1037
1038
1039
    GST_LOG_OBJECT (mux, "swapped out page with mime type %s",
        gst_structure_get_name (structure));

1040
    /* quick hack: put Theora and Dirac video pages at the front.
1041
     * Ideally, we would have a settable enum for which Ogg
1042
1043
1044
1045
1046
1047
1048
1049
1050
     * 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");
1051
      hbufs = g_list_prepend (hbufs, hbuf);
1052
      pad->always_flush_page = TRUE;
1053
    } else {
1054
1055
      hbufs = g_list_append (hbufs, hbuf);
    }
1056
    gst_caps_unref (caps);
1057
1058
  }

1059
  GST_LOG_OBJECT (mux, "creating next headers");
Wim Taymans's avatar
Wim Taymans committed
1060
  walk = mux->collect->data;
1061
  while (walk) {
1062
    GstOggPadData *pad;
Wim Taymans's avatar
Wim Taymans committed
1063
1064
    GstPad *thepad;

1065
    pad = (GstOggPadData *) walk->data;
Wim Taymans's avatar
Wim Taymans committed
1066
    thepad = pad->collect.pad;
1067
1068
1069

    walk = walk->next;

1070
1071
    GST_LOG_OBJECT (mux, "looping over headers for pad %s:%s",
        GST_DEBUG_PAD_NAME (thepad));
1072
1073
1074
1075
1076
1077
1078
1079
1080
1081
1082
1083
1084

    hwalk = pad->headers;
    while (hwalk) {
      GstBuffer *buf = GST_BUFFER (hwalk->data);
      ogg_packet packet;
      ogg_page page;

      hwalk = hwalk->next;

      /* 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);
1085
1086
      if (packet.granulepos == -1)
        packet.granulepos = 0;
1087
1088
1089
1090
1091
1092
1093
1094
1095
1096
1097
1098
      /* 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 */
      ogg_stream_packetin (&pad->stream, &packet);
      gst_buffer_unref (buf);

      /* if last header, flush page */
      if (hwalk == NULL) {
1099
        GST_LOG_OBJECT (mux,
Tim-Philipp Müller's avatar
Tim-Philipp Müller committed
1100
1101
            "flushing page as packet %" G_GUINT64_FORMAT " is first or "
            "last packet", pad->packetno);
1102
        while (ogg_stream_flush (&pad->stream, &page)) {
1103
          GstBuffer *hbuf = gst_ogg_mux_buffer_from_page (mux, &page, FALSE);
1104

1105
          GST_LOG_OBJECT (mux, "swapped out page");
1106
1107
1108
          hbufs = g_list_append (hbufs, hbuf);
        }
      } else {
1109
        GST_LOG_OBJECT (mux, "try to swap out page");
1110
1111
        /* just try to swap out a page then */
        while (ogg_stream_pageout (&pad->stream, &page) > 0) {
1112
          GstBuffer *hbuf = gst_ogg_mux_buffer_from_page (mux, &page, FALSE);
1113

1114
          GST_LOG_OBJECT (mux, "swapped out page");