rendered paste body#include <unistd.h>#include <stdlib.h>#include <stdio.h>#include <string.h>/************************************************************************/#include <gst/gst.h>static GstStaticPadTemplate srctemplate =GST_STATIC_PAD_TEMPLATE ( "src", GST_PAD_SRC, GST_PAD_ALWAYS, GST_STATIC_CAPS( "audio/x-raw-int, " "width = (int) 16, " "depth = (int) 16, " "endianness = (int) BYTE_ORDER, " "channels = (int) 1, " "rate = (int) 8000, " "signed = (boolean) true"));typedef struct _AstAudioSrc AstAudioSrc;typedef struct _AstAudioSrcClass AstAudioSrcClass;/** * AstAudioSrc: * * Opaque #AstAudioSrc data structure */struct _AstAudioSrc { GstElement element; GstPad *srcpad; gboolean push; gboolean playing;};struct _AstAudioSrcClass { GstElementClass parent_class;};/* Standard macros for defining types for this element. */#define GST_TYPE_AST_AUDIO_SRC \ (ast_audio_src_get_type())#define AST_AUDIO_SRC(obj) \ (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_AST_AUDIO_SRC,AstAudioSrc))#define AST_AUDIO_SRC_CLASS(klass) \ (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_AST_AUDIO_SRC,AstAudioSrcClass))#define GST_IS_AST_AUDIO_SRC(obj) \ (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_AST_AUDIO_SRC))#define GST_IS_AST_AUDIO_SRC_CLASS(obj) \ (G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_AST_AUDIO_SRC))/* Standard function returning type information. */GType ast_audio_src_get_type(void);GST_BOILERPLATE(AstAudioSrc, ast_audio_src, GstElement, GST_TYPE_ELEMENT);static GstElementDetails ast_audio_src_details = GST_ELEMENT_DETAILS("Asterisk Channel Audio", "Blah", "Blah Blah", "Jeffrey C. Ollie <jeff@ocjtech.us>");static void ast_audio_src_base_init (gpointer g_class){ GstElementClass *gstelement_class = GST_ELEMENT_CLASS (g_class); gst_element_class_add_pad_template(gstelement_class, gst_static_pad_template_get(&srctemplate)); gst_element_class_set_details(gstelement_class, &ast_audio_src_details);}static GstStateChangeReturn ast_audio_src_change_state (GstElement *element, GstStateChange transition){ GstStateChangeReturn ret = GST_STATE_CHANGE_SUCCESS; AstAudioSrc *aasrc = AST_AUDIO_SRC(element); switch (transition) { case GST_STATE_CHANGE_NULL_TO_READY: fprintf(stderr, "AstAudioSrc transitioning to READY...\n"); break; case GST_STATE_CHANGE_READY_TO_PAUSED: fprintf(stderr, "AstAudioSrc transitioning to PAUSED...\n"); fprintf(stderr, "Sending new segment event...\n"); if (!gst_pad_push_event(aasrc->srcpad, gst_event_new_new_segment(FALSE, 1.0, GST_FORMAT_TIME, 0, -1, 0))) { fprintf(stderr, "Unable to send new segment event...\n"); } break; case GST_STATE_CHANGE_PAUSED_TO_PLAYING: fprintf(stderr, "AstAudioSrc transitioning to PLAYING...\n"); aasrc->playing = TRUE; break; default: break; } ret = GST_ELEMENT_CLASS (parent_class)->change_state (element, transition); switch (transition) { case GST_STATE_CHANGE_PLAYING_TO_PAUSED: fprintf(stderr, "AstAudioSrc transitioning to PAUSED...\n"); aasrc->playing = FALSE; break; case GST_STATE_CHANGE_PAUSED_TO_READY: fprintf(stderr, "AstAudioSrc transitioning to PAUSED...\n"); break; case GST_STATE_CHANGE_READY_TO_NULL: fprintf(stderr, "AstAudioSrc transitioning to NULL...\n"); break; default: break; } if (ret == GST_STATE_CHANGE_SUCCESS && GST_STATE_CHANGE_READY_TO_PAUSED) { ret = GST_STATE_CHANGE_NO_PREROLL; } return ret;}static void ast_audio_src_class_init(AstAudioSrcClass *klass){ GObjectClass *gobject_class; GstElementClass *gstelement_class; gobject_class = G_OBJECT_CLASS (klass); gstelement_class = GST_ELEMENT_CLASS (klass); gstelement_class->change_state = ast_audio_src_change_state;}static gboolean ast_audio_src_activatepush(GstPad *pad, gboolean active){ GstElement *e; AstAudioSrc *a; if (active) fprintf(stderr, "Activating push on pad...\n"); else fprintf(stderr, "Deactivating push on pad...\n"); e = gst_pad_get_parent_element(pad); a = AST_AUDIO_SRC(e); a->push = active; return TRUE;}static void ast_audio_src_init (AstAudioSrc *aasrc, AstAudioSrcClass *klass){ aasrc->srcpad = gst_pad_new_from_template(gst_element_class_get_pad_template(GST_ELEMENT_CLASS(klass), "src"), "src"); aasrc->push = FALSE; aasrc->playing = FALSE; gst_pad_set_activatepush_function(aasrc->srcpad, ast_audio_src_activatepush); gst_element_add_pad(GST_ELEMENT(aasrc), aasrc->srcpad);}static gboolean register_elements (GstPlugin *plugin){ return gst_element_register(plugin, "ast_audio_src", GST_RANK_NONE, GST_TYPE_AST_AUDIO_SRC);}static GstPluginDesc plugin_desc = { GST_VERSION_MAJOR, GST_VERSION_MINOR, "format_gstreamer_plugins", "Private elements of format_gstreamer", register_elements, "0.0.1", "GPL", "format_gstreamer", "format_gstreamer", "http://www.asterisk.org/", GST_PADDING_INIT};/************************************************************************/struct filestream { FILE *f; GstElement *pipeline; GstElement *audio; guint64 offset; GstClockTime timestamp;};static void *write_runner(void *data) { struct filestream *fs; GstBus *bus; GstMessage *message; fprintf(stderr, "Write runner started...\n"); fs = (struct filestream *) data; bus = gst_pipeline_get_bus(GST_PIPELINE(fs->pipeline)); while(1) { message = gst_bus_poll(bus, GST_MESSAGE_EOS, -1); switch(GST_MESSAGE_TYPE(message)) { case GST_MESSAGE_EOS: { fprintf(stderr, "EOS message received, shutting down...\n"); /* shut down pipeline here */ gst_element_set_state(fs->pipeline, GST_STATE_NULL); fprintf(stderr, "Pipeline state set to NULL.\n"); fprintf(stderr, "Unreferencing pipeline...\n"); gst_object_unref(GST_OBJECT(fs->pipeline)); fprintf(stderr, "Unreferencing pipeline... finished\n"); fprintf(stderr, "Closing file...\n"); fclose(fs->f); fprintf(stderr, "Freeing filestream...\n"); free(fs); fprintf(stderr, "Freeing filestream... finished.\n"); fs = NULL; return NULL; break; } default: { break; } } } fprintf(stderr, "Write runner finished...\n"); return NULL;}static struct filestream *gstreamer_rewrite(FILE *f){ struct filestream *tmp; static pthread_t runner; GstElement *fdsink; GstElement *subpipeline; GError *error; GstElement *audio_input; GstElement *video_input; GstElement *output; fprintf(stderr, "Opening new stream...\n"); if ((tmp = malloc(sizeof(struct filestream)))) { memset(tmp, 0, sizeof(struct filestream)); tmp->f = f; fprintf(stderr, "Creating pipeline...\n"); tmp->pipeline = gst_pipeline_new("format_gstreamer"); if (!tmp->pipeline) { fprintf(stderr, "Unable to create pipeline...\n"); free(tmp); return NULL; } fprintf(stderr, "Creating ast_audio_src...\n"); tmp->audio = gst_element_factory_make("ast_audio_src", "ast_audio_src"); if (!tmp->audio) { fprintf(stderr, "Could not make ast_audio_src element!\n"); gst_object_unref(tmp->pipeline); free(tmp); return NULL; } gst_bin_add(GST_BIN(tmp->pipeline), tmp->audio); fprintf(stderr, "Creating fdsink fd=%i...\n", fileno(tmp->f)); fdsink = gst_element_factory_make("fdsink", "fdsink"); if (!fdsink) { fprintf(stderr, "Unable to link queue and audioconvert!\n"); gst_object_unref(tmp->pipeline); free(tmp); return NULL; } g_object_set(G_OBJECT(fdsink), "fd", fileno(tmp->f), NULL); gst_bin_add(GST_BIN(tmp->pipeline), fdsink); fprintf(stderr, "Creating sub-pipeline...\n"); error = NULL; subpipeline = gst_parse_launch("queue name=audio_input ! audioconvert ! vorbisenc ! oggmux name=output", &error); if (error) { fprintf(stderr, "There was an error creating the sub pipeline: %s\n", error->message); if (subpipeline) gst_object_unref(subpipeline); gst_object_unref(tmp->pipeline); free(tmp); return NULL; } gst_bin_add(GST_BIN(tmp->pipeline), subpipeline); audio_input = gst_bin_get_by_name(GST_BIN(subpipeline), "audio_input"); if (!audio_input) { fprintf(stderr, "Unable to find audio input element in pipeline!\n"); gst_object_unref(tmp->pipeline); free(tmp); return NULL; } if (!gst_element_link(tmp->audio, audio_input)) { fprintf(stderr, "Unable to link audio input...\n"); gst_object_unref(tmp->pipeline); free(tmp); return NULL; } output = gst_bin_get_by_name(GST_BIN(subpipeline), "output"); if (!output) { fprintf(stderr, "Unable to find output element in pipeline!\n"); gst_object_unref(tmp->pipeline); free(tmp); return NULL; } if (!gst_element_link(output, fdsink)) { fprintf(stderr, "Unable to link output...\n"); gst_object_unref(tmp->pipeline); free(tmp); return NULL; } fprintf(stderr, "Setting pipeline to playing state...\n"); gst_element_set_state(tmp->pipeline, GST_STATE_PLAYING); fprintf(stderr, "Starting thread...\n"); pthread_create(&runner, NULL, write_runner, tmp); } else { fprintf(stderr, "Out of memory...\n"); } return tmp;}static void gstreamer_close(struct filestream *fs){ AstAudioSrc *a; a = AST_AUDIO_SRC(fs->audio); fprintf(stderr, "Close received, sending EOS.\n"); gst_pad_push_event(a->srcpad, gst_event_new_eos());}static int gstreamer_write(struct filestream *fs){ GstBuffer *buffer; GstClockTime duration; AstAudioSrc *a; a = AST_AUDIO_SRC(fs->audio); if (!(a->push)) { fprintf(stderr, "Dropping frame because pad is not ready to push.\n"); return 0; } if (!(a->playing)) { fprintf(stderr, "Dropping frame beause not playing yet...\n"); return 0; } duration = 160 * (1000000000 / 8000); /*fprintf(stderr, "Creating buffer for frame (%i samples, duration %ld) ...\n", f->samples, (long int) duration);*/ /* create buffer and send it */ buffer = gst_buffer_new_and_alloc(160 *2); gst_buffer_set_caps(buffer, gst_pad_get_caps(a->srcpad)); memset(GST_BUFFER_DATA(buffer), 0, 160 * 2); GST_BUFFER_OFFSET(buffer) = fs->offset; GST_BUFFER_SIZE(buffer) = 160 * 2; GST_BUFFER_TIMESTAMP(buffer) = fs->timestamp; GST_BUFFER_DURATION(buffer) = duration; fs->offset += 160 * 2; fs->timestamp += duration; /*fprintf(stderr, "Pushing frame...\n");*/ gst_pad_push(a->srcpad, buffer); return 0;}int main(int argc, char *argv[]){ struct filestream *fs; FILE *f; int i; fprintf(stderr, "Gstreamer initialization starting...\n"); gst_init(NULL, NULL); fprintf(stderr, "Gstreamer initialization finished...\n"); fprintf(stderr, "Enabling gstreamer debugging...\n"); gst_debug_set_colored(FALSE); gst_debug_set_active(TRUE); gst_debug_set_default_threshold(GST_LEVEL_WARNING); fprintf(stderr, "Registering static plugins...\n"); _gst_plugin_register_static(&plugin_desc); fprintf(stderr, "Registering static plugins... finished\n"); f = fopen("/tmp/t.ogg", "w"); fs = gstreamer_rewrite(f); for (i = 0; i < 100; i++) { usleep(20000); /* 20 ms */ gstreamer_write(fs); } gstreamer_close(fs); usleep(10000000); /* 10 s */}