1 /* AVI muxer plugin for GStreamer
2 * Copyright (C) 2002 Ronald Bultje <rbultje@ronald.bitfreak.net>
4 * This library is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU Library General Public
6 * License as published by the Free Software Foundation; either
7 * version 2 of the License, or (at your option) any later version.
9 * This library is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 * Library General Public License for more details.
14 * You should have received a copy of the GNU Library General Public
15 * License along with this library; if not, write to the
16 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
17 * Boston, MA 02111-1307, USA.
21 * - the old avimuxer (by Wim Taymans)
22 * - xawtv's aviwriter (by Gerd Knorr)
23 * - mjpegtools' avilib (by Rainer Johanni)
24 * - openDML large-AVI docs
33 #include "gstavimux.h"
35 #ifndef LE_FROM_GUINT16
36 #define LE_FROM_GUINT16 GUINT16_FROM_LE
39 #ifndef LE_FROM_GUINT32
40 #define LE_FROM_GUINT32 GUINT32_FROM_LE
44 /* elementfactory information */
45 static GstElementDetails
50 "Muxes audio and video into an avi stream",
52 "Ronald Bultje <rbultje@ronald.bitfreak.net>",
56 /* AviMux signals and args */
68 GST_PADTEMPLATE_FACTORY (src_factory,
79 GST_PADTEMPLATE_FACTORY (video_sink_factory,
86 "format", GST_PROPS_STRING ("strf_vids")
91 "format", GST_PROPS_LIST (
92 GST_PROPS_FOURCC (GST_MAKE_FOURCC('Y','U','Y','2')),
93 GST_PROPS_FOURCC (GST_MAKE_FOURCC('I','4','2','0')),
94 GST_PROPS_FOURCC (GST_MAKE_FOURCC('Y','4','1','P'))
96 "width", GST_PROPS_INT_RANGE (16, 4096),
97 "height", GST_PROPS_INT_RANGE (16, 4096)
102 "format", GST_PROPS_FOURCC (GST_MAKE_FOURCC('R','G','B',' ')),
103 "width", GST_PROPS_INT_RANGE (16, 4096),
104 "height", GST_PROPS_INT_RANGE (16, 4096),
105 "depth", GST_PROPS_LIST(
111 "bpp", GST_PROPS_LIST(
121 "width", GST_PROPS_INT_RANGE (16, 4096),
122 "height", GST_PROPS_INT_RANGE (16, 4096)
126 GST_PADTEMPLATE_FACTORY (audio_sink_factory,
133 "format", GST_PROPS_STRING ("strf_auds")
138 "format", GST_PROPS_STRING ("int"),
139 "law", GST_PROPS_INT (0),
140 "endianness", GST_PROPS_INT (G_BYTE_ORDER),
141 "signed", GST_PROPS_LIST (
142 GST_PROPS_BOOLEAN (TRUE),
143 GST_PROPS_BOOLEAN (FALSE)
145 "width", GST_PROPS_LIST (
149 "depth", GST_PROPS_LIST (
153 "rate", GST_PROPS_INT_RANGE (11025, 44100),
154 "channels", GST_PROPS_INT_RANGE (1, 2)
164 static void gst_avimux_class_init (GstAviMuxClass *klass);
165 static void gst_avimux_init (GstAviMux *avimux);
167 static void gst_avimux_chain (GstPad *pad,
169 static gboolean gst_avimux_handle_event (GstPad *pad,
171 static GstPad* gst_avimux_request_new_pad (GstElement *element,
172 GstPadTemplate *templ,
174 static void gst_avimux_set_property (GObject *object,
178 static void gst_avimux_get_property (GObject *object,
182 static GstElementStateReturn gst_avimux_change_state (GstElement *element);
184 static GstElementClass *parent_class = NULL;
185 /*static guint gst_avimux_signals[LAST_SIGNAL] = { 0 }; */
188 gst_avimux_get_type (void)
190 static GType avimux_type = 0;
193 static const GTypeInfo avimux_info = {
194 sizeof(GstAviMuxClass),
197 (GClassInitFunc)gst_avimux_class_init,
202 (GInstanceInitFunc)gst_avimux_init,
204 avimux_type = g_type_register_static(GST_TYPE_ELEMENT, "GstAviMux", &avimux_info, 0);
210 gst_avimux_class_init (GstAviMuxClass *klass)
212 GObjectClass *gobject_class;
213 GstElementClass *gstelement_class;
215 gobject_class = (GObjectClass*)klass;
216 gstelement_class = (GstElementClass*)klass;
218 parent_class = g_type_class_ref (GST_TYPE_ELEMENT);
220 g_object_class_install_property(G_OBJECT_CLASS(klass), ARG_BIGFILE,
221 g_param_spec_boolean("bigfile","Bigfile Support","Whether to capture large or small AVI files",
222 0,G_PARAM_READWRITE));
224 g_object_class_install_property(G_OBJECT_CLASS(klass), ARG_FRAMERATE,
225 g_param_spec_double("framerate","Framerate","Frames/sec",
226 G_MINDOUBLE,G_MAXDOUBLE,25.0,G_PARAM_READWRITE));
228 gstelement_class->request_new_pad = gst_avimux_request_new_pad;
230 gstelement_class->change_state = gst_avimux_change_state;
232 gstelement_class->get_property = gst_avimux_get_property;
233 gstelement_class->set_property = gst_avimux_set_property;
237 gst_avimux_init (GstAviMux *avimux)
240 avimux->srcpad = gst_pad_new_from_template (
241 GST_PADTEMPLATE_GET (src_factory), "src");
242 gst_element_add_pad (GST_ELEMENT (avimux), avimux->srcpad);
244 GST_FLAG_SET (GST_ELEMENT(avimux), GST_ELEMENT_EVENT_AWARE);
245 gst_pad_set_event_function(avimux->srcpad, gst_avimux_handle_event);
247 for (i=0;i<MAX_NUM_AUDIO_PADS;i++)
248 avimux->audiosinkpad[i] = NULL;
249 avimux->num_audio_pads = 0;
250 for (i=0;i<MAX_NUM_VIDEO_PADS;i++)
251 avimux->videosinkpad[i] = NULL;
252 avimux->num_video_pads = 0;
254 avimux->num_frames = 0;
256 /* audio/video/AVI header initialisation */
257 memset(&(avimux->avi_hdr),0,sizeof(gst_riff_avih));
258 memset(&(avimux->vids_hdr),0,sizeof(gst_riff_strh));
259 memset(&(avimux->vids),0,sizeof(gst_riff_strf_vids));
260 memset(&(avimux->auds_hdr),0,sizeof(gst_riff_strh));
261 memset(&(avimux->auds),0,sizeof(gst_riff_strf_auds));
262 avimux->vids_hdr.type = GST_MAKE_FOURCC('v','i','d','s');
263 avimux->vids_hdr.rate = 1000000;
264 avimux->auds_hdr.type = GST_MAKE_FOURCC('a','u','d','s');
268 avimux->write_header = TRUE;
270 avimux->enable_large_avi = TRUE;
272 avimux->framerate = 25.;
275 static GstPadConnectReturn
276 gst_avimux_sinkconnect (GstPad *pad, GstCaps *vscaps)
281 avimux = GST_AVIMUX (gst_pad_get_parent (pad));
283 /* we are not going to act on variable caps */
284 if (!GST_CAPS_IS_FIXED (vscaps))
285 return GST_PAD_CONNECT_DELAYED;
287 GST_DEBUG (0, "avimux: sinkconnect triggered on %s", gst_pad_get_name (pad));
289 for (caps = vscaps; caps != NULL; caps = vscaps = vscaps->next)
291 const gchar* mimetype = gst_caps_get_mime(caps);
293 if (!strcmp (mimetype, "video/avi"))
297 gst_caps_get_string (caps, "format", &format);
299 if (!strncmp (format, "strf_vids", 9)) {
300 avimux->vids.size = sizeof(gst_riff_strf_vids);
302 "width", GST_PROPS_INT_TYPE, &avimux->vids.width,
303 "height", GST_PROPS_INT_TYPE, &avimux->vids.height,
304 "planes", GST_PROPS_INT_TYPE, &avimux->vids.planes,
305 "bit_cnt", GST_PROPS_INT_TYPE, &avimux->vids.bit_cnt,
306 "compression", GST_PROPS_FOURCC_TYPE, &avimux->vids.compression,
307 "image_size", GST_PROPS_INT_TYPE, &avimux->vids.image_size,
308 "xpels_meter", GST_PROPS_INT_TYPE, &avimux->vids.xpels_meter,
309 "ypels_meter", GST_PROPS_INT_TYPE, &avimux->vids.ypels_meter,
310 "num_colors", GST_PROPS_INT_TYPE, &avimux->vids.num_colors,
311 "imp_colors", GST_PROPS_INT_TYPE, &avimux->vids.imp_colors,
314 else if (!strncmp (format, "strf_auds", 9)) {
316 "format", GST_PROPS_INT_TYPE, &avimux->auds.format,
317 "channels", GST_PROPS_INT_TYPE, &avimux->auds.channels,
318 "rate", GST_PROPS_INT_TYPE, &avimux->auds.rate,
319 "av_bps", GST_PROPS_INT_TYPE, &avimux->auds.av_bps,
320 "blockalign", GST_PROPS_INT_TYPE, &avimux->auds.blockalign,
321 "size", GST_PROPS_INT_TYPE, &avimux->auds.size,
326 else if (!strcmp (mimetype, "video/raw"))
331 gst_caps_get_fourcc_int (caps, "format", &format);
334 case GST_MAKE_FOURCC('Y','U','Y','2'):
335 case GST_MAKE_FOURCC('I','4','2','0'):
336 case GST_MAKE_FOURCC('Y','4','1','P'):
337 case GST_MAKE_FOURCC('R','G','B',' '):
338 avimux->vids.size = sizeof(gst_riff_strf_vids);
340 "width", GST_PROPS_INT_TYPE, &avimux->vids.width,
341 "height", GST_PROPS_INT_TYPE, &avimux->vids.height,
343 avimux->vids.planes = 1;
346 case GST_MAKE_FOURCC('Y','U','Y','2'):
347 avimux->vids.bit_cnt = 16; /* YUY2 */
349 case GST_MAKE_FOURCC('R','G','B',' '):
350 gst_caps_get_int (caps, "bpp", &temp); /* RGB */
351 avimux->vids.bit_cnt = temp;
353 case GST_MAKE_FOURCC('Y','4','1','P'):
354 case GST_MAKE_FOURCC('I','4','2','0'):
355 avimux->vids.bit_cnt = 12; /* Y41P or I420 */
358 gst_caps_get_fourcc_int(caps, "format", &avimux->vids.compression);
359 avimux->vids.image_size = avimux->vids.height * avimux->vids.width;
365 else if (!strcmp (mimetype, "video/jpeg"))
367 avimux->vids.size = sizeof(gst_riff_strf_vids);
369 "width", GST_PROPS_INT_TYPE, &avimux->vids.width,
370 "height", GST_PROPS_INT_TYPE, &avimux->vids.height,
372 avimux->vids.planes = 1;
373 avimux->vids.bit_cnt = 24;
374 avimux->vids.compression = GST_MAKE_FOURCC('M','J','P','G');
375 avimux->vids.image_size = avimux->vids.height * avimux->vids.width;
378 else if (!strcmp (mimetype, "audio/raw"))
382 avimux->auds.format = GST_RIFF_WAVE_FORMAT_PCM;
384 "channels", GST_PROPS_INT_TYPE, &avimux->auds.channels,
385 "rate", GST_PROPS_INT_TYPE, &avimux->auds.rate,
386 "width", GST_PROPS_INT_TYPE, &width,
387 "depth", GST_PROPS_INT_TYPE, &avimux->auds.size,
389 avimux->auds.av_bps = width * avimux->auds.rate * avimux->auds.channels / 8;
390 avimux->auds.blockalign = width * avimux->auds.channels/8;
393 else if (!strcmp (mimetype, "audio/mp3"))
397 gst_caps_get_int(caps, "layer", &layer);
399 /* we don't need to do anything here, compressed mp3 contains it all */
400 avimux->auds.format = (layer == 3?
401 GST_RIFF_WAVE_FORMAT_MPEGL3 :
402 GST_RIFF_WAVE_FORMAT_MPEGL12);
406 return GST_PAD_CONNECT_REFUSED;
409 return GST_PAD_CONNECT_OK;
413 gst_avimux_request_new_pad (GstElement *element,
414 GstPadTemplate *templ,
415 const gchar *req_name)
421 g_return_val_if_fail (templ != NULL, NULL);
423 if (templ->direction != GST_PAD_SINK) {
424 g_warning ("avimux: request pad that is not a SINK pad\n");
428 g_return_val_if_fail (GST_IS_AVIMUX (element), NULL);
430 avimux = GST_AVIMUX (element);
432 if (templ == GST_PADTEMPLATE_GET (audio_sink_factory)) {
433 g_return_val_if_fail(avimux->num_audio_pads == 0 /*< MAX_NUM_AUDIO_PADS*/, NULL);
434 name = g_strdup_printf ("audio_%02d", avimux->num_audio_pads);
435 newpad = gst_pad_new_from_template (templ, name);
436 gst_pad_set_element_private (newpad, GINT_TO_POINTER (avimux->num_audio_pads));
438 avimux->audiosinkpad[avimux->num_audio_pads] = newpad;
439 avimux->num_audio_pads++;
441 else if (templ == GST_PADTEMPLATE_GET (video_sink_factory)) {
442 g_return_val_if_fail(avimux->num_video_pads == 0 /*< MAX_NUM_VIDEO_PADS*/, NULL);
443 name = g_strdup_printf ("video_%02d", avimux->num_video_pads);
444 newpad = gst_pad_new_from_template (templ, name);
445 gst_pad_set_element_private (newpad, GINT_TO_POINTER (avimux->num_video_pads));
447 avimux->videosinkpad[avimux->num_video_pads] = newpad;
448 avimux->num_video_pads++;
451 g_warning ("avimux: this is not our template!\n");
455 gst_pad_set_chain_function (newpad, gst_avimux_chain);
456 gst_pad_set_connect_function (newpad, gst_avimux_sinkconnect);
457 gst_element_add_pad (element, newpad);
462 /* maybe some of these functions should be moved to riff.h? */
464 /* DISCLAIMER: this function is ugly. So be it (i.e. it makes the rest easier) */
467 gst_avimux_riff_get_avi_header (GstAviMux *avimux)
474 buffer = gst_buffer_new();
476 /* first, let's see what actually needs to be in the buffer */
477 GST_BUFFER_SIZE(buffer) = 0;
478 GST_BUFFER_SIZE(buffer) += 32 + sizeof(gst_riff_avih); /* avi header */
479 if (avimux->num_video_pads)
480 { /* we have video */
481 GST_BUFFER_SIZE(buffer) += 28 + sizeof(gst_riff_strh) + sizeof(gst_riff_strf_vids); /* vid hdr */
482 GST_BUFFER_SIZE(buffer) += 24; /* odml header */
484 if (avimux->num_audio_pads)
485 { /* we have audio */
486 GST_BUFFER_SIZE(buffer) += 28 + sizeof(gst_riff_strh) + sizeof(gst_riff_strf_auds); /* aud hdr */
488 /* this is the "riff size" */
489 avimux->header_size = GST_BUFFER_SIZE(buffer);
490 GST_BUFFER_SIZE(buffer) += 12; /* avi data header */
492 /* allocate the buffer */
493 buffdata = GST_BUFFER_DATA(buffer) = g_malloc(GST_BUFFER_SIZE(buffer));
495 /* avi header metadata */
496 memcpy(buffdata, "RIFF", 4); buffdata += 4;
497 temp32 = LE_FROM_GUINT32(avimux->header_size + avimux->idx_size + avimux->data_size);
498 memcpy(buffdata, &temp32, 4); buffdata += 4;
499 memcpy(buffdata, "AVI ", 4); buffdata += 4;
500 memcpy(buffdata, "LIST", 4); buffdata += 4;
501 temp32 = LE_FROM_GUINT32(avimux->header_size - 4*5);
502 memcpy(buffdata, &temp32, 4); buffdata += 4;
503 memcpy(buffdata, "hdrl", 4); buffdata += 4;
504 memcpy(buffdata, "avih", 4); buffdata += 4;
505 temp32 = LE_FROM_GUINT32(sizeof(gst_riff_avih));
506 memcpy(buffdata, &temp32, 4); buffdata += 4;
507 /* the AVI header itself */
508 temp32 = LE_FROM_GUINT32(avimux->avi_hdr.us_frame);
509 memcpy(buffdata, &temp32, 4); buffdata += 4;
510 temp32 = LE_FROM_GUINT32(avimux->avi_hdr.max_bps);
511 memcpy(buffdata, &temp32, 4); buffdata += 4;
512 temp32 = LE_FROM_GUINT32(avimux->avi_hdr.pad_gran);
513 memcpy(buffdata, &temp32, 4); buffdata += 4;
514 temp32 = LE_FROM_GUINT32(avimux->avi_hdr.flags);
515 memcpy(buffdata, &temp32, 4); buffdata += 4;
516 temp32 = LE_FROM_GUINT32(avimux->avi_hdr.tot_frames);
517 memcpy(buffdata, &temp32, 4); buffdata += 4;
518 temp32 = LE_FROM_GUINT32(avimux->avi_hdr.init_frames);
519 memcpy(buffdata, &temp32, 4); buffdata += 4;
520 temp32 = LE_FROM_GUINT32(avimux->avi_hdr.streams);
521 memcpy(buffdata, &temp32, 4); buffdata += 4;
522 temp32 = LE_FROM_GUINT32(avimux->avi_hdr.bufsize);
523 memcpy(buffdata, &temp32, 4); buffdata += 4;
524 temp32 = LE_FROM_GUINT32(avimux->avi_hdr.width);
525 memcpy(buffdata, &temp32, 4); buffdata += 4;
526 temp32 = LE_FROM_GUINT32(avimux->avi_hdr.height);
527 memcpy(buffdata, &temp32, 4); buffdata += 4;
528 temp32 = LE_FROM_GUINT32(avimux->avi_hdr.scale);
529 memcpy(buffdata, &temp32, 4); buffdata += 4;
530 temp32 = LE_FROM_GUINT32(avimux->avi_hdr.rate);
531 memcpy(buffdata, &temp32, 4); buffdata += 4;
532 temp32 = LE_FROM_GUINT32(avimux->avi_hdr.start);
533 memcpy(buffdata, &temp32, 4); buffdata += 4;
534 temp32 = LE_FROM_GUINT32(avimux->avi_hdr.length);
535 memcpy(buffdata, &temp32, 4); buffdata += 4;
537 if (avimux->num_video_pads)
539 /* video header metadata */
540 memcpy(buffdata, "LIST", 4); buffdata += 4;
541 temp32 = LE_FROM_GUINT32(sizeof(gst_riff_strh) + sizeof(gst_riff_strf_vids) + 4*5);
542 memcpy(buffdata, &temp32, 4); buffdata += 4;
543 memcpy(buffdata, "strl", 4); buffdata += 4;
545 memcpy(buffdata, "strh", 4); buffdata += 4;
546 temp32 = LE_FROM_GUINT32(sizeof(gst_riff_strh));
547 memcpy(buffdata, &temp32, 4); buffdata += 4;
548 /* the actual header */
549 temp32 = LE_FROM_GUINT32(avimux->vids_hdr.type);
550 memcpy(buffdata, &temp32, 4); buffdata += 4;
551 temp32 = LE_FROM_GUINT32(avimux->vids_hdr.fcc_handler);
552 memcpy(buffdata, &temp32, 4); buffdata += 4;
553 temp32 = LE_FROM_GUINT32(avimux->vids_hdr.flags);
554 memcpy(buffdata, &temp32, 4); buffdata += 4;
555 temp32 = LE_FROM_GUINT32(avimux->vids_hdr.priority);
556 memcpy(buffdata, &temp32, 4); buffdata += 4;
557 temp32 = LE_FROM_GUINT32(avimux->vids_hdr.init_frames);
558 memcpy(buffdata, &temp32, 4); buffdata += 4;
559 temp32 = LE_FROM_GUINT32(avimux->vids_hdr.scale);
560 memcpy(buffdata, &temp32, 4); buffdata += 4;
561 temp32 = LE_FROM_GUINT32(avimux->vids_hdr.rate);
562 memcpy(buffdata, &temp32, 4); buffdata += 4;
563 temp32 = LE_FROM_GUINT32(avimux->vids_hdr.start);
564 memcpy(buffdata, &temp32, 4); buffdata += 4;
565 temp32 = LE_FROM_GUINT32(avimux->vids_hdr.length);
566 memcpy(buffdata, &temp32, 4); buffdata += 4;
567 temp32 = LE_FROM_GUINT32(avimux->vids_hdr.bufsize);
568 memcpy(buffdata, &temp32, 4); buffdata += 4;
569 temp32 = LE_FROM_GUINT32(avimux->vids_hdr.quality);
570 memcpy(buffdata, &temp32, 4); buffdata += 4;
571 temp32 = LE_FROM_GUINT32(avimux->vids_hdr.samplesize);
572 memcpy(buffdata, &temp32, 4); buffdata += 4;
573 /* the video header */
574 memcpy(buffdata, "strf", 4); buffdata += 4;
575 temp32 = LE_FROM_GUINT32(sizeof(gst_riff_strf_vids));
576 memcpy(buffdata, &temp32, 4); buffdata += 4;
577 /* the actual header */
578 temp32 = LE_FROM_GUINT32(avimux->vids.size);
579 memcpy(buffdata, &temp32, 4); buffdata += 4;
580 temp32 = LE_FROM_GUINT32(avimux->vids.width);
581 memcpy(buffdata, &temp32, 4); buffdata += 4;
582 temp32 = LE_FROM_GUINT32(avimux->vids.height);
583 memcpy(buffdata, &temp32, 4); buffdata += 4;
584 temp16 = LE_FROM_GUINT16(avimux->vids.planes);
585 memcpy(buffdata, &temp16, 2); buffdata += 2;
586 temp16 = LE_FROM_GUINT16(avimux->vids.bit_cnt);
587 memcpy(buffdata, &temp16, 2); buffdata += 2;
588 temp32 = LE_FROM_GUINT32(avimux->vids.compression);
589 memcpy(buffdata, &temp32, 4); buffdata += 4;
590 temp32 = LE_FROM_GUINT32(avimux->vids.image_size);
591 memcpy(buffdata, &temp32, 4); buffdata += 4;
592 temp32 = LE_FROM_GUINT32(avimux->vids.xpels_meter);
593 memcpy(buffdata, &temp32, 4); buffdata += 4;
594 temp32 = LE_FROM_GUINT32(avimux->vids.ypels_meter);
595 memcpy(buffdata, &temp32, 4); buffdata += 4;
596 temp32 = LE_FROM_GUINT32(avimux->vids.num_colors);
597 memcpy(buffdata, &temp32, 4); buffdata += 4;
598 temp32 = LE_FROM_GUINT32(avimux->vids.imp_colors);
599 memcpy(buffdata, &temp32, 4); buffdata += 4;
602 if (avimux->num_audio_pads)
605 memcpy(buffdata, "LIST", 4); buffdata += 4;
606 temp32 = LE_FROM_GUINT32(sizeof(gst_riff_strh) + sizeof(gst_riff_strf_auds) + 4*5);
607 memcpy(buffdata, &temp32, 4); buffdata += 4;
608 memcpy(buffdata, "strl", 4); buffdata += 4;
610 memcpy(buffdata, "strh", 4); buffdata += 4;
611 temp32 = LE_FROM_GUINT32(sizeof(gst_riff_strh));
612 memcpy(buffdata, &temp32, 4); buffdata += 4;
613 /* the actual header */
614 temp32 = LE_FROM_GUINT32(avimux->auds_hdr.type);
615 memcpy(buffdata, &temp32, 4); buffdata += 4;
616 temp32 = LE_FROM_GUINT32(avimux->auds_hdr.fcc_handler);
617 memcpy(buffdata, &temp32, 4); buffdata += 4;
618 temp32 = LE_FROM_GUINT32(avimux->auds_hdr.flags);
619 memcpy(buffdata, &temp32, 4); buffdata += 4;
620 temp32 = LE_FROM_GUINT32(avimux->auds_hdr.priority);
621 memcpy(buffdata, &temp32, 4); buffdata += 4;
622 temp32 = LE_FROM_GUINT32(avimux->auds_hdr.init_frames);
623 memcpy(buffdata, &temp32, 4); buffdata += 4;
624 temp32 = LE_FROM_GUINT32(avimux->auds_hdr.scale);
625 memcpy(buffdata, &temp32, 4); buffdata += 4;
626 temp32 = LE_FROM_GUINT32(avimux->auds_hdr.rate);
627 memcpy(buffdata, &temp32, 4); buffdata += 4;
628 temp32 = LE_FROM_GUINT32(avimux->auds_hdr.start);
629 memcpy(buffdata, &temp32, 4); buffdata += 4;
630 temp32 = LE_FROM_GUINT32(avimux->auds_hdr.length);
631 memcpy(buffdata, &temp32, 4); buffdata += 4;
632 temp32 = LE_FROM_GUINT32(avimux->auds_hdr.bufsize);
633 memcpy(buffdata, &temp32, 4); buffdata += 4;
634 temp32 = LE_FROM_GUINT32(avimux->auds_hdr.quality);
635 memcpy(buffdata, &temp32, 4); buffdata += 4;
636 temp32 = LE_FROM_GUINT32(avimux->auds_hdr.samplesize);
637 memcpy(buffdata, &temp32, 4); buffdata += 4;
638 /* the audio header */
639 memcpy(buffdata, "strf", 4); buffdata += 4;
640 temp32 = LE_FROM_GUINT32(sizeof(gst_riff_strf_vids));
641 memcpy(buffdata, &temp32, 4); buffdata += 4;
642 /* the actual header */
643 temp16 = LE_FROM_GUINT16(avimux->auds.format);
644 memcpy(buffdata, &temp16, 2); buffdata += 2;
645 temp16 = LE_FROM_GUINT16(avimux->auds.channels);
646 memcpy(buffdata, &temp16, 2); buffdata += 2;
647 temp32 = LE_FROM_GUINT32(avimux->auds.rate);
648 memcpy(buffdata, &temp32, 4); buffdata += 4;
649 temp32 = LE_FROM_GUINT32(avimux->auds.av_bps);
650 memcpy(buffdata, &temp32, 4); buffdata += 4;
651 temp16 = LE_FROM_GUINT16(avimux->auds.blockalign);
652 memcpy(buffdata, &temp16, 2); buffdata += 2;
653 temp16 = LE_FROM_GUINT16(avimux->auds.size);
654 memcpy(buffdata, &temp16, 2); buffdata += 2;
657 if (avimux->num_video_pads)
660 memcpy(buffdata, "LIST", 4); buffdata += 4;
661 temp32 = LE_FROM_GUINT32(sizeof(guint32)+4*3);
662 memcpy(buffdata, &temp32, 4); buffdata += 4;
663 memcpy(buffdata, "odml", 4); buffdata += 4;
664 memcpy(buffdata, "dmlh", 4); buffdata += 4;
665 temp32 = LE_FROM_GUINT32(sizeof(guint32));
666 memcpy(buffdata, &temp32, 4); buffdata += 4;
667 temp32 = LE_FROM_GUINT32(avimux->total_frames);
668 memcpy(buffdata, &temp32, 4); buffdata += 4;
671 /* avi data header */
672 memcpy(buffdata, "LIST", 4); buffdata += 4;
673 temp32 = LE_FROM_GUINT32(avimux->data_size);
674 memcpy(buffdata, &temp32, 4); buffdata += 4;
675 memcpy(buffdata, "movi", 4);
681 gst_avimux_riff_get_avix_header (guint32 datax_size)
687 buffer = gst_buffer_new();
688 GST_BUFFER_SIZE(buffer) = 24;
689 buffdata = GST_BUFFER_DATA(buffer) = g_malloc(GST_BUFFER_SIZE(buffer));
691 memcpy(buffdata, "LIST", 4); buffdata += 4;
692 temp32 = LE_FROM_GUINT32(datax_size+4*4);
693 memcpy(buffdata, &temp32, 4); buffdata += 4;
694 memcpy(buffdata, "AVIX", 4); buffdata += 4;
695 memcpy(buffdata, "LIST", 4); buffdata += 4;
696 temp32 = LE_FROM_GUINT32(datax_size);
697 memcpy(buffdata, &temp32, 4); buffdata += 4;
698 memcpy(buffdata, "movi", 4);
704 gst_avimux_riff_get_video_header (guint32 video_frame_size)
709 buffer = gst_buffer_new();
710 GST_BUFFER_DATA(buffer) = g_malloc(8);
711 GST_BUFFER_SIZE(buffer) = 8;
712 memcpy(GST_BUFFER_DATA(buffer), "00db", 4);
713 temp32 = LE_FROM_GUINT32(video_frame_size);
714 memcpy(GST_BUFFER_DATA(buffer)+4, &temp32, 4);
720 gst_avimux_riff_get_audio_header (guint32 audio_sample_size)
725 buffer = gst_buffer_new();
726 GST_BUFFER_DATA(buffer) = g_malloc(8);
727 GST_BUFFER_SIZE(buffer) = 8;
728 memcpy(GST_BUFFER_DATA(buffer), "01wb", 4);
729 temp32 = LE_FROM_GUINT32(audio_sample_size);
730 memcpy(GST_BUFFER_DATA(buffer)+4, &temp32, 4);
735 /* some other usable functions (thankyou xawtv ;-) ) */
738 gst_avimux_add_index (GstAviMux *avimux, guint32 fourcc, guint32 flags, guint32 size)
742 if (avimux->idx_index == avimux->idx_count)
744 avimux->idx_count += 256;
745 avimux->idx = realloc(avimux->idx, avimux->idx_count*sizeof(gst_riff_index_entry));
747 temp32 = LE_FROM_GUINT32(fourcc);
748 memcpy(&(avimux->idx[avimux->idx_index].id), &temp32, 4);
749 avimux->idx[avimux->idx_index].flags = LE_FROM_GUINT32(flags);
750 avimux->idx[avimux->idx_index].offset = LE_FROM_GUINT32(avimux->idx_offset-avimux->header_size-8);
751 avimux->idx[avimux->idx_index].size = LE_FROM_GUINT32(size);
753 avimux->idx_offset += size + sizeof(gst_riff_index_entry);
757 gst_avimux_write_index (GstAviMux *avimux)
762 buffer = gst_buffer_new();
763 GST_BUFFER_SIZE(buffer) = 8;
764 GST_BUFFER_DATA(buffer) = g_malloc(8);
765 memcpy(GST_BUFFER_DATA(buffer), "idx1", 4);
766 temp32 = LE_FROM_GUINT32(avimux->idx_index * sizeof(gst_riff_index_entry));
767 memcpy(GST_BUFFER_DATA(buffer)+4, &temp32, 4);
768 gst_pad_push(avimux->srcpad, buffer);
770 buffer = gst_buffer_new();
771 GST_BUFFER_SIZE(buffer) = avimux->idx_index * sizeof(gst_riff_index_entry);
772 GST_BUFFER_DATA(buffer) = (unsigned char*) avimux->idx;
773 avimux->idx = NULL; /* will be free()'ed by gst_buffer_unref() */
774 avimux->total_data += GST_BUFFER_SIZE(buffer);
775 gst_pad_push(avimux->srcpad, buffer);
777 avimux->idx_size += avimux->idx_index * sizeof(gst_riff_index_entry) + 8;
780 avimux->avi_hdr.flags |= GST_RIFF_AVIH_HASINDEX;
784 gst_avimux_bigfile(GstAviMux *avimux, gboolean last)
789 if (avimux->is_bigfile)
792 event = gst_event_new_seek(GST_SEEK_BYTEOFFSET_SET, avimux->avix_start, TRUE);
793 gst_pad_send_event(avimux->srcpad, event);
795 /* rewrite AVIX header */
796 header = gst_avimux_riff_get_avix_header(avimux->datax_size);
797 gst_pad_push(avimux->srcpad, header);
799 /* go back to current location */
800 event = gst_event_new_seek(GST_SEEK_BYTEOFFSET_SET, avimux->total_data, TRUE);
801 gst_pad_send_event(avimux->srcpad, event);
803 avimux->avix_start = avimux->total_data;
808 avimux->is_bigfile = TRUE;
809 avimux->numx_frames = 0;
810 avimux->datax_size = 0;
812 header = gst_avimux_riff_get_avix_header(0);
813 avimux->total_data += GST_BUFFER_SIZE(header);
814 gst_pad_push(avimux->srcpad, header);
817 /* enough header blabla now, let's go on to actually writing the headers */
820 gst_avimux_start_file (GstAviMux *avimux)
824 avimux->total_data = 0;
825 avimux->total_frames = 0;
826 avimux->data_size = 4; /* ? */
827 avimux->datax_size = 0;
828 avimux->num_frames = 0;
829 avimux->numx_frames = 0;
830 avimux->audio_size = 0;
832 avimux->idx_index = 0;
833 avimux->idx_offset = avimux->header_size + 12;
834 avimux->idx_size = 0;
835 avimux->idx_count = 0;
839 avimux->avi_hdr.streams = avimux->num_video_pads + avimux->num_audio_pads;
840 avimux->is_bigfile = FALSE;
842 header = gst_avimux_riff_get_avi_header(avimux);
843 avimux->total_data += GST_BUFFER_SIZE(header);
844 gst_pad_push(avimux->srcpad, header);
846 avimux->write_header = FALSE;
847 avimux->restart = FALSE;
851 gst_avimux_stop_file (GstAviMux *avimux)
856 /* if bigfile, rewrite header, else write indexes */
857 if (avimux->num_video_pads)
859 if (avimux->is_bigfile)
861 gst_avimux_bigfile(avimux, TRUE);
862 avimux->idx_size = 0;
866 gst_avimux_write_index(avimux);
870 /* statistics/total_frames/... */
871 avimux->avi_hdr.tot_frames = avimux->num_frames;
872 if (avimux->num_video_pads)
873 avimux->vids_hdr.length = avimux->num_frames;
874 if (avimux->num_audio_pads)
875 avimux->auds_hdr.length = avimux->audio_size/avimux->auds_hdr.scale;
877 /* TODO: fps calculation!! */
878 avimux->avi_hdr.us_frame = 1000000/avimux->framerate;
879 avimux->avi_hdr.max_bps = 0;
880 if (avimux->num_audio_pads)
881 avimux->avi_hdr.max_bps += avimux->auds.av_bps;
882 if (avimux->num_video_pads)
883 avimux->avi_hdr.max_bps += avimux->vids.bit_cnt/8 * avimux->framerate;
885 /* seek and rewrite the header */
886 header = gst_avimux_riff_get_avi_header(avimux);
887 event = gst_event_new_seek(GST_SEEK_BYTEOFFSET_SET, 0, TRUE);
888 gst_pad_send_event(avimux->srcpad, event);
889 gst_pad_push(avimux->srcpad, header);
891 avimux->write_header = TRUE;
895 gst_avimux_restart_file (GstAviMux *avimux)
899 gst_avimux_stop_file(avimux);
901 event = gst_event_new(GST_EVENT_NEW_MEDIA);
902 gst_pad_send_event(avimux->srcpad, event);
904 gst_avimux_start_file(avimux);
907 /* handle events (search) */
909 gst_avimux_handle_event (GstPad *pad, GstEvent *event)
914 avimux = GST_AVIMUX (gst_pad_get_parent (pad));
916 type = event ? GST_EVENT_TYPE (event) : GST_EVENT_UNKNOWN;
919 case GST_EVENT_NEW_MEDIA:
920 avimux->restart = TRUE;
930 gst_avimux_chain (GstPad *pad, GstBuffer *buf)
934 const gchar *padname = gst_pad_get_name (pad);
936 g_return_if_fail (pad != NULL);
937 g_return_if_fail (GST_IS_PAD (pad));
938 g_return_if_fail (buf != NULL);
939 g_return_if_fail (GST_BUFFER_DATA (buf) != NULL);
941 avimux = GST_AVIMUX (gst_pad_get_parent (pad));
943 if (GST_IS_EVENT(buf))
945 gst_avimux_handle_event(pad, GST_EVENT(buf));
950 if (avimux->write_header)
951 gst_avimux_start_file(avimux);
953 if (strncmp(padname, "audio_", 6) == 0)
955 /* write a audio header + index entry */
956 newbuf = gst_avimux_riff_get_audio_header(GST_BUFFER_SIZE(buf));
957 avimux->total_data += GST_BUFFER_SIZE(newbuf) + GST_BUFFER_SIZE(buf);
959 if (avimux->is_bigfile)
961 avimux->datax_size += GST_BUFFER_SIZE(newbuf) + GST_BUFFER_SIZE(buf);
965 avimux->data_size += GST_BUFFER_SIZE(newbuf) + GST_BUFFER_SIZE(buf);
966 avimux->audio_size += GST_BUFFER_SIZE(buf);
967 gst_avimux_add_index(avimux, avimux->auds.format, 0x0, GST_BUFFER_SIZE(buf));
970 gst_pad_push(avimux->srcpad, newbuf);
972 else if (strncmp(padname, "video_", 6) == 0)
975 gst_avimux_restart_file(avimux);
977 /* write a video header + index entry */
978 GST_BUFFER_SIZE(buf) = (GST_BUFFER_SIZE(buf)+3)&~3;
980 if ((avimux->is_bigfile?avimux->datax_size:avimux->data_size)+GST_BUFFER_SIZE(buf)>1024*1024*2000)
982 if (avimux->enable_large_avi)
983 gst_avimux_bigfile(avimux, FALSE);
985 gst_avimux_restart_file(avimux);
988 newbuf = gst_avimux_riff_get_video_header(GST_BUFFER_SIZE(buf));
989 avimux->total_data += GST_BUFFER_SIZE(newbuf) + GST_BUFFER_SIZE(buf);
990 avimux->total_frames++;
992 if (avimux->is_bigfile)
994 avimux->datax_size += GST_BUFFER_SIZE(newbuf) + GST_BUFFER_SIZE(buf);
995 avimux->numx_frames++;
999 avimux->data_size += GST_BUFFER_SIZE(newbuf) + GST_BUFFER_SIZE(buf);
1000 avimux->num_frames++;
1001 gst_avimux_add_index(avimux, avimux->vids.compression, 0x12, GST_BUFFER_SIZE(buf));
1004 gst_pad_push(avimux->srcpad, newbuf);
1008 g_warning("Unknown padname \'%s\'\n", padname);
1013 gst_pad_push(avimux->srcpad, buf);
1017 gst_avimux_get_property (GObject *object,
1024 /* it's not null if we got it, but it might not be ours */
1025 g_return_if_fail(GST_IS_AVIMUX(object));
1026 avimux = GST_AVIMUX(object);
1031 g_value_set_boolean(value, avimux->enable_large_avi);
1034 g_value_set_double(value, avimux->framerate);
1037 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
1043 gst_avimux_set_property (GObject *object,
1045 const GValue *value,
1050 /* it's not null if we got it, but it might not be ours */
1051 g_return_if_fail(GST_IS_AVIMUX(object));
1052 avimux = GST_AVIMUX(object);
1057 avimux->enable_large_avi = g_value_get_boolean(value);
1060 avimux->framerate = g_value_get_double(value);
1063 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
1068 static GstElementStateReturn
1069 gst_avimux_change_state (GstElement *element)
1072 gint transition = GST_STATE_TRANSITION (element);
1074 /* TODO: timer (for fps calculations) */
1076 g_return_val_if_fail(GST_IS_AVIMUX(element), GST_STATE_FAILURE);
1078 avimux = GST_AVIMUX(element);
1080 switch (transition) {
1081 case GST_STATE_READY_TO_PAUSED:
1082 /*gst_avimux_start_file(avimux);*/
1084 case GST_STATE_PAUSED_TO_PLAYING:
1086 case GST_STATE_PLAYING_TO_PAUSED:
1087 gst_avimux_stop_file(avimux);
1089 case GST_STATE_PAUSED_TO_READY:
1090 /*gst_avimux_stop_file(avimux);*/
1094 if (GST_ELEMENT_CLASS (parent_class)->change_state)
1095 return GST_ELEMENT_CLASS (parent_class)->change_state (element);
1097 return GST_STATE_SUCCESS;
1101 plugin_init (GModule *module, GstPlugin *plugin)
1103 GstElementFactory *factory;
1105 /* this filter needs the riff parser */
1107 if (!gst_library_load ("gstriff")) {
1108 gst_info ("avimux: could not load support library: 'gstriff'\n");
1113 /* create an elementfactory for the avimux element */
1114 factory = gst_elementfactory_new ("avimux", GST_TYPE_AVIMUX,
1115 &gst_avimux_details);
1116 g_return_val_if_fail (factory != NULL, FALSE);
1118 gst_elementfactory_add_padtemplate (factory, GST_PADTEMPLATE_GET (src_factory));
1119 gst_elementfactory_add_padtemplate (factory, GST_PADTEMPLATE_GET (audio_sink_factory));
1120 gst_elementfactory_add_padtemplate (factory, GST_PADTEMPLATE_GET (video_sink_factory));
1122 gst_plugin_add_feature (plugin, GST_PLUGIN_FEATURE (factory));
1127 GstPluginDesc plugin_desc = {