From da47131cd629b899d617243f01cb23fa815597f1 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Sebastian=20Dr=C3=B6ge?= Date: Sun, 23 Jun 2013 10:04:29 +0200 Subject: [PATCH] daalaenc: Add encoder element --- configure.ac | 2 +- ext/daala/gstdaala.c | 5 + ext/daala/gstdaalaenc.c | 729 ++++++++++++++++++++++++++++++++++++++++ ext/daala/gstdaalaenc.h | 88 +++++ 4 files changed, 823 insertions(+), 1 deletion(-) diff --git a/configure.ac b/configure.ac index d0113f5cd8..a179364e92 100644 --- a/configure.ac +++ b/configure.ac @@ -1254,7 +1254,7 @@ dnl *** Daala *** translit(dnm, m, l) AM_CONDITIONAL(USE_DAALA, true) AG_GST_CHECK_FEATURE(DAALA, [daala], daala, [ if test "x$BUILD_EXPERIMENTAL" = "xyes"; then - PKG_CHECK_MODULES(DAALA, daala, [ + PKG_CHECK_MODULES(DAALA, daalaenc daaladec, [ HAVE_DAALA="yes" ], [ HAVE_DAALA="no" diff --git a/ext/daala/gstdaala.c b/ext/daala/gstdaala.c index b21f38939a..eb8fd850c5 100644 --- a/ext/daala/gstdaala.c +++ b/ext/daala/gstdaala.c @@ -23,9 +23,14 @@ #include +#include "gstdaalaenc.h" +#include "gstdaaladec.h" + static gboolean plugin_init (GstPlugin * plugin) { + gst_daala_enc_register (plugin); + return TRUE; } diff --git a/ext/daala/gstdaalaenc.c b/ext/daala/gstdaalaenc.c index e69de29bb2..810632ec52 100644 --- a/ext/daala/gstdaalaenc.c +++ b/ext/daala/gstdaalaenc.c @@ -0,0 +1,729 @@ +/* GStreamer + * Copyright (C) 2004 Wim Taymans + * Copyright (c) 2012 Collabora Ltd. + * Author : Edward Hervey + * Author : Mark Nauwelaerts + * Copyright (c) 2013 Sebastian Dröge + * + * 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., 51 Franklin St, Fifth Floor, + * Boston, MA 02110-1301, USA. + */ + +/** + * SECTION:element-daalaenc + * @see_also: daaladec, oggmux + * + * This element encodes raw video into a Daala stream. + * Daala is a royalty-free + * video codec maintained by the Xiph.org + * Foundation. + * + * + * Example pipeline + * |[ + * gst-launch -v videotestsrc num-buffers=1000 ! daalaenc ! oggmux ! filesink location=videotestsrc.ogg + * ]| This example pipeline will encode a test video source to daala muxed in an + * ogg container. Refer to the daaladec documentation to decode the create + * stream. + * + */ + +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif + +#include +#include /* free */ + +#include +#include +#include + +#include "gstdaalaenc.h" + +#define GST_CAT_DEFAULT daalaenc_debug +GST_DEBUG_CATEGORY_STATIC (GST_CAT_DEFAULT); + +enum +{ + PROP_0, + PROP_QUANT, + PROP_KEYFRAME_RATE +}; + +#define DEFAULT_QUANT 10 +#define DEFAULT_KEYFRAME_RATE 1 + +static GstStaticPadTemplate daala_enc_sink_factory = +GST_STATIC_PAD_TEMPLATE ("sink", + GST_PAD_SINK, + GST_PAD_ALWAYS, + GST_STATIC_CAPS (GST_VIDEO_CAPS_MAKE ("{ I420, Y444 }")) + ); + +static GstStaticPadTemplate daala_enc_src_factory = +GST_STATIC_PAD_TEMPLATE ("src", + GST_PAD_SRC, + GST_PAD_ALWAYS, + GST_STATIC_CAPS ("video/x-daala, " + "framerate = (fraction) [1/MAX, MAX], " + "width = (int) [ 1, MAX ], " "height = (int) [ 1, MAX ]") + ); + +#define gst_daala_enc_parent_class parent_class +G_DEFINE_TYPE (GstDaalaEnc, gst_daala_enc, GST_TYPE_VIDEO_ENCODER); + +static gboolean daala_enc_start (GstVideoEncoder * enc); +static gboolean daala_enc_stop (GstVideoEncoder * enc); +static gboolean daala_enc_set_format (GstVideoEncoder * enc, + GstVideoCodecState * state); +static GstFlowReturn daala_enc_handle_frame (GstVideoEncoder * enc, + GstVideoCodecFrame * frame); +static GstFlowReturn daala_enc_pre_push (GstVideoEncoder * benc, + GstVideoCodecFrame * frame); +static GstFlowReturn daala_enc_finish (GstVideoEncoder * enc); +static gboolean daala_enc_propose_allocation (GstVideoEncoder * encoder, + GstQuery * query); + +static GstCaps *daala_enc_getcaps (GstVideoEncoder * encoder, GstCaps * filter); +static void daala_enc_get_property (GObject * object, guint prop_id, + GValue * value, GParamSpec * pspec); +static void daala_enc_set_property (GObject * object, guint prop_id, + const GValue * value, GParamSpec * pspec); +static void daala_enc_finalize (GObject * object); + +static void +gst_daala_enc_class_init (GstDaalaEncClass * klass) +{ + GObjectClass *gobject_class = (GObjectClass *) klass; + GstElementClass *element_class = (GstElementClass *) klass; + GstVideoEncoderClass *gstvideo_encoder_class = + GST_VIDEO_ENCODER_CLASS (klass); + + gobject_class->set_property = daala_enc_set_property; + gobject_class->get_property = daala_enc_get_property; + gobject_class->finalize = daala_enc_finalize; + + g_object_class_install_property (gobject_class, PROP_QUANT, + g_param_spec_int ("quant", "Quant", "Quant", + 0, 511, DEFAULT_QUANT, + (GParamFlags) G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)); + + g_object_class_install_property (gobject_class, PROP_KEYFRAME_RATE, + g_param_spec_int ("keyframe-rate", "Keyframe Rate", "Keyframe Rate", + 1, G_MAXINT, DEFAULT_KEYFRAME_RATE, + (GParamFlags) G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)); + + gst_element_class_add_pad_template (element_class, + gst_static_pad_template_get (&daala_enc_src_factory)); + gst_element_class_add_pad_template (element_class, + gst_static_pad_template_get (&daala_enc_sink_factory)); + gst_element_class_set_static_metadata (element_class, + "Daala video encoder", "Codec/Encoder/Video", + "Encode raw YUV video to a Daala stream", + "Sebastian Dröge "); + + gstvideo_encoder_class->start = GST_DEBUG_FUNCPTR (daala_enc_start); + gstvideo_encoder_class->stop = GST_DEBUG_FUNCPTR (daala_enc_stop); + gstvideo_encoder_class->set_format = GST_DEBUG_FUNCPTR (daala_enc_set_format); + gstvideo_encoder_class->handle_frame = + GST_DEBUG_FUNCPTR (daala_enc_handle_frame); + gstvideo_encoder_class->pre_push = GST_DEBUG_FUNCPTR (daala_enc_pre_push); + gstvideo_encoder_class->finish = GST_DEBUG_FUNCPTR (daala_enc_finish); + gstvideo_encoder_class->getcaps = GST_DEBUG_FUNCPTR (daala_enc_getcaps); + gstvideo_encoder_class->propose_allocation = + GST_DEBUG_FUNCPTR (daala_enc_propose_allocation); + + GST_DEBUG_CATEGORY_INIT (daalaenc_debug, "daalaenc", 0, "Daala encoder"); +} + +static void +gst_daala_enc_init (GstDaalaEnc * enc) +{ + enc->quant = DEFAULT_QUANT; + enc->keyframe_rate = DEFAULT_KEYFRAME_RATE; +} + +static void +daala_enc_finalize (GObject * object) +{ + GstDaalaEnc *enc = GST_DAALA_ENC (object); + + GST_DEBUG_OBJECT (enc, "Finalizing"); + if (enc->encoder) + daala_encode_free (enc->encoder); + daala_comment_clear (&enc->comment); + daala_info_clear (&enc->info); + + if (enc->input_state) + gst_video_codec_state_unref (enc->input_state); + + G_OBJECT_CLASS (parent_class)->finalize (object); +} + +static void +daala_enc_reset (GstDaalaEnc * enc) +{ + int quant; + + GST_OBJECT_LOCK (enc); + quant = enc->quant; + enc->quant_changed = FALSE; + enc->info.keyframe_rate = enc->keyframe_rate; + enc->keyframe_rate_changed = FALSE; + GST_OBJECT_UNLOCK (enc); + + if (enc->encoder) + daala_encode_free (enc->encoder); + enc->encoder = daala_encode_create (&enc->info); + + daala_encode_ctl (enc->encoder, OD_SET_QUANT, &quant, sizeof (int)); +} + +static gboolean +daala_enc_start (GstVideoEncoder * benc) +{ + GstDaalaEnc *enc; + + GST_DEBUG_OBJECT (benc, "start: init daala"); + enc = GST_DAALA_ENC (benc); + + daala_info_init (&enc->info); + daala_comment_init (&enc->comment); + enc->packetno = 0; + + return TRUE; +} + +static gboolean +daala_enc_stop (GstVideoEncoder * benc) +{ + GstDaalaEnc *enc; + + GST_DEBUG_OBJECT (benc, "stop: clearing daala state"); + enc = GST_DAALA_ENC (benc); + + if (enc->encoder) { + daala_encode_free (enc->encoder); + enc->encoder = NULL; + } + daala_comment_clear (&enc->comment); + daala_info_clear (&enc->info); + + enc->initialised = FALSE; + + return TRUE; +} + +static char * +daala_enc_get_supported_formats (void) +{ + daala_enc_ctx *encoder; + daala_info info; + struct + { + GstVideoFormat fmt; + gint planes; + gint xdec[3], ydec[3]; + } formats[] = { + { + GST_VIDEO_FORMAT_Y444, 3, { + 0, 0, 0}, { + 0, 0, 0}}, { + GST_VIDEO_FORMAT_I420, 3, { + 0, 1, 1}, { + 0, 1, 1}} + }; + GString *string = NULL; + guint i; + + daala_info_init (&info); + info.pic_width = 16; + info.pic_height = 16; + info.timebase_numerator = 25; + info.timebase_denominator = 1; + info.frame_duration = 1; + for (i = 0; i < G_N_ELEMENTS (formats); i++) { + gint j; + + info.nplanes = formats[i].planes; + for (j = 0; j < formats[i].planes; j++) { + info.plane_info[j].xdec = formats[i].xdec[j]; + info.plane_info[j].ydec = formats[i].ydec[j]; + } + + encoder = daala_encode_create (&info); + if (encoder == NULL) + continue; + + GST_LOG ("format %s is supported", + gst_video_format_to_string (formats[i].fmt)); + daala_encode_free (encoder); + + if (string == NULL) { + string = g_string_new (gst_video_format_to_string (formats[i].fmt)); + } else { + g_string_append (string, ", "); + g_string_append (string, gst_video_format_to_string (formats[i].fmt)); + } + } + daala_info_clear (&info); + + return string == NULL ? NULL : g_string_free (string, FALSE); +} + +static GstCaps * +daala_enc_getcaps (GstVideoEncoder * encoder, GstCaps * filter) +{ + GstCaps *caps, *ret; + char *supported_formats, *caps_string; + + supported_formats = daala_enc_get_supported_formats (); + if (!supported_formats) { + GST_WARNING ("no supported formats found. Encoder disabled?"); + return gst_caps_new_empty (); + } + + caps_string = g_strdup_printf ("video/x-raw, " + "format = (string) { %s }, " + "framerate = (fraction) [1/MAX, MAX], " + "width = (int) [ 1, MAX ], " "height = (int) [ 1, MAX ]", + supported_formats); + caps = gst_caps_from_string (caps_string); + g_free (caps_string); + g_free (supported_formats); + GST_DEBUG ("Supported caps: %" GST_PTR_FORMAT, caps); + + ret = gst_video_encoder_proxy_getcaps (encoder, caps, filter); + gst_caps_unref (caps); + + return ret; +} + +static gboolean +daala_enc_set_format (GstVideoEncoder * benc, GstVideoCodecState * state) +{ + GstDaalaEnc *enc = GST_DAALA_ENC (benc); + GstVideoInfo *info = &state->info; + + daala_info_clear (&enc->info); + daala_info_init (&enc->info); + enc->info.pic_width = GST_VIDEO_INFO_WIDTH (info); + enc->info.pic_height = GST_VIDEO_INFO_HEIGHT (info); + switch (GST_VIDEO_INFO_FORMAT (info)) { + case GST_VIDEO_FORMAT_I420: + enc->info.nplanes = 3; + enc->info.plane_info[0].xdec = 0; + enc->info.plane_info[0].ydec = 0; + enc->info.plane_info[1].xdec = 1; + enc->info.plane_info[1].ydec = 1; + enc->info.plane_info[2].xdec = 1; + enc->info.plane_info[2].ydec = 1; + break; + case GST_VIDEO_FORMAT_Y444: + enc->info.nplanes = 3; + enc->info.plane_info[0].xdec = 0; + enc->info.plane_info[0].ydec = 0; + enc->info.plane_info[1].xdec = 0; + enc->info.plane_info[1].ydec = 0; + enc->info.plane_info[2].xdec = 0; + enc->info.plane_info[2].ydec = 0; + break; + default: + g_assert_not_reached (); + } + + enc->info.timebase_numerator = GST_VIDEO_INFO_FPS_N (info); + enc->info.timebase_denominator = GST_VIDEO_INFO_FPS_D (info); + enc->info.frame_duration = 1; + enc->info.pixel_aspect_numerator = GST_VIDEO_INFO_PAR_N (info); + enc->info.pixel_aspect_denominator = GST_VIDEO_INFO_PAR_D (info); + + /* Save input state */ + if (enc->input_state) + gst_video_codec_state_unref (enc->input_state); + enc->input_state = gst_video_codec_state_ref (state); + + daala_enc_reset (enc); + enc->initialised = TRUE; + + return TRUE; +} + +/* this function does a straight granulepos -> timestamp conversion */ +static GstClockTime +granulepos_to_timestamp (GstDaalaEnc * enc, ogg_int64_t granulepos) +{ + guint64 iframe, pframe; + int shift = enc->info.keyframe_granule_shift; + + if (granulepos < 0) + return GST_CLOCK_TIME_NONE; + + iframe = granulepos >> shift; + pframe = granulepos - (iframe << shift); + + /* num and den are 32 bit, so we can safely multiply with GST_SECOND */ + return gst_util_uint64_scale ((guint64) (iframe + pframe), + GST_SECOND * enc->info.timebase_denominator, + enc->info.timebase_numerator); +} + +static GstFlowReturn +daala_enc_pre_push (GstVideoEncoder * benc, GstVideoCodecFrame * frame) +{ + GstDaalaEnc *enc = GST_DAALA_ENC (benc); + guint64 pfn; + + /* see ext/ogg/README; OFFSET_END takes "our" granulepos, OFFSET its + * time representation */ + /* granulepos from sync frame */ + pfn = frame->presentation_frame_number - frame->distance_from_sync; + /* correct to correspond to linear running time */ + pfn -= enc->pfn_offset; + pfn += enc->granulepos_offset + 1; + /* granulepos */ + GST_BUFFER_OFFSET_END (frame->output_buffer) = + (pfn << enc->info.keyframe_granule_shift) + frame->distance_from_sync; + GST_BUFFER_OFFSET (frame->output_buffer) = granulepos_to_timestamp (enc, + GST_BUFFER_OFFSET_END (frame->output_buffer)); + + return GST_FLOW_OK; +} + +static GstFlowReturn +daala_push_packet (GstDaalaEnc * enc, ogg_packet * packet) +{ + GstVideoEncoder *benc; + GstFlowReturn ret; + GstVideoCodecFrame *frame; + + benc = GST_VIDEO_ENCODER (enc); + + frame = gst_video_encoder_get_oldest_frame (benc); + if (gst_video_encoder_allocate_output_frame (benc, frame, + packet->bytes) != GST_FLOW_OK) { + GST_WARNING_OBJECT (enc, "Could not allocate buffer"); + gst_video_codec_frame_unref (frame); + ret = GST_FLOW_ERROR; + goto done; + } + + if (packet->bytes > 0) + gst_buffer_fill (frame->output_buffer, 0, packet->packet, packet->bytes); + + /* the second most significant bit of the first data byte is cleared + * for keyframes */ + if (packet->bytes > 0 && (packet->packet[0] & 0x40) == 0) { + GST_VIDEO_CODEC_FRAME_SET_SYNC_POINT (frame); + } else { + GST_VIDEO_CODEC_FRAME_UNSET_SYNC_POINT (frame); + } + enc->packetno++; + + ret = gst_video_encoder_finish_frame (benc, frame); + +done: + return ret; +} + +static GstCaps * +daala_set_header_on_caps (GstCaps * caps, GList * buffers) +{ + GstStructure *structure; + GValue array = { 0 }; + GValue value = { 0 }; + GstBuffer *buffer; + GList *walk; + + caps = gst_caps_make_writable (caps); + structure = gst_caps_get_structure (caps, 0); + + /* put copies of the buffers in a fixed list */ + g_value_init (&array, GST_TYPE_ARRAY); + + for (walk = buffers; walk; walk = walk->next) { + buffer = walk->data; + g_value_init (&value, GST_TYPE_BUFFER); + gst_value_set_buffer (&value, buffer); + gst_value_array_append_value (&array, &value); + g_value_unset (&value); + } + + gst_structure_take_value (structure, "streamheader", &array); + + return caps; +} + +static void +daala_enc_init_buffer (GstDaalaEnc * enc, od_img * buf, GstVideoFrame * frame) +{ + guint i; + + buf->nplanes = 3; + buf->width = GST_VIDEO_FRAME_WIDTH (frame); + buf->height = GST_VIDEO_FRAME_HEIGHT (frame); + + for (i = 0; i < 3; i++) { + buf->planes[i].data = GST_VIDEO_FRAME_COMP_DATA (frame, i); + buf->planes[i].xdec = enc->info.plane_info[i].xdec; + buf->planes[i].ydec = enc->info.plane_info[i].ydec; + buf->planes[i].xstride = 1; + buf->planes[i].ystride = GST_VIDEO_FRAME_COMP_STRIDE (frame, i); + } +} + +static void +daala_enc_reset_ts (GstDaalaEnc * enc, GstClockTime running_time, gint pfn) +{ + enc->granulepos_offset = + gst_util_uint64_scale (running_time, enc->input_state->info.fps_n, + GST_SECOND * enc->input_state->info.fps_d); + enc->timestamp_offset = running_time; + enc->pfn_offset = pfn; +} + +static GstBuffer * +daala_enc_buffer_from_header_packet (GstDaalaEnc * enc, ogg_packet * packet) +{ + GstBuffer *outbuf; + + outbuf = + gst_video_encoder_allocate_output_buffer (GST_VIDEO_ENCODER (enc), + packet->bytes); + gst_buffer_fill (outbuf, 0, packet->packet, packet->bytes); + GST_BUFFER_OFFSET (outbuf) = 0; + GST_BUFFER_OFFSET_END (outbuf) = 0; + GST_BUFFER_TIMESTAMP (outbuf) = GST_CLOCK_TIME_NONE; + GST_BUFFER_DURATION (outbuf) = GST_CLOCK_TIME_NONE; + GST_BUFFER_FLAG_SET (outbuf, GST_BUFFER_FLAG_HEADER); + + GST_DEBUG ("created header packet buffer, %u bytes", + (guint) gst_buffer_get_size (outbuf)); + return outbuf; +} + +static GstFlowReturn +daala_enc_handle_frame (GstVideoEncoder * benc, GstVideoCodecFrame * frame) +{ + GstDaalaEnc *enc; + ogg_packet op; + GstClockTime timestamp, running_time; + GstFlowReturn ret; + gboolean force_keyframe; + + enc = GST_DAALA_ENC (benc); + + /* we keep track of two timelines. + * - The timestamps from the incoming buffers, which we copy to the outgoing + * encoded buffers as-is. We need to do this as we simply forward the + * newsegment events. + * - The running_time of the buffers, which we use to construct the granulepos + * in the packets. + */ + timestamp = frame->pts; + + /* incoming buffers are clipped, so this should be positive */ + running_time = + gst_segment_to_running_time (&GST_VIDEO_ENCODER_INPUT_SEGMENT (enc), + GST_FORMAT_TIME, timestamp); + g_return_val_if_fail (running_time >= 0 || timestamp < 0, GST_FLOW_ERROR); + + GST_OBJECT_LOCK (enc); + if (enc->quant_changed) { + int quant = enc->quant; + + daala_encode_ctl (enc->encoder, OD_SET_QUANT, &quant, sizeof (int)); + enc->quant_changed = FALSE; + } + + /* see if we need to schedule a keyframe */ + force_keyframe = GST_VIDEO_CODEC_FRAME_IS_FORCE_KEYFRAME (frame); + GST_OBJECT_UNLOCK (enc); + + if (enc->packetno == 0) { + /* no packets written yet, setup headers */ + GstCaps *caps; + GstBuffer *buf; + GList *buffers = NULL; + int result; + GstVideoCodecState *state; + + enc->granulepos_offset = 0; + enc->timestamp_offset = 0; + + GST_DEBUG_OBJECT (enc, "output headers"); + /* Daala streams begin with three headers; the initial header (with + most of the codec setup parameters) which is mandated by the Ogg + bitstream spec. The second header holds any comment fields. The + third header holds the bitstream codebook. We merely need to + make the headers, then pass them to libdaala one at a time; + libdaala handles the additional Ogg bitstream constraints */ + + /* create the remaining daala headers */ + daala_comment_clear (&enc->comment); + daala_comment_init (&enc->comment); + + while ((result = + daala_encode_flush_header (enc->encoder, &enc->comment, &op)) > 0) { + buf = daala_enc_buffer_from_header_packet (enc, &op); + buffers = g_list_prepend (buffers, buf); + } + if (result < 0) { + g_list_foreach (buffers, (GFunc) gst_buffer_unref, NULL); + g_list_free (buffers); + goto encoder_disabled; + } + + buffers = g_list_reverse (buffers); + + /* mark buffers and put on caps */ + caps = gst_caps_new_empty_simple ("video/x-daala"); + caps = daala_set_header_on_caps (caps, buffers); + state = gst_video_encoder_set_output_state (benc, caps, enc->input_state); + + GST_DEBUG ("here are the caps: %" GST_PTR_FORMAT, state->caps); + + gst_video_codec_state_unref (state); + + gst_video_encoder_negotiate (GST_VIDEO_ENCODER (enc)); + + gst_video_encoder_set_headers (benc, buffers); + + daala_enc_reset_ts (enc, running_time, frame->presentation_frame_number); + } + + { + od_img img; + gint res; + GstVideoFrame vframe; + + if (force_keyframe) { + /* TODO */ + } + + gst_video_frame_map (&vframe, &enc->input_state->info, frame->input_buffer, + GST_MAP_READ); + daala_enc_init_buffer (enc, &img, &vframe); + + res = daala_encode_img_in (enc->encoder, &img, 1); + gst_video_frame_unmap (&vframe); + + /* none of the failure cases can happen here */ + g_assert (res == 0); + + ret = GST_FLOW_OK; + while (daala_encode_packet_out (enc->encoder, 0, &op)) { + ret = daala_push_packet (enc, &op); + if (ret != GST_FLOW_OK) + goto beach; + } + } + +beach: + gst_video_codec_frame_unref (frame); + return ret; + + /* ERRORS */ +encoder_disabled: + { + gst_video_codec_frame_unref (frame); + GST_ELEMENT_ERROR (enc, STREAM, ENCODE, (NULL), + ("libdaala has been compiled with the encoder disabled")); + return GST_FLOW_ERROR; + } +} + +static gboolean +daala_enc_finish (GstVideoEncoder * benc) +{ + GstDaalaEnc *enc; + ogg_packet op; + + enc = GST_DAALA_ENC (benc); + + if (enc->initialised) { + /* push last packet with eos flag, should not be called */ + while (daala_encode_packet_out (enc->encoder, 1, &op)) { + daala_push_packet (enc, &op); + } + } + + return TRUE; +} + +static gboolean +daala_enc_propose_allocation (GstVideoEncoder * encoder, GstQuery * query) +{ + gst_query_add_allocation_meta (query, GST_VIDEO_META_API_TYPE, NULL); + + return GST_VIDEO_ENCODER_CLASS (parent_class)->propose_allocation (encoder, + query); +} + +static void +daala_enc_set_property (GObject * object, guint prop_id, + const GValue * value, GParamSpec * pspec) +{ + GstDaalaEnc *enc = GST_DAALA_ENC (object); + + switch (prop_id) { + case PROP_QUANT: + GST_OBJECT_LOCK (enc); + enc->quant = g_value_get_int (value); + enc->quant_changed = TRUE; + GST_OBJECT_UNLOCK (enc); + break; + case PROP_KEYFRAME_RATE: + GST_OBJECT_LOCK (enc); + enc->keyframe_rate = g_value_get_int (value); + enc->keyframe_rate_changed = TRUE; + GST_OBJECT_UNLOCK (enc); + break; + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); + break; + } +} + +static void +daala_enc_get_property (GObject * object, guint prop_id, + GValue * value, GParamSpec * pspec) +{ + GstDaalaEnc *enc = GST_DAALA_ENC (object); + + switch (prop_id) { + case PROP_QUANT: + GST_OBJECT_LOCK (enc); + g_value_set_int (value, enc->quant); + GST_OBJECT_UNLOCK (enc); + break; + case PROP_KEYFRAME_RATE: + GST_OBJECT_LOCK (enc); + g_value_set_int (value, enc->keyframe_rate); + GST_OBJECT_UNLOCK (enc); + break; + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); + break; + } +} + +gboolean +gst_daala_enc_register (GstPlugin * plugin) +{ + return gst_element_register (plugin, "daalaenc", + GST_RANK_PRIMARY, GST_TYPE_DAALA_ENC); +} diff --git a/ext/daala/gstdaalaenc.h b/ext/daala/gstdaalaenc.h index e69de29bb2..53e911422a 100644 --- a/ext/daala/gstdaalaenc.h +++ b/ext/daala/gstdaalaenc.h @@ -0,0 +1,88 @@ +/* GStreamer + * Copyright (C) 2004 Wim Taymans + * Copyright (c) 2012 Collabora Ltd. + * Author : Edward Hervey + * Author : Mark Nauwelaerts + * Copyright (c) 2013 Sebastian Dröge + * + * 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., 51 Franklin St, Fifth Floor, + * Boston, MA 02110-1301, USA. + */ + +#ifndef __GST_DAALAENC_H__ +#define __GST_DAALAENC_H__ + +#include +#include +#include + +G_BEGIN_DECLS + +#define GST_TYPE_DAALA_ENC \ + (gst_daala_enc_get_type()) +#define GST_DAALA_ENC(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_DAALA_ENC,GstDaalaEnc)) +#define GST_DAALA_ENC_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_DAALA_ENC,GstDaalaEncClass)) +#define GST_IS_DAALA_ENC(obj) \ + (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_DAALA_ENC)) +#define GST_IS_DAALA_ENC_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_DAALA_ENC)) + +typedef struct _GstDaalaEnc GstDaalaEnc; +typedef struct _GstDaalaEncClass GstDaalaEncClass; + +/** + * GstDaalaEnc: + * + * Opaque data structure. + */ +struct _GstDaalaEnc +{ + GstVideoEncoder element; + + ogg_stream_state vo; + + daala_enc_ctx *encoder; + daala_info info; + daala_comment comment; + gboolean initialised; + + guint packetno; + guint64 bytes_out; + guint64 granulepos_offset; + guint64 timestamp_offset; + guint64 pfn_offset; + + int quant; + int keyframe_rate; + gboolean quant_changed; + gboolean keyframe_rate_changed; + + GstVideoCodecState *input_state; +}; + +struct _GstDaalaEncClass +{ + GstVideoEncoderClass parent_class; +}; + +GType gst_daala_enc_get_type (void); +gboolean gst_daala_enc_register (GstPlugin * plugin); + +G_END_DECLS + +#endif /* __GST_DAALAENC_H__ */ +