remove unused sources and write some comments.
[platform/adaptation/emulator/gst-plugins-emulator.git] / src / gstmaruutils.c
1 /* GStreamer
2  * Copyright (C) <1999> Erik Walthinsen <omega@cse.ogi.edu>
3  * Copyright (C) 2013 Samsung Electronics Co., Ltd.
4  *
5  * This library is free software; you can redistribute it and/or
6  * modify it under the terms of the GNU Library General Public
7  * License as published by the Free Software Foundation; either
8  * version 2 of the License, or (at your option) any later version.
9  *
10  * This library is distributed in the hope that it will be useful,
11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13  * Library General Public License for more details.
14  *
15  * You should have received a copy of the GNU Library General Public
16  * License along with this library; if not, write to the
17  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
18  * Boston, MA 02111-1307, USA.
19  */
20
21 #include "gstmaruutils.h"
22 #include <gst/audio/multichannel.h>
23 #include <gst/pbutils/codec-utils.h>
24
25 gint
26 gst_maru_smpfmt_depth (int smp_fmt)
27 {
28   gint depth = -1;
29
30   switch (smp_fmt) {
31   case SAMPLE_FMT_U8:
32   case SAMPLE_FMT_U8P:
33     depth = 1;
34     break;
35   case SAMPLE_FMT_S16:
36   case SAMPLE_FMT_S16P:
37     depth = 2;
38     break;
39   case SAMPLE_FMT_S32:
40   case SAMPLE_FMT_FLT:
41   case SAMPLE_FMT_S32P:
42   case SAMPLE_FMT_FLTP:
43     depth = 4;
44     break;
45   case SAMPLE_FMT_DBL:
46   case SAMPLE_FMT_DBLP:
47     depth = 8;
48     break;
49   default:
50     GST_ERROR ("Unhandled sample format !");
51     break;
52   }
53
54   return depth;
55 }
56
57 // FFmpeg
58 static const struct
59 {
60   guint64 ff;
61   GstAudioChannelPosition gst;
62 } _ff_to_gst_layout[] = {
63   {
64   CH_FRONT_LEFT, GST_AUDIO_CHANNEL_POSITION_FRONT_LEFT}, {
65   CH_FRONT_RIGHT, GST_AUDIO_CHANNEL_POSITION_FRONT_RIGHT}, {
66   CH_FRONT_CENTER, GST_AUDIO_CHANNEL_POSITION_FRONT_CENTER}, {
67   CH_LOW_FREQUENCY, GST_AUDIO_CHANNEL_POSITION_LFE}, {
68   CH_BACK_LEFT, GST_AUDIO_CHANNEL_POSITION_REAR_LEFT}, {
69   CH_BACK_RIGHT, GST_AUDIO_CHANNEL_POSITION_REAR_RIGHT}, {
70   CH_FRONT_LEFT_OF_CENTER, GST_AUDIO_CHANNEL_POSITION_FRONT_LEFT_OF_CENTER}, {
71   CH_FRONT_RIGHT_OF_CENTER, GST_AUDIO_CHANNEL_POSITION_FRONT_RIGHT_OF_CENTER}, {
72   CH_BACK_CENTER, GST_AUDIO_CHANNEL_POSITION_REAR_CENTER}, {
73   CH_SIDE_LEFT, GST_AUDIO_CHANNEL_POSITION_SIDE_LEFT}, {
74   CH_SIDE_RIGHT, GST_AUDIO_CHANNEL_POSITION_SIDE_RIGHT}, {
75   CH_TOP_CENTER, GST_AUDIO_CHANNEL_POSITION_NONE}, {
76   CH_TOP_FRONT_LEFT, GST_AUDIO_CHANNEL_POSITION_NONE}, {
77   CH_TOP_FRONT_CENTER, GST_AUDIO_CHANNEL_POSITION_NONE}, {
78   CH_TOP_FRONT_RIGHT, GST_AUDIO_CHANNEL_POSITION_NONE}, {
79   CH_TOP_BACK_LEFT, GST_AUDIO_CHANNEL_POSITION_NONE}, {
80   CH_TOP_BACK_CENTER, GST_AUDIO_CHANNEL_POSITION_NONE}, {
81   CH_TOP_BACK_RIGHT, GST_AUDIO_CHANNEL_POSITION_NONE}, {
82   CH_STEREO_LEFT, GST_AUDIO_CHANNEL_POSITION_FRONT_LEFT}, {
83   CH_STEREO_RIGHT, GST_AUDIO_CHANNEL_POSITION_FRONT_RIGHT}
84 };
85
86 static GstAudioChannelPosition *
87 gst_ff_channel_layout_to_gst (guint64 channel_layout, guint channels)
88 {
89   guint nchannels = 0, i, j;
90   GstAudioChannelPosition *pos = NULL;
91   gboolean none_layout = FALSE;
92
93   for (i = 0; i < 64; i++) {
94     if ((channel_layout & (G_GUINT64_CONSTANT (1) << i)) != 0) {
95       nchannels++;
96     }
97   }
98
99   if (channel_layout == 0) {
100     nchannels = channels;
101     none_layout = TRUE;
102   }
103
104   if (nchannels != channels) {
105     GST_ERROR ("Number of channels is different (%u != %u)", channels,
106         nchannels);
107     return NULL;
108   }
109
110   pos = g_new (GstAudioChannelPosition, nchannels);
111
112   for (i = 0, j = 0; i < G_N_ELEMENTS (_ff_to_gst_layout); i++) {
113     if ((channel_layout & _ff_to_gst_layout[i].ff) != 0) {
114       pos[j++] = _ff_to_gst_layout[i].gst;
115
116       if (_ff_to_gst_layout[i].gst == GST_AUDIO_CHANNEL_POSITION_NONE) {
117         none_layout = TRUE;
118       }
119     }
120   }
121
122   if (j != nchannels) {
123     GST_WARNING ("Unknown channels in channel layout - assuming NONE layout");
124     none_layout = TRUE;
125   }
126
127   if (!none_layout && !gst_audio_check_channel_positions (pos, nchannels)) {
128     GST_ERROR ("Invalid channel layout %" G_GUINT64_FORMAT
129       " - assuming NONE layout", channel_layout);
130     none_layout = TRUE;
131   }
132
133   if (none_layout) {
134     if (nchannels == 1) {
135       pos[0] = GST_AUDIO_CHANNEL_POSITION_FRONT_MONO;
136     } else if (nchannels == 2) {
137       pos[0] = GST_AUDIO_CHANNEL_POSITION_FRONT_LEFT;
138       pos[1] = GST_AUDIO_CHANNEL_POSITION_FRONT_RIGHT;
139     } else if (channel_layout == 0) {
140       g_free (pos);
141       pos = NULL;
142     } else {
143       for (i = 0; i < nchannels; i++) {
144         pos[i] = GST_AUDIO_CHANNEL_POSITION_NONE;
145       }
146     }
147   }
148
149   if (nchannels == 1 && pos[0] == GST_AUDIO_CHANNEL_POSITION_FRONT_CENTER) {
150     GST_DEBUG ("mono common case; won't set channel positions");
151     g_free (pos);
152     pos = NULL;
153   } else if (nchannels == 2 && pos[0] == GST_AUDIO_CHANNEL_POSITION_FRONT_LEFT
154     && pos[1] == GST_AUDIO_CHANNEL_POSITION_FRONT_RIGHT) {
155     GST_DEBUG ("stereo common case; won't set channel positions");
156     g_free (pos);
157     pos = NULL;
158   }
159
160   return pos;
161 }
162
163 GstCaps*
164 gst_maru_codectype_to_video_caps (CodecContext *ctx, const char *name,
165     gboolean encode, CodecElement *codec)
166 {
167   GstCaps *caps;
168
169   GST_DEBUG ("context: %p, codec: %s, encode: %d, pixel format: %d",
170       ctx, name, encode, ctx->video.pix_fmt);
171
172   if (ctx) {
173     caps = gst_maru_pixfmt_to_caps (ctx->video.pix_fmt, ctx, name);
174   } else {
175     GstCaps *temp;
176     enum PixelFormat i;
177     CodecContext ctx;
178
179     caps = gst_caps_new_empty ();
180     for (i = 0; i <= PIX_FMT_NB; i++) {
181       temp = gst_maru_pixfmt_to_caps (i, encode ? &ctx : NULL, name);
182       if (temp != NULL) {
183         gst_caps_append (caps, temp);
184       }
185     }
186   }
187
188   return caps;
189 }
190
191 GstCaps *
192 gst_maru_codectype_to_audio_caps (CodecContext *ctx, const char *name,
193     gboolean encode, CodecElement *codec)
194 {
195   GstCaps *caps = NULL;
196
197   GST_DEBUG ("context: %p, codec: %s, encode: %d, codec: %p",
198             ctx, name, encode, codec);
199
200   if (ctx) {
201     caps = gst_maru_smpfmt_to_caps (ctx->audio.sample_fmt, ctx, name);
202   } else if (codec && codec->sample_fmts[0] != -1){
203     GstCaps *temp;
204     int i;
205
206     caps = gst_caps_new_empty ();
207     for (i = 0; codec->sample_fmts[i] != -1; i++) {
208       int8_t sample_fmt = -1;
209
210       sample_fmt = codec->sample_fmts[i];
211       if (!strcmp(name, "aac") && encode) {
212         sample_fmt = SAMPLE_FMT_S16;
213         GST_DEBUG ("convert sample_fmt. codec %s, encode %d, sample_fmt %d",
214                   name, encode, sample_fmt);
215       }
216
217       temp =
218           gst_maru_smpfmt_to_caps (sample_fmt, ctx, name);
219       if (temp != NULL) {
220         gst_caps_append (caps, temp);
221       }
222     }
223   } else {
224     GstCaps *temp;
225     int i;
226     CodecContext ctx = {{0}, {0}, 0};
227
228     ctx.audio.channels = -1;
229     caps = gst_caps_new_empty ();
230     for (i = 0; i <= SAMPLE_FMT_DBL; i++) {
231       temp = gst_maru_smpfmt_to_caps (i, encode ? &ctx : NULL, name);
232       if (temp != NULL) {
233         gst_caps_append (caps, temp);
234       }
235     }
236   }
237
238   return caps;
239 }
240
241 GstCaps*
242 gst_maru_codectype_to_caps (int media_type, CodecContext *ctx,
243     const char *name, gboolean encode)
244 {
245   GstCaps *caps;
246
247   switch (media_type) {
248   case AVMEDIA_TYPE_VIDEO:
249     caps =
250         gst_maru_codectype_to_video_caps (ctx, name, encode, NULL);
251     break;
252   case AVMEDIA_TYPE_AUDIO:
253     caps =
254         gst_maru_codectype_to_audio_caps (ctx, name, encode, NULL);
255    break;
256   default:
257     caps = NULL;
258     break;
259   }
260
261   return caps;
262 }
263
264 void
265 gst_maru_caps_to_pixfmt (const GstCaps *caps, CodecContext *ctx, gboolean raw)
266 {
267   GstStructure *str;
268   const GValue *fps;
269   const GValue *par = NULL;
270
271   GST_DEBUG ("converting caps %" GST_PTR_FORMAT, caps);
272   g_return_if_fail (gst_caps_get_size (caps) == 1);
273   str = gst_caps_get_structure (caps, 0);
274
275   gst_structure_get_int (str, "width", &ctx->video.width);
276   gst_structure_get_int (str, "height", &ctx->video.height);
277   gst_structure_get_int (str, "bpp", &ctx->video.bpp);
278
279   fps = gst_structure_get_value (str, "framerate");
280   if (fps != NULL && GST_VALUE_HOLDS_FRACTION (fps)) {
281     ctx->video.fps_d = gst_value_get_fraction_numerator (fps);
282     ctx->video.fps_n = gst_value_get_fraction_denominator (fps);
283     ctx->video.ticks_per_frame = 1;
284
285     GST_DEBUG ("setting framerate %d/%d = %lf",
286         ctx->video.fps_d, ctx->video.fps_n,
287         1. * ctx->video.fps_d / ctx->video.fps_n);
288   }
289
290   par = gst_structure_get_value (str, "pixel-aspect-ratio");
291   if (par && GST_VALUE_HOLDS_FRACTION (par)) {
292     ctx->video.par_n = gst_value_get_fraction_numerator (par);
293     ctx->video.par_d = gst_value_get_fraction_denominator (par);
294   }
295
296   if (!raw) {
297     return;
298   }
299
300   g_return_if_fail (fps != NULL && GST_VALUE_HOLDS_FRACTION (fps));
301
302   if (strcmp (gst_structure_get_name (str), "video/x-raw-yuv") == 0) {
303     guint32 fourcc;
304
305     if (gst_structure_get_fourcc (str, "format", &fourcc)) {
306     switch (fourcc) {
307       case GST_MAKE_FOURCC ('Y', 'U', 'Y', '2'):
308         ctx->video.pix_fmt = PIX_FMT_YUYV422;
309         break;
310       case GST_MAKE_FOURCC ('I', '4', '2', '0'):
311         ctx->video.pix_fmt = PIX_FMT_YUV420P;
312         break;
313       case GST_MAKE_FOURCC ('A', '4', '2', '0'):
314         ctx->video.pix_fmt = PIX_FMT_YUVA420P;
315         break;
316       case GST_MAKE_FOURCC ('Y', '4', '1', 'B'):
317         ctx->video.pix_fmt = PIX_FMT_YUV411P;
318         break;
319       case GST_MAKE_FOURCC ('Y', '4', '2', 'B'):
320         ctx->video.pix_fmt = PIX_FMT_YUV422P;
321         break;
322       case GST_MAKE_FOURCC ('Y', 'U', 'V', '9'):
323         ctx->video.pix_fmt = PIX_FMT_YUV410P;
324         break;
325       }
326     }
327   } else if (strcmp (gst_structure_get_name (str), "video/x-raw-rgb") == 0) {
328     gint bpp = 0, rmask = 0, endianness = 0;
329
330     if (gst_structure_get_int (str, "bpp", &bpp) &&
331       gst_structure_get_int (str, "endianness", &endianness)) {
332       if (gst_structure_get_int (str, "red_mask", &rmask)) {
333         switch (bpp) {
334         case 32:
335 #if (G_BYTE_ORDER == G_BIG_ENDIAN)
336           if (rmask == 0x00ff0000) {
337 #else
338           if (rmask == 0x00ff0000) {
339 #endif
340             ctx->video.pix_fmt = PIX_FMT_RGB32;
341           }
342           break;
343         case 24:
344           if (rmask == 0x0000FF) {
345             ctx->video.pix_fmt = PIX_FMT_BGR24;
346           } else {
347             ctx->video.pix_fmt = PIX_FMT_RGB24;
348           }
349           break;
350         case 16:
351           if (endianness == G_BYTE_ORDER) {
352             ctx->video.pix_fmt = PIX_FMT_RGB565;
353           }
354           break;
355         case 15:
356           if (endianness == G_BYTE_ORDER) {
357             ctx->video.pix_fmt = PIX_FMT_RGB555;
358           }
359           break;
360         default:
361           break;
362         }
363       }
364     } else {
365       if (bpp == 8) {
366         ctx->video.pix_fmt = PIX_FMT_PAL8;
367         // get palette
368       }
369     }
370   } else if (strcmp (gst_structure_get_name (str), "video/x-raw-gray") == 0) {
371     gint bpp = 0;
372
373     if (gst_structure_get_int (str, "bpp", &bpp)) {
374       switch (bpp) {
375       case 8:
376         ctx->video.pix_fmt = PIX_FMT_GRAY8;
377         break;
378       }
379     }
380   }
381 }
382
383 void
384 gst_maru_caps_to_smpfmt (const GstCaps *caps, CodecContext *ctx, gboolean raw)
385 {
386   GstStructure *str;
387   gint depth = 0, width = 0, endianness = 0;
388   gboolean signedness = FALSE;
389   const gchar *name;
390
391   g_return_if_fail (gst_caps_get_size (caps) == 1);
392   str = gst_caps_get_structure (caps, 0);
393
394   gst_structure_get_int (str, "channels", &ctx->audio.channels);
395   gst_structure_get_int (str, "rate", &ctx->audio.sample_rate);
396   gst_structure_get_int (str, "block_align", &ctx->audio.block_align);
397   gst_structure_get_int (str, "bitrate", &ctx->bit_rate);
398
399   if (!raw) {
400     return;
401   }
402
403   name = gst_structure_get_name (str);
404   if (!name) {
405     GST_ERROR ("Couldn't get audio sample format from caps %" GST_PTR_FORMAT, caps);
406     return;
407   }
408
409   if (!strcmp (name, "audio/x-raw-float")) {
410     if (gst_structure_get_int (str, "width", &width) &&
411       gst_structure_get_int (str, "endianness", &endianness)) {
412       if (endianness == G_BYTE_ORDER) {
413         if (width == 32) {
414           ctx->audio.sample_fmt = SAMPLE_FMT_FLT;
415         } else if (width == 64) {
416           ctx->audio.sample_fmt = SAMPLE_FMT_DBL;
417         }
418       }
419     }
420   } else {
421     if (gst_structure_get_int (str, "width", &width) &&
422       gst_structure_get_int (str, "depth", &depth) &&
423       gst_structure_get_boolean (str, "signed", &signedness) &&
424       gst_structure_get_int (str, "endianness", &endianness)) {
425       if ((endianness == G_BYTE_ORDER) && (signedness == TRUE)) {
426         if ((width == 16) && (depth == 16)) {
427           ctx->audio.sample_fmt = SAMPLE_FMT_S16;
428         } else if ((width == 32) && (depth == 32)) {
429           ctx->audio.sample_fmt = SAMPLE_FMT_S32;
430         }
431       }
432     }
433   }
434 }
435
436 void
437 gst_maru_caps_with_codecname (const char *name, int media_type,
438     const GstCaps *caps, CodecContext *ctx)
439 {
440   GstStructure *structure;
441   const GValue *value;
442   const GstBuffer *buf;
443
444   if (!ctx || !gst_caps_get_size (caps)) {
445     return;
446   }
447
448   structure = gst_caps_get_structure (caps, 0);
449
450   if ((value = gst_structure_get_value (structure, "codec_data"))) {
451     guint size;
452     guint8 *data;
453
454     buf = GST_BUFFER_CAST (gst_value_get_mini_object (value));
455     size = GST_BUFFER_SIZE (buf);
456     data = GST_BUFFER_DATA (buf);
457     GST_DEBUG ("extradata: %p, size: %d", data, size);
458
459     if (ctx->codecdata) {
460       g_free (ctx->codecdata);
461     }
462
463     ctx->codecdata =
464         g_malloc0 (GST_ROUND_UP_16 (size + FF_INPUT_BUFFER_PADDING_SIZE));
465     memcpy (ctx->codecdata, data, size);
466     ctx->codecdata_size = size;
467
468     if ((strcmp (name, "vc1") == 0) && size > 0 && data[0] == 0) {
469       ctx->codecdata[0] = (guint8) size;
470     }
471   } else if (ctx->codecdata == NULL) {
472     ctx->codecdata_size = 0;
473     ctx->codecdata = g_malloc0 (GST_ROUND_UP_16(FF_INPUT_BUFFER_PADDING_SIZE));
474     GST_DEBUG ("no extra data");
475   }
476
477   if ((strcmp (name, "mpeg4") == 0)) {
478     const gchar *mime = gst_structure_get_name (structure);
479     if (!mime) {
480       GST_ERROR ("Couldn't get mime type from caps %" GST_PTR_FORMAT, caps);
481       return;
482     }
483
484     if (!strcmp (mime, "video/x-divx")) {
485       ctx->codec_tag = GST_MAKE_FOURCC ('D', 'I', 'V', 'X');
486     } else if (!strcmp (mime, "video/x-xvid")) {
487       ctx->codec_tag = GST_MAKE_FOURCC ('X', 'V', 'I', 'D');
488     } else if (!strcmp (mime, "video/x-3ivx")) {
489       ctx->codec_tag = GST_MAKE_FOURCC ('3', 'I', 'V', '1');
490     } else if (!strcmp (mime, "video/mpeg")) {
491       ctx->codec_tag = GST_MAKE_FOURCC ('m', 'p', '4', 'v');
492     }
493   } else {
494     // TODO
495   }
496
497   if (!gst_caps_is_fixed (caps)) {
498     return;
499   }
500
501   switch (media_type) {
502   case AVMEDIA_TYPE_VIDEO:
503     gst_maru_caps_to_pixfmt (caps, ctx, FALSE);
504     // get_palette
505     break;
506   case AVMEDIA_TYPE_AUDIO:
507     gst_maru_caps_to_smpfmt (caps, ctx, FALSE);
508     break;
509   default:
510     break;
511   }
512 }
513
514 #define CODEC_NAME_BUFFER_SIZE 32
515
516 void
517 gst_maru_caps_to_codecname (const GstCaps *caps,
518                             gchar *codec_name,
519                             CodecContext *context)
520 {
521   const gchar *mimetype;
522   const GstStructure *str;
523   int media_type = AVMEDIA_TYPE_UNKNOWN;
524
525   str = gst_caps_get_structure (caps, 0);
526
527   mimetype = gst_structure_get_name (str);
528   if (!mimetype) {
529     GST_ERROR ("Couldn't get mimetype from caps %" GST_PTR_FORMAT, caps);
530     return;
531   }
532
533   if (!strcmp (mimetype, "video/x-h263")) {
534     const gchar *h263version = gst_structure_get_string (str, "h263version");
535     if (h263version && !strcmp (h263version, "h263p")) {
536       g_strlcpy (codec_name, "h263p", CODEC_NAME_BUFFER_SIZE);
537     } else {
538       g_strlcpy (codec_name, "h263", CODEC_NAME_BUFFER_SIZE);
539     }
540     media_type = AVMEDIA_TYPE_VIDEO;
541   } else if (!strcmp (mimetype, "video/mpeg")) {
542     gboolean sys_strm;
543     gint mpegversion;
544
545     if (gst_structure_get_boolean (str, "systemstream", &sys_strm) &&
546         gst_structure_get_int (str, "mpegversion", &mpegversion) &&
547         !sys_strm) {
548       switch (mpegversion) {
549         case 1:
550           g_strlcpy (codec_name, "mpeg1video", CODEC_NAME_BUFFER_SIZE);
551           break;
552         case 2:
553           g_strlcpy (codec_name, "mpeg2video", CODEC_NAME_BUFFER_SIZE);
554           break;
555         case 4:
556           g_strlcpy (codec_name, "mpeg4", CODEC_NAME_BUFFER_SIZE);
557           break;
558       }
559     }
560
561     media_type = AVMEDIA_TYPE_VIDEO;
562   } else if (!strcmp (mimetype, "video/x-wmv")) {
563     gint wmvversion = 0;
564
565     if (gst_structure_get_int (str, "wmvversion", &wmvversion)) {
566       switch (wmvversion) {
567         case 1:
568           g_strlcpy (codec_name, "wmv1", CODEC_NAME_BUFFER_SIZE);
569           break;
570         case 2:
571           g_strlcpy (codec_name, "wmv2", CODEC_NAME_BUFFER_SIZE);
572           break;
573         case 3:
574         {
575           guint32 fourcc;
576
577           g_strlcpy (codec_name, "wmv3", CODEC_NAME_BUFFER_SIZE);
578           if (gst_structure_get_fourcc (str, "format", &fourcc)) {
579             if ((fourcc == GST_MAKE_FOURCC ('W', 'V', 'C', '1')) ||
580                 (fourcc == GST_MAKE_FOURCC ('W', 'M', 'V', 'A'))) {
581               g_strlcpy (codec_name, "vc1", CODEC_NAME_BUFFER_SIZE);
582             }
583           }
584         }
585           break;
586       }
587     }
588
589     media_type = AVMEDIA_TYPE_VIDEO;
590   } else if (!strcmp (mimetype, "audio/mpeg")) {
591     gint layer = 0;
592     gint mpegversion = 0;
593
594     if (gst_structure_get_int (str, "mpegversion", &mpegversion)) {
595       switch (mpegversion) {
596       case 2:
597       case 4:
598         g_strlcpy (codec_name, "aac", CODEC_NAME_BUFFER_SIZE);
599         break;
600       case 1:
601         if (gst_structure_get_int (str, "layer", &layer)) {
602           switch(layer) {
603             case 1:
604               g_strlcpy (codec_name, "mp1", CODEC_NAME_BUFFER_SIZE);
605               break;
606             case 2:
607               g_strlcpy (codec_name, "mp2", CODEC_NAME_BUFFER_SIZE);
608               break;
609             case 3:
610               g_strlcpy (codec_name, "mp3", CODEC_NAME_BUFFER_SIZE);
611               break;
612           }
613         }
614         break;
615       }
616     }
617
618     media_type = AVMEDIA_TYPE_AUDIO;
619   } else if (!strcmp (mimetype, "audio/x-wma")) {
620     gint wmaversion = 0;
621
622     if (gst_structure_get_int (str, "wmaversion", &wmaversion)) {
623       switch (wmaversion) {
624       case 1:
625         g_strlcpy (codec_name, "wmav1", CODEC_NAME_BUFFER_SIZE);
626         break;
627       case 2:
628         g_strlcpy (codec_name, "wmav2", CODEC_NAME_BUFFER_SIZE);
629         break;
630       case 3:
631         g_strlcpy (codec_name, "wmapro", CODEC_NAME_BUFFER_SIZE);
632         break;
633       }
634     }
635
636     media_type = AVMEDIA_TYPE_AUDIO;
637   } else if (!strcmp (mimetype, "audio/x-ac3")) {
638     g_strlcpy (codec_name, "ac3", CODEC_NAME_BUFFER_SIZE);
639     media_type = AVMEDIA_TYPE_AUDIO;
640   } else if (!strcmp (mimetype, "audio/x-msmpeg")) {
641     gint msmpegversion = 0;
642
643     if (gst_structure_get_int (str, "msmpegversion", &msmpegversion)) {
644       switch (msmpegversion) {
645       case 41:
646         g_strlcpy (codec_name, "msmpeg4v1", CODEC_NAME_BUFFER_SIZE);
647         break;
648       case 42:
649         g_strlcpy (codec_name, "msmpeg4v2", CODEC_NAME_BUFFER_SIZE);
650         break;
651       case 43:
652         g_strlcpy (codec_name, "msmpeg4", CODEC_NAME_BUFFER_SIZE);
653         break;
654       }
655     }
656
657     media_type = AVMEDIA_TYPE_VIDEO;
658   } else if (!strcmp (mimetype, "video/x-h264")) {
659     g_strlcpy (codec_name, "h264", CODEC_NAME_BUFFER_SIZE);
660     media_type = AVMEDIA_TYPE_VIDEO;
661   }
662
663   if (context != NULL) {
664     gst_maru_caps_with_codecname (codec_name, media_type, caps, context);
665   }
666
667   if (codec_name != NULL) {
668     GST_DEBUG ("The %s belongs to the caps %" GST_PTR_FORMAT, codec_name, caps);
669   } else {
670     GST_WARNING ("Couldn't figure out the name for caps %" GST_PTR_FORMAT, caps);
671   }
672 }
673
674 void
675 gst_maru_caps_with_codectype (int media_type, const GstCaps *caps, CodecContext *ctx)
676 {
677   if (ctx == NULL) {
678     return;
679   }
680
681   switch (media_type) {
682   case AVMEDIA_TYPE_VIDEO:
683     gst_maru_caps_to_pixfmt (caps, ctx, TRUE);
684     break;
685   case AVMEDIA_TYPE_AUDIO:
686     gst_maru_caps_to_smpfmt (caps, ctx, TRUE);
687     break;
688   default:
689     break;
690   }
691 }
692
693 GstCaps *
694 gst_maru_video_caps_new (CodecContext *ctx, const char *name,
695         const char *mimetype, const char *fieldname, ...)
696 {
697   GstStructure *structure = NULL;
698   GstCaps *caps = NULL;
699   va_list var_args;
700   gint i;
701
702   GST_LOG ("context: %p, name: %s, mimetype: %s", ctx, name, mimetype);
703
704   if (ctx != NULL && ctx->video.width != -1) {
705     gint num, denom;
706
707     caps = gst_caps_new_simple (mimetype,
708       "width", G_TYPE_INT, ctx->video.width,
709       "height", G_TYPE_INT, ctx->video.height, NULL);
710
711     num = ctx->video.fps_d / ctx->video.ticks_per_frame;
712     denom = ctx->video.fps_n;
713
714     if (!denom) {
715       GST_LOG ("invalid framerate: %d/0, -> %d/1", num, num);
716     }
717     if (gst_util_fraction_compare (num, denom, 1000, 1) > 0) {
718       GST_LOG ("excessive framerate: %d/%d, -> 0/1", num, denom);
719       num = 0;
720       denom = 1;
721     }
722     GST_LOG ("setting framerate: %d/%d", num, denom);
723     gst_caps_set_simple (caps,
724       "framerate", GST_TYPE_FRACTION, num, denom, NULL);
725   } else {
726     if (strcmp (name, "h263") == 0) {
727       /* 128x96, 176x144, 352x288, 704x576, and 1408x1152. slightly reordered
728        * because we want automatic negotiation to go as close to 320x240 as
729        * possible. */
730       const static gint widths[] = { 352, 704, 176, 1408, 128 };
731       const static gint heights[] = { 288, 576, 144, 1152, 96 };
732       GstCaps *temp;
733       gint n_sizes = G_N_ELEMENTS (widths);
734
735       caps = gst_caps_new_empty ();
736       for (i = 0; i < n_sizes; i++) {
737         temp = gst_caps_new_simple (mimetype,
738             "width", G_TYPE_INT, widths[i],
739             "height", G_TYPE_INT, heights[i],
740             "framerate", GST_TYPE_FRACTION_RANGE, 0, 1, G_MAXINT, 1, NULL);
741
742         gst_caps_append (caps, temp);
743       }
744     } else if (strcmp (name, "none") == 0) {
745       GST_LOG ("default caps");
746     }
747   }
748
749   /* no fixed caps or special restrictions applied;
750    * default unfixed setting */
751   if (!caps) {
752     GST_DEBUG ("Creating default caps");
753     caps = gst_caps_new_simple (mimetype,
754             "width", GST_TYPE_INT_RANGE, 16, 4096,
755             "height", GST_TYPE_INT_RANGE, 16, 4096,
756              "framerate", GST_TYPE_FRACTION_RANGE, 0, 1, G_MAXINT, 1, NULL);
757   }
758
759   for (i = 0; i < gst_caps_get_size (caps); i++) {
760     va_start (var_args, fieldname);
761     structure = gst_caps_get_structure (caps, i);
762     gst_structure_set_valist (structure, fieldname, var_args);
763     va_end (var_args);
764   }
765
766   return caps;
767 }
768
769 GstCaps *
770 gst_maru_audio_caps_new (CodecContext *ctx, const char *name,
771         const char *mimetype, const char *fieldname, ...)
772 {
773   GstStructure *structure = NULL;
774   GstCaps *caps = NULL;
775   gint i;
776   va_list var_args;
777
778   if (ctx != NULL && ctx->audio.channels != -1) {
779     GstAudioChannelPosition *pos;
780     guint64 channel_layout = ctx->audio.channel_layout;
781
782     if (channel_layout == 0) {
783       const guint64 default_channel_set[] = {
784         0, 0, CH_LAYOUT_SURROUND, CH_LAYOUT_QUAD, CH_LAYOUT_5POINT0,
785         CH_LAYOUT_5POINT1, 0, CH_LAYOUT_7POINT1
786       };
787
788       if (strcmp (name, "ac3") == 0) {
789         if (ctx->audio.channels > 0 &&
790           ctx->audio.channels < G_N_ELEMENTS (default_channel_set)) {
791           channel_layout = default_channel_set[ctx->audio.channels - 1];
792         }
793       } else {
794         // TODO
795       }
796     }
797
798     caps = gst_caps_new_simple (mimetype,
799             "rate", G_TYPE_INT, ctx->audio.sample_rate,
800             "channels", G_TYPE_INT, ctx->audio.channels, NULL);
801
802     pos = gst_ff_channel_layout_to_gst (channel_layout, ctx->audio.channels);
803     if (pos != NULL) {
804       gst_audio_set_channel_positions (gst_caps_get_structure (caps, 0), pos);
805       g_free (pos);
806     }
807   } else {
808     gint maxchannels = 2;
809     const gint *rates = NULL;
810     gint n_rates = 0;
811
812     if (strcmp (name, "aac") == 0) {
813       maxchannels = 6;
814     } else if (g_str_has_prefix(name, "ac3")) {
815       const static gint l_rates[] = { 48000, 44100, 32000 };
816       maxchannels = 6;
817       n_rates = G_N_ELEMENTS (l_rates);
818       rates = l_rates;
819     } else {
820      // TODO
821     }
822
823     if (maxchannels == 1) {
824       caps = gst_caps_new_simple(mimetype,
825               "channels", G_TYPE_INT, maxchannels, NULL);
826     } else {
827       caps = gst_caps_new_simple(mimetype,
828               "channels", GST_TYPE_INT_RANGE, 1, maxchannels, NULL);
829     }
830
831     if (n_rates) {
832       GValue list = { 0, };
833       GstStructure *structure;
834
835       g_value_init(&list, GST_TYPE_LIST);
836       for (i = 0; i < n_rates; i++) {
837         GValue v = { 0, };
838
839         g_value_init(&v, G_TYPE_INT);
840         g_value_set_int(&v, rates[i]);
841         gst_value_list_append_value(&list, &v);
842         g_value_unset(&v);
843       }
844       structure = gst_caps_get_structure(caps, 0);
845       gst_structure_set_value(structure, "rate", &list);
846       g_value_unset(&list);
847     } else {
848       gst_caps_set_simple(caps, "rate", GST_TYPE_INT_RANGE, 4000, 96000, NULL);
849     }
850   }
851
852   for (i = 0; i < gst_caps_get_size (caps); i++) {
853     va_start (var_args, fieldname);
854     structure = gst_caps_get_structure (caps, i);
855     gst_structure_set_valist (structure, fieldname, var_args);
856     va_end (var_args);
857   }
858
859   return caps;
860 }
861
862 GstCaps *
863 gst_maru_pixfmt_to_caps (enum PixelFormat pix_fmt, CodecContext *ctx, const char *name)
864 {
865   GstCaps *caps = NULL;
866
867   int bpp = 0, depth = 0, endianness = 0;
868   gulong g_mask = 0, r_mask = 0, b_mask = 0, a_mask = 0;
869   guint32 fmt = 0;
870
871   switch (pix_fmt) {
872   case PIX_FMT_YUV420P:
873     fmt = GST_MAKE_FOURCC ('I', '4', '2', '0');
874     break;
875   case PIX_FMT_YUYV422:
876     fmt = GST_MAKE_FOURCC ('A', '4', '2', '0');
877     break;
878   case PIX_FMT_RGB24:
879     bpp = depth = 24;
880     endianness = G_BIG_ENDIAN;
881     r_mask = 0xff0000;
882     g_mask = 0x00ff00;
883     b_mask = 0x0000ff;
884     break;
885   case PIX_FMT_BGR24:
886     bpp = depth = 24;
887     endianness = G_BIG_ENDIAN;
888     r_mask = 0x0000ff;
889     g_mask = 0x00ff00;
890     b_mask = 0xff0000;
891     break;
892   case PIX_FMT_YUV422P:
893     fmt = GST_MAKE_FOURCC ('Y', '4', '2', 'B');
894     break;
895   case PIX_FMT_YUV444P:
896     fmt = GST_MAKE_FOURCC ('Y', '4', '4', '4');
897     break;
898   case PIX_FMT_RGB32:
899     bpp = 32;
900     depth = 32;
901     endianness = G_BIG_ENDIAN;
902 #if (G_BYTE_ORDER == G_BIG_ENDIAN)
903     r_mask = 0x00ff0000;
904     g_mask = 0x0000ff00;
905     b_mask = 0x000000ff;
906     a_mask = 0xff000000;
907 #else
908     r_mask = 0x00ff0000;
909     g_mask = 0x0000ff00;
910     b_mask = 0x000000ff;
911     a_mask = 0xff000000;
912 #endif
913     break;
914   case PIX_FMT_YUV410P:
915     fmt = GST_MAKE_FOURCC ('Y', 'U', 'V', '9');
916     break;
917   case PIX_FMT_YUV411P:
918     fmt = GST_MAKE_FOURCC ('Y', '4', '1', 'b');
919     break;
920   case PIX_FMT_RGB565:
921     bpp = depth = 16;
922     endianness = G_BYTE_ORDER;
923     r_mask = 0xf800;
924     g_mask = 0x07e0;
925     b_mask = 0x001f;
926     break;
927   case PIX_FMT_RGB555:
928     bpp = 16;
929     depth = 15;
930     endianness = G_BYTE_ORDER;
931     r_mask = 0x7c00;
932     g_mask = 0x03e0;
933     b_mask = 0x001f;
934     break;
935   default:
936     break;
937   }
938
939   if (caps == NULL) {
940     if (bpp != 0) {
941       if (r_mask != 0) {
942         if (a_mask) {
943         caps = gst_maru_video_caps_new (ctx, name, "video/x-raw-rgb",
944                 "bpp", G_TYPE_INT, bpp,
945                 "depth", G_TYPE_INT, depth,
946                 "red_mask", G_TYPE_INT, r_mask,
947                 "green_mask", G_TYPE_INT, g_mask,
948                 "blue_mask", G_TYPE_INT, b_mask,
949                 "alpha_mask", G_TYPE_INT, a_mask,
950                 "endianness", G_TYPE_INT, endianness, NULL);
951         } else {
952           caps = gst_maru_video_caps_new (ctx, name, "video/x-raw-rgb",
953                   "bpp", G_TYPE_INT, bpp,
954                   "depth", G_TYPE_INT, depth,
955                   "red_mask", G_TYPE_INT, r_mask,
956                   "green_mask", G_TYPE_INT, g_mask,
957                   "blue_mask", G_TYPE_INT, b_mask,
958                   "alpha_mask", G_TYPE_INT, a_mask,
959                   "endianness", G_TYPE_INT, endianness, NULL);
960         }
961       } else {
962         caps = gst_maru_video_caps_new (ctx, name, "video/x-raw-rgb",
963                   "bpp", G_TYPE_INT, bpp,
964                   "depth", G_TYPE_INT, depth,
965                   "endianness", G_TYPE_INT, endianness, NULL);
966         if (caps && ctx) {
967           // set paletee
968         }
969       }
970     } else if (fmt) {
971       caps = gst_maru_video_caps_new (ctx, name, "video/x-raw-yuv",
972                "format", GST_TYPE_FOURCC, fmt, NULL);
973     }
974   }
975
976   if (caps != NULL) {
977     GST_DEBUG ("caps for pix_fmt=%d: %", GST_PTR_FORMAT, pix_fmt, caps);
978   } else {
979     GST_LOG ("No caps found for pix_fmt=%d", pix_fmt);
980   }
981
982   return caps;
983 }
984
985 GstCaps *
986 gst_maru_smpfmt_to_caps (int8_t sample_fmt, CodecContext *ctx, const char *name)
987 {
988   GstCaps *caps = NULL;
989
990   int bpp = 0;
991   gboolean integer = TRUE;
992   gboolean signedness = FALSE;
993
994   switch (sample_fmt) {
995   case SAMPLE_FMT_S16:
996   case SAMPLE_FMT_S16P:
997     signedness = TRUE;
998     bpp = 16;
999     break;
1000   case SAMPLE_FMT_S32:
1001   case SAMPLE_FMT_S32P:
1002     signedness = TRUE;
1003     bpp = 32;
1004     break;
1005   case SAMPLE_FMT_FLT:
1006   case SAMPLE_FMT_FLTP:
1007     integer = FALSE;
1008     bpp = 32;
1009     break;
1010   case SAMPLE_FMT_DBL:
1011   case SAMPLE_FMT_DBLP:
1012     integer = FALSE;
1013     bpp = 64;
1014     break;
1015   default:
1016     break;
1017   }
1018
1019   GST_DEBUG ("sample format: %d", sample_fmt);
1020
1021   if (bpp) {
1022     if (integer) {
1023       caps = gst_maru_audio_caps_new (ctx, name, "audio/x-raw-int",
1024           "signed", G_TYPE_BOOLEAN, signedness,
1025           "endianness", G_TYPE_INT, G_BYTE_ORDER,
1026           "width", G_TYPE_INT, bpp, "depth", G_TYPE_INT, bpp, NULL);
1027     } else {
1028       caps = gst_maru_audio_caps_new (ctx, name, "audio/x-raw-float",
1029           "endianness", G_TYPE_INT, G_BYTE_ORDER,
1030           "width", G_TYPE_INT, bpp, NULL);
1031     }
1032   }
1033
1034   if (caps != NULL) {
1035     GST_LOG ("caps for sample_fmt=%d: %" GST_PTR_FORMAT, sample_fmt, caps);
1036   } else {
1037     GST_LOG ("No caps found for sample_fmt=%d", sample_fmt);
1038   }
1039
1040   return caps;
1041 }
1042
1043 GstCaps *
1044 gst_maru_codecname_to_caps (const char *name, CodecContext *ctx, gboolean encode)
1045 {
1046   GstCaps *caps = NULL;
1047
1048   GST_LOG ("codec: %s, context: %p, encode: %d", name, ctx, encode);
1049
1050   if (strcmp (name, "mpegvideo") == 0) {
1051     caps = gst_maru_video_caps_new (ctx, name, "video/mpeg",
1052                 "mpegversion", G_TYPE_INT, 1,
1053                 "systemstream", G_TYPE_BOOLEAN, FALSE, NULL);
1054   } else if (strcmp (name, "h263") == 0) {
1055     if (encode) {
1056       caps = gst_maru_video_caps_new (ctx, name, "video/x-h263",
1057                   "variant", G_TYPE_STRING, "itu", NULL);
1058     } else {
1059       caps = gst_maru_video_caps_new (ctx, "none", "video/x-h263",
1060                   "variant", G_TYPE_STRING, "itu", NULL);
1061     }
1062   } else if (strcmp (name, "h263p") == 0) {
1063     caps = gst_maru_video_caps_new (ctx, name, "video/x-h263",
1064               "variant", G_TYPE_STRING, "itu",
1065               "h263version", G_TYPE_STRING, "h263p", NULL);
1066   } else if (strcmp (name, "mpeg2video") == 0) {
1067     if (encode) {
1068       caps = gst_maru_video_caps_new (ctx, name, "video/mpeg",
1069             "mpegversion", G_TYPE_INT, 2,
1070             "systemstream", G_TYPE_BOOLEAN, FALSE, NULL);
1071     } else {
1072       caps = gst_caps_new_simple ("video/mpeg",
1073             "mpegversion", GST_TYPE_INT_RANGE, 1, 2,
1074             "systemstream", G_TYPE_BOOLEAN, FALSE, NULL);
1075     }
1076   } else if (strcmp (name, "mpeg4") == 0) {
1077     if (encode && ctx != NULL) {
1078       // TODO
1079       switch (ctx->codec_tag) {
1080         case GST_MAKE_FOURCC ('D', 'I', 'V', 'X'):
1081           caps = gst_maru_video_caps_new (ctx, name, "video/x-divx",
1082               "divxversion", G_TYPE_INT, 5, NULL);
1083           break;
1084         case GST_MAKE_FOURCC ('m', 'p', '4', 'v'):
1085         default:
1086           caps = gst_maru_video_caps_new (ctx, name, "video/mpeg",
1087               "systemstream", G_TYPE_BOOLEAN, FALSE,
1088               "mpegversion", G_TYPE_INT, 4, NULL);
1089           break;
1090       }
1091     } else {
1092       caps = gst_maru_video_caps_new (ctx, name, "video/mpeg",
1093             "mpegversion", G_TYPE_INT, 4,
1094             "systemstream", G_TYPE_BOOLEAN, FALSE, NULL);
1095       if (encode) {
1096         caps = gst_maru_video_caps_new (ctx, name, "video/mpeg",
1097             "mpegversion", G_TYPE_INT, 4,
1098             "systemstream", G_TYPE_BOOLEAN, FALSE, NULL);
1099       } else {
1100         gst_caps_append (caps, gst_maru_video_caps_new (ctx, name,
1101             "video/x-divx", "divxversion", GST_TYPE_INT_RANGE, 4, 5, NULL));
1102         gst_caps_append (caps, gst_maru_video_caps_new (ctx, name,
1103             "video/x-xvid", NULL));
1104         gst_caps_append (caps, gst_maru_video_caps_new (ctx, name,
1105             "video/x-3ivx", NULL));
1106       }
1107     }
1108   } else if ((strcmp (name, "h264") == 0) || (strcmp (name, "libx264") == 0)) {
1109     caps = gst_maru_video_caps_new (ctx, name, "video/x-h264", NULL);
1110   } else if (g_str_has_prefix(name, "msmpeg4")) {
1111     // msmpeg4v1,m msmpeg4v2, msmpeg4
1112     gint version;
1113
1114     if (strcmp (name, "msmpeg4v1") == 0) {
1115       version = 41;
1116     } else if (strcmp (name, "msmpeg4v2") == 0) {
1117       version = 42;
1118     } else {
1119       version = 43;
1120     }
1121
1122     caps = gst_maru_video_caps_new (ctx, name, "video/x-msmpeg",
1123           "msmpegversion", G_TYPE_INT, version, NULL);
1124     if (!encode && !strcmp (name, "msmpeg4")) {
1125        gst_caps_append (caps, gst_maru_video_caps_new (ctx, name,
1126             "video/x-divx", "divxversion", G_TYPE_INT, 3, NULL));
1127     }
1128   } else if (strcmp (name, "wmv3") == 0) {
1129     caps = gst_maru_video_caps_new (ctx, name, "video/x-wmv",
1130                 "wmvversion", G_TYPE_INT, 3, NULL);
1131   } else if (strcmp (name, "vc1") == 0) {
1132     caps = gst_maru_video_caps_new (ctx, name, "video/x-wmv",
1133                 "wmvversion", G_TYPE_INT, 3, "format", GST_TYPE_FOURCC,
1134                 GST_MAKE_FOURCC ('W', 'V', 'C', '1'),  NULL);
1135   } else if (strcmp (name, "aac") == 0) {
1136     caps = gst_maru_audio_caps_new (ctx, name, "audio/mpeg", NULL);
1137     if (!encode) {
1138         GValue arr = { 0, };
1139         GValue item = { 0, };
1140
1141         g_value_init (&arr, GST_TYPE_LIST);
1142         g_value_init (&item, G_TYPE_INT);
1143         g_value_set_int (&item, 2);
1144         gst_value_list_append_value (&arr, &item);
1145         g_value_set_int (&item, 4);
1146         gst_value_list_append_value (&arr, &item);
1147         g_value_unset (&item);
1148
1149         gst_caps_set_value (caps, "mpegversion", &arr);
1150         g_value_unset (&arr);
1151
1152         g_value_init (&arr, GST_TYPE_LIST);
1153         g_value_init (&item, G_TYPE_STRING);
1154         g_value_set_string (&item, "raw");
1155         gst_value_list_append_value (&arr, &item);
1156         g_value_set_string (&item, "adts");
1157         gst_value_list_append_value (&arr, &item);
1158         g_value_set_string (&item, "adif");
1159         gst_value_list_append_value (&arr, &item);
1160         g_value_unset (&item);
1161
1162         gst_caps_set_value (caps, "stream-format", &arr);
1163         g_value_unset (&arr);
1164     } else {
1165       gst_caps_set_simple (caps, "mpegversion", G_TYPE_INT, 4,
1166         "stream-format", G_TYPE_STRING, "raw",
1167         "base-profile", G_TYPE_STRING, "lc", NULL);
1168
1169         if (ctx && ctx->codecdata_size > 0) {
1170           gst_codec_utils_aac_caps_set_level_and_profile (caps,
1171             ctx->codecdata, ctx->codecdata_size);
1172         }
1173     }
1174   } else if (strcmp (name, "ac3") == 0) {
1175     caps = gst_maru_audio_caps_new (ctx, name, "audio/x-ac3", NULL);
1176   } else if (strcmp (name, "mp3") == 0) {
1177     if (encode) {
1178       caps = gst_maru_audio_caps_new (ctx, name, "audio/mpeg",
1179               "mpegversion", G_TYPE_INT, 1,
1180               "layer", GST_TYPE_INT_RANGE, 1, 3, NULL);
1181     } else {
1182       caps = gst_caps_new_simple("audio/mpeg",
1183               "mpegversion", G_TYPE_INT, 1,
1184               "layer", GST_TYPE_INT_RANGE, 1, 3, NULL);
1185     }
1186   } else if (strcmp (name, "mp3adu") == 0) {
1187     gchar *mime_type;
1188
1189     mime_type = g_strdup_printf ("audio/x-gst_ff-%s", name);
1190     caps = gst_maru_audio_caps_new (ctx, name, mime_type, NULL);
1191
1192     if (mime_type) {
1193       g_free(mime_type);
1194     }
1195   } else if (g_str_has_prefix(name, "wmav")) {
1196     gint version = 1;
1197     if (strcmp (name, "wmav2") == 0) {
1198       version = 2;
1199     }
1200     caps = gst_maru_audio_caps_new (ctx, name, "audio/x-wma", "wmaversion",
1201           G_TYPE_INT, version, "block_align", GST_TYPE_INT_RANGE, 0, G_MAXINT,
1202           "bitrate", GST_TYPE_INT_RANGE, 0, G_MAXINT, NULL);
1203   } else {
1204     GST_ERROR("failed to new caps for %s", name);
1205   }
1206
1207   if (caps != NULL) {
1208     if (ctx && ctx->codecdata_size > 0) {
1209       GST_DEBUG ("codec_data size %d", ctx->codecdata_size);
1210
1211       GstBuffer *data = gst_buffer_new_and_alloc (ctx->codecdata_size);
1212
1213       memcpy (GST_BUFFER_DATA(data), ctx->codecdata, ctx->codecdata_size);
1214       gst_caps_set_simple (caps, "codec_data", GST_TYPE_BUFFER, data, NULL);
1215       gst_buffer_unref (data);
1216     }
1217     GST_LOG ("caps for codec %s %" GST_PTR_FORMAT, name, caps);
1218   } else {
1219     GST_LOG ("No caps found for codec %s", name);
1220   }
1221
1222   return caps;
1223 }
1224
1225 typedef struct PixFmtInfo
1226 {
1227   uint8_t x_chroma_shift;       /* X chroma subsampling factor is 2 ^ shift */
1228   uint8_t y_chroma_shift;       /* Y chroma subsampling factor is 2 ^ shift */
1229 } PixFmtInfo;
1230
1231 static PixFmtInfo pix_fmt_info[PIX_FMT_NB];
1232
1233 void
1234 gst_maru_init_pix_fmt_info (void)
1235 {
1236   pix_fmt_info[PIX_FMT_YUV420P].x_chroma_shift = 1,
1237   pix_fmt_info[PIX_FMT_YUV420P].y_chroma_shift = 1;
1238
1239   pix_fmt_info[PIX_FMT_YUV422P].x_chroma_shift = 1;
1240   pix_fmt_info[PIX_FMT_YUV422P].y_chroma_shift = 0;
1241
1242   pix_fmt_info[PIX_FMT_YUV444P].x_chroma_shift = 0;
1243   pix_fmt_info[PIX_FMT_YUV444P].y_chroma_shift = 0;
1244
1245   pix_fmt_info[PIX_FMT_YUYV422].x_chroma_shift = 1;
1246   pix_fmt_info[PIX_FMT_YUYV422].y_chroma_shift = 0;
1247
1248   pix_fmt_info[PIX_FMT_YUV410P].x_chroma_shift = 2;
1249   pix_fmt_info[PIX_FMT_YUV410P].y_chroma_shift = 2;
1250
1251   pix_fmt_info[PIX_FMT_YUV411P].x_chroma_shift = 2;
1252   pix_fmt_info[PIX_FMT_YUV411P].y_chroma_shift = 0;
1253
1254   /* RGB formats */
1255   pix_fmt_info[PIX_FMT_RGB24].x_chroma_shift = 0;
1256   pix_fmt_info[PIX_FMT_RGB24].y_chroma_shift = 0;
1257
1258   pix_fmt_info[PIX_FMT_BGR24].x_chroma_shift = 0;
1259   pix_fmt_info[PIX_FMT_BGR24].y_chroma_shift = 0;
1260
1261   pix_fmt_info[PIX_FMT_RGB32].x_chroma_shift = 0;
1262   pix_fmt_info[PIX_FMT_RGB32].y_chroma_shift = 0;
1263
1264   pix_fmt_info[PIX_FMT_RGB565].x_chroma_shift = 0;
1265   pix_fmt_info[PIX_FMT_RGB565].y_chroma_shift = 0;
1266
1267   pix_fmt_info[PIX_FMT_RGB555].x_chroma_shift = 0;
1268   pix_fmt_info[PIX_FMT_RGB555].y_chroma_shift = 0;
1269 }
1270
1271 int
1272 gst_maru_avpicture_size (int pix_fmt, int width, int height)
1273 {
1274   int size, w2, h2, size2;
1275   int stride, stride2;
1276   int fsize;
1277   PixFmtInfo *pinfo;
1278
1279   pinfo = &pix_fmt_info[pix_fmt];
1280
1281   switch (pix_fmt) {
1282   case PIX_FMT_YUV420P:
1283   case PIX_FMT_YUV422P:
1284   case PIX_FMT_YUV444P:
1285   case PIX_FMT_YUV410P:
1286   case PIX_FMT_YUV411P:
1287     stride = ROUND_UP_4(width);
1288     h2 = ROUND_UP_X(height, pinfo->y_chroma_shift);
1289     size = stride * h2;
1290     w2 = DIV_ROUND_UP_X(width, pinfo->x_chroma_shift);
1291     stride2 = ROUND_UP_4(w2);
1292     h2 = DIV_ROUND_UP_X(height, pinfo->y_chroma_shift);
1293     size2 = stride2 * h2;
1294     fsize = size + 2 * size2;
1295     break;
1296   case PIX_FMT_RGB24:
1297   case PIX_FMT_BGR24:
1298     stride = ROUND_UP_4 (width * 3);
1299     fsize = stride * height;
1300     break;
1301   case PIX_FMT_RGB32:
1302     stride = width * 4;
1303     fsize = stride * height;
1304     break;
1305   case PIX_FMT_RGB555:
1306   case PIX_FMT_RGB565:
1307     stride = ROUND_UP_4 (width * 2);
1308     fsize = stride * height;
1309     break;
1310   default:
1311     fsize = -1;
1312     break;
1313   }
1314
1315   return fsize;
1316 }
1317
1318 int
1319 gst_maru_align_size (int buf_size)
1320 {
1321   int i, align_size;
1322
1323   align_size = buf_size / 1024;
1324
1325   for (i = 0; i < 14; i++) {
1326     if (align_size < (1 << i)) {
1327       align_size = 1024 * (1 << i);
1328       break;
1329     }
1330   }
1331
1332   return align_size;
1333 }