2 * GStreamer codec plugin for Tizen Emulator.
4 * Copyright (C) 2013 Samsung Electronics Co., Ltd. All rights reserved.
7 * KiTae Kim <kt920.kim@samsung.com>
8 * SeokYeon Hwang <syeon.hwang@samsung.com>
9 * YeongKyoon Lee <yeongkyoon.lee@samsung.com>
11 * This library is free software; you can redistribute it and/or
12 * modify it under the terms of the GNU Library General Public
13 * License as published by the Free Software Foundation; either
14 * version 2 of the License, or (at your option) any later version.
16 * This library is distributed in the hope that it will be useful,
17 * but WITHOUT ANY WARRANTY; without even the implied warranty of
18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
19 * Library General Public License for more details.
21 * You should have received a copy of the GNU Library General Public
22 * License along with this library; if not, write to the
23 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
24 * Boston, MA 02111-1307, USA.
31 #include "gstmaruutils.h"
32 #include <gst/audio/multichannel.h>
33 #include <gst/pbutils/codec-utils.h>
36 gst_maru_smpfmt_depth (int smp_fmt)
55 GST_ERROR ("Unhandled sample format !");
66 GstAudioChannelPosition gst;
67 } _ff_to_gst_layout[] = {
69 CH_FRONT_LEFT, GST_AUDIO_CHANNEL_POSITION_FRONT_LEFT}, {
70 CH_FRONT_RIGHT, GST_AUDIO_CHANNEL_POSITION_FRONT_RIGHT}, {
71 CH_FRONT_CENTER, GST_AUDIO_CHANNEL_POSITION_FRONT_CENTER}, {
72 CH_LOW_FREQUENCY, GST_AUDIO_CHANNEL_POSITION_LFE}, {
73 CH_BACK_LEFT, GST_AUDIO_CHANNEL_POSITION_REAR_LEFT}, {
74 CH_BACK_RIGHT, GST_AUDIO_CHANNEL_POSITION_REAR_RIGHT}, {
75 CH_FRONT_LEFT_OF_CENTER, GST_AUDIO_CHANNEL_POSITION_FRONT_LEFT_OF_CENTER}, {
76 CH_FRONT_RIGHT_OF_CENTER, GST_AUDIO_CHANNEL_POSITION_FRONT_RIGHT_OF_CENTER}, {
77 CH_BACK_CENTER, GST_AUDIO_CHANNEL_POSITION_REAR_CENTER}, {
78 CH_SIDE_LEFT, GST_AUDIO_CHANNEL_POSITION_SIDE_LEFT}, {
79 CH_SIDE_RIGHT, GST_AUDIO_CHANNEL_POSITION_SIDE_RIGHT}, {
80 CH_TOP_CENTER, GST_AUDIO_CHANNEL_POSITION_NONE}, {
81 CH_TOP_FRONT_LEFT, GST_AUDIO_CHANNEL_POSITION_NONE}, {
82 CH_TOP_FRONT_CENTER, GST_AUDIO_CHANNEL_POSITION_NONE}, {
83 CH_TOP_FRONT_RIGHT, GST_AUDIO_CHANNEL_POSITION_NONE}, {
84 CH_TOP_BACK_LEFT, GST_AUDIO_CHANNEL_POSITION_NONE}, {
85 CH_TOP_BACK_CENTER, GST_AUDIO_CHANNEL_POSITION_NONE}, {
86 CH_TOP_BACK_RIGHT, GST_AUDIO_CHANNEL_POSITION_NONE}, {
87 CH_STEREO_LEFT, GST_AUDIO_CHANNEL_POSITION_FRONT_LEFT}, {
88 CH_STEREO_RIGHT, GST_AUDIO_CHANNEL_POSITION_FRONT_RIGHT}
91 static GstAudioChannelPosition *
92 gst_ff_channel_layout_to_gst (guint64 channel_layout, guint channels)
94 guint nchannels = 0, i, j;
95 GstAudioChannelPosition *pos = NULL;
96 gboolean none_layout = FALSE;
98 for (i = 0; i < 64; i++) {
99 if ((channel_layout & (G_GUINT64_CONSTANT (1) << i)) != 0) {
104 if (channel_layout == 0) {
105 nchannels = channels;
109 if (nchannels != channels) {
110 GST_ERROR ("Number of channels is different (%u != %u)", channels,
115 pos = g_new (GstAudioChannelPosition, nchannels);
117 for (i = 0, j = 0; i < G_N_ELEMENTS (_ff_to_gst_layout); i++) {
118 if ((channel_layout & _ff_to_gst_layout[i].ff) != 0) {
119 pos[j++] = _ff_to_gst_layout[i].gst;
121 if (_ff_to_gst_layout[i].gst == GST_AUDIO_CHANNEL_POSITION_NONE) {
127 if (j != nchannels) {
128 GST_WARNING ("Unknown channels in channel layout - assuming NONE layout");
132 if (!none_layout && !gst_audio_check_channel_positions (pos, nchannels)) {
133 GST_ERROR ("Invalid channel layout %" G_GUINT64_FORMAT
134 " - assuming NONE layout", channel_layout);
139 if (nchannels == 1) {
140 pos[0] = GST_AUDIO_CHANNEL_POSITION_FRONT_MONO;
141 } else if (nchannels == 2) {
142 pos[0] = GST_AUDIO_CHANNEL_POSITION_FRONT_LEFT;
143 pos[1] = GST_AUDIO_CHANNEL_POSITION_FRONT_RIGHT;
144 } else if (channel_layout == 0) {
148 for (i = 0; i < nchannels; i++) {
149 pos[i] = GST_AUDIO_CHANNEL_POSITION_NONE;
154 if (nchannels == 1 && pos[0] == GST_AUDIO_CHANNEL_POSITION_FRONT_CENTER) {
155 GST_DEBUG ("mono common case; won't set channel positions");
158 } else if (nchannels == 2 && pos[0] == GST_AUDIO_CHANNEL_POSITION_FRONT_LEFT
159 && pos[1] == GST_AUDIO_CHANNEL_POSITION_FRONT_RIGHT) {
160 GST_DEBUG ("stereo common case; won't set channel positions");
169 gst_maru_codectype_to_video_caps (CodecContext *ctx, const char *name,
170 gboolean encode, CodecElement *codec)
174 GST_DEBUG ("context: %p, codec: %s, encode: %d, pixel format: %d",
175 ctx, name, encode, ctx->video.pix_fmt);
178 caps = gst_maru_pixfmt_to_caps (ctx->video.pix_fmt, ctx, name);
184 caps = gst_caps_new_empty ();
185 for (i = 0; i <= PIX_FMT_NB; i++) {
186 temp = gst_maru_pixfmt_to_caps (i, encode ? &ctx : NULL, name);
188 gst_caps_append (caps, temp);
197 gst_maru_codectype_to_audio_caps (CodecContext *ctx, const char *name,
198 gboolean encode, CodecElement *codec)
200 GstCaps *caps = NULL;
202 GST_DEBUG ("context: %p, codec: %s, encode: %d, codec: %p",
203 ctx, name, encode, codec);
206 caps = gst_maru_smpfmt_to_caps (ctx->audio.sample_fmt, ctx, name);
207 } else if (codec && codec->sample_fmts[0] != -1){
211 caps = gst_caps_new_empty ();
212 for (i = 0; codec->sample_fmts[i] != -1; i++) {
214 gst_maru_smpfmt_to_caps (codec->sample_fmts[i], ctx, name);
216 gst_caps_append (caps, temp);
222 CodecContext ctx = {{0}, {0}, 0};
224 ctx.audio.channels = -1;
225 caps = gst_caps_new_empty ();
226 for (i = 0; i <= SAMPLE_FMT_DBL; i++) {
227 temp = gst_maru_smpfmt_to_caps (i, encode ? &ctx : NULL, name);
229 gst_caps_append (caps, temp);
238 gst_maru_codectype_to_caps (int media_type, CodecContext *ctx,
239 const char *name, gboolean encode)
243 switch (media_type) {
244 case AVMEDIA_TYPE_VIDEO:
246 gst_maru_codectype_to_video_caps (ctx, name, encode, NULL);
248 case AVMEDIA_TYPE_AUDIO:
250 gst_maru_codectype_to_audio_caps (ctx, name, encode, NULL);
261 gst_maru_caps_to_pixfmt (const GstCaps *caps, CodecContext *ctx, gboolean raw)
265 const GValue *par = NULL;
267 GST_DEBUG ("converting caps %" GST_PTR_FORMAT, caps);
268 g_return_if_fail (gst_caps_get_size (caps) == 1);
269 str = gst_caps_get_structure (caps, 0);
271 gst_structure_get_int (str, "width", &ctx->video.width);
272 gst_structure_get_int (str, "height", &ctx->video.height);
273 gst_structure_get_int (str, "bpp", &ctx->video.bpp);
275 fps = gst_structure_get_value (str, "framerate");
276 if (fps != NULL && GST_VALUE_HOLDS_FRACTION (fps)) {
277 ctx->video.fps_d = gst_value_get_fraction_numerator (fps);
278 ctx->video.fps_n = gst_value_get_fraction_denominator (fps);
279 ctx->video.ticks_per_frame = 1;
281 GST_DEBUG ("setting framerate %d/%d = %lf",
282 ctx->video.fps_d, ctx->video.fps_n,
283 1. * ctx->video.fps_d / ctx->video.fps_n);
286 par = gst_structure_get_value (str, "pixel-aspect-ratio");
287 if (par && GST_VALUE_HOLDS_FRACTION (par)) {
288 ctx->video.par_n = gst_value_get_fraction_numerator (par);
289 ctx->video.par_d = gst_value_get_fraction_denominator (par);
296 g_return_if_fail (fps != NULL && GST_VALUE_HOLDS_FRACTION (fps));
298 if (strcmp (gst_structure_get_name (str), "video/x-raw-yuv") == 0) {
301 if (gst_structure_get_fourcc (str, "format", &fourcc)) {
303 case GST_MAKE_FOURCC ('Y', 'U', 'Y', '2'):
304 ctx->video.pix_fmt = PIX_FMT_YUYV422;
306 case GST_MAKE_FOURCC ('I', '4', '2', '0'):
307 ctx->video.pix_fmt = PIX_FMT_YUV420P;
309 case GST_MAKE_FOURCC ('A', '4', '2', '0'):
310 ctx->video.pix_fmt = PIX_FMT_YUVA420P;
312 case GST_MAKE_FOURCC ('Y', '4', '1', 'B'):
313 ctx->video.pix_fmt = PIX_FMT_YUV411P;
315 case GST_MAKE_FOURCC ('Y', '4', '2', 'B'):
316 ctx->video.pix_fmt = PIX_FMT_YUV422P;
318 case GST_MAKE_FOURCC ('Y', 'U', 'V', '9'):
319 ctx->video.pix_fmt = PIX_FMT_YUV410P;
323 // printf ("get pixel format: %d, fourcc: %d\n", ctx->video.pix_fmt, fourcc);
324 } else if (strcmp (gst_structure_get_name (str), "video/x-raw-rgb") == 0) {
325 gint bpp = 0, rmask = 0, endianness = 0;
327 if (gst_structure_get_int (str, "bpp", &bpp) &&
328 gst_structure_get_int (str, "endianness", &endianness)) {
329 if (gst_structure_get_int (str, "red_mask", &rmask)) {
332 #if (G_BYTE_ORDER == G_BIG_ENDIAN)
333 if (rmask == 0x00ff0000) {
335 if (rmask == 0x00ff0000) {
337 ctx->video.pix_fmt = PIX_FMT_RGB32;
341 if (rmask == 0x0000FF) {
342 ctx->video.pix_fmt = PIX_FMT_BGR24;
344 ctx->video.pix_fmt = PIX_FMT_RGB24;
348 if (endianness == G_BYTE_ORDER) {
349 ctx->video.pix_fmt = PIX_FMT_RGB565;
353 if (endianness == G_BYTE_ORDER) {
354 ctx->video.pix_fmt = PIX_FMT_RGB555;
363 ctx->video.pix_fmt = PIX_FMT_PAL8;
367 } else if (strcmp (gst_structure_get_name (str), "video/x-raw-gray") == 0) {
370 if (gst_structure_get_int (str, "bpp", &bpp)) {
373 ctx->video.pix_fmt = PIX_FMT_GRAY8;
381 gst_maru_caps_to_smpfmt (const GstCaps *caps, CodecContext *ctx, gboolean raw)
384 gint depth = 0, width = 0, endianness = 0;
385 gboolean signedness = FALSE;
388 g_return_if_fail (gst_caps_get_size (caps) == 1);
389 str = gst_caps_get_structure (caps, 0);
391 gst_structure_get_int (str, "channels", &ctx->audio.channels);
392 gst_structure_get_int (str, "rate", &ctx->audio.sample_rate);
393 gst_structure_get_int (str, "block_align", &ctx->audio.block_align);
394 // gst_structure_get_int (str, "bitrate", &ctx->audio.bit_rate);
395 gst_structure_get_int (str, "bitrate", &ctx->bit_rate);
401 name = gst_structure_get_name (str);
403 if (!strcmp (name, "audio/x-raw-float")) {
404 if (gst_structure_get_int (str, "width", &width) &&
405 gst_structure_get_int (str, "endianness", &endianness)) {
406 if (endianness == G_BYTE_ORDER) {
408 ctx->audio.sample_fmt = SAMPLE_FMT_FLT;
409 } else if (width == 64) {
410 ctx->audio.sample_fmt = SAMPLE_FMT_DBL;
415 if (gst_structure_get_int (str, "width", &width) &&
416 gst_structure_get_int (str, "depth", &depth) &&
417 gst_structure_get_boolean (str, "signed", &signedness) &&
418 gst_structure_get_int (str, "endianness", &endianness)) {
419 if ((endianness == G_BYTE_ORDER) && (signedness == TRUE)) {
420 if ((width == 16) && (depth == 16)) {
421 ctx->audio.sample_fmt = SAMPLE_FMT_S16;
422 } else if ((width == 32) && (depth == 32)) {
423 ctx->audio.sample_fmt = SAMPLE_FMT_S32;
431 gst_maru_caps_with_codecname (const char *name, int media_type,
432 const GstCaps *caps, CodecContext *ctx)
434 GstStructure *structure;
436 const GstBuffer *buf;
438 if (!ctx || !gst_caps_get_size (caps)) {
442 structure = gst_caps_get_structure (caps, 0);
444 if ((value = gst_structure_get_value (structure, "codec_data"))) {
448 buf = GST_BUFFER_CAST (gst_value_get_mini_object (value));
449 size = GST_BUFFER_SIZE (buf);
450 data = GST_BUFFER_DATA (buf);
451 GST_DEBUG ("extradata: %p, size: %d\n", data, size);
453 if (ctx->codecdata) {
454 g_free (ctx->codecdata);
458 g_malloc0 (GST_ROUND_UP_16 (size + FF_INPUT_BUFFER_PADDING_SIZE));
459 memcpy (ctx->codecdata, data, size);
460 ctx->codecdata_size = size;
462 if ((strcmp (name, "vc1") == 0) && size > 0 && data[0] == 0) {
463 ctx->codecdata[0] = (guint8) size;
465 } else if (ctx->codecdata == NULL) {
466 ctx->codecdata_size = 0;
467 ctx->codecdata = g_malloc0 (GST_ROUND_UP_16(FF_INPUT_BUFFER_PADDING_SIZE));
468 GST_DEBUG ("no extra data.\n");
471 if ((strcmp (name, "mpeg4") == 0)) {
472 const gchar *mime = gst_structure_get_name (structure);
474 if (!strcmp (mime, "video/x-divx")) {
475 ctx->codec_tag = GST_MAKE_FOURCC ('D', 'I', 'V', 'X');
476 } else if (!strcmp (mime, "video/x-xvid")) {
477 ctx->codec_tag = GST_MAKE_FOURCC ('X', 'V', 'I', 'D');
478 } else if (!strcmp (mime, "video/x-3ivx")) {
479 ctx->codec_tag = GST_MAKE_FOURCC ('3', 'I', 'V', '1');
480 } else if (!strcmp (mime, "video/mpeg")) {
481 ctx->codec_tag = GST_MAKE_FOURCC ('m', 'p', '4', 'v');
484 } else if (strcmp (name, "h263p") == 0) {
487 if (!gst_structure_get_boolean (structure, "annex-f", &val) || val) {
488 ctx->flags |= CODEC_FLAG_4MV;
490 ctx->flags &= ~CODEC_FLAG_4MV;
492 if ((!gst_structure_get_boolean (structure, "annex-i", &val) || val) &&
493 (!gst_structure_get_boolean (structure, "annex-t", &val) || val)) {
494 ctx->flags |= CODEC_FLAG_AC_PRED;
496 ctx->flags &= ~CODEC_FLAG_AC_PRED;
498 if ((!gst_structure_get_boolean (structure, "annex-j", &val) || val)) {
499 ctx->flags |= CODEC_FLAG_LOOP_FILTER;
501 ctx->flags &= ~CODEC_FLAG_LOOP_FILTER;
508 if (!gst_caps_is_fixed (caps)) {
512 switch (media_type) {
513 case AVMEDIA_TYPE_VIDEO:
514 gst_maru_caps_to_pixfmt (caps, ctx, FALSE);
517 case AVMEDIA_TYPE_AUDIO:
518 gst_maru_caps_to_smpfmt (caps, ctx, FALSE);
526 gst_maru_caps_to_codecname (const GstCaps *caps,
528 CodecContext *context)
530 const gchar *mimetype;
531 const GstStructure *str;
533 str = gst_caps_get_structure (caps, 0);
535 mimetype = gst_structure_get_name (str);
537 if (!strcmp (mimetype, "video/x-wmv")) {
540 if (gst_structure_get_int (str, "wmvversion", &wmvversion)) {
541 switch (wmvversion) {
543 g_strlcpy(codec_name, "wmv1", 32);
546 g_strlcpy(codec_name, "wmv2", 32);
552 g_strlcpy(codec_name, "wmv3", 32);
554 if (gst_structure_get_fourcc (str, "format", &fourcc)) {
555 if ((fourcc == GST_MAKE_FOURCC ('W', 'V', 'C', '1')) ||
556 (fourcc == GST_MAKE_FOURCC ('W', 'M', 'V', 'A'))) {
557 g_strlcpy(codec_name, "vc1", 32);
567 if (context != NULL) {
569 context->codec_type = CODEC_TYPE_VIDEO;
570 } else if (audio == TRUE) {
571 context->codec_type = CODEC_TYPE_AUDIO;
573 context->codec_type = CODEC_TYPE_UNKNOWN;
575 context->codec_id = id;
576 gst_maru_caps_with_codecname (name, context->codec_type, caps, context);
580 if (codec_name != NULL) {
581 GST_DEBUG ("The %s belongs to the caps %" GST_PTR_FORMAT, codec_name, caps);
583 GST_WARNING ("Couldn't figure out the name for caps %" GST_PTR_FORMAT, caps);
588 gst_maru_caps_with_codectype (int media_type, const GstCaps *caps, CodecContext *ctx)
594 switch (media_type) {
595 case AVMEDIA_TYPE_VIDEO:
596 gst_maru_caps_to_pixfmt (caps, ctx, TRUE);
598 case AVMEDIA_TYPE_AUDIO:
599 gst_maru_caps_to_smpfmt (caps, ctx, TRUE);
607 gst_maru_video_caps_new (CodecContext *ctx, const char *name,
608 const char *mimetype, const char *fieldname, ...)
610 GstStructure *structure = NULL;
611 GstCaps *caps = NULL;
615 GST_LOG ("context: %p, name: %s, mimetype: %s", ctx, name, mimetype);
617 if (ctx != NULL && ctx->video.width != -1) {
620 caps = gst_caps_new_simple (mimetype,
621 "width", G_TYPE_INT, ctx->video.width,
622 "height", G_TYPE_INT, ctx->video.height, NULL);
624 num = ctx->video.fps_d / ctx->video.ticks_per_frame;
625 denom = ctx->video.fps_n;
628 GST_LOG ("invalid framerate: %d/0, -> %d/1", num, num);
630 if (gst_util_fraction_compare (num, denom, 1000, 1) > 0) {
631 GST_LOG ("excessive framerate: %d/%d, -> 0/1", num, denom);
635 GST_LOG ("setting framerate: %d/%d", num, denom);
636 gst_caps_set_simple (caps,
637 "framerate", GST_TYPE_FRACTION, num, denom, NULL);
639 if (strcmp (name, "h263") == 0) {
640 /* 128x96, 176x144, 352x288, 704x576, and 1408x1152. slightly reordered
641 * because we want automatic negotiation to go as close to 320x240 as
643 const static gint widths[] = { 352, 704, 176, 1408, 128 };
644 const static gint heights[] = { 288, 576, 144, 1152, 96 };
646 gint n_sizes = G_N_ELEMENTS (widths);
648 caps = gst_caps_new_empty ();
649 for (i = 0; i < n_sizes; i++) {
650 temp = gst_caps_new_simple (mimetype,
651 "width", G_TYPE_INT, widths[i],
652 "height", G_TYPE_INT, heights[i],
653 "framerate", GST_TYPE_FRACTION_RANGE, 0, 1, G_MAXINT, 1, NULL);
655 gst_caps_append (caps, temp);
657 } else if (strcmp (name, "none") == 0) {
658 GST_LOG ("default caps");
662 /* no fixed caps or special restrictions applied;
663 * default unfixed setting */
665 GST_DEBUG ("Creating default caps");
666 caps = gst_caps_new_simple (mimetype,
667 "width", GST_TYPE_INT_RANGE, 16, 4096,
668 "height", GST_TYPE_INT_RANGE, 16, 4096,
669 "framerate", GST_TYPE_FRACTION_RANGE, 0, 1, G_MAXINT, 1, NULL);
672 for (i = 0; i < gst_caps_get_size (caps); i++) {
673 va_start (var_args, fieldname);
674 structure = gst_caps_get_structure (caps, i);
675 gst_structure_set_valist (structure, fieldname, var_args);
683 gst_maru_audio_caps_new (CodecContext *ctx, const char *name,
684 const char *mimetype, const char *fieldname, ...)
686 GstStructure *structure = NULL;
687 GstCaps *caps = NULL;
691 if (ctx != NULL && ctx->audio.channels != -1) {
692 GstAudioChannelPosition *pos;
693 guint64 channel_layout = ctx->audio.channel_layout;
695 if (channel_layout == 0) {
696 const guint64 default_channel_set[] = {
697 0, 0, CH_LAYOUT_SURROUND, CH_LAYOUT_QUAD, CH_LAYOUT_5POINT0,
698 CH_LAYOUT_5POINT1, 0, CH_LAYOUT_7POINT1
701 if (strcmp (name, "ac3") == 0) {
702 if (ctx->audio.channels > 0 &&
703 ctx->audio.channels < G_N_ELEMENTS (default_channel_set)) {
704 channel_layout = default_channel_set[ctx->audio.channels - 1];
711 caps = gst_caps_new_simple (mimetype,
712 "rate", G_TYPE_INT, ctx->audio.sample_rate,
713 "channels", G_TYPE_INT, ctx->audio.channels, NULL);
715 pos = gst_ff_channel_layout_to_gst (channel_layout, ctx->audio.channels);
717 gst_audio_set_channel_positions (gst_caps_get_structure (caps, 0), pos);
721 gint maxchannels = 2;
722 const gint *rates = NULL;
725 if (strcmp (name, "aac") == 0) {
727 } else if (g_str_has_prefix(name, "ac3")) {
728 const static gint l_rates[] = { 48000, 44100, 32000 };
730 n_rates = G_N_ELEMENTS (l_rates);
736 if (maxchannels == 1) {
737 caps = gst_caps_new_simple(mimetype,
738 "channels", G_TYPE_INT, maxchannels, NULL);
740 caps = gst_caps_new_simple(mimetype,
741 "channels", GST_TYPE_INT_RANGE, 1, maxchannels, NULL);
745 GValue list = { 0, };
746 GstStructure *structure;
748 g_value_init(&list, GST_TYPE_LIST);
749 for (i = 0; i < n_rates; i++) {
752 g_value_init(&v, G_TYPE_INT);
753 g_value_set_int(&v, rates[i]);
754 gst_value_list_append_value(&list, &v);
757 structure = gst_caps_get_structure(caps, 0);
758 gst_structure_set_value(structure, "rate", &list);
759 g_value_unset(&list);
761 gst_caps_set_simple(caps, "rate", GST_TYPE_INT_RANGE, 4000, 96000, NULL);
765 for (i = 0; i < gst_caps_get_size (caps); i++) {
766 va_start (var_args, fieldname);
767 structure = gst_caps_get_structure (caps, i);
768 gst_structure_set_valist (structure, fieldname, var_args);
776 gst_maru_pixfmt_to_caps (enum PixelFormat pix_fmt, CodecContext *ctx, const char *name)
778 GstCaps *caps = NULL;
780 int bpp = 0, depth = 0, endianness = 0;
781 gulong g_mask = 0, r_mask = 0, b_mask = 0, a_mask = 0;
785 case PIX_FMT_YUV420P:
786 fmt = GST_MAKE_FOURCC ('I', '4', '2', '0');
788 case PIX_FMT_YUYV422:
789 fmt = GST_MAKE_FOURCC ('A', '4', '2', '0');
793 endianness = G_BIG_ENDIAN;
800 endianness = G_BIG_ENDIAN;
805 case PIX_FMT_YUV422P:
806 fmt = GST_MAKE_FOURCC ('Y', '4', '2', 'B');
808 case PIX_FMT_YUV444P:
809 fmt = GST_MAKE_FOURCC ('Y', '4', '4', '4');
814 endianness = G_BIG_ENDIAN;
815 #if (G_BYTE_ORDER == G_BIG_ENDIAN)
827 case PIX_FMT_YUV410P:
828 fmt = GST_MAKE_FOURCC ('Y', 'U', 'V', '9');
830 case PIX_FMT_YUV411P:
831 fmt = GST_MAKE_FOURCC ('Y', '4', '1', 'b');
835 endianness = G_BYTE_ORDER;
843 endianness = G_BYTE_ORDER;
856 caps = gst_maru_video_caps_new (ctx, name, "video/x-raw-rgb",
857 "bpp", G_TYPE_INT, bpp,
858 "depth", G_TYPE_INT, depth,
859 "red_mask", G_TYPE_INT, r_mask,
860 "green_mask", G_TYPE_INT, g_mask,
861 "blue_mask", G_TYPE_INT, b_mask,
862 "alpha_mask", G_TYPE_INT, a_mask,
863 "endianness", G_TYPE_INT, endianness, NULL);
865 caps = gst_maru_video_caps_new (ctx, name, "video/x-raw-rgb",
866 "bpp", G_TYPE_INT, bpp,
867 "depth", G_TYPE_INT, depth,
868 "red_mask", G_TYPE_INT, r_mask,
869 "green_mask", G_TYPE_INT, g_mask,
870 "blue_mask", G_TYPE_INT, b_mask,
871 "alpha_mask", G_TYPE_INT, a_mask,
872 "endianness", G_TYPE_INT, endianness, NULL);
875 caps = gst_maru_video_caps_new (ctx, name, "video/x-raw-rgb",
876 "bpp", G_TYPE_INT, bpp,
877 "depth", G_TYPE_INT, depth,
878 "endianness", G_TYPE_INT, endianness, NULL);
884 caps = gst_maru_video_caps_new (ctx, name, "video/x-raw-yuv",
885 "format", GST_TYPE_FOURCC, fmt, NULL);
890 GST_DEBUG ("caps for pix_fmt=%d: %", GST_PTR_FORMAT, pix_fmt, caps);
892 GST_LOG ("No caps found for pix_fmt=%d", pix_fmt);
899 gst_maru_smpfmt_to_caps (int8_t sample_fmt, CodecContext *ctx, const char *name)
901 GstCaps *caps = NULL;
904 gboolean integer = TRUE;
905 gboolean signedness = FALSE;
907 switch (sample_fmt) {
930 caps = gst_maru_audio_caps_new (ctx, name, "audio/x-raw-int",
931 "signed", G_TYPE_BOOLEAN, signedness,
932 "endianness", G_TYPE_INT, G_BYTE_ORDER,
933 "width", G_TYPE_INT, bpp, "depth", G_TYPE_INT, bpp, NULL);
935 caps = gst_maru_audio_caps_new (ctx, name, "audio/x-raw-float",
936 "endianness", G_TYPE_INT, G_BYTE_ORDER,
937 "width", G_TYPE_INT, bpp, NULL);
942 GST_LOG ("caps for sample_fmt=%d: %" GST_PTR_FORMAT, sample_fmt, caps);
944 GST_LOG ("No caps found for sample_fmt=%d", sample_fmt);
951 gst_maru_codecname_to_caps (const char *name, CodecContext *ctx, gboolean encode)
953 GstCaps *caps = NULL;
955 GST_LOG ("codec: %s, context: %p, encode: %d", name, ctx, encode);
957 if (strcmp (name, "mpegvideo") == 0) {
958 caps = gst_maru_video_caps_new (ctx, name, "video/mpeg",
959 "mpegversion", G_TYPE_INT, 1,
960 "systemstream", G_TYPE_BOOLEAN, FALSE, NULL);
961 } else if (strcmp (name, "h263") == 0) {
963 caps = gst_maru_video_caps_new (ctx, name, "video/x-h263",
964 "variant", G_TYPE_STRING, "itu", NULL);
966 caps = gst_maru_video_caps_new (ctx, "none", "video/x-h263",
967 "variant", G_TYPE_STRING, "itu", NULL);
969 } else if (strcmp (name, "h263p") == 0) {
970 caps = gst_maru_video_caps_new (ctx, name, "video/x-h263",
971 "variant", G_TYPE_STRING, "itu",
972 "h263version", G_TYPE_STRING, "h263p", NULL);
975 gst_caps_set_simple (caps,
976 "annex-f", G_TYPE_BOOLEAN, ctx->flags & CODEC_FLAG_4MV,
977 "annex-j", G_TYPE_BOOLEAN, ctx->flags & CODEC_FLAG_LOOP_FILTER,
978 "annex-i", G_TYPE_BOOLEAN, ctx->flags & CODEC_FLAG_AC_PRED,
979 "annex-t", G_TYPE_BOOLEAN, ctx->flags & CODEC_FLAG_AC_PRED,
983 } else if (strcmp (name, "mpeg4") == 0) {
984 if (encode && ctx != NULL) {
986 switch (ctx->codec_tag) {
987 case GST_MAKE_FOURCC ('D', 'I', 'V', 'X'):
988 caps = gst_maru_video_caps_new (ctx, name, "video/x-divx",
989 "divxversion", G_TYPE_INT, 5, NULL);
991 case GST_MAKE_FOURCC ('m', 'p', '4', 'v'):
993 caps = gst_maru_video_caps_new (ctx, name, "video/mpeg",
994 "systemstream", G_TYPE_BOOLEAN, FALSE,
995 "mpegversion", G_TYPE_INT, 4, NULL);
999 caps = gst_maru_video_caps_new (ctx, name, "video/mpeg",
1000 "mpegversion", G_TYPE_INT, 4,
1001 "systemstream", G_TYPE_BOOLEAN, FALSE, NULL);
1003 caps = gst_maru_video_caps_new (ctx, name, "video/mpeg",
1004 "mpegversion", G_TYPE_INT, 4,
1005 "systemstream", G_TYPE_BOOLEAN, FALSE, NULL);
1007 gst_caps_append (caps, gst_maru_video_caps_new (ctx, name,
1008 "video/x-divx", "divxversion", GST_TYPE_INT_RANGE, 4, 5, NULL));
1009 gst_caps_append (caps, gst_maru_video_caps_new (ctx, name,
1010 "video/x-xvid", NULL));
1011 gst_caps_append (caps, gst_maru_video_caps_new (ctx, name,
1012 "video/x-3ivx", NULL));
1015 } else if (strcmp (name, "h264") == 0) {
1016 caps = gst_maru_video_caps_new (ctx, name, "video/x-h264", NULL);
1017 } else if (g_str_has_prefix(name, "msmpeg4")) {
1018 // msmpeg4v1,m msmpeg4v2, msmpeg4
1021 if (strcmp (name, "msmpeg4v1") == 0) {
1023 } else if (strcmp (name, "msmpeg4v2") == 0) {
1029 caps = gst_maru_video_caps_new (ctx, name, "video/x-msmpeg",
1030 "msmpegversion", G_TYPE_INT, version, NULL);
1031 if (!encode && !strcmp (name, "msmpeg4")) {
1032 gst_caps_append (caps, gst_maru_video_caps_new (ctx, name,
1033 "video/x-divx", "divxversion", G_TYPE_INT, 3, NULL));
1035 } else if (strcmp (name, "wmv3") == 0) {
1036 caps = gst_maru_video_caps_new (ctx, name, "video/x-wmv",
1037 "wmvversion", G_TYPE_INT, 3, NULL);
1038 } else if (strcmp (name, "vc1") == 0) {
1039 caps = gst_maru_video_caps_new (ctx, name, "video/x-wmv",
1040 "wmvversion", G_TYPE_INT, 3, "format", GST_TYPE_FOURCC,
1041 GST_MAKE_FOURCC ('W', 'V', 'C', '1'), NULL);
1043 } else if (strcmp (name, "vp3") == 0) {
1044 mime_type = g_strdup ("video/x-vp3");
1045 } else if (strcmp (name, "vp8") == 0) {
1046 mime_type = g_strdup ("video/x-vp8");
1048 } else if (strcmp (name, "aac") == 0) {
1049 caps = gst_maru_audio_caps_new (ctx, name, "audio/mpeg", NULL);
1051 GValue arr = { 0, };
1052 GValue item = { 0, };
1054 g_value_init (&arr, GST_TYPE_LIST);
1055 g_value_init (&item, G_TYPE_INT);
1056 g_value_set_int (&item, 2);
1057 gst_value_list_append_value (&arr, &item);
1058 g_value_set_int (&item, 4);
1059 gst_value_list_append_value (&arr, &item);
1060 g_value_unset (&item);
1062 gst_caps_set_value (caps, "mpegversion", &arr);
1063 g_value_unset (&arr);
1065 g_value_init (&arr, GST_TYPE_LIST);
1066 g_value_init (&item, G_TYPE_STRING);
1067 g_value_set_string (&item, "raw");
1068 gst_value_list_append_value (&arr, &item);
1069 g_value_set_string (&item, "adts");
1070 gst_value_list_append_value (&arr, &item);
1071 g_value_set_string (&item, "adif");
1072 gst_value_list_append_value (&arr, &item);
1073 g_value_unset (&item);
1075 gst_caps_set_value (caps, "stream-format", &arr);
1076 g_value_unset (&arr);
1078 gst_caps_set_simple (caps, "mpegversion", G_TYPE_INT, 4,
1079 "stream-format", G_TYPE_STRING, "raw",
1080 "base-profile", G_TYPE_STRING, "lc", NULL);
1082 if (ctx && ctx->codecdata_size > 0) {
1083 gst_codec_utils_aac_caps_set_level_and_profile (caps,
1084 ctx->codecdata, ctx->codecdata_size);
1087 } else if (strcmp (name, "ac3") == 0) {
1088 caps = gst_maru_audio_caps_new (ctx, name, "audio/x-ac3", NULL);
1089 } else if (strcmp (name, "mp3") == 0) {
1091 caps = gst_maru_audio_caps_new (ctx, name, "audio/mpeg",
1092 "mpegversion", G_TYPE_INT, 1,
1093 "layer", GST_TYPE_INT_RANGE, 1, 3, NULL);
1095 caps = gst_caps_new_simple("audio/mpeg",
1096 "mpegversion", G_TYPE_INT, 1,
1097 "layer", GST_TYPE_INT_RANGE, 1, 3, NULL);
1099 } else if (strcmp (name, "mp3adu") == 0) {
1102 mime_type = g_strdup_printf ("audio/x-gst_ff-%s", name);
1103 caps = gst_maru_audio_caps_new (ctx, name, mime_type, NULL);
1108 } else if (g_str_has_prefix(name, "wmav")) {
1110 if (strcmp (name, "wmav2") == 0) {
1113 caps = gst_maru_audio_caps_new (ctx, name, "audio/x-wma", "wmaversion",
1114 G_TYPE_INT, version, "block_align", GST_TYPE_INT_RANGE, 0, G_MAXINT,
1115 "bitrate", GST_TYPE_INT_RANGE, 0, G_MAXINT, NULL);
1117 GST_ERROR("failed to new caps for %s.\n", name);
1123 typedef struct PixFmtInfo
1125 uint8_t x_chroma_shift; /* X chroma subsampling factor is 2 ^ shift */
1126 uint8_t y_chroma_shift; /* Y chroma subsampling factor is 2 ^ shift */
1129 static PixFmtInfo pix_fmt_info[PIX_FMT_NB];
1132 gst_maru_init_pix_fmt_info (void)
1134 pix_fmt_info[PIX_FMT_YUV420P].x_chroma_shift = 1,
1135 pix_fmt_info[PIX_FMT_YUV420P].y_chroma_shift = 1;
1137 pix_fmt_info[PIX_FMT_YUV422P].x_chroma_shift = 1;
1138 pix_fmt_info[PIX_FMT_YUV422P].y_chroma_shift = 0;
1140 pix_fmt_info[PIX_FMT_YUV444P].x_chroma_shift = 0;
1141 pix_fmt_info[PIX_FMT_YUV444P].y_chroma_shift = 0;
1143 pix_fmt_info[PIX_FMT_YUYV422].x_chroma_shift = 1;
1144 pix_fmt_info[PIX_FMT_YUYV422].y_chroma_shift = 0;
1146 pix_fmt_info[PIX_FMT_YUV410P].x_chroma_shift = 2;
1147 pix_fmt_info[PIX_FMT_YUV410P].y_chroma_shift = 2;
1149 pix_fmt_info[PIX_FMT_YUV411P].x_chroma_shift = 2;
1150 pix_fmt_info[PIX_FMT_YUV411P].y_chroma_shift = 0;
1153 pix_fmt_info[PIX_FMT_RGB24].x_chroma_shift = 0;
1154 pix_fmt_info[PIX_FMT_RGB24].y_chroma_shift = 0;
1156 pix_fmt_info[PIX_FMT_BGR24].x_chroma_shift = 0;
1157 pix_fmt_info[PIX_FMT_BGR24].y_chroma_shift = 0;
1159 pix_fmt_info[PIX_FMT_RGB32].x_chroma_shift = 0;
1160 pix_fmt_info[PIX_FMT_RGB32].y_chroma_shift = 0;
1162 pix_fmt_info[PIX_FMT_RGB565].x_chroma_shift = 0;
1163 pix_fmt_info[PIX_FMT_RGB565].y_chroma_shift = 0;
1165 pix_fmt_info[PIX_FMT_RGB555].x_chroma_shift = 0;
1166 pix_fmt_info[PIX_FMT_RGB555].y_chroma_shift = 0;
1170 gst_maru_avpicture_size (int pix_fmt, int width, int height)
1172 int size, w2, h2, size2;
1173 int stride, stride2;
1177 pinfo = &pix_fmt_info[pix_fmt];
1180 case PIX_FMT_YUV420P:
1181 case PIX_FMT_YUV422P:
1182 case PIX_FMT_YUV444P:
1183 case PIX_FMT_YUV410P:
1184 case PIX_FMT_YUV411P:
1185 stride = ROUND_UP_4(width);
1186 h2 = ROUND_UP_X(height, pinfo->y_chroma_shift);
1188 w2 = DIV_ROUND_UP_X(width, pinfo->x_chroma_shift);
1189 stride2 = ROUND_UP_4(w2);
1190 h2 = DIV_ROUND_UP_X(height, pinfo->y_chroma_shift);
1191 size2 = stride2 * h2;
1192 fsize = size + 2 * size2;
1196 stride = ROUND_UP_4 (width * 3);
1197 fsize = stride * height;
1201 fsize = stride * height;
1203 case PIX_FMT_RGB555:
1204 case PIX_FMT_RGB565:
1205 stride = ROUND_UP_4 (width * 2);
1206 fsize = stride * height;
1217 gst_maru_align_size (int buf_size)
1221 align_size = buf_size / 1024;
1223 for (i = 0; i < 14; i++) {
1224 if (align_size < (1 << i)) {
1225 align_size = 1024 * (1 << i);