2
* Copyright (C) <1999> Erik Walthinsen <omega@cse.ogi.edu>
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.
26
/* for stats file handling */
28
#include <glib/gstdio.h>
31
#include <libavcodec/avcodec.h>
36
#include "gstavcodecmap.h"
37
#include "gstavutils.h"
40
#define DEFAULT_AUDIO_BITRATE 128000
56
/* A number of function prototypes are given so we can refer to them later. */
57
static void gst_ffmpegaudenc_class_init (GstFFMpegAudEncClass * klass);
58
static void gst_ffmpegaudenc_base_init (GstFFMpegAudEncClass * klass);
59
static void gst_ffmpegaudenc_init (GstFFMpegAudEnc * ffmpegaudenc);
60
static void gst_ffmpegaudenc_finalize (GObject * object);
62
static gboolean gst_ffmpegaudenc_setcaps (GstFFMpegAudEnc * ffmpegenc,
64
static GstCaps *gst_ffmpegaudenc_getcaps (GstFFMpegAudEnc * ffmpegenc,
66
static GstFlowReturn gst_ffmpegaudenc_chain_audio (GstPad * pad,
67
GstObject * parent, GstBuffer * buffer);
68
static gboolean gst_ffmpegaudenc_query_sink (GstPad * pad, GstObject * parent,
70
static gboolean gst_ffmpegaudenc_event_sink (GstPad * pad, GstObject * parent,
73
static void gst_ffmpegaudenc_set_property (GObject * object,
74
guint prop_id, const GValue * value, GParamSpec * pspec);
75
static void gst_ffmpegaudenc_get_property (GObject * object,
76
guint prop_id, GValue * value, GParamSpec * pspec);
78
static GstStateChangeReturn gst_ffmpegaudenc_change_state (GstElement * element,
79
GstStateChange transition);
81
#define GST_FFENC_PARAMS_QDATA g_quark_from_static_string("avenc-params")
83
static GstElementClass *parent_class = NULL;
85
/*static guint gst_ffmpegaudenc_signals[LAST_SIGNAL] = { 0 }; */
88
gst_ffmpegaudenc_base_init (GstFFMpegAudEncClass * klass)
90
GstElementClass *element_class = GST_ELEMENT_CLASS (klass);
92
GstPadTemplate *srctempl = NULL, *sinktempl = NULL;
93
GstCaps *srccaps = NULL, *sinkcaps = NULL;
94
gchar *longname, *description;
97
(AVCodec *) g_type_get_qdata (G_OBJECT_CLASS_TYPE (klass),
98
GST_FFENC_PARAMS_QDATA);
99
g_assert (in_plugin != NULL);
101
/* construct the element details struct */
102
longname = g_strdup_printf ("libav %s encoder", in_plugin->long_name);
103
description = g_strdup_printf ("libav %s encoder", in_plugin->name);
104
gst_element_class_set_metadata (element_class, longname,
105
"Codec/Encoder/Audio", description,
106
"Wim Taymans <wim.taymans@gmail.com>, "
107
"Ronald Bultje <rbultje@ronald.bitfreak.net>");
109
g_free (description);
111
if (!(srccaps = gst_ffmpeg_codecid_to_caps (in_plugin->id, NULL, TRUE))) {
112
GST_DEBUG ("Couldn't get source caps for encoder '%s'", in_plugin->name);
113
srccaps = gst_caps_new_empty_simple ("unknown/unknown");
116
sinkcaps = gst_ffmpeg_codectype_to_audio_caps (NULL,
117
in_plugin->id, TRUE, in_plugin);
119
GST_DEBUG ("Couldn't get sink caps for encoder '%s'", in_plugin->name);
120
sinkcaps = gst_caps_new_empty_simple ("unknown/unknown");
124
sinktempl = gst_pad_template_new ("sink", GST_PAD_SINK,
125
GST_PAD_ALWAYS, sinkcaps);
126
srctempl = gst_pad_template_new ("src", GST_PAD_SRC, GST_PAD_ALWAYS, srccaps);
128
gst_element_class_add_pad_template (element_class, srctempl);
129
gst_element_class_add_pad_template (element_class, sinktempl);
131
klass->in_plugin = in_plugin;
132
klass->srctempl = srctempl;
133
klass->sinktempl = sinktempl;
134
klass->sinkcaps = NULL;
140
gst_ffmpegaudenc_class_init (GstFFMpegAudEncClass * klass)
142
GObjectClass *gobject_class;
143
GstElementClass *gstelement_class;
145
gobject_class = (GObjectClass *) klass;
146
gstelement_class = (GstElementClass *) klass;
148
parent_class = g_type_class_peek_parent (klass);
150
gobject_class->set_property = gst_ffmpegaudenc_set_property;
151
gobject_class->get_property = gst_ffmpegaudenc_get_property;
153
/* FIXME: could use -1 for a sensible per-codec defaults */
154
g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_BIT_RATE,
155
g_param_spec_int ("bitrate", "Bit Rate",
156
"Target Audio Bitrate", 0, G_MAXINT, DEFAULT_AUDIO_BITRATE,
157
G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
159
gstelement_class->change_state = gst_ffmpegaudenc_change_state;
161
gobject_class->finalize = gst_ffmpegaudenc_finalize;
165
gst_ffmpegaudenc_init (GstFFMpegAudEnc * ffmpegaudenc)
167
GstFFMpegAudEncClass *oclass =
168
(GstFFMpegAudEncClass *) (G_OBJECT_GET_CLASS (ffmpegaudenc));
171
ffmpegaudenc->sinkpad = gst_pad_new_from_template (oclass->sinktempl, "sink");
172
gst_pad_set_event_function (ffmpegaudenc->sinkpad,
173
gst_ffmpegaudenc_event_sink);
174
gst_pad_set_query_function (ffmpegaudenc->sinkpad,
175
gst_ffmpegaudenc_query_sink);
176
gst_pad_set_chain_function (ffmpegaudenc->sinkpad,
177
gst_ffmpegaudenc_chain_audio);
179
ffmpegaudenc->srcpad = gst_pad_new_from_template (oclass->srctempl, "src");
180
gst_pad_use_fixed_caps (ffmpegaudenc->srcpad);
183
ffmpegaudenc->context = avcodec_alloc_context ();
184
ffmpegaudenc->opened = FALSE;
186
gst_element_add_pad (GST_ELEMENT (ffmpegaudenc), ffmpegaudenc->sinkpad);
187
gst_element_add_pad (GST_ELEMENT (ffmpegaudenc), ffmpegaudenc->srcpad);
189
ffmpegaudenc->adapter = gst_adapter_new ();
193
gst_ffmpegaudenc_finalize (GObject * object)
195
GstFFMpegAudEnc *ffmpegaudenc = (GstFFMpegAudEnc *) object;
198
/* close old session */
199
if (ffmpegaudenc->opened) {
200
gst_ffmpeg_avcodec_close (ffmpegaudenc->context);
201
ffmpegaudenc->opened = FALSE;
204
/* clean up remaining allocated data */
205
av_free (ffmpegaudenc->context);
207
g_object_unref (ffmpegaudenc->adapter);
209
G_OBJECT_CLASS (parent_class)->finalize (object);
213
gst_ffmpegaudenc_getcaps (GstFFMpegAudEnc * ffmpegaudenc, GstCaps * filter)
215
GstCaps *caps = NULL;
217
GST_DEBUG_OBJECT (ffmpegaudenc, "getting caps");
219
/* audio needs no special care */
220
caps = gst_pad_get_pad_template_caps (ffmpegaudenc->sinkpad);
224
tmp = gst_caps_intersect_full (filter, caps, GST_CAPS_INTERSECT_FIRST);
225
gst_caps_unref (caps);
229
GST_DEBUG_OBJECT (ffmpegaudenc,
230
"audio caps, return template %" GST_PTR_FORMAT, caps);
236
gst_ffmpegaudenc_setcaps (GstFFMpegAudEnc * ffmpegaudenc, GstCaps * caps)
239
GstCaps *allowed_caps;
241
GstFFMpegAudEncClass *oclass =
242
(GstFFMpegAudEncClass *) G_OBJECT_GET_CLASS (ffmpegaudenc);
244
/* close old session */
245
if (ffmpegaudenc->opened) {
246
gst_ffmpeg_avcodec_close (ffmpegaudenc->context);
247
ffmpegaudenc->opened = FALSE;
251
avcodec_get_context_defaults (ffmpegaudenc->context);
253
/* if we set it in _getcaps we should set it also in _link */
254
ffmpegaudenc->context->strict_std_compliance = -1;
256
/* user defined properties */
257
if (ffmpegaudenc->bitrate > 0) {
258
GST_INFO_OBJECT (ffmpegaudenc, "Setting avcontext to bitrate %d",
259
ffmpegaudenc->bitrate);
260
ffmpegaudenc->context->bit_rate = ffmpegaudenc->bitrate;
261
ffmpegaudenc->context->bit_rate_tolerance = ffmpegaudenc->bitrate;
263
GST_INFO_OBJECT (ffmpegaudenc, "Using avcontext default bitrate %d",
264
ffmpegaudenc->context->bit_rate);
267
/* RTP payload used for GOB production (for Asterisk) */
268
if (ffmpegaudenc->rtp_payload_size) {
269
ffmpegaudenc->context->rtp_payload_size = ffmpegaudenc->rtp_payload_size;
272
/* some other defaults */
273
ffmpegaudenc->context->rc_strategy = 2;
274
ffmpegaudenc->context->b_frame_strategy = 0;
275
ffmpegaudenc->context->coder_type = 0;
276
ffmpegaudenc->context->context_model = 0;
277
ffmpegaudenc->context->scenechange_threshold = 0;
278
ffmpegaudenc->context->inter_threshold = 0;
281
/* fetch pix_fmt and so on */
282
gst_ffmpeg_caps_with_codectype (oclass->in_plugin->type,
283
caps, ffmpegaudenc->context);
284
if (!ffmpegaudenc->context->time_base.den) {
285
ffmpegaudenc->context->time_base.den = 25;
286
ffmpegaudenc->context->time_base.num = 1;
287
ffmpegaudenc->context->ticks_per_frame = 1;
291
if (gst_ffmpeg_avcodec_open (ffmpegaudenc->context, oclass->in_plugin) < 0) {
292
if (ffmpegaudenc->context->priv_data)
293
gst_ffmpeg_avcodec_close (ffmpegaudenc->context);
294
if (ffmpegaudenc->context->stats_in)
295
g_free (ffmpegaudenc->context->stats_in);
296
GST_DEBUG_OBJECT (ffmpegaudenc, "avenc_%s: Failed to open FFMPEG codec",
297
oclass->in_plugin->name);
301
/* second pass stats buffer no longer needed */
302
if (ffmpegaudenc->context->stats_in)
303
g_free (ffmpegaudenc->context->stats_in);
305
/* some codecs support more than one format, first auto-choose one */
306
GST_DEBUG_OBJECT (ffmpegaudenc, "picking an output format ...");
307
allowed_caps = gst_pad_get_allowed_caps (ffmpegaudenc->srcpad);
309
GST_DEBUG_OBJECT (ffmpegaudenc, "... but no peer, using template caps");
310
/* we need to copy because get_allowed_caps returns a ref, and
311
* get_pad_template_caps doesn't */
312
allowed_caps = gst_pad_get_pad_template_caps (ffmpegaudenc->srcpad);
314
GST_DEBUG_OBJECT (ffmpegaudenc, "chose caps %" GST_PTR_FORMAT, allowed_caps);
315
gst_ffmpeg_caps_with_codecid (oclass->in_plugin->id,
316
oclass->in_plugin->type, allowed_caps, ffmpegaudenc->context);
318
/* try to set this caps on the other side */
319
other_caps = gst_ffmpeg_codecid_to_caps (oclass->in_plugin->id,
320
ffmpegaudenc->context, TRUE);
323
gst_caps_unref (allowed_caps);
324
gst_ffmpeg_avcodec_close (ffmpegaudenc->context);
325
GST_DEBUG ("Unsupported codec - no caps found");
329
icaps = gst_caps_intersect (allowed_caps, other_caps);
330
gst_caps_unref (allowed_caps);
331
gst_caps_unref (other_caps);
332
if (gst_caps_is_empty (icaps)) {
333
gst_caps_unref (icaps);
337
if (gst_caps_get_size (icaps) > 1) {
341
gst_caps_new_full (gst_structure_copy (gst_caps_get_structure (icaps,
343
gst_caps_unref (icaps);
347
if (!gst_pad_set_caps (ffmpegaudenc->srcpad, icaps)) {
348
gst_ffmpeg_avcodec_close (ffmpegaudenc->context);
349
gst_caps_unref (icaps);
352
gst_caps_unref (icaps);
355
ffmpegaudenc->opened = TRUE;
362
gst_ffmpegaudenc_encode_audio (GstFFMpegAudEnc * ffmpegaudenc,
363
guint8 * audio_in, guint in_size, guint max_size, GstClockTime timestamp,
364
GstClockTime duration, gboolean discont)
372
ctx = ffmpegaudenc->context;
374
/* We need to provide at least ffmpegs minimal buffer size */
375
outbuf = gst_buffer_new_and_alloc (max_size + FF_MIN_BUFFER_SIZE);
376
gst_buffer_map (outbuf, &map, GST_MAP_WRITE);
378
GST_LOG_OBJECT (ffmpegaudenc, "encoding buffer of max size %d", max_size);
379
if (ffmpegaudenc->buffer_size != max_size)
380
ffmpegaudenc->buffer_size = max_size;
382
res = avcodec_encode_audio (ctx, map.data, max_size, (short *) audio_in);
385
gst_buffer_unmap (outbuf, &map);
386
GST_ERROR_OBJECT (ffmpegaudenc, "Failed to encode buffer: %d", res);
387
gst_buffer_unref (outbuf);
390
GST_LOG_OBJECT (ffmpegaudenc, "got output size %d", res);
391
gst_buffer_unmap (outbuf, &map);
392
gst_buffer_resize (outbuf, 0, res);
394
GST_BUFFER_TIMESTAMP (outbuf) = timestamp;
395
GST_BUFFER_DURATION (outbuf) = duration;
397
GST_BUFFER_FLAG_SET (outbuf, GST_BUFFER_FLAG_DISCONT);
399
GST_LOG_OBJECT (ffmpegaudenc, "pushing size %d, timestamp %" GST_TIME_FORMAT,
400
res, GST_TIME_ARGS (timestamp));
402
ret = gst_pad_push (ffmpegaudenc->srcpad, outbuf);
408
gst_ffmpegaudenc_chain_audio (GstPad * pad, GstObject * parent,
411
GstFFMpegAudEnc *ffmpegaudenc;
412
GstFFMpegAudEncClass *oclass;
414
GstClockTime timestamp, duration;
415
gsize size, frame_size;
422
ffmpegaudenc = (GstFFMpegAudEnc *) parent;
423
oclass = (GstFFMpegAudEncClass *) G_OBJECT_GET_CLASS (ffmpegaudenc);
425
if (G_UNLIKELY (!ffmpegaudenc->opened))
428
ctx = ffmpegaudenc->context;
430
size = gst_buffer_get_size (inbuf);
431
timestamp = GST_BUFFER_TIMESTAMP (inbuf);
432
duration = GST_BUFFER_DURATION (inbuf);
433
discont = GST_BUFFER_IS_DISCONT (inbuf);
435
GST_DEBUG_OBJECT (ffmpegaudenc,
436
"Received time %" GST_TIME_FORMAT ", duration %" GST_TIME_FORMAT
437
", size %" G_GSIZE_FORMAT, GST_TIME_ARGS (timestamp),
438
GST_TIME_ARGS (duration), size);
440
frame_size = ctx->frame_size;
441
osize = av_get_bits_per_sample_format (ctx->sample_fmt) / 8;
443
if (frame_size > 1) {
444
/* we have a frame_size, feed the encoder multiples of this frame size */
445
guint avail, frame_bytes;
448
GST_LOG_OBJECT (ffmpegaudenc, "DISCONT, clear adapter");
449
gst_adapter_clear (ffmpegaudenc->adapter);
450
ffmpegaudenc->discont = TRUE;
453
if (gst_adapter_available (ffmpegaudenc->adapter) == 0) {
454
/* lock on to new timestamp */
455
GST_LOG_OBJECT (ffmpegaudenc, "taking buffer timestamp %" GST_TIME_FORMAT,
456
GST_TIME_ARGS (timestamp));
457
ffmpegaudenc->adapter_ts = timestamp;
458
ffmpegaudenc->adapter_consumed = 0;
460
GstClockTime upstream_time;
461
GstClockTime consumed_time;
464
/* use timestamp at head of the adapter */
466
gst_util_uint64_scale (ffmpegaudenc->adapter_consumed, GST_SECOND,
468
timestamp = ffmpegaudenc->adapter_ts + consumed_time;
469
GST_LOG_OBJECT (ffmpegaudenc, "taking adapter timestamp %" GST_TIME_FORMAT
470
" and adding consumed time %" GST_TIME_FORMAT,
471
GST_TIME_ARGS (ffmpegaudenc->adapter_ts),
472
GST_TIME_ARGS (consumed_time));
474
/* check with upstream timestamps, if too much deviation,
475
* forego some timestamp perfection in favour of upstream syncing
476
* (particularly in case these do not happen to come in multiple
479
gst_adapter_prev_timestamp (ffmpegaudenc->adapter, &bytes);
480
if (GST_CLOCK_TIME_IS_VALID (upstream_time)) {
481
GstClockTimeDiff diff;
484
gst_util_uint64_scale (bytes, GST_SECOND,
485
ctx->sample_rate * osize * ctx->channels);
486
diff = upstream_time - timestamp;
487
/* relaxed difference, rather than half a sample or so ... */
488
if (diff > GST_SECOND / 10 || diff < -GST_SECOND / 10) {
489
GST_DEBUG_OBJECT (ffmpegaudenc, "adapter timestamp drifting, "
490
"taking upstream timestamp %" GST_TIME_FORMAT,
491
GST_TIME_ARGS (upstream_time));
492
timestamp = upstream_time;
493
/* samples corresponding to bytes */
494
ffmpegaudenc->adapter_consumed = bytes / (osize * ctx->channels);
495
ffmpegaudenc->adapter_ts = upstream_time -
496
gst_util_uint64_scale (ffmpegaudenc->adapter_consumed, GST_SECOND,
498
ffmpegaudenc->discont = TRUE;
503
GST_LOG_OBJECT (ffmpegaudenc, "pushing buffer in adapter");
504
gst_adapter_push (ffmpegaudenc->adapter, inbuf);
506
/* first see how many bytes we need to feed to the decoder. */
507
frame_bytes = frame_size * osize * ctx->channels;
508
avail = gst_adapter_available (ffmpegaudenc->adapter);
510
GST_LOG_OBJECT (ffmpegaudenc, "frame_bytes %u, avail %u", frame_bytes,
513
/* while there is more than a frame size in the adapter, consume it */
514
while (avail >= frame_bytes) {
515
GST_LOG_OBJECT (ffmpegaudenc, "taking %u bytes from the adapter",
518
/* Note that we take frame_bytes and add frame_size.
519
* Makes sense when resyncing because you don't have to count channels
520
* or samplesize to divide by the samplerate */
522
/* take an audio buffer out of the adapter */
523
in_data = (guint8 *) gst_adapter_map (ffmpegaudenc->adapter, frame_bytes);
524
ffmpegaudenc->adapter_consumed += frame_size;
526
/* calculate timestamp and duration relative to start of adapter and to
527
* the amount of samples we consumed */
529
gst_util_uint64_scale (ffmpegaudenc->adapter_consumed, GST_SECOND,
531
duration -= (timestamp - ffmpegaudenc->adapter_ts);
533
/* 4 times the input size should be big enough... */
534
out_size = frame_bytes * 4;
537
gst_ffmpegaudenc_encode_audio (ffmpegaudenc, in_data, frame_bytes,
538
out_size, timestamp, duration, ffmpegaudenc->discont);
540
gst_adapter_unmap (ffmpegaudenc->adapter);
541
gst_adapter_flush (ffmpegaudenc->adapter, frame_bytes);
543
if (ret != GST_FLOW_OK)
546
/* advance the adapter timestamp with the duration */
547
timestamp += duration;
549
ffmpegaudenc->discont = FALSE;
550
avail = gst_adapter_available (ffmpegaudenc->adapter);
552
GST_LOG_OBJECT (ffmpegaudenc, "%u bytes left in the adapter", avail);
555
/* we have no frame_size, feed the encoder all the data and expect a fixed
557
int coded_bps = av_get_bits_per_sample (oclass->in_plugin->id);
559
GST_LOG_OBJECT (ffmpegaudenc, "coded bps %d, osize %d", coded_bps, osize);
561
out_size = size / osize;
563
out_size = (out_size * coded_bps) / 8;
565
gst_buffer_map (inbuf, &map, GST_MAP_READ);
568
ret = gst_ffmpegaudenc_encode_audio (ffmpegaudenc, in_data, size, out_size,
569
timestamp, duration, discont);
570
gst_buffer_unmap (inbuf, &map);
571
gst_buffer_unref (inbuf);
573
if (ret != GST_FLOW_OK)
582
GST_ELEMENT_ERROR (ffmpegaudenc, CORE, NEGOTIATION, (NULL),
583
("not configured to input format before data start"));
584
gst_buffer_unref (inbuf);
585
return GST_FLOW_NOT_NEGOTIATED;
589
GST_DEBUG_OBJECT (ffmpegaudenc, "Failed to push buffer %d (%s)", ret,
590
gst_flow_get_name (ret));
596
gst_ffmpegaudenc_event_sink (GstPad * pad, GstObject * parent, GstEvent * event)
598
GstFFMpegAudEnc *ffmpegaudenc = (GstFFMpegAudEnc *) parent;
600
switch (GST_EVENT_TYPE (event)) {
606
gst_event_parse_caps (event, &caps);
607
ret = gst_ffmpegaudenc_setcaps (ffmpegaudenc, caps);
608
gst_event_unref (event);
615
return gst_pad_event_default (pad, parent, event);
619
gst_ffmpegaudenc_query_sink (GstPad * pad, GstObject * parent, GstQuery * query)
621
GstFFMpegAudEnc *ffmpegaudenc = (GstFFMpegAudEnc *) parent;
622
gboolean res = FALSE;
624
switch (GST_QUERY_TYPE (query)) {
627
GstCaps *filter, *caps;
629
gst_query_parse_caps (query, &filter);
630
caps = gst_ffmpegaudenc_getcaps (ffmpegaudenc, filter);
631
gst_query_set_caps_result (query, caps);
632
gst_caps_unref (caps);
637
res = gst_pad_query_default (pad, parent, query);
645
gst_ffmpegaudenc_set_property (GObject * object,
646
guint prop_id, const GValue * value, GParamSpec * pspec)
648
GstFFMpegAudEnc *ffmpegaudenc;
650
/* Get a pointer of the right type. */
651
ffmpegaudenc = (GstFFMpegAudEnc *) (object);
653
if (ffmpegaudenc->opened) {
654
GST_WARNING_OBJECT (ffmpegaudenc,
655
"Can't change properties once decoder is setup !");
659
/* Check the argument id to see which argument we're setting. */
662
ffmpegaudenc->bitrate = g_value_get_int (value);
666
case ARG_RTP_PAYLOAD_SIZE:
667
ffmpegaudenc->rtp_payload_size = g_value_get_int (value);
670
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
675
/* The set function is simply the inverse of the get fuction. */
677
gst_ffmpegaudenc_get_property (GObject * object,
678
guint prop_id, GValue * value, GParamSpec * pspec)
680
GstFFMpegAudEnc *ffmpegaudenc;
682
/* It's not null if we got it, but it might not be ours */
683
ffmpegaudenc = (GstFFMpegAudEnc *) (object);
687
g_value_set_int (value, ffmpegaudenc->bitrate);
691
g_value_set_int (value, ffmpegaudenc->buffer_size);
693
case ARG_RTP_PAYLOAD_SIZE:
694
g_value_set_int (value, ffmpegaudenc->rtp_payload_size);
697
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
702
static GstStateChangeReturn
703
gst_ffmpegaudenc_change_state (GstElement * element, GstStateChange transition)
705
GstFFMpegAudEnc *ffmpegaudenc = (GstFFMpegAudEnc *) element;
706
GstStateChangeReturn result;
708
switch (transition) {
713
result = GST_ELEMENT_CLASS (parent_class)->change_state (element, transition);
715
switch (transition) {
716
case GST_STATE_CHANGE_PAUSED_TO_READY:
717
if (ffmpegaudenc->opened) {
718
gst_ffmpeg_avcodec_close (ffmpegaudenc->context);
719
ffmpegaudenc->opened = FALSE;
721
gst_adapter_clear (ffmpegaudenc->adapter);
730
gst_ffmpegaudenc_register (GstPlugin * plugin)
732
GTypeInfo typeinfo = {
733
sizeof (GstFFMpegAudEncClass),
734
(GBaseInitFunc) gst_ffmpegaudenc_base_init,
736
(GClassInitFunc) gst_ffmpegaudenc_class_init,
739
sizeof (GstFFMpegAudEnc),
741
(GInstanceInitFunc) gst_ffmpegaudenc_init,
747
GST_LOG ("Registering encoders");
749
in_plugin = av_codec_next (NULL);
753
/* Skip non-AV codecs */
754
if (in_plugin->type != AVMEDIA_TYPE_AUDIO)
757
/* no quasi codecs, please */
758
if ((in_plugin->id >= CODEC_ID_PCM_S16LE &&
759
in_plugin->id <= CODEC_ID_PCM_BLURAY)) {
763
/* No encoders depending on external libraries (we don't build them, but
764
* people who build against an external ffmpeg might have them.
765
* We have native gstreamer plugins for all of those libraries anyway. */
766
if (!strncmp (in_plugin->name, "lib", 3)) {
768
("Not using external library encoder %s. Use the gstreamer-native ones instead.",
774
if (!in_plugin->encode) {
778
/* FIXME : We should have a method to know cheaply whether we have a mapping
779
* for the given plugin or not */
781
GST_DEBUG ("Trying plugin %s [%s]", in_plugin->name, in_plugin->long_name);
783
/* no codecs for which we're GUARANTEED to have better alternatives */
784
if (!strcmp (in_plugin->name, "vorbis")
785
|| !strcmp (in_plugin->name, "flac")) {
786
GST_LOG ("Ignoring encoder %s", in_plugin->name);
790
/* construct the type */
791
type_name = g_strdup_printf ("avenc_%s", in_plugin->name);
793
type = g_type_from_name (type_name);
797
/* create the glib type now */
798
type = g_type_register_static (GST_TYPE_ELEMENT, type_name, &typeinfo, 0);
799
g_type_set_qdata (type, GST_FFENC_PARAMS_QDATA, (gpointer) in_plugin);
802
static const GInterfaceInfo preset_info = {
807
g_type_add_interface_static (type, GST_TYPE_PRESET, &preset_info);
811
if (!gst_element_register (plugin, type_name, GST_RANK_SECONDARY, type)) {
819
in_plugin = av_codec_next (in_plugin);
822
GST_LOG ("Finished registering encoders");
added
removed
ext/libav/gstavenc.c
