diff options
Diffstat (limited to 'ext')
| -rw-r--r-- | ext/Makefile.am | 8 | ||||
| -rw-r--r-- | ext/x264/Makefile.am | 8 | ||||
| -rw-r--r-- | ext/x264/gstx264enc.c | 1053 | ||||
| -rw-r--r-- | ext/x264/gstx264enc.h | 97 |
4 files changed, 1166 insertions, 0 deletions
diff --git a/ext/Makefile.am b/ext/Makefile.am index d8ddaa47..1f42647e 100644 --- a/ext/Makefile.am +++ b/ext/Makefile.am @@ -244,6 +244,12 @@ endif TARKIN_DIR= # endif +if USE_X264 +X264_DIR=x264 +else +X264_DIR= +endif + # if USE_XINE # XINE_DIR=xine # else @@ -298,6 +304,7 @@ SUBDIRS=\ $(THEORA_DIR) \ $(TIMIDITY_DIR) \ $(WAVPACK_DIR) \ + $(X264_DIR) \ $(XINE_DIR) \ $(XVID_DIR) @@ -330,4 +337,5 @@ DIST_SUBDIRS= \ theora \ timidity \ wavpack \ + x264 \ xvid diff --git a/ext/x264/Makefile.am b/ext/x264/Makefile.am new file mode 100644 index 00000000..35906d93 --- /dev/null +++ b/ext/x264/Makefile.am @@ -0,0 +1,8 @@ +plugin_LTLIBRARIES = libgstx264.la + +libgstx264_la_SOURCES = gstx264enc.c +libgstx264_la_CFLAGS = $(X264_CFLAGS) $(GST_CFLAGS) +libgstx264_la_LIBADD = $(X264_LIBS) $(GST_LIBS) +libgstx264_la_LDFLAGS = $(GST_PLUGIN_LDFLAGS) + +noinst_HEADERS = gstx264enc.h diff --git a/ext/x264/gstx264enc.c b/ext/x264/gstx264enc.c new file mode 100644 index 00000000..5105f98d --- /dev/null +++ b/ext/x264/gstx264enc.c @@ -0,0 +1,1053 @@ +/* GStreamer H264 encoder plugin + * Copyright (C) 2005 Michal Benes <michal.benes@itonis.tv> + * Copyright (C) 2005 Josef Zlomek <josef.zlomek@itonis.tv> + * + * 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. + */ + +#ifdef HAVE_CONFIG_H +# include "config.h" +#endif + +#include "gstx264enc.h" + +#include <string.h> + +enum +{ + ARG_0, + ARG_THREADS, + ARG_PASS, + ARG_STATS_FILE, + ARG_BYTE_STREAM, + ARG_BITRATE, + ARG_VBV_BUF_CAPACITY, + ARG_ME, + ARG_SUBME, + ARG_ANALYSE, + ARG_DCT8x8, + ARG_REF, + ARG_BFRAMES, + ARG_B_PYRAMID, + ARG_WEIGHTB, + ARG_SPS_ID, + ARG_TRELLIS, + ARG_KEYINT_MAX, + ARG_CABAC +}; + +#define ARG_THREADS_DEFAULT 1 +#define ARG_PASS_DEFAULT 0 +#define ARG_STATS_FILE_DEFAULT "x264.log" +#define ARG_BYTE_STREAM_DEFAULT FALSE +#define ARG_BITRATE_DEFAULT (2 * 1024) +#define ARG_VBV_BUF_CAPACITY_DEFAULT 600 +#define ARG_ME_DEFAULT X264_ME_HEX +#define ARG_SUBME_DEFAULT 1 +#define ARG_ANALYSE_DEFAULT 0 +#define ARG_DCT8x8_DEFAULT FALSE +#define ARG_REF_DEFAULT 1 +#define ARG_BFRAMES_DEFAULT 0 +#define ARG_B_PYRAMID_DEFAULT FALSE +#define ARG_WEIGHTB_DEFAULT FALSE +#define ARG_SPS_ID_DEFAULT 0 +#define ARG_TRELLIS_DEFAULT TRUE +#define ARG_KEYINT_MAX_DEFAULT 0 +#define ARG_CABAC_DEFAULT TRUE + +#define GST_X264_ENC_ME_TYPE (gst_x264_enc_me_get_type()) +static GType +gst_x264_enc_me_get_type (void) +{ + static GType me_type = 0; + static const GEnumValue me_types[] = { + {X264_ME_DIA, "diamond search, radius 1 (fast)", "dia"}, + {X264_ME_HEX, "hexagonal search, radius 2", "hex"}, + {X264_ME_UMH, "uneven multi-hexagon search", "umh"}, + {X264_ME_ESA, "exhaustive search (slow)", "esa"}, + {0, NULL, NULL} + }; + + if (!me_type) { + me_type = g_enum_register_static ("GstX264EncMe", me_types); + } + return me_type; +} + +#define GST_X264_ENC_ANALYSE_TYPE (gst_x264_enc_analyse_get_type()) +static GType +gst_x264_enc_analyse_get_type (void) +{ + static GType analyse_type = 0; + static const GFlagsValue analyse_types[] = { + {X264_ANALYSE_I4x4, "i4x4", "i4x4"}, + {X264_ANALYSE_I8x8, "i8x8", "i8x8"}, + {X264_ANALYSE_PSUB16x16, "p8x8", "p8x8"}, + {X264_ANALYSE_PSUB8x8, "p4x4", "p4x4"}, + {X264_ANALYSE_BSUB16x16, "b8x8", "b8x8"}, + {0, NULL, NULL}, + }; + + if (!analyse_type) { + analyse_type = g_flags_register_static ("GstX264EncAnalyse", analyse_types); + } + return analyse_type; +} + +static GstStaticPadTemplate sink_factory = GST_STATIC_PAD_TEMPLATE ("sink", + GST_PAD_SINK, + GST_PAD_ALWAYS, + GST_STATIC_CAPS ("video/x-raw-yuv, " + "format = (fourcc) I420, " + "framerate = (fraction) [0, MAX], " + "width = (int) [ 16, MAX ], " "height = (int) [ 16, MAX ]") + ); + +static GstStaticPadTemplate src_factory = GST_STATIC_PAD_TEMPLATE ("src", + GST_PAD_SRC, + GST_PAD_ALWAYS, + GST_STATIC_CAPS ("video/x-h264") + ); + +GST_BOILERPLATE (GstX264Enc, gst_x264_enc, GstElement, GST_TYPE_ELEMENT); + +static void gst_x264_enc_dispose (GObject * object); + +static gboolean gst_x264_enc_init_encoder (GstX264Enc * encoder); +static void gst_x264_enc_close_encoder (GstX264Enc * encoder); + +static gboolean gst_x264_enc_sink_event (GstPad * pad, GstEvent * event); +static GstFlowReturn gst_x264_enc_chain (GstPad * pad, GstBuffer * buf); +static GstFlowReturn gst_x264_enc_encode_frame (GstX264Enc * encoder, + x264_picture_t * pic_in, int *i_nal); +static GstStateChangeReturn gst_x264_enc_change_state (GstElement * element, + GstStateChange transition); + +static void gst_x264_enc_set_property (GObject * object, guint prop_id, + const GValue * value, GParamSpec * pspec); +static void gst_x264_enc_get_property (GObject * object, guint prop_id, + GValue * value, GParamSpec * pspec); + +static void +gst_x264_enc_timestamp_queue_init (GstX264Enc * encoder) +{ + encoder->timestamp_queue_size = (2 + encoder->bframes + encoder->threads) * 2; + encoder->timestamp_queue_head = 0; + encoder->timestamp_queue_tail = 0; + encoder->timestamp_queue = + g_new (GstClockTime, encoder->timestamp_queue_size); + encoder->timestamp_queue_dur = + g_new (GstClockTime, encoder->timestamp_queue_size); +} + +static void +gst_x264_enc_timestamp_queue_free (GstX264Enc * encoder) +{ + if (encoder->timestamp_queue) { + g_free (encoder->timestamp_queue); + encoder->timestamp_queue = NULL; + } + if (encoder->timestamp_queue_dur) { + g_free (encoder->timestamp_queue_dur); + encoder->timestamp_queue_dur = NULL; + } + + encoder->timestamp_queue_size = 0; + encoder->timestamp_queue_head = 0; + encoder->timestamp_queue_tail = 0; +} + +static void +gst_x264_enc_timestamp_queue_put (GstX264Enc * encoder, GstClockTime clock_time, + GstClockTime duration) +{ + encoder->timestamp_queue[encoder->timestamp_queue_tail] = clock_time; + encoder->timestamp_queue_dur[encoder->timestamp_queue_tail] = duration; + encoder->timestamp_queue_tail++; + encoder->timestamp_queue_tail %= encoder->timestamp_queue_size; + + if (encoder->timestamp_queue_tail == encoder->timestamp_queue_head) { + GST_ELEMENT_ERROR (encoder, STREAM, ENCODE, + ("Timestamp queue overflow."), ("FIX CODE")); + } +} + +static void +gst_x264_enc_timestamp_queue_get (GstX264Enc * encoder, + GstClockTime * clock_time, GstClockTime * duration) +{ + if (encoder->timestamp_queue_head == encoder->timestamp_queue_tail) { + GST_ELEMENT_ERROR (encoder, STREAM, ENCODE, + ("Timestamp queue empty or after overflow."), ("FIX CODE")); + *clock_time = GST_CLOCK_TIME_NONE; + *duration = GST_CLOCK_TIME_NONE; + return; + } + + *clock_time = encoder->timestamp_queue[encoder->timestamp_queue_head]; + *duration = encoder->timestamp_queue_dur[encoder->timestamp_queue_head]; + encoder->timestamp_queue_head++; + encoder->timestamp_queue_head %= encoder->timestamp_queue_size; +} + +/* + * Returns: Buffer with the stream headers. + */ +static GstBuffer * +gst_x264_enc_header_buf (GstX264Enc * encoder) +{ + GstBuffer *buf; + x264_nal_t *nal; + int i_nal; + int header_return; + int i_size; + int nal_size, i_data; + guint8 *buffer, *sps; + gulong buffer_size; + + /* Create avcC header. */ + + header_return = x264_encoder_headers (encoder->x264enc, &nal, &i_nal); + if (header_return < 0) { + GST_ELEMENT_ERROR (encoder, STREAM, ENCODE, + ("Encode x264 header failed."), + ("x264_encoder_headers return code=%d", header_return)); + return NULL; + } + + /* This should be enough for a header buffer. */ + buffer_size = 100000; + buffer = g_malloc (buffer_size); + + if (nal[1].i_type != 7 || nal[2].i_type != 8) { + GST_ELEMENT_ERROR (encoder, STREAM, ENCODE, + ("Unexpected x264 header."), + ("TODO avcC header construction for high profiles needs some work")); + return NULL; + } + + sps = nal[1].p_payload; + + buffer[0] = 1; /* AVC Decoder Configuration Record ver. 1 */ + buffer[1] = sps[0]; /* profile_idc */ + buffer[2] = sps[1]; /* profile_compability */ + buffer[3] = sps[2]; /* level_idc */ + buffer[4] = 0xfc | (4 - 1); /* nal_length_size_minus1 */ + + i_size = 5; + + buffer[i_size++] = 0xe0 | 1; /* number of SPSs */ + + i_data = buffer_size - i_size - 2; + nal_size = x264_nal_encode (buffer + i_size + 2, &i_data, 0, &nal[1]); + buffer[i_size + 0] = (nal_size >> 8) & 0xff; + buffer[i_size + 1] = nal_size & 0xff; + i_size += nal_size + 2; + + buffer[i_size++] = 1; /* number of PPSs */ + + i_data = buffer_size - i_size - 2; + nal_size = x264_nal_encode (buffer + i_size + 2, &i_data, 0, &nal[2]); + buffer[i_size + 0] = (nal_size >> 8) & 0xff; + buffer[i_size + 1] = nal_size & 0xff; + i_size += nal_size + 2; + + buf = gst_buffer_new_and_alloc (i_size); + + memcpy (GST_BUFFER_DATA (buf), buffer, i_size); + + free (buffer); + + return buf; +} + +/* gst_x264_enc_set_src_caps + * Returns: TRUE on success. + */ +static gboolean +gst_x264_enc_set_src_caps (GstX264Enc * encoder, GstPad * pad, GstCaps * caps) +{ + GstStructure *structure; + GValue header = { 0, }; + GstBuffer *buf; + + structure = gst_caps_get_structure (caps, 0); + structure = gst_structure_copy (structure); + gst_structure_set_name (structure, "video/x-h264"); + + if (!encoder->byte_stream) { + buf = gst_x264_enc_header_buf (encoder); + if (buf != NULL) { + GST_BUFFER_FLAG_SET (buf, GST_BUFFER_FLAG_IN_CAPS); + g_value_init (&header, GST_TYPE_BUFFER); + gst_value_set_buffer (&header, buf); + gst_structure_set_value (structure, "codec_data", &header); + g_value_unset (&header); + } + } + + /* FIXME: doesn't this leak? (tpm) */ + return gst_pad_set_caps (pad, gst_caps_new_full (structure, NULL)); +} + +static gboolean +gst_x264_enc_sink_set_caps (GstPad * pad, GstCaps * caps) +{ + GstX264Enc *encoder = GST_X264_ENC (GST_OBJECT_PARENT (pad)); + GstStructure *structure; + const GValue *framerate, *par; + gint width, height; + gint framerate_num, framerate_den; + gint par_num, par_den; + + structure = gst_caps_get_structure (caps, 0); + if (!gst_structure_get_int (structure, "width", &width)) + return FALSE; + if (!gst_structure_get_int (structure, "height", &height)) + return FALSE; + if (!(framerate = gst_structure_get_value (structure, "framerate"))) + return FALSE; + framerate_num = gst_value_get_fraction_numerator (framerate); + framerate_den = gst_value_get_fraction_denominator (framerate); + if (!(par = gst_structure_get_value (structure, "pixel-aspect-ratio"))) { + par_num = 1; + par_den = 1; + } else { + par_num = gst_value_get_fraction_numerator (par); + par_den = gst_value_get_fraction_denominator (par); + } + + /* If the encoder is initialized, do not + reinitialize it again if not necessary */ + if (encoder->x264enc) { + gboolean caps_same = width == encoder->width + && height == encoder->height + && framerate_num == encoder->framerate_num + && framerate_den == encoder->framerate_den + && par_num == encoder->par_num && par_den == encoder->par_den; + + GstFlowReturn flow_ret; + int i_nal; + + if (caps_same) + /* Negotiating the same caps */ + return TRUE; + + do { + flow_ret = gst_x264_enc_encode_frame (encoder, NULL, &i_nal); + } while (flow_ret == GST_FLOW_OK && i_nal > 0); + + encoder->sps_id++; + } + encoder->width = width; + encoder->height = height; + encoder->framerate_num = framerate_num; + encoder->framerate_den = framerate_den; + encoder->par_num = par_num; + encoder->par_den = par_den; + + /* FIXME: is this correct for odd widths/heights? (tpm) */ + encoder->stride = encoder->width; + encoder->luma_plane_size = encoder->width * encoder->height; + + if (!gst_x264_enc_init_encoder (encoder)) + return FALSE; + + if (!gst_x264_enc_set_src_caps (encoder, encoder->srcpad, caps)) { + gst_x264_enc_close_encoder (encoder); + return FALSE; + } + + return TRUE; +} + +static void +gst_x264_enc_base_init (gpointer g_class) +{ + static GstElementDetails plugin_details = { + "x264enc", + "Codec/Encoder/Video", + "H264 Encoder", + "Josef Zlomek <josef.zlomek@itonis.tv>" + }; + 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)); + gst_element_class_set_details (element_class, &plugin_details); +} + +static void +gst_x264_enc_class_init (GstX264EncClass * klass) +{ + GObjectClass *gobject_class; + GstElementClass *gstelement_class; + + gobject_class = (GObjectClass *) klass; + gstelement_class = (GstElementClass *) klass; + + gobject_class->set_property = gst_x264_enc_set_property; + gobject_class->get_property = gst_x264_enc_get_property; + gobject_class->dispose = gst_x264_enc_dispose; + + gstelement_class->change_state = + GST_DEBUG_FUNCPTR (gst_x264_enc_change_state); + + g_object_class_install_property (gobject_class, ARG_THREADS, + g_param_spec_uint ("threads", "Threads", + "Number of threads used by the codec", 1, 4, ARG_THREADS_DEFAULT, + G_PARAM_READWRITE)); + g_object_class_install_property (gobject_class, ARG_PASS, + g_param_spec_uint ("pass", "Pass", + "Pass of multipass encoding (0=single pass; 1=first pass, 2=middle pass, 3=last pass)", + 0, 3, ARG_PASS_DEFAULT, G_PARAM_READWRITE)); + g_object_class_install_property (gobject_class, ARG_STATS_FILE, + g_param_spec_string ("stats_file", "Stats File", + "Filename for multipass statistics", ARG_STATS_FILE_DEFAULT, + G_PARAM_READWRITE)); + g_object_class_install_property (gobject_class, ARG_BYTE_STREAM, + g_param_spec_boolean ("byte_stream", "Byte Stream", + "Generate byte stream format of NALU", ARG_BYTE_STREAM_DEFAULT, + G_PARAM_READWRITE)); + g_object_class_install_property (gobject_class, ARG_BITRATE, + g_param_spec_uint ("bitrate", "Bitrate", "Bitrate in kbit/sec", 1, + 100 * 1024, ARG_BITRATE_DEFAULT, G_PARAM_READWRITE)); + g_object_class_install_property (gobject_class, ARG_VBV_BUF_CAPACITY, + g_param_spec_uint ("vbv_buf_capacity", "VBV buffer capacity", + "Size of the VBV buffer in milliseconds", 300, + 10000, ARG_VBV_BUF_CAPACITY_DEFAULT, G_PARAM_READWRITE)); + g_object_class_install_property (gobject_class, ARG_ME, + g_param_spec_enum ("me", "Motion Estimation", + "Integer pixel motion estimation method", GST_X264_ENC_ME_TYPE, + ARG_ME_DEFAULT, G_PARAM_READWRITE)); + g_object_class_install_property (gobject_class, ARG_SUBME, + g_param_spec_uint ("subme", "Subpixel Motion Estimation", + "Subpixel motion estimation and partition decision quality: 1=fast, 6=best", + 1, 6, ARG_SUBME_DEFAULT, G_PARAM_READWRITE)); + g_object_class_install_property (gobject_class, ARG_ANALYSE, + g_param_spec_flags ("analyse", "Analyse", "Partitions to consider", + GST_X264_ENC_ANALYSE_TYPE, ARG_ANALYSE_DEFAULT, G_PARAM_READWRITE)); + g_object_class_install_property (gobject_class, ARG_DCT8x8, + g_param_spec_boolean ("dct8x8", "DCT8x8", + "Adaptive spatial transform size", ARG_DCT8x8_DEFAULT, + G_PARAM_READWRITE)); + g_object_class_install_property (gobject_class, ARG_REF, + g_param_spec_uint ("ref", "Reference Frames", + "Number of reference frames", 1, 12, ARG_REF_DEFAULT, + G_PARAM_READWRITE)); + g_object_class_install_property (gobject_class, ARG_BFRAMES, + g_param_spec_uint ("bframes", "B-Frames", + "Number of B-frames between I and P", 0, 4, ARG_BFRAMES_DEFAULT, + G_PARAM_READWRITE)); + g_object_class_install_property (gobject_class, ARG_B_PYRAMID, + g_param_spec_boolean ("b_pyramid", "B-Pyramid", + "Keep some B-frames as references", ARG_B_PYRAMID_DEFAULT, + G_PARAM_READWRITE)); + g_object_class_install_property (gobject_class, ARG_WEIGHTB, + g_param_spec_boolean ("weightb", "Weighted B-Frames", + "Weighted prediction for B-frames", ARG_WEIGHTB_DEFAULT, + G_PARAM_READWRITE)); + g_object_class_install_property (gobject_class, ARG_SPS_ID, + g_param_spec_uint ("sps_id", "SPS ID", + "SPS and PPS ID number", 0, 31, ARG_SPS_ID_DEFAULT, + G_PARAM_READWRITE)); + g_object_class_install_property (gobject_class, ARG_TRELLIS, + g_param_spec_boolean ("trellis", "Trellis quantization", + "Enable trellis searched quantization", ARG_TRELLIS_DEFAULT, + G_PARAM_READWRITE)); + g_object_class_install_property (gobject_class, ARG_KEYINT_MAX, + g_param_spec_uint ("key_int_max", "Key-frame maximal interval", + "Maximal distance between two key-frames (0 for automatic)", 0, + G_MAXINT, ARG_KEYINT_MAX_DEFAULT, G_PARAM_READWRITE)); + g_object_class_install_property (gobject_class, ARG_CABAC, + g_param_spec_boolean ("cabac", "Use CABAC", + "Enable CABAC entropy coding", ARG_CABAC_DEFAULT, G_PARAM_READWRITE)); +} + +/* initialize the new element + * instantiate pads and add them to element + * set functions + * initialize structure + */ +static void +gst_x264_enc_init (GstX264Enc * encoder, GstX264EncClass * klass) +{ + encoder->sinkpad = gst_pad_new_from_static_template (&sink_factory, "sink"); + gst_pad_set_setcaps_function (encoder->sinkpad, + GST_DEBUG_FUNCPTR (gst_x264_enc_sink_set_caps)); + gst_pad_set_event_function (encoder->sinkpad, + GST_DEBUG_FUNCPTR (gst_x264_enc_sink_event)); + gst_pad_set_chain_function (encoder->sinkpad, + GST_DEBUG_FUNCPTR (gst_x264_enc_chain)); + gst_element_add_pad (GST_ELEMENT (encoder), encoder->sinkpad); + + encoder->srcpad = gst_pad_new_from_static_template (&src_factory, "src"); + gst_pad_use_fixed_caps (encoder->srcpad); + gst_element_add_pad (GST_ELEMENT (encoder), encoder->srcpad); + + /* initialize internals */ + encoder->x264enc = NULL; + + encoder->width = 16; + encoder->height = 16; + + encoder->threads = ARG_THREADS_DEFAULT; + encoder->pass = ARG_PASS_DEFAULT; + encoder->stats_file = g_strdup (ARG_STATS_FILE_DEFAULT); + encoder->byte_stream = ARG_BYTE_STREAM_DEFAULT; + encoder->bitrate = ARG_BITRATE_DEFAULT; + encoder->vbv_buf_capacity = ARG_VBV_BUF_CAPACITY_DEFAULT; + encoder->me = ARG_ME_DEFAULT; + encoder->subme = ARG_SUBME_DEFAULT; + encoder->analyse = ARG_ANALYSE_DEFAULT; + encoder->dct8x8 = ARG_DCT8x8_DEFAULT; + encoder->ref = ARG_REF_DEFAULT; + encoder->bframes = ARG_BFRAMES_DEFAULT; + encoder->b_pyramid = ARG_B_PYRAMID_DEFAULT; + encoder->weightb = ARG_WEIGHTB_DEFAULT; + encoder->sps_id = ARG_SPS_ID_DEFAULT; + encoder->trellis = ARG_TRELLIS_DEFAULT; + encoder->keyint_max = ARG_KEYINT_MAX_DEFAULT; + encoder->cabac = ARG_CABAC_DEFAULT; + + encoder->last_timestamp = GST_CLOCK_TIME_NONE; + gst_x264_enc_timestamp_queue_init (encoder); + + encoder->buffer_size = 1040000; + encoder->buffer = g_malloc (encoder->buffer_size); + + x264_param_default (&encoder->x264param); +} + +/* + * gst_x264_enc_init_encoder + * @encoder: Encoder which should be initialized. + * + * Initialize x264 encoder. + * + */ +static gboolean +gst_x264_enc_init_encoder (GstX264Enc * encoder) +{ + /* make sure that the encoder is closed */ + gst_x264_enc_close_encoder (encoder); + + /* set up encoder parameters */ + encoder->x264param.i_threads = encoder->threads; + encoder->x264param.i_fps_num = encoder->framerate_num; + encoder->x264param.i_fps_den = encoder->framerate_den; + encoder->x264param.i_width = encoder->width; + encoder->x264param.i_height = encoder->height; + if (encoder->par_den > 0) { + encoder->x264param.vui.i_sar_width = encoder->par_num; + encoder->x264param.vui.i_sar_height = encoder->par_den; + } + encoder->x264param.i_keyint_max = encoder->keyint_max ? encoder->keyint_max : + (2 * encoder->framerate_num / encoder->framerate_den); + encoder->x264param.b_cabac = encoder->cabac; + encoder->x264param.b_aud = 1; + encoder->x264param.i_sps_id = encoder->sps_id; + if ((((encoder->height == 576) && ((encoder->width == 720) + || (encoder->width == 704) || (encoder->width == 352))) + || ((encoder->height == 288) && (encoder->width == 352))) + && (encoder->framerate_den == 1) && (encoder->framerate_num == 25)) { + encoder->x264param.vui.i_vidformat = 1; /* PAL */ + } else if ((((encoder->height == 480) && ((encoder->width == 720) + || (encoder->width == 704) || (encoder->width == 352))) + || ((encoder->height == 240) && (encoder->width == 352))) + && (encoder->framerate_den == 1001) && ((encoder->framerate_num == 30000) + || (encoder->framerate_num == 24000))) { + encoder->x264param.vui.i_vidformat = 2; /* NTSC */ + } else + encoder->x264param.vui.i_vidformat = 5; /* unspecified */ + encoder->x264param.analyse.i_trellis = encoder->trellis ? 1 : 0; + encoder->x264param.analyse.b_psnr = 0; + encoder->x264param.analyse.b_ssim = 0; + encoder->x264param.analyse.i_me_method = encoder->me; + encoder->x264param.analyse.i_subpel_refine = encoder->subme; + encoder->x264param.analyse.inter = encoder->analyse; + encoder->x264param.analyse.b_transform_8x8 = encoder->dct8x8; + encoder->x264param.analyse.b_weighted_bipred = encoder->weightb; + /*encoder->x264param.analyse.i_noise_reduction = 600; */ + encoder->x264param.i_frame_reference = encoder->ref; + encoder->x264param.i_bframe = encoder->bframes; + encoder->x264param.b_bframe_pyramid = encoder->b_pyramid; + encoder->x264param.b_bframe_adaptive = 0; + encoder->x264param.b_deblocking_filter = 1; + encoder->x264param.i_deblocking_filter_alphac0 = 0; + encoder->x264param.i_deblocking_filter_beta = 0; + encoder->x264param.rc.i_rc_method = X264_RC_ABR; + encoder->x264param.rc.i_bitrate = encoder->bitrate; + encoder->x264param.rc.i_vbv_max_bitrate = encoder->bitrate; + encoder->x264param.rc.i_vbv_buffer_size + = encoder->x264param.rc.i_vbv_max_bitrate + * encoder->vbv_buf_capacity / 1000; + + switch (encoder->pass) { + case 0: + encoder->x264param.rc.b_stat_read = 0; + encoder->x264param.rc.b_stat_write = 0; + break; + case 1: + /* Turbo mode parameters. */ + encoder->x264param.i_frame_reference = (encoder->ref + 1) >> 1; + encoder->x264param.analyse.i_subpel_refine = + CLAMP (encoder->subme - 1, 1, 3); + encoder->x264param.analyse.inter &= ~X264_ANALYSE_PSUB8x8; + encoder->x264param.analyse.inter &= ~X264_ANALYSE_BSUB16x16; + encoder->x264param.analyse.i_trellis = 0; + + encoder->x264param.rc.b_stat_read = 0; + encoder->x264param.rc.b_stat_write = 1; + break; + case 2: + encoder->x264param.rc.b_stat_read = 1; + encoder->x264param.rc.b_stat_write = 1; + break; + case 3: + encoder->x264param.rc.b_stat_read = 1; + encoder->x264param.rc.b_stat_write = 0; + break; + } + encoder->x264param.rc.psz_stat_in = encoder->stats_file; + encoder->x264param.rc.psz_stat_out = encoder->stats_file; + + encoder->x264enc = x264_encoder_open (&encoder->x264param); + if (!encoder->x264enc) { + GST_ELEMENT_ERROR (encoder, STREAM, ENCODE, + ("Can not initialize x264 encoder."), ("")); + return FALSE; + } + + return TRUE; +} + +/* gst_x264_enc_close_encoder + * @encoder: Encoder which should close. + * + * Close x264 encoder. + */ +static void +gst_x264_enc_close_encoder (GstX264Enc * encoder) +{ + if (encoder->x264enc != NULL) { + x264_encoder_close (encoder->x264enc); + encoder->x264enc = NULL; + } +} + +static void +gst_x264_enc_dispose (GObject * object) +{ + GstX264Enc *encoder = GST_X264_ENC (object); + + g_free (encoder->stats_file); + encoder->stats_file = NULL; + g_free (encoder->buffer); + encoder->buffer = NULL; + + gst_x264_enc_timestamp_queue_free (encoder); + + G_OBJECT_CLASS (parent_class)->dispose (object); + + gst_x264_enc_close_encoder (encoder); +} + +static gboolean +gst_x264_enc_sink_event (GstPad * pad, GstEvent * event) +{ + gboolean ret; + GstX264Enc *encoder; + GstFlowReturn flow_ret; + int i_nal; + + encoder = GST_X264_ENC (gst_pad_get_parent (pad)); + + switch (GST_EVENT_TYPE (event)) { + case GST_EVENT_EOS: + /* send the rest NAL units */ + do { + flow_ret = gst_x264_enc_encode_frame (encoder, NULL, &i_nal); + } while (flow_ret == GST_FLOW_OK && i_nal > 0); + + /* send EOS */ + if (flow_ret == GST_FLOW_OK) { + ret = gst_pad_push_event (encoder->srcpad, event); + } else { + ret = FALSE; + } + break; + default: + ret = gst_pad_push_event (encoder->srcpad, event); + break; + } + gst_object_unref (encoder); + return ret; +} + +/* chain function + * this function does the actual processing + */ + +static GstFlowReturn +gst_x264_enc_chain (GstPad * pad, GstBuffer * buf) +{ + GstX264Enc *encoder = GST_X264_ENC (GST_OBJECT_PARENT (pad)); + GstFlowReturn ret; + x264_picture_t pic_in; + int i_nal; + + if (G_UNLIKELY (encoder->x264enc == NULL)) + goto not_inited; + + /* create x264_picture_t from the buffer */ + /* mostly taken from mplayer (file ve_x264.c) */ + /* FIXME: this looks wrong for odd widths/heights (tpm) */ + if (G_UNLIKELY (GST_BUFFER_SIZE (buf) < encoder->luma_plane_size * 6 / 4)) + goto wrong_buffer_size; + + /* ignore duplicated packets */ + if (GST_CLOCK_TIME_IS_VALID (GST_BUFFER_TIMESTAMP (buf))) { + if (GST_CLOCK_TIME_IS_VALID (encoder->last_timestamp)) { + GstClockTimeDiff diff = + GST_BUFFER_TIMESTAMP (buf) - encoder->last_timestamp; + if (diff <= 0) { + GST_ELEMENT_WARNING (encoder, STREAM, ENCODE, + ("Duplicated packet in input, dropping"), + ("Time difference was -%" GST_TIME_FORMAT, GST_TIME_ARGS (-diff))); + gst_buffer_unref (buf); + return GST_FLOW_OK; + } + } + encoder->last_timestamp = GST_BUFFER_TIMESTAMP (buf); + } + + /* remember the timestamp and duration */ + gst_x264_enc_timestamp_queue_put (encoder, GST_BUFFER_TIMESTAMP (buf), + GST_BUFFER_DURATION (buf)); + + memset (&pic_in, 0, sizeof (x264_picture_t)); + + pic_in.img.i_csp = X264_CSP_I420; + pic_in.img.i_plane = 3; + + /* FIXME: again, this looks wrong for odd widths/heights (tpm) */ + pic_in.img.plane[0] = (guint8 *) (GST_BUFFER_DATA (buf)); + pic_in.img.i_stride[0] = encoder->stride; + + pic_in.img.plane[1] = pic_in.img.plane[0] + + encoder->luma_plane_size; + pic_in.img.i_stride[1] = encoder->stride / 2; + + pic_in.img.plane[2] = pic_in.img.plane[1] + + encoder->luma_plane_size / 4; + pic_in.img.i_stride[2] = encoder->stride / 2; + + pic_in.img.plane[3] = NULL; + pic_in.img.i_stride[3] = 0; + + pic_in.i_type = X264_TYPE_AUTO; + pic_in.i_pts = GST_BUFFER_TIMESTAMP (buf); + + ret = gst_x264_enc_encode_frame (encoder, &pic_in, &i_nal); + gst_buffer_unref (buf); + return ret; + +/* ERRORS */ +not_inited: + { + GST_ELEMENT_ERROR (encoder, CORE, NEGOTIATION, (NULL), + ("Got buffer before pads were fully negotiated")); + gst_buffer_unref (buf); + return GST_FLOW_ERROR; + } +wrong_buffer_size: + { + GST_ELEMENT_ERROR (encoder, STREAM, ENCODE, + ("Encode x264 frame failed."), + ("Wrong buffer size %d (should be %d)", + GST_BUFFER_SIZE (buf), encoder->luma_plane_size * 6 / 4)); + gst_buffer_unref (buf); + return GST_FLOW_ERROR; + } +} + +static GstFlowReturn +gst_x264_enc_encode_frame (GstX264Enc * encoder, x264_picture_t * pic_in, + int *i_nal) +{ + GstBuffer *out_buf = NULL; + x264_picture_t pic_out; + x264_nal_t *nal; + int i_size; + int nal_size; + int encoder_return; + gint i; + GstFlowReturn ret; + GstClockTime timestamp; + GstClockTime duration; + + encoder_return = x264_encoder_encode (encoder->x264enc, + &nal, i_nal, pic_in, &pic_out); + + if (encoder_return < 0) { + GST_ELEMENT_ERROR (encoder, STREAM, ENCODE, + ("Encode x264 frame failed."), + ("x264_encoder_encode return code=%d", encoder_return)); + return GST_FLOW_ERROR; + } + + if (!*i_nal) { + return GST_FLOW_OK; + } + + i_size = 0; + for (i = 0; i < *i_nal; i++) { + int i_data = encoder->buffer_size - i_size - 4; + + if (i_data < encoder->buffer_size / 2) { + encoder->buffer_size *= 2; + encoder->buffer = g_realloc (encoder->buffer, encoder->buffer_size); + i_data = encoder->buffer_size - i_size; + } + + nal_size = + x264_nal_encode (encoder->buffer + i_size + 4, &i_data, 0, &nal[i]); + if (encoder->byte_stream) { + encoder->buffer[i_size + 0] = 0; + encoder->buffer[i_size + 1] = 0; + encoder->buffer[i_size + 2] = 0; + encoder->buffer[i_size + 3] = 1; + } else { + encoder->buffer[i_size + 0] = (nal_size >> 24) & 0xff; + encoder->buffer[i_size + 1] = (nal_size >> 16) & 0xff; + encoder->buffer[i_size + 2] = (nal_size >> 8) & 0xff; + encoder->buffer[i_size + 3] = nal_size & 0xff; + } + + i_size += nal_size + 4; + } + + ret = gst_pad_alloc_buffer (encoder->srcpad, GST_BUFFER_OFFSET_NONE, + i_size, GST_PAD_CAPS (encoder->srcpad), &out_buf); + if (ret != GST_FLOW_OK) + return ret; + + memcpy (GST_BUFFER_DATA (out_buf), encoder->buffer, i_size); + GST_BUFFER_SIZE (out_buf) = i_size; + + gst_x264_enc_timestamp_queue_get (encoder, ×tamp, &duration); + + /* PTS */ + GST_BUFFER_TIMESTAMP (out_buf) = pic_out.i_pts; + if (encoder->bframes) { + /* When using B-frames, the frames will be reordered. + Make PTS start one frame after DTS. */ + GST_BUFFER_TIMESTAMP (out_buf) + += GST_SECOND * encoder->framerate_den / encoder->framerate_num; + } + + GST_BUFFER_DURATION (out_buf) = duration; + + if (pic_out.i_type == X264_TYPE_IDR) { + GST_BUFFER_FLAG_UNSET (out_buf, GST_BUFFER_FLAG_DELTA_UNIT); + } else { + GST_BUFFER_FLAG_SET (out_buf, GST_BUFFER_FLAG_DELTA_UNIT); + } + + return gst_pad_push (encoder->srcpad, out_buf); +} + +static GstStateChangeReturn +gst_x264_enc_change_state (GstElement * element, GstStateChange transition) +{ + GstX264Enc *encoder = GST_X264_ENC (element); + GstStateChangeReturn ret = GST_STATE_CHANGE_SUCCESS; + + ret = parent_class->change_state (element, transition); + if (ret == GST_STATE_CHANGE_FAILURE) + goto out; + + switch (transition) { + case GST_STATE_CHANGE_READY_TO_NULL: + gst_x264_enc_close_encoder (encoder); + break; + default: + break; + } + +out: + return ret; +} + +static void +gst_x264_enc_set_property (GObject * object, guint prop_id, + const GValue * value, GParamSpec * pspec) +{ + GstX264Enc *encoder; + + encoder = GST_X264_ENC (object); + + /* FIXME: should probably do locking or check state */ + switch (prop_id) { + case ARG_THREADS: + encoder->threads = g_value_get_uint (value); + break; + case ARG_PASS: + encoder->pass = g_value_get_uint (value); + break; + case ARG_STATS_FILE: + if (encoder->stats_file) + g_free (encoder->stats_file); + encoder->stats_file = g_value_dup_string (value); + break; + case ARG_BYTE_STREAM: + encoder->byte_stream = g_value_get_boolean (value); + break; + case ARG_BITRATE: + encoder->bitrate = g_value_get_uint (value); + break; + case ARG_VBV_BUF_CAPACITY: + encoder->vbv_buf_capacity = g_value_get_uint (value); + break; + case ARG_ME: + encoder->me = g_value_get_enum (value); + break; + case ARG_SUBME: + encoder->subme = g_value_get_uint (value); + break; + case ARG_ANALYSE: + encoder->analyse = g_value_get_flags (value); + break; + case ARG_DCT8x8: + encoder->dct8x8 = g_value_get_boolean (value); + break; + case ARG_REF: + encoder->ref = g_value_get_uint (value); + break; + case ARG_BFRAMES: + encoder->bframes = g_value_get_uint (value); + gst_x264_enc_timestamp_queue_free (encoder); + gst_x264_enc_timestamp_queue_init (encoder); + break; + case ARG_B_PYRAMID: + encoder->b_pyramid = g_value_get_boolean (value); + break; + case ARG_WEIGHTB: + encoder->weightb = g_value_get_boolean (value); + break; + case ARG_SPS_ID: + encoder->sps_id = g_value_get_uint (value); + break; + case ARG_TRELLIS: + encoder->trellis = g_value_get_boolean (value); + break; + case ARG_KEYINT_MAX: + encoder->keyint_max = g_value_get_uint (value); + break; + case ARG_CABAC: + encoder->cabac = g_value_get_boolean (value); + break; + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); + break; + } +} + +static void +gst_x264_enc_get_property (GObject * object, guint prop_id, + GValue * value, GParamSpec * pspec) +{ + GstX264Enc *encoder; + + encoder = GST_X264_ENC (object); + + /* FIXME: should probably do locking or check state */ + switch (prop_id) { + case ARG_THREADS: + g_value_set_uint (value, encoder->threads); + break; + case ARG_PASS: + g_value_set_uint (value, encoder->pass); + break; + case ARG_STATS_FILE: + g_value_set_string (value, encoder->stats_file); + break; + case ARG_BYTE_STREAM: + g_value_set_boolean (value, encoder->byte_stream); + break; + case ARG_BITRATE: + g_value_set_uint (value, encoder->bitrate); + break; + case ARG_VBV_BUF_CAPACITY: + g_value_set_uint (value, encoder->vbv_buf_capacity); + break; + case ARG_ME: + g_value_set_enum (value, encoder->me); + break; + case ARG_SUBME: + g_value_set_uint (value, encoder->subme); + break; + case ARG_ANALYSE: + g_value_set_flags (value, encoder->analyse); + break; + case ARG_DCT8x8: + g_value_set_boolean (value, encoder->dct8x8); + break; + case ARG_REF: + g_value_set_uint (value, encoder->ref); + break; + case ARG_BFRAMES: + g_value_set_uint (value, encoder->bframes); + break; + case ARG_B_PYRAMID: + g_value_set_boolean (value, encoder->b_pyramid); + break; + case ARG_WEIGHTB: + g_value_set_boolean (value, encoder->weightb); + break; + case ARG_SPS_ID: + g_value_set_uint (value, encoder->sps_id); + break; + case ARG_TRELLIS: + g_value_set_boolean (value, encoder->trellis); + break; + case ARG_KEYINT_MAX: + g_value_set_uint (value, encoder->keyint_max); + break; + case ARG_CABAC: + g_value_set_boolean (value, encoder->cabac); + break; + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); + break; + } +} + +static gboolean +plugin_init (GstPlugin * plugin) +{ + return gst_element_register (plugin, "x264enc", + GST_RANK_NONE, GST_TYPE_X264_ENC); +} + +GST_PLUGIN_DEFINE (GST_VERSION_MAJOR, + GST_VERSION_MINOR, + "x264", + "libx264-based H264 plugins", + plugin_init, VERSION, "GPL", GST_PACKAGE_NAME, GST_PACKAGE_ORIGIN) diff --git a/ext/x264/gstx264enc.h b/ext/x264/gstx264enc.h new file mode 100644 index 00000000..412cfa36 --- /dev/null +++ b/ext/x264/gstx264enc.h @@ -0,0 +1,97 @@ +/* GStreamer H264 encoder plugin + * Copyright (C) 2005 Michal Benes <michal.benes@itonis.tv> + * Copyright (C) 2005 Josef Zlomek <josef.zlomek@itonis.tv> + * + * 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. + */ + +#ifndef __GST_X264_ENC_H__ +#define __GST_X264_ENC_H__ + +#include <gst/gst.h> +#include <_stdint.h> +#include <x264.h> + +G_BEGIN_DECLS + +#define GST_TYPE_X264_ENC \ + (gst_x264_enc_get_type()) +#define GST_X264_ENC(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_X264_ENC,GstX264Enc)) +#define GST_X264_ENC_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_X264_ENC,GstX264EncClass)) +#define GST_IS_X264_ENC(obj) \ + (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_X264_ENC)) +#define GST_IS_X264_ENC_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_X264_ENC)) + +typedef struct _GstX264Enc GstX264Enc; +typedef struct _GstX264EncClass GstX264EncClass; + +struct _GstX264Enc +{ + GstElement element; + + /*< private >*/ + GstPad *sinkpad; + GstPad *srcpad; + + x264_t *x264enc; + x264_param_t x264param; + + guint threads; + guint pass; + gchar *stats_file; + gboolean byte_stream; + guint bitrate; + gint me; + guint subme; + guint analyse; + gboolean dct8x8; + guint ref; + guint bframes; + gboolean b_pyramid; + gboolean weightb; + guint sps_id; + gboolean trellis; + guint vbv_buf_capacity; + guint keyint_max; + gboolean cabac; + + gint width, height; + guint stride, luma_plane_size; + gint framerate_num, framerate_den; + gint par_num, par_den; + + GstClockTime last_timestamp; + GstClockTime *timestamp_queue; + GstClockTime *timestamp_queue_dur; + guint timestamp_queue_size; + guint timestamp_queue_head; + guint timestamp_queue_tail; + + guint8 *buffer; + gulong buffer_size; +}; + +struct _GstX264EncClass +{ + GstElementClass parent_class; +}; + +G_END_DECLS + +#endif /* __GST_X264_ENC_H__ */ |