ext/ffmpeg/gstffmpegcodecmap.c

   1 /* GStreamer
   2  * Copyright (C) <1999> Erik Walthinsen <omega@cse.ogi.edu>
   3  * This file:
   4  * Copyright (c) 2002-2004 Ronald Bultje <rbultje@ronald.bitfreak.net>
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Library General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Library General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Library General Public
  17  * License along with this library; if not, write to the
  18  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  19  * Boston, MA 02111-1307, USA.
  20  */
  21
  22 #ifdef HAVE_CONFIG_H
  23 #include "config.h"
  24 #endif
  25 #include <gst/gst.h>
  26 #ifdef HAVE_FFMPEG_UNINSTALLED
  27 #include <avcodec.h>
  28 #else
  29 #include <libavcodec/avcodec.h>
  30 #endif
  31 #include <string.h>
  32
  33 #include "gstffmpeg.h"
  34 #include "gstffmpegcodecmap.h"
  35
  36 /*
  37  * Read a palette from a caps.
  38  */
  39
  40 static void
  41 gst_ffmpeg_get_palette (const GstCaps * caps, AVCodecContext * context)
  42 {
  43   GstStructure *str = gst_caps_get_structure (caps, 0);
  44   const GValue *palette_v;
  45   const GstBuffer *palette;
  46
  47   /* do we have a palette? */
  48   if ((palette_v = gst_structure_get_value (str, "palette_data")) && context) {
  49     palette = gst_value_get_buffer (palette_v);
  50     if (GST_BUFFER_SIZE (palette) >= AVPALETTE_SIZE) {
  51       if (context->palctrl)
  52         av_free (context->palctrl);
  53       context->palctrl = av_malloc (sizeof (AVPaletteControl));
  54       context->palctrl->palette_changed = 1;
  55       memcpy (context->palctrl->palette, GST_BUFFER_DATA (palette),
  56           AVPALETTE_SIZE);
  57     }
  58   }
  59 }
  60
  61 static void
  62 gst_ffmpeg_set_palette (GstCaps * caps, AVCodecContext * context)
  63 {
  64   if (context->palctrl) {
  65     GstBuffer *palette = gst_buffer_new_and_alloc (AVPALETTE_SIZE);
  66
  67     memcpy (GST_BUFFER_DATA (palette), context->palctrl->palette,
  68         AVPALETTE_SIZE);
  69     gst_caps_set_simple (caps, "palette_data", GST_TYPE_BUFFER, palette, NULL);
  70   }
  71 }
  72
  73 /* IMPORTANT: Keep this sorted by the ffmpeg channel masks */
  74 static const struct
  75 {
  76   guint64 ff;
  77   GstAudioChannelPosition gst;
  78 } _ff_to_gst_layout[] = {
  79   {
  80   CH_FRONT_LEFT, GST_AUDIO_CHANNEL_POSITION_FRONT_LEFT}, {
  81   CH_FRONT_RIGHT, GST_AUDIO_CHANNEL_POSITION_FRONT_RIGHT}, {
  82   CH_FRONT_CENTER, GST_AUDIO_CHANNEL_POSITION_FRONT_CENTER}, {
  83   CH_LOW_FREQUENCY, GST_AUDIO_CHANNEL_POSITION_LFE}, {
  84   CH_BACK_LEFT, GST_AUDIO_CHANNEL_POSITION_REAR_LEFT}, {
  85   CH_BACK_RIGHT, GST_AUDIO_CHANNEL_POSITION_REAR_RIGHT}, {
  86   CH_FRONT_LEFT_OF_CENTER, GST_AUDIO_CHANNEL_POSITION_FRONT_LEFT_OF_CENTER}, {
  87   CH_FRONT_RIGHT_OF_CENTER, GST_AUDIO_CHANNEL_POSITION_FRONT_RIGHT_OF_CENTER}, {
  88   CH_BACK_CENTER, GST_AUDIO_CHANNEL_POSITION_REAR_CENTER}, {
  89   CH_SIDE_LEFT, GST_AUDIO_CHANNEL_POSITION_SIDE_LEFT}, {
  90   CH_SIDE_RIGHT, GST_AUDIO_CHANNEL_POSITION_SIDE_RIGHT}, {
  91   CH_TOP_CENTER, GST_AUDIO_CHANNEL_POSITION_NONE}, {
  92   CH_TOP_FRONT_LEFT, GST_AUDIO_CHANNEL_POSITION_NONE}, {
  93   CH_TOP_FRONT_CENTER, GST_AUDIO_CHANNEL_POSITION_NONE}, {
  94   CH_TOP_FRONT_RIGHT, GST_AUDIO_CHANNEL_POSITION_NONE}, {
  95   CH_TOP_BACK_LEFT, GST_AUDIO_CHANNEL_POSITION_NONE}, {
  96   CH_TOP_BACK_CENTER, GST_AUDIO_CHANNEL_POSITION_NONE}, {
  97   CH_TOP_BACK_RIGHT, GST_AUDIO_CHANNEL_POSITION_NONE}, {
  98   CH_STEREO_LEFT, GST_AUDIO_CHANNEL_POSITION_FRONT_LEFT}, {
  99   CH_STEREO_RIGHT, GST_AUDIO_CHANNEL_POSITION_FRONT_RIGHT}
 100 };
 101
 102 static GstAudioChannelPosition *
 103 gst_ff_channel_layout_to_gst (guint64 channel_layout, guint channels)
 104 {
 105   guint nchannels = 0, i, j;
 106   GstAudioChannelPosition *pos = NULL;
 107   gboolean none_layout = FALSE;
 108
 109   for (i = 0; i < 64; i++) {
 110     if ((channel_layout & (G_GUINT64_CONSTANT (1) << i)) != 0) {
 111       nchannels++;
 112     }
 113   }
 114
 115   if (channel_layout == 0) {
 116     nchannels = channels;
 117     none_layout = TRUE;
 118   }
 119
 120   if (nchannels != channels) {
 121     GST_ERROR ("Number of channels is different (%u != %u)", channels,
 122         nchannels);
 123     return NULL;
 124   }
 125
 126   pos = g_new (GstAudioChannelPosition, nchannels);
 127
 128   for (i = 0, j = 0; i < G_N_ELEMENTS (_ff_to_gst_layout); i++) {
 129     if ((channel_layout & _ff_to_gst_layout[i].ff) != 0) {
 130       pos[j++] = _ff_to_gst_layout[i].gst;
 131
 132       if (_ff_to_gst_layout[i].gst == GST_AUDIO_CHANNEL_POSITION_NONE)
 133         none_layout = TRUE;
 134     }
 135   }
 136
 137   if (j != nchannels) {
 138     GST_WARNING ("Unknown channels in channel layout - assuming NONE layout");
 139     none_layout = TRUE;
 140   }
 141
 142   if (!none_layout && !gst_audio_check_channel_positions (pos, nchannels)) {
 143     GST_ERROR ("Invalid channel layout %" G_GUINT64_FORMAT
 144         " - assuming NONE layout", channel_layout);
 145     none_layout = TRUE;
 146   }
 147
 148   if (none_layout) {
 149     if (nchannels == 1) {
 150       pos[0] = GST_AUDIO_CHANNEL_POSITION_FRONT_MONO;
 151     } else if (nchannels == 2) {
 152       pos[0] = GST_AUDIO_CHANNEL_POSITION_FRONT_LEFT;
 153       pos[1] = GST_AUDIO_CHANNEL_POSITION_FRONT_RIGHT;
 154     } else if (channel_layout == 0) {
 155       g_free (pos);
 156       pos = NULL;
 157     } else {
 158       for (i = 0; i < nchannels; i++)
 159         pos[i] = GST_AUDIO_CHANNEL_POSITION_NONE;
 160     }
 161   }
 162
 163   if (nchannels == 1 && pos[0] == GST_AUDIO_CHANNEL_POSITION_FRONT_CENTER) {
 164     GST_DEBUG ("mono common case; won't set channel positions");
 165     g_free (pos);
 166     pos = NULL;
 167   } else if (nchannels == 2 && pos[0] == GST_AUDIO_CHANNEL_POSITION_FRONT_LEFT
 168       && pos[1] == GST_AUDIO_CHANNEL_POSITION_FRONT_RIGHT) {
 169     GST_DEBUG ("stereo common case; won't set channel positions");
 170     g_free (pos);
 171     pos = NULL;
 172   }
 173
 174   return pos;
 175 }
 176
 177 /* this macro makes a caps width fixed or unfixed width/height
 178  * properties depending on whether we've got a context.
 179  *
 180  * See below for why we use this.
 181  *
 182  * We should actually do this stuff at the end, like in riff-media.c,
 183  * but I'm too lazy today. Maybe later.
 184  */
 185 static GstCaps *
 186 gst_ff_vid_caps_new (AVCodecContext * context, enum CodecID codec_id,
 187     const char *mimetype, const char *fieldname, ...)
 188 {
 189   GstStructure *structure = NULL;
 190   GstCaps *caps = NULL;
 191   va_list var_args;
 192   gint i;
 193
 194   GST_LOG ("context:%p, codec_id:%d, mimetype:%s", context, codec_id, mimetype);
 195
 196   /* fixed, non probing context */
 197   if (context != NULL && context->width != -1) {
 198     caps = gst_caps_new_simple (mimetype,
 199         "width", G_TYPE_INT, context->width,
 200         "height", G_TYPE_INT, context->height,
 201         "framerate", GST_TYPE_FRACTION,
 202         context->time_base.den / context->ticks_per_frame,
 203         context->time_base.num, NULL);
 204   } else {
 205     /* so we are after restricted caps in this case */
 206     switch (codec_id) {
 207       case CODEC_ID_H261:
 208       {
 209         caps = gst_caps_new_simple (mimetype,
 210             "width", G_TYPE_INT, 352,
 211             "height", G_TYPE_INT, 288,
 212             "framerate", GST_TYPE_FRACTION_RANGE, 0, 1, G_MAXINT, 1, NULL);
 213         gst_caps_append (caps, gst_caps_new_simple (mimetype,
 214                 "width", G_TYPE_INT, 176,
 215                 "height", G_TYPE_INT, 144,
 216                 "framerate", GST_TYPE_FRACTION_RANGE, 0, 1, G_MAXINT, 1, NULL));
 217         break;
 218       }
 219       case CODEC_ID_H263:
 220       {
 221         /* 128x96, 176x144, 352x288, 704x576, and 1408x1152. slightly reordered
 222          * because we want automatic negotiation to go as close to 320x240 as
 223          * possible. */
 224         const static gint widths[] = { 352, 704, 176, 1408, 128 };
 225         const static gint heights[] = { 288, 576, 144, 1152, 96 };
 226         GstCaps *temp;
 227         gint n_sizes = G_N_ELEMENTS (widths);
 228
 229         caps = gst_caps_new_empty ();
 230         for (i = 0; i < n_sizes; i++) {
 231           temp = gst_caps_new_simple (mimetype,
 232               "width", G_TYPE_INT, widths[i],
 233               "height", G_TYPE_INT, heights[i],
 234               "framerate", GST_TYPE_FRACTION_RANGE, 0, 1, G_MAXINT, 1, NULL);
 235
 236           gst_caps_append (caps, temp);
 237         }
 238         break;
 239       }
 240       case CODEC_ID_DVVIDEO:
 241       {
 242         static struct
 243         {
 244           guint32 csp;
 245           gint width, height;
 246           gint par_n, par_d;
 247           gint framerate_n, framerate_d;
 248         } profiles[] = {
 249           {
 250           GST_MAKE_FOURCC ('Y', '4', '1', 'B'), 720, 480, 10, 11, 30000, 1001}, {
 251           GST_MAKE_FOURCC ('Y', '4', '1', 'B'), 720, 480, 40, 33, 30000, 1001}, {
 252           GST_MAKE_FOURCC ('I', '4', '2', '0'), 720, 576, 59, 54, 25, 1}, {
 253           GST_MAKE_FOURCC ('I', '4', '2', '0'), 720, 576, 118, 81, 25, 1}, {
 254           GST_MAKE_FOURCC ('Y', '4', '1', 'B'), 720, 576, 59, 54, 25, 1}, {
 255           GST_MAKE_FOURCC ('Y', '4', '1', 'B'), 720, 576, 118, 81, 25, 1}
 256         };
 257         GstCaps *temp;
 258         gint n_sizes = G_N_ELEMENTS (profiles);
 259
 260         caps = gst_caps_new_empty ();
 261         for (i = 0; i < n_sizes; i++) {
 262           temp = gst_caps_new_simple (mimetype,
 263               "width", G_TYPE_INT, profiles[i].width,
 264               "height", G_TYPE_INT, profiles[i].height,
 265               "framerate", GST_TYPE_FRACTION, profiles[i].framerate_n,
 266               profiles[i].framerate_d, "pixel-aspect-ratio", GST_TYPE_FRACTION,
 267               profiles[i].par_n, profiles[i].par_d, NULL);
 268
 269           gst_caps_append (caps, temp);
 270         }
 271         break;
 272       }
 273       case CODEC_ID_DNXHD:
 274       {
 275         caps = gst_caps_new_simple (mimetype,
 276             "width", G_TYPE_INT, 1920,
 277             "height", G_TYPE_INT, 1080,
 278             "framerate", GST_TYPE_FRACTION_RANGE, 0, 1, G_MAXINT, 1, NULL);
 279         gst_caps_append (caps, gst_caps_new_simple (mimetype,
 280                 "width", G_TYPE_INT, 1280,
 281                 "height", G_TYPE_INT, 720,
 282                 "framerate", GST_TYPE_FRACTION_RANGE, 0, 1, G_MAXINT, 1, NULL));
 283         break;
 284       }
 285       default:
 286         break;
 287     }
 288   }
 289
 290   /* no fixed caps or special restrictions applied;
 291    * default unfixed setting */
 292   if (!caps) {
 293     GST_DEBUG ("Creating default caps");
 294     caps = gst_caps_new_simple (mimetype,
 295         "width", GST_TYPE_INT_RANGE, 16, 4096,
 296         "height", GST_TYPE_INT_RANGE, 16, 4096,
 297         "framerate", GST_TYPE_FRACTION_RANGE, 0, 1, G_MAXINT, 1, NULL);
 298   }
 299
 300   for (i = 0; i < gst_caps_get_size (caps); i++) {
 301     va_start (var_args, fieldname);
 302     structure = gst_caps_get_structure (caps, i);
 303     gst_structure_set_valist (structure, fieldname, var_args);
 304     va_end (var_args);
 305   }
 306
 307   return caps;
 308 }
 309
 310 /* same for audio - now with channels/sample rate
 311  */
 312 static GstCaps *
 313 gst_ff_aud_caps_new (AVCodecContext * context, enum CodecID codec_id,
 314     const char *mimetype, const char *fieldname, ...)
 315 {
 316   GstCaps *caps = NULL;
 317   GstStructure *structure = NULL;
 318   gint i;
 319   va_list var_args;
 320
 321   /* fixed, non-probing context */
 322   if (context != NULL && context->channels != -1) {
 323     GstAudioChannelPosition *pos;
 324     guint64 channel_layout = context->channel_layout;
 325
 326     if (channel_layout == 0) {
 327       const guint64 default_channel_set[] = {
 328         0, 0, CH_LAYOUT_SURROUND, CH_LAYOUT_QUAD, CH_LAYOUT_5POINT0,
 329         CH_LAYOUT_5POINT1, 0, CH_LAYOUT_7POINT1
 330       };
 331
 332       switch (codec_id) {
 333         case CODEC_ID_EAC3:
 334         case CODEC_ID_AC3:
 335         case CODEC_ID_DTS:
 336           if (context->channels > 0
 337               && context->channels < G_N_ELEMENTS (default_channel_set))
 338             channel_layout = default_channel_set[context->channels - 1];
 339           break;
 340         default:
 341           break;
 342       }
 343     }
 344
 345     caps = gst_caps_new_simple (mimetype,
 346         "rate", G_TYPE_INT, context->sample_rate,
 347         "channels", G_TYPE_INT, context->channels, NULL);
 348
 349     pos = gst_ff_channel_layout_to_gst (channel_layout, context->channels);
 350     if (pos != NULL) {
 351       gst_audio_set_channel_positions (gst_caps_get_structure (caps, 0), pos);
 352       g_free (pos);
 353     }
 354   } else {
 355     gint maxchannels = 2;
 356     const gint *rates = NULL;
 357     gint n_rates = 0;
 358
 359     if (context) {
 360       /* so we must be after restricted caps in this particular case */
 361       switch (codec_id) {
 362         case CODEC_ID_MP2:
 363         {
 364           const static gint l_rates[] =
 365               { 48000, 44100, 32000, 24000, 22050, 16000 };
 366           n_rates = G_N_ELEMENTS (l_rates);
 367           rates = l_rates;
 368           break;
 369         }
 370         case CODEC_ID_EAC3:
 371         case CODEC_ID_AC3:
 372         {
 373           const static gint l_rates[] = { 48000, 44100, 32000 };
 374           n_rates = G_N_ELEMENTS (l_rates);
 375           rates = l_rates;
 376           break;
 377         }
 378         case CODEC_ID_ADPCM_SWF:
 379         {
 380           const static gint l_rates[] = { 11025, 22050, 44100 };
 381           n_rates = G_N_ELEMENTS (l_rates);
 382           rates = l_rates;
 383           break;
 384         }
 385         case CODEC_ID_ROQ_DPCM:
 386         {
 387           const static gint l_rates[] = { 22050 };
 388           n_rates = G_N_ELEMENTS (l_rates);
 389           rates = l_rates;
 390           break;
 391         }
 392         case CODEC_ID_ADPCM_G726:
 393           maxchannels = 1;
 394           break;
 395         case CODEC_ID_AMR_NB:
 396         {
 397           const static gint l_rates[] = { 8000 };
 398           maxchannels = 1;
 399           n_rates = G_N_ELEMENTS (l_rates);
 400           rates = l_rates;
 401           break;
 402         }
 403         case CODEC_ID_AMR_WB:
 404         {
 405           const static gint l_rates[] = { 16000 };
 406           maxchannels = 1;
 407           n_rates = G_N_ELEMENTS (l_rates);
 408           rates = l_rates;
 409           break;
 410         }
 411         default:
 412           break;
 413       }
 414
 415       /* TODO: handle context->channel_layouts here to set
 416        * the list of channel layouts supported by the encoder.
 417        * Unfortunately no encoder uses this yet....
 418        */
 419     }
 420
 421     /* regardless of encode/decode, open up channels if applicable */
 422     /* Until decoders/encoders expose the maximum number of channels
 423      * they support, we whitelist them here. */
 424     switch (codec_id) {
 425       case CODEC_ID_AC3:
 426       case CODEC_ID_EAC3:
 427       case CODEC_ID_AAC:
 428       case CODEC_ID_DTS:
 429         maxchannels = 6;
 430         break;
 431       case CODEC_ID_WMAPRO:
 432       case CODEC_ID_TRUEHD:
 433         maxchannels = 8;
 434         break;
 435       default:
 436         break;
 437     }
 438
 439     if (maxchannels == 1)
 440       caps = gst_caps_new_simple (mimetype,
 441           "channels", G_TYPE_INT, maxchannels, NULL);
 442     else
 443       caps = gst_caps_new_simple (mimetype,
 444           "channels", GST_TYPE_INT_RANGE, 1, maxchannels, NULL);
 445     if (n_rates) {
 446       GValue list = { 0, };
 447       GstStructure *structure;
 448
 449       g_value_init (&list, GST_TYPE_LIST);
 450       for (i = 0; i < n_rates; i++) {
 451         GValue v = { 0, };
 452
 453         g_value_init (&v, G_TYPE_INT);
 454         g_value_set_int (&v, rates[i]);
 455         gst_value_list_append_value (&list, &v);
 456         g_value_unset (&v);
 457       }
 458       structure = gst_caps_get_structure (caps, 0);
 459       gst_structure_set_value (structure, "rate", &list);
 460       g_value_unset (&list);
 461     } else
 462       gst_caps_set_simple (caps, "rate", GST_TYPE_INT_RANGE, 4000, 96000, NULL);
 463   }
 464
 465   for (i = 0; i < gst_caps_get_size (caps); i++) {
 466     va_start (var_args, fieldname);
 467     structure = gst_caps_get_structure (caps, i);
 468     gst_structure_set_valist (structure, fieldname, var_args);
 469     va_end (var_args);
 470   }
 471
 472   return caps;
 473 }
 474
 475 /* Convert a FFMPEG codec ID and optional AVCodecContext
 476  * to a GstCaps. If the context is ommitted, no fixed values
 477  * for video/audio size will be included in the GstCaps
 478  *
 479  * CodecID is primarily meant for compressed data GstCaps!
 480  *
 481  * encode is a special parameter. gstffmpegdec will say
 482  * FALSE, gstffmpegenc will say TRUE. The output caps
 483  * depends on this, in such a way that it will be very
 484  * specific, defined, fixed and correct caps for encoders,
 485  * yet very wide, "forgiving" caps for decoders. Example
 486  * for mp3: decode: audio/mpeg,mpegversion=1,layer=[1-3]
 487  * but encode: audio/mpeg,mpegversion=1,layer=3,bitrate=x,
 488  * rate=x,channels=x.
 489  */
 490
 491 GstCaps *
 492 gst_ffmpeg_codecid_to_caps (enum CodecID codec_id,
 493     AVCodecContext * context, gboolean encode)
 494 {
 495   GstCaps *caps = NULL;
 496   gboolean buildcaps = FALSE;
 497
 498   GST_LOG ("codec_id:%d, context:%p, encode:%d", codec_id, context, encode);
 499
 500   switch (codec_id) {
 501     case CODEC_ID_MPEG1VIDEO:
 502       /* FIXME: bitrate */
 503       caps = gst_ff_vid_caps_new (context, codec_id, "video/mpeg",
 504           "mpegversion", G_TYPE_INT, 1,
 505           "systemstream", G_TYPE_BOOLEAN, FALSE, NULL);
 506       break;
 507
 508     case CODEC_ID_MPEG2VIDEO:
 509       if (encode) {
 510         /* FIXME: bitrate */
 511         caps = gst_ff_vid_caps_new (context, codec_id, "video/mpeg",
 512             "mpegversion", G_TYPE_INT, 2,
 513             "systemstream", G_TYPE_BOOLEAN, FALSE, NULL);
 514       } else {
 515         /* decode both MPEG-1 and MPEG-2; width/height/fps are all in
 516          * the MPEG video stream headers, so may be omitted from caps. */
 517         caps = gst_caps_new_simple ("video/mpeg",
 518             "mpegversion", GST_TYPE_INT_RANGE, 1, 2,
 519             "systemstream", G_TYPE_BOOLEAN, FALSE, NULL);
 520       }
 521       break;
 522
 523     case CODEC_ID_MPEG2VIDEO_XVMC:
 524       /* this is a special ID - don't need it in GStreamer, I think */
 525       break;
 526
 527     case CODEC_ID_H263:
 528       if (encode) {
 529         caps = gst_ff_vid_caps_new (context, codec_id, "video/x-h263",
 530             "variant", G_TYPE_STRING, "itu",
 531             "h263version", G_TYPE_STRING, "h263", NULL);
 532       } else {
 533         /* don't pass codec_id, we can decode other variants with the H263
 534          * decoder that don't have specific size requirements
 535          */
 536         caps = gst_ff_vid_caps_new (context, CODEC_ID_NONE, "video/x-h263",
 537             "variant", G_TYPE_STRING, "itu", NULL);
 538       }
 539       break;
 540
 541     case CODEC_ID_H263P:
 542       caps = gst_ff_vid_caps_new (context, codec_id, "video/x-h263",
 543           "variant", G_TYPE_STRING, "itu",
 544           "h263version", G_TYPE_STRING, "h263p", NULL);
 545       if (encode && context) {
 546
 547         gst_caps_set_simple (caps,
 548             "annex-f", G_TYPE_BOOLEAN, context->flags & CODEC_FLAG_4MV,
 549             "annex-j", G_TYPE_BOOLEAN, context->flags & CODEC_FLAG_LOOP_FILTER,
 550             "annex-i", G_TYPE_BOOLEAN, context->flags & CODEC_FLAG_AC_PRED,
 551             "annex-t", G_TYPE_BOOLEAN, context->flags & CODEC_FLAG_AC_PRED,
 552             NULL);
 553       }
 554       break;
 555
 556     case CODEC_ID_H263I:
 557       caps = gst_ff_vid_caps_new (context, codec_id, "video/x-intel-h263",
 558           "variant", G_TYPE_STRING, "intel", NULL);
 559       break;
 560
 561     case CODEC_ID_H261:
 562       caps = gst_ff_vid_caps_new (context, codec_id, "video/x-h261", NULL);
 563       break;
 564
 565     case CODEC_ID_RV10:
 566     case CODEC_ID_RV20:
 567     case CODEC_ID_RV30:
 568     case CODEC_ID_RV40:
 569     {
 570       gint version;
 571
 572       switch (codec_id) {
 573         case CODEC_ID_RV40:
 574           version = 4;
 575           break;
 576         case CODEC_ID_RV30:
 577           version = 3;
 578           break;
 579         case CODEC_ID_RV20:
 580           version = 2;
 581           break;
 582         default:
 583           version = 1;
 584           break;
 585       }
 586
 587       /* FIXME: context->sub_id must be filled in during decoding */
 588       caps = gst_ff_vid_caps_new (context, codec_id, "video/x-pn-realvideo",
 589           "systemstream", G_TYPE_BOOLEAN, FALSE,
 590           "rmversion", G_TYPE_INT, version, NULL);
 591       if (context) {
 592         gst_caps_set_simple (caps, "format", G_TYPE_INT, context->sub_id, NULL);
 593         if (context->extradata_size >= 8) {
 594           gst_caps_set_simple (caps,
 595               "subformat", G_TYPE_INT, GST_READ_UINT32_BE (context->extradata),
 596               NULL);
 597         }
 598       }
 599     }
 600       break;
 601
 602     case CODEC_ID_MP1:
 603       /* FIXME: bitrate */
 604       caps = gst_ff_aud_caps_new (context, codec_id, "audio/mpeg",
 605           "mpegversion", G_TYPE_INT, 1, "layer", G_TYPE_INT, 1, NULL);
 606       break;
 607
 608     case CODEC_ID_MP2:
 609       /* FIXME: bitrate */
 610       caps = gst_ff_aud_caps_new (context, codec_id, "audio/mpeg",
 611           "mpegversion", G_TYPE_INT, 1, "layer", G_TYPE_INT, 2, NULL);
 612       break;
 613
 614     case CODEC_ID_MP3:
 615       if (encode) {
 616         /* FIXME: bitrate */
 617         caps = gst_ff_aud_caps_new (context, codec_id, "audio/mpeg",
 618             "mpegversion", G_TYPE_INT, 1, "layer", G_TYPE_INT, 3, NULL);
 619       } else {
 620         /* Decodes MPEG-1 layer 1/2/3. Samplerate, channels et al are
 621          * in the MPEG audio header, so may be omitted from caps. */
 622         caps = gst_caps_new_simple ("audio/mpeg",
 623             "mpegversion", G_TYPE_INT, 1,
 624             "layer", GST_TYPE_INT_RANGE, 1, 3, NULL);
 625       }
 626       break;
 627
 628     case CODEC_ID_MUSEPACK7:
 629       caps =
 630           gst_ff_aud_caps_new (context, codec_id,
 631           "audio/x-ffmpeg-parsed-musepack", "streamversion", G_TYPE_INT, 7,
 632           NULL);
 633       break;
 634
 635     case CODEC_ID_MUSEPACK8:
 636       caps =
 637           gst_ff_aud_caps_new (context, codec_id,
 638           "audio/x-ffmpeg-parsed-musepack", "streamversion", G_TYPE_INT, 8,
 639           NULL);
 640       break;
 641
 642     case CODEC_ID_AC3:
 643       /* FIXME: bitrate */
 644       caps = gst_ff_aud_caps_new (context, codec_id, "audio/x-ac3", NULL);
 645       break;
 646
 647     case CODEC_ID_EAC3:
 648       /* FIXME: bitrate */
 649       caps = gst_ff_aud_caps_new (context, codec_id, "audio/x-eac3", NULL);
 650       break;
 651
 652     case CODEC_ID_TRUEHD:
 653       caps = gst_ff_aud_caps_new (context, codec_id, "audio/x-true-hd", NULL);
 654       break;
 655
 656     case CODEC_ID_ATRAC1:
 657       caps =
 658           gst_ff_aud_caps_new (context, codec_id, "audio/x-vnd.sony.atrac1",
 659           NULL);
 660       break;
 661
 662     case CODEC_ID_ATRAC3:
 663       caps =
 664           gst_ff_aud_caps_new (context, codec_id, "audio/x-vnd.sony.atrac3",
 665           NULL);
 666       break;
 667
 668     case CODEC_ID_DTS:
 669       caps = gst_ff_aud_caps_new (context, codec_id, "audio/x-dts", NULL);
 670       break;
 671
 672     case CODEC_ID_APE:
 673       caps =
 674           gst_ff_aud_caps_new (context, codec_id, "audio/x-ffmpeg-parsed-ape",
 675           NULL);
 676       if (context) {
 677         gst_caps_set_simple (caps,
 678             "depth", G_TYPE_INT, context->bits_per_coded_sample, NULL);
 679       }
 680       break;
 681
 682     case CODEC_ID_MLP:
 683       caps = gst_ff_aud_caps_new (context, codec_id, "audio/x-mlp", NULL);
 684       break;
 685
 686     case CODEC_ID_IMC:
 687       caps = gst_ff_aud_caps_new (context, codec_id, "audio/x-imc", NULL);
 688       break;
 689
 690       /* MJPEG is normal JPEG, Motion-JPEG and Quicktime MJPEG-A. MJPEGB
 691        * is Quicktime's MJPEG-B. LJPEG is lossless JPEG. I don't know what
 692        * sp5x is, but it's apparently something JPEG... We don't separate
 693        * between those in GStreamer. Should we (at least between MJPEG,
 694        * MJPEG-B and sp5x decoding...)? */
 695     case CODEC_ID_MJPEG:
 696     case CODEC_ID_LJPEG:
 697       caps = gst_ff_vid_caps_new (context, codec_id, "image/jpeg", NULL);
 698       break;
 699
 700     case CODEC_ID_SP5X:
 701       caps = gst_ff_vid_caps_new (context, codec_id, "video/sp5x", NULL);
 702       break;
 703
 704     case CODEC_ID_MJPEGB:
 705       caps = gst_ff_vid_caps_new (context, codec_id, "video/x-mjpeg-b", NULL);
 706       break;
 707
 708     case CODEC_ID_MPEG4:
 709       if (encode && context != NULL) {
 710         /* I'm not exactly sure what ffmpeg outputs... ffmpeg itself uses
 711          * the AVI fourcc 'DIVX', but 'mp4v' for Quicktime... */
 712         switch (context->codec_tag) {
 713           case GST_MAKE_FOURCC ('D', 'I', 'V', 'X'):
 714             caps = gst_ff_vid_caps_new (context, codec_id, "video/x-divx",
 715                 "divxversion", G_TYPE_INT, 5, NULL);
 716             break;
 717           case GST_MAKE_FOURCC ('m', 'p', '4', 'v'):
 718           default:
 719             /* FIXME: bitrate */
 720             caps = gst_ff_vid_caps_new (context, codec_id, "video/mpeg",
 721                 "systemstream", G_TYPE_BOOLEAN, FALSE,
 722                 "mpegversion", G_TYPE_INT, 4, NULL);
 723             break;
 724         }
 725       } else {
 726         /* The trick here is to separate xvid, divx, mpeg4, 3ivx et al */
 727         caps = gst_ff_vid_caps_new (context, codec_id, "video/mpeg",
 728             "mpegversion", G_TYPE_INT, 4,
 729             "systemstream", G_TYPE_BOOLEAN, FALSE, NULL);
 730         if (encode) {
 731           gst_caps_append (caps, gst_ff_vid_caps_new (context, codec_id,
 732                   "video/x-divx", "divxversion", G_TYPE_INT, 5, NULL));
 733         } else {
 734           gst_caps_append (caps, gst_ff_vid_caps_new (context, codec_id,
 735                   "video/x-divx", "divxversion", GST_TYPE_INT_RANGE, 4, 5,
 736                   NULL));
 737           gst_caps_append (caps, gst_ff_vid_caps_new (context, codec_id,
 738                   "video/x-xvid", NULL));
 739           gst_caps_append (caps, gst_ff_vid_caps_new (context, codec_id,
 740                   "video/x-3ivx", NULL));
 741         }
 742       }
 743       break;
 744
 745     case CODEC_ID_RAWVIDEO:
 746       caps = gst_ffmpeg_codectype_to_caps (CODEC_TYPE_VIDEO, context, codec_id,
 747           encode);
 748       break;
 749
 750     case CODEC_ID_MSMPEG4V1:
 751     case CODEC_ID_MSMPEG4V2:
 752     case CODEC_ID_MSMPEG4V3:
 753     {
 754       gint version = 41 + codec_id - CODEC_ID_MSMPEG4V1;
 755
 756       /* encode-FIXME: bitrate */
 757       caps = gst_ff_vid_caps_new (context, codec_id, "video/x-msmpeg",
 758           "msmpegversion", G_TYPE_INT, version, NULL);
 759       if (!encode && codec_id == CODEC_ID_MSMPEG4V3) {
 760         gst_caps_append (caps, gst_ff_vid_caps_new (context, codec_id,
 761                 "video/x-divx", "divxversion", G_TYPE_INT, 3, NULL));
 762       }
 763     }
 764       break;
 765
 766     case CODEC_ID_WMV1:
 767     case CODEC_ID_WMV2:
 768     {
 769       gint version = (codec_id == CODEC_ID_WMV1) ? 1 : 2;
 770
 771       caps = gst_ff_vid_caps_new (context, codec_id, "video/x-wmv",
 772           "wmvversion", G_TYPE_INT, version, NULL);
 773     }
 774       break;
 775
 776     case CODEC_ID_FLV1:
 777       caps = gst_ff_vid_caps_new (context, codec_id, "video/x-flash-video",
 778           "flvversion", G_TYPE_INT, 1, NULL);
 779       break;
 780
 781     case CODEC_ID_SVQ1:
 782       caps = gst_ff_vid_caps_new (context, codec_id, "video/x-svq",
 783           "svqversion", G_TYPE_INT, 1, NULL);
 784       break;
 785
 786     case CODEC_ID_SVQ3:
 787       caps = gst_ff_vid_caps_new (context, codec_id, "video/x-svq",
 788           "svqversion", G_TYPE_INT, 3, NULL);
 789       break;
 790
 791     case CODEC_ID_DVAUDIO:
 792       caps = gst_ff_aud_caps_new (context, codec_id, "audio/x-dv", NULL);
 793       break;
 794
 795     case CODEC_ID_DVVIDEO:
 796     {
 797       if (encode && context) {
 798         guint32 fourcc;
 799
 800         switch (context->pix_fmt) {
 801           case PIX_FMT_YUYV422:
 802             fourcc = GST_MAKE_FOURCC ('Y', 'U', 'Y', '2');
 803             break;
 804           case PIX_FMT_YUV420P:
 805             fourcc = GST_MAKE_FOURCC ('I', '4', '2', '0');
 806             break;
 807           case PIX_FMT_YUV411P:
 808             fourcc = GST_MAKE_FOURCC ('Y', '4', '1', 'B');
 809             break;
 810           case PIX_FMT_YUV422P:
 811             fourcc = GST_MAKE_FOURCC ('Y', '4', '2', 'B');
 812             break;
 813           case PIX_FMT_YUV410P:
 814             fourcc = GST_MAKE_FOURCC ('Y', 'U', 'V', '9');
 815             break;
 816           default:
 817             GST_WARNING
 818                 ("Couldnt' find fourcc for pixfmt %d, defaulting to I420",
 819                 context->pix_fmt);
 820             fourcc = GST_MAKE_FOURCC ('I', '4', '2', '0');
 821             break;
 822         }
 823         caps = gst_ff_vid_caps_new (context, codec_id, "video/x-dv",
 824             "systemstream", G_TYPE_BOOLEAN, FALSE,
 825             "format", GST_TYPE_FOURCC, fourcc, NULL);
 826       } else {
 827         caps = gst_ff_vid_caps_new (context, codec_id, "video/x-dv",
 828             "systemstream", G_TYPE_BOOLEAN, FALSE, NULL);
 829       }
 830     }
 831       break;
 832
 833     case CODEC_ID_WMAV1:
 834     case CODEC_ID_WMAV2:
 835     {
 836       gint version = (codec_id == CODEC_ID_WMAV1) ? 1 : 2;
 837
 838       if (context) {
 839         caps = gst_ff_aud_caps_new (context, codec_id, "audio/x-wma",
 840             "wmaversion", G_TYPE_INT, version,
 841             "block_align", G_TYPE_INT, context->block_align,
 842             "bitrate", G_TYPE_INT, context->bit_rate, NULL);
 843       } else {
 844         caps = gst_ff_aud_caps_new (context, codec_id, "audio/x-wma",
 845             "wmaversion", G_TYPE_INT, version,
 846             "block_align", GST_TYPE_INT_RANGE, 0, G_MAXINT,
 847             "bitrate", GST_TYPE_INT_RANGE, 0, G_MAXINT, NULL);
 848       }
 849     }
 850       break;
 851     case CODEC_ID_WMAPRO:
 852     {
 853       caps = gst_ff_aud_caps_new (context, codec_id, "audio/x-wma",
 854           "wmaversion", G_TYPE_INT, 3, NULL);
 855       break;
 856     }
 857
 858     case CODEC_ID_WMAVOICE:
 859     {
 860       caps = gst_ff_aud_caps_new (context, codec_id, "audio/x-wms", NULL);
 861       break;
 862     }
 863
 864     case CODEC_ID_MACE3:
 865     case CODEC_ID_MACE6:
 866     {
 867       gint version = (codec_id == CODEC_ID_MACE3) ? 3 : 6;
 868
 869       caps = gst_ff_aud_caps_new (context, codec_id, "audio/x-mace",
 870           "maceversion", G_TYPE_INT, version, NULL);
 871     }
 872       break;
 873
 874     case CODEC_ID_HUFFYUV:
 875       caps = gst_ff_vid_caps_new (context, codec_id, "video/x-huffyuv", NULL);
 876       if (context) {
 877         gst_caps_set_simple (caps,
 878             "bpp", G_TYPE_INT, context->bits_per_coded_sample, NULL);
 879       }
 880       break;
 881
 882     case CODEC_ID_CYUV:
 883       caps =
 884           gst_ff_vid_caps_new (context, codec_id, "video/x-compressed-yuv",
 885           NULL);
 886       break;
 887
 888     case CODEC_ID_H264:
 889       caps = gst_ff_vid_caps_new (context, codec_id, "video/x-h264", NULL);
 890       break;
 891
 892     case CODEC_ID_INDEO5:
 893       caps = gst_ff_vid_caps_new (context, codec_id, "video/x-indeo",
 894           "indeoversion", G_TYPE_INT, 5, NULL);
 895       break;
 896
 897     case CODEC_ID_INDEO3:
 898       caps = gst_ff_vid_caps_new (context, codec_id, "video/x-indeo",
 899           "indeoversion", G_TYPE_INT, 3, NULL);
 900       break;
 901
 902     case CODEC_ID_INDEO2:
 903       caps = gst_ff_vid_caps_new (context, codec_id, "video/x-indeo",
 904           "indeoversion", G_TYPE_INT, 2, NULL);
 905       break;
 906
 907     case CODEC_ID_FLASHSV:
 908       caps =
 909           gst_ff_vid_caps_new (context, codec_id, "video/x-flash-screen", NULL);
 910       break;
 911
 912     case CODEC_ID_VP3:
 913       caps = gst_ff_vid_caps_new (context, codec_id, "video/x-vp3", NULL);
 914       break;
 915
 916     case CODEC_ID_VP5:
 917       caps = gst_ff_vid_caps_new (context, codec_id, "video/x-vp5", NULL);
 918       break;
 919
 920     case CODEC_ID_VP6:
 921       caps = gst_ff_vid_caps_new (context, codec_id, "video/x-vp6", NULL);
 922       break;
 923
 924     case CODEC_ID_VP6F:
 925       caps = gst_ff_vid_caps_new (context, codec_id, "video/x-vp6-flash", NULL);
 926       break;
 927
 928     case CODEC_ID_VP6A:
 929       caps = gst_ff_vid_caps_new (context, codec_id, "video/x-vp6-alpha", NULL);
 930       break;
 931
 932     case CODEC_ID_THEORA:
 933       caps = gst_ff_vid_caps_new (context, codec_id, "video/x-theora", NULL);
 934       break;
 935
 936     case CODEC_ID_AAC:
 937       caps = gst_ff_aud_caps_new (context, codec_id, "audio/mpeg",
 938           "mpegversion", G_TYPE_INT, 4, NULL);
 939       break;
 940
 941     case CODEC_ID_ASV1:
 942       caps = gst_ff_vid_caps_new (context, codec_id, "video/x-asus",
 943           "asusversion", G_TYPE_INT, 1, NULL);
 944       break;
 945     case CODEC_ID_ASV2:
 946       caps = gst_ff_vid_caps_new (context, codec_id, "video/x-asus",
 947           "asusversion", G_TYPE_INT, 2, NULL);
 948       break;
 949
 950     case CODEC_ID_FFV1:
 951       caps = gst_ff_vid_caps_new (context, codec_id, "video/x-ffv",
 952           "ffvversion", G_TYPE_INT, 1, NULL);
 953       break;
 954
 955     case CODEC_ID_4XM:
 956       caps = gst_ff_vid_caps_new (context, codec_id, "video/x-4xm", NULL);
 957       break;
 958
 959     case CODEC_ID_XAN_WC3:
 960     case CODEC_ID_XAN_WC4:
 961       caps = gst_ff_vid_caps_new (context, codec_id, "video/x-xan",
 962           "wcversion", G_TYPE_INT, 3 - CODEC_ID_XAN_WC3 + codec_id, NULL);
 963       break;
 964
 965     case CODEC_ID_CLJR:
 966       caps =
 967           gst_ff_vid_caps_new (context, codec_id,
 968           "video/x-cirrus-logic-accupak", NULL);
 969       break;
 970
 971     case CODEC_ID_FRAPS:
 972       caps = gst_ff_vid_caps_new (context, codec_id, "video/x-fraps", NULL);
 973       break;
 974
 975     case CODEC_ID_MDEC:
 976     case CODEC_ID_ROQ:
 977     case CODEC_ID_INTERPLAY_VIDEO:
 978       buildcaps = TRUE;
 979       break;
 980
 981     case CODEC_ID_VCR1:
 982       caps = gst_ff_vid_caps_new (context, codec_id, "video/x-ati-vcr",
 983           "vcrversion", G_TYPE_INT, 1, NULL);
 984       break;
 985
 986     case CODEC_ID_RPZA:
 987       caps =
 988           gst_ff_vid_caps_new (context, codec_id, "video/x-apple-video", NULL);
 989       break;
 990
 991     case CODEC_ID_CINEPAK:
 992       caps = gst_ff_vid_caps_new (context, codec_id, "video/x-cinepak", NULL);
 993       break;
 994
 995       /* WS_VQA belogns here (order) */
 996
 997     case CODEC_ID_MSRLE:
 998       caps = gst_ff_vid_caps_new (context, codec_id, "video/x-rle",
 999           "layout", G_TYPE_STRING, "microsoft", NULL);
1000       if (context) {
1001         gst_caps_set_simple (caps,
1002             "depth", G_TYPE_INT, (gint) context->bits_per_coded_sample, NULL);
1003       } else {
1004         gst_caps_set_simple (caps, "depth", GST_TYPE_INT_RANGE, 1, 64, NULL);
1005       }
1006       break;
1007
1008     case CODEC_ID_QTRLE:
1009       caps = gst_ff_vid_caps_new (context, codec_id, "video/x-rle",
1010           "layout", G_TYPE_STRING, "quicktime", NULL);
1011       if (context) {
1012         gst_caps_set_simple (caps,
1013             "depth", G_TYPE_INT, (gint) context->bits_per_coded_sample, NULL);
1014       } else {
1015         gst_caps_set_simple (caps, "depth", GST_TYPE_INT_RANGE, 1, 64, NULL);
1016       }
1017       break;
1018
1019     case CODEC_ID_MSVIDEO1:
1020       caps = gst_ff_vid_caps_new (context, codec_id, "video/x-msvideocodec",
1021           "msvideoversion", G_TYPE_INT, 1, NULL);
1022       break;
1023
1024     case CODEC_ID_WMV3:
1025       caps = gst_ff_vid_caps_new (context, codec_id, "video/x-wmv",
1026           "wmvversion", G_TYPE_INT, 3, NULL);
1027       break;
1028     case CODEC_ID_VC1:
1029       caps = gst_ff_vid_caps_new (context, codec_id, "video/x-wmv",
1030           "wmvversion", G_TYPE_INT, 3, "format", GST_TYPE_FOURCC,
1031           GST_MAKE_FOURCC ('W', 'V', 'C', '1'), NULL);
1032       break;
1033     case CODEC_ID_QDM2:
1034       caps = gst_ff_aud_caps_new (context, codec_id, "audio/x-qdm2", NULL);
1035       break;
1036
1037     case CODEC_ID_MSZH:
1038       caps = gst_ff_vid_caps_new (context, codec_id, "video/x-mszh", NULL);
1039       break;
1040
1041     case CODEC_ID_ZLIB:
1042       caps = gst_ff_vid_caps_new (context, codec_id, "video/x-zlib", NULL);
1043       break;
1044
1045     case CODEC_ID_TRUEMOTION1:
1046       caps = gst_ff_vid_caps_new (context, codec_id, "video/x-truemotion",
1047           "trueversion", G_TYPE_INT, 1, NULL);
1048       break;
1049     case CODEC_ID_TRUEMOTION2:
1050       caps = gst_ff_vid_caps_new (context, codec_id, "video/x-truemotion",
1051           "trueversion", G_TYPE_INT, 2, NULL);
1052       break;
1053
1054     case CODEC_ID_ULTI:
1055       caps = gst_ff_vid_caps_new (context, codec_id, "video/x-ultimotion",
1056           NULL);
1057       break;
1058
1059     case CODEC_ID_TSCC:
1060       caps = gst_ff_vid_caps_new (context, codec_id, "video/x-camtasia", NULL);
1061       if (context) {
1062         gst_caps_set_simple (caps,
1063             "depth", G_TYPE_INT, (gint) context->bits_per_coded_sample, NULL);
1064       } else {
1065         gst_caps_set_simple (caps, "depth", GST_TYPE_INT_RANGE, 8, 32, NULL);
1066       }
1067       break;
1068
1069     case CODEC_ID_KMVC:
1070       caps = gst_ff_vid_caps_new (context, codec_id, "video/x-kmvc", NULL);
1071       break;
1072
1073     case CODEC_ID_NUV:
1074       caps = gst_ff_vid_caps_new (context, codec_id, "video/x-nuv", NULL);
1075       break;
1076
1077     case CODEC_ID_GIF:
1078       caps = gst_ff_vid_caps_new (context, codec_id, "image/gif", NULL);
1079       break;
1080
1081     case CODEC_ID_PNG:
1082       caps = gst_ff_vid_caps_new (context, codec_id, "image/png", NULL);
1083       break;
1084
1085     case CODEC_ID_PPM:
1086       caps = gst_ff_vid_caps_new (context, codec_id, "image/ppm", NULL);
1087       break;
1088
1089     case CODEC_ID_PBM:
1090       caps = gst_ff_vid_caps_new (context, codec_id, "image/pbm", NULL);
1091       break;
1092
1093     case CODEC_ID_PAM:
1094       caps =
1095           gst_ff_vid_caps_new (context, codec_id, "image/x-portable-anymap",
1096           NULL);
1097       break;
1098
1099     case CODEC_ID_PGM:
1100       caps =
1101           gst_ff_vid_caps_new (context, codec_id, "image/x-portable-graymap",
1102           NULL);
1103       break;
1104
1105     case CODEC_ID_PCX:
1106       caps = gst_ff_vid_caps_new (context, codec_id, "image/x-pcx", NULL);
1107       break;
1108
1109     case CODEC_ID_SGI:
1110       caps = gst_ff_vid_caps_new (context, codec_id, "image/x-sgi", NULL);
1111       break;
1112
1113     case CODEC_ID_TARGA:
1114       caps = gst_ff_vid_caps_new (context, codec_id, "image/x-tga", NULL);
1115       break;
1116
1117     case CODEC_ID_TIFF:
1118       caps = gst_ff_vid_caps_new (context, codec_id, "image/tiff", NULL);
1119       break;
1120
1121     case CODEC_ID_SUNRAST:
1122       caps =
1123           gst_ff_vid_caps_new (context, codec_id, "image/x-sun-raster", NULL);
1124       break;
1125
1126     case CODEC_ID_SMC:
1127       caps = gst_ff_vid_caps_new (context, codec_id, "video/x-smc", NULL);
1128       break;
1129
1130     case CODEC_ID_QDRAW:
1131       caps = gst_ff_vid_caps_new (context, codec_id, "video/x-qdrw", NULL);
1132       break;
1133
1134     case CODEC_ID_DNXHD:
1135       caps = gst_ff_vid_caps_new (context, codec_id, "video/x-dnxhd", NULL);
1136       break;
1137
1138     case CODEC_ID_MIMIC:
1139       caps = gst_ff_vid_caps_new (context, codec_id, "video/x-mimic", NULL);
1140       break;
1141
1142     case CODEC_ID_VMNC:
1143       caps = gst_ff_vid_caps_new (context, codec_id, "video/x-vmnc", NULL);
1144       break;
1145
1146     case CODEC_ID_TRUESPEECH:
1147       caps =
1148           gst_ff_aud_caps_new (context, codec_id, "audio/x-truespeech", NULL);
1149       break;
1150
1151     case CODEC_ID_QCELP:
1152       caps = gst_ff_aud_caps_new (context, codec_id, "audio/qcelp", NULL);
1153       break;
1154
1155     case CODEC_ID_AMV:
1156       caps = gst_ff_vid_caps_new (context, codec_id, "video/x-amv", NULL);
1157       break;
1158
1159     case CODEC_ID_AASC:
1160       caps = gst_ff_vid_caps_new (context, codec_id, "video/x-aasc", NULL);
1161       break;
1162
1163     case CODEC_ID_LOCO:
1164       caps = gst_ff_vid_caps_new (context, codec_id, "video/x-loco", NULL);
1165       break;
1166
1167     case CODEC_ID_ZMBV:
1168       caps = gst_ff_vid_caps_new (context, codec_id, "video/x-zmbv", NULL);
1169       break;
1170
1171
1172     case CODEC_ID_WS_VQA:
1173     case CODEC_ID_IDCIN:
1174     case CODEC_ID_8BPS:
1175     case CODEC_ID_FLIC:
1176     case CODEC_ID_VMDVIDEO:
1177     case CODEC_ID_VMDAUDIO:
1178     case CODEC_ID_SONIC:
1179     case CODEC_ID_SONIC_LS:
1180     case CODEC_ID_SNOW:
1181     case CODEC_ID_VIXL:
1182     case CODEC_ID_QPEG:
1183     case CODEC_ID_XVID:
1184     case CODEC_ID_PGMYUV:
1185     case CODEC_ID_FFVHUFF:
1186     case CODEC_ID_WNV1:
1187     case CODEC_ID_MP3ADU:
1188     case CODEC_ID_MP3ON4:
1189     case CODEC_ID_WESTWOOD_SND1:
1190     case CODEC_ID_CSCD:
1191     case CODEC_ID_MMVIDEO:
1192     case CODEC_ID_AVS:
1193     case CODEC_ID_CAVS:
1194       buildcaps = TRUE;
1195       break;
1196
1197       /* weird quasi-codecs for the demuxers only */
1198     case CODEC_ID_PCM_S16LE:
1199     case CODEC_ID_PCM_S16BE:
1200     case CODEC_ID_PCM_U16LE:
1201     case CODEC_ID_PCM_U16BE:
1202     case CODEC_ID_PCM_S8:
1203     case CODEC_ID_PCM_U8:
1204     {
1205       gint width = 0, depth = 0, endianness = 0;
1206       gboolean signedness = FALSE;      /* blabla */
1207
1208       switch (codec_id) {
1209         case CODEC_ID_PCM_S16LE:
1210           width = 16;
1211           depth = 16;
1212           endianness = G_LITTLE_ENDIAN;
1213           signedness = TRUE;
1214           break;
1215         case CODEC_ID_PCM_S16BE:
1216           width = 16;
1217           depth = 16;
1218           endianness = G_BIG_ENDIAN;
1219           signedness = TRUE;
1220           break;
1221         case CODEC_ID_PCM_U16LE:
1222           width = 16;
1223           depth = 16;
1224           endianness = G_LITTLE_ENDIAN;
1225           signedness = FALSE;
1226           break;
1227         case CODEC_ID_PCM_U16BE:
1228           width = 16;
1229           depth = 16;
1230           endianness = G_BIG_ENDIAN;
1231           signedness = FALSE;
1232           break;
1233         case CODEC_ID_PCM_S8:
1234           width = 8;
1235           depth = 8;
1236           endianness = G_BYTE_ORDER;
1237           signedness = TRUE;
1238           break;
1239         case CODEC_ID_PCM_U8:
1240           width = 8;
1241           depth = 8;
1242           endianness = G_BYTE_ORDER;
1243           signedness = FALSE;
1244           break;
1245         default:
1246           g_assert (0);         /* don't worry, we never get here */
1247           break;
1248       }
1249
1250       caps = gst_ff_aud_caps_new (context, codec_id, "audio/x-raw-int",
1251           "width", G_TYPE_INT, width,
1252           "depth", G_TYPE_INT, depth,
1253           "endianness", G_TYPE_INT, endianness,
1254           "signed", G_TYPE_BOOLEAN, signedness, NULL);
1255     }
1256       break;
1257
1258     case CODEC_ID_PCM_MULAW:
1259       caps = gst_ff_aud_caps_new (context, codec_id, "audio/x-mulaw", NULL);
1260       break;
1261
1262     case CODEC_ID_PCM_ALAW:
1263       caps = gst_ff_aud_caps_new (context, codec_id, "audio/x-alaw", NULL);
1264       break;
1265
1266     case CODEC_ID_ADPCM_G726:
1267     {
1268       /* the G726 decoder can also handle G721 */
1269       caps = gst_ff_aud_caps_new (context, codec_id, "audio/x-adpcm",
1270           "layout", G_TYPE_STRING, "g726", NULL);
1271       if (context)
1272         gst_caps_set_simple (caps,
1273             "block_align", G_TYPE_INT, context->block_align,
1274             "bitrate", G_TYPE_INT, context->bit_rate, NULL);
1275
1276       if (!encode) {
1277         gst_caps_append (caps, gst_caps_new_simple ("audio/x-adpcm",
1278                 "layout", G_TYPE_STRING, "g721",
1279                 "channels", G_TYPE_INT, 1, "rate", G_TYPE_INT, 8000, NULL));
1280       }
1281       break;
1282     }
1283     case CODEC_ID_ADPCM_IMA_QT:
1284     case CODEC_ID_ADPCM_IMA_WAV:
1285     case CODEC_ID_ADPCM_IMA_DK3:
1286     case CODEC_ID_ADPCM_IMA_DK4:
1287     case CODEC_ID_ADPCM_IMA_WS:
1288     case CODEC_ID_ADPCM_IMA_SMJPEG:
1289     case CODEC_ID_ADPCM_IMA_AMV:
1290     case CODEC_ID_ADPCM_IMA_ISS:
1291     case CODEC_ID_ADPCM_IMA_EA_EACS:
1292     case CODEC_ID_ADPCM_IMA_EA_SEAD:
1293     case CODEC_ID_ADPCM_MS:
1294     case CODEC_ID_ADPCM_4XM:
1295     case CODEC_ID_ADPCM_XA:
1296     case CODEC_ID_ADPCM_ADX:
1297     case CODEC_ID_ADPCM_EA:
1298     case CODEC_ID_ADPCM_CT:
1299     case CODEC_ID_ADPCM_SWF:
1300     case CODEC_ID_ADPCM_YAMAHA:
1301     case CODEC_ID_ADPCM_SBPRO_2:
1302     case CODEC_ID_ADPCM_SBPRO_3:
1303     case CODEC_ID_ADPCM_SBPRO_4:
1304     case CODEC_ID_ADPCM_EA_R1:
1305     case CODEC_ID_ADPCM_EA_R2:
1306     case CODEC_ID_ADPCM_EA_R3:
1307     case CODEC_ID_ADPCM_EA_MAXIS_XA:
1308     case CODEC_ID_ADPCM_EA_XAS:
1309     case CODEC_ID_ADPCM_THP:
1310     {
1311       const gchar *layout = NULL;
1312
1313       switch (codec_id) {
1314         case CODEC_ID_ADPCM_IMA_QT:
1315           layout = "quicktime";
1316           break;
1317         case CODEC_ID_ADPCM_IMA_WAV:
1318           layout = "dvi";
1319           break;
1320         case CODEC_ID_ADPCM_IMA_DK3:
1321           layout = "dk3";
1322           break;
1323         case CODEC_ID_ADPCM_IMA_DK4:
1324           layout = "dk4";
1325           break;
1326         case CODEC_ID_ADPCM_IMA_WS:
1327           layout = "westwood";
1328           break;
1329         case CODEC_ID_ADPCM_IMA_SMJPEG:
1330           layout = "smjpeg";
1331           break;
1332         case CODEC_ID_ADPCM_IMA_AMV:
1333           layout = "amv";
1334           break;
1335         case CODEC_ID_ADPCM_IMA_ISS:
1336           layout = "iss";
1337           break;
1338         case CODEC_ID_ADPCM_IMA_EA_EACS:
1339           layout = "ea-eacs";
1340           break;
1341         case CODEC_ID_ADPCM_IMA_EA_SEAD:
1342           layout = "ea-sead";
1343           break;
1344         case CODEC_ID_ADPCM_MS:
1345           layout = "microsoft";
1346           break;
1347         case CODEC_ID_ADPCM_4XM:
1348           layout = "4xm";
1349           break;
1350         case CODEC_ID_ADPCM_XA:
1351           layout = "xa";
1352           break;
1353         case CODEC_ID_ADPCM_ADX:
1354           layout = "adx";
1355           break;
1356         case CODEC_ID_ADPCM_EA:
1357           layout = "ea";
1358           break;
1359         case CODEC_ID_ADPCM_CT:
1360           layout = "ct";
1361           break;
1362         case CODEC_ID_ADPCM_SWF:
1363           layout = "swf";
1364           break;
1365         case CODEC_ID_ADPCM_YAMAHA:
1366           layout = "yamaha";
1367           break;
1368         case CODEC_ID_ADPCM_SBPRO_2:
1369           layout = "sbpro2";
1370           break;
1371         case CODEC_ID_ADPCM_SBPRO_3:
1372           layout = "sbpro3";
1373           break;
1374         case CODEC_ID_ADPCM_SBPRO_4:
1375           layout = "sbpro4";
1376           break;
1377         case CODEC_ID_ADPCM_EA_R1:
1378           layout = "ea-r1";
1379           break;
1380         case CODEC_ID_ADPCM_EA_R2:
1381           layout = "ea-r3";
1382           break;
1383         case CODEC_ID_ADPCM_EA_R3:
1384           layout = "ea-r3";
1385           break;
1386         case CODEC_ID_ADPCM_EA_MAXIS_XA:
1387           layout = "ea-maxis-xa";
1388           break;
1389         case CODEC_ID_ADPCM_EA_XAS:
1390           layout = "ea-xas";
1391           break;
1392         case CODEC_ID_ADPCM_THP:
1393           layout = "thp";
1394           break;
1395         default:
1396           g_assert (0);         /* don't worry, we never get here */
1397           break;
1398       }
1399
1400       /* FIXME: someone please check whether we need additional properties
1401        * in this caps definition. */
1402       caps = gst_ff_aud_caps_new (context, codec_id, "audio/x-adpcm",
1403           "layout", G_TYPE_STRING, layout, NULL);
1404       if (context)
1405         gst_caps_set_simple (caps,
1406             "block_align", G_TYPE_INT, context->block_align,
1407             "bitrate", G_TYPE_INT, context->bit_rate, NULL);
1408     }
1409       break;
1410
1411     case CODEC_ID_AMR_NB:
1412       caps = gst_ff_aud_caps_new (context, codec_id, "audio/AMR", NULL);
1413       break;
1414
1415     case CODEC_ID_AMR_WB:
1416       caps = gst_ff_aud_caps_new (context, codec_id, "audio/AMR-WB", NULL);
1417       break;
1418
1419     case CODEC_ID_NELLYMOSER:
1420       caps =
1421           gst_ff_aud_caps_new (context, codec_id, "audio/x-nellymoser", NULL);
1422       break;
1423
1424     case CODEC_ID_SIPR:
1425     {
1426       caps = gst_ff_aud_caps_new (context, codec_id, "audio/x-sipro", NULL);
1427       if (context) {
1428         gst_caps_set_simple (caps,
1429             "leaf_size", G_TYPE_INT, context->block_align,
1430             "bitrate", G_TYPE_INT, context->bit_rate, NULL);
1431       }
1432     }
1433       break;
1434
1435     case CODEC_ID_RA_144:
1436     case CODEC_ID_RA_288:
1437     case CODEC_ID_COOK:
1438     {
1439       gint version = 0;
1440
1441       switch (codec_id) {
1442         case CODEC_ID_RA_144:
1443           version = 1;
1444           break;
1445         case CODEC_ID_RA_288:
1446           version = 2;
1447           break;
1448         case CODEC_ID_COOK:
1449           version = 8;
1450           break;
1451         default:
1452           break;
1453       }
1454
1455       /* FIXME: properties? */
1456       caps = gst_ff_aud_caps_new (context, codec_id, "audio/x-pn-realaudio",
1457           "raversion", G_TYPE_INT, version, NULL);
1458       if (context) {
1459         gst_caps_set_simple (caps,
1460             "leaf_size", G_TYPE_INT, context->block_align,
1461             "bitrate", G_TYPE_INT, context->bit_rate, NULL);
1462       }
1463     }
1464       break;
1465
1466     case CODEC_ID_ROQ_DPCM:
1467     case CODEC_ID_INTERPLAY_DPCM:
1468     case CODEC_ID_XAN_DPCM:
1469     case CODEC_ID_SOL_DPCM:
1470     {
1471       const gchar *layout = NULL;
1472
1473       switch (codec_id) {
1474         case CODEC_ID_ROQ_DPCM:
1475           layout = "roq";
1476           break;
1477         case CODEC_ID_INTERPLAY_DPCM:
1478           layout = "interplay";
1479           break;
1480         case CODEC_ID_XAN_DPCM:
1481           layout = "xan";
1482           break;
1483         case CODEC_ID_SOL_DPCM:
1484           layout = "sol";
1485           break;
1486         default:
1487           g_assert (0);         /* don't worry, we never get here */
1488           break;
1489       }
1490
1491       /* FIXME: someone please check whether we need additional properties
1492        * in this caps definition. */
1493       caps = gst_ff_aud_caps_new (context, codec_id, "audio/x-dpcm",
1494           "layout", G_TYPE_STRING, layout, NULL);
1495       if (context)
1496         gst_caps_set_simple (caps,
1497             "block_align", G_TYPE_INT, context->block_align,
1498             "bitrate", G_TYPE_INT, context->bit_rate, NULL);
1499     }
1500       break;
1501
1502     case CODEC_ID_SHORTEN:
1503       caps = gst_caps_new_simple ("audio/x-shorten", NULL);
1504       break;
1505
1506     case CODEC_ID_ALAC:
1507       caps = gst_ff_aud_caps_new (context, codec_id, "audio/x-alac", NULL);
1508       if (context) {
1509         gst_caps_set_simple (caps,
1510             "samplesize", G_TYPE_INT, context->bits_per_coded_sample, NULL);
1511       }
1512       break;
1513
1514     case CODEC_ID_FLAC:
1515       /* Note that ffmpeg has no encoder yet, but just for safety. In the
1516        * encoder case, we want to add things like samplerate, channels... */
1517       if (!encode) {
1518         caps = gst_caps_new_simple ("audio/x-flac", NULL);
1519       }
1520       break;
1521
1522     case CODEC_ID_DVD_SUBTITLE:
1523     case CODEC_ID_DVB_SUBTITLE:
1524       caps = NULL;
1525       break;
1526     case CODEC_ID_BMP:
1527       caps = gst_caps_new_simple ("image/bmp", NULL);
1528       break;
1529     case CODEC_ID_TTA:
1530       caps = gst_ff_aud_caps_new (context, codec_id, "audio/x-tta", NULL);
1531       if (context) {
1532         gst_caps_set_simple (caps,
1533             "samplesize", G_TYPE_INT, context->bits_per_coded_sample, NULL);
1534       }
1535       break;
1536     case CODEC_ID_TWINVQ:
1537       caps = gst_ff_aud_caps_new (context, codec_id, "audio/x-twin-vq", NULL);
1538       break;
1539     default:
1540       GST_DEBUG ("Unknown codec ID %d, please add mapping here", codec_id);
1541       break;
1542   }
1543
1544   if (buildcaps) {
1545     AVCodec *codec;
1546
1547     if ((codec = avcodec_find_decoder (codec_id)) ||
1548         (codec = avcodec_find_encoder (codec_id))) {
1549       gchar *mime = NULL;
1550
1551       GST_LOG ("Could not create stream format caps for %s", codec->name);
1552
1553       switch (codec->type) {
1554         case CODEC_TYPE_VIDEO:
1555           mime = g_strdup_printf ("video/x-gst_ff-%s", codec->name);
1556           caps = gst_ff_vid_caps_new (context, codec_id, mime, NULL);
1557           g_free (mime);
1558           break;
1559         case CODEC_TYPE_AUDIO:
1560           mime = g_strdup_printf ("audio/x-gst_ff-%s", codec->name);
1561           caps = gst_ff_aud_caps_new (context, codec_id, mime, NULL);
1562           if (context)
1563             gst_caps_set_simple (caps,
1564                 "block_align", G_TYPE_INT, context->block_align,
1565                 "bitrate", G_TYPE_INT, context->bit_rate, NULL);
1566           g_free (mime);
1567           break;
1568         default:
1569           break;
1570       }
1571     }
1572   }
1573
1574   if (caps != NULL) {
1575
1576     /* set private data */
1577     if (context && context->extradata_size > 0) {
1578       GstBuffer *data = gst_buffer_new_and_alloc (context->extradata_size);
1579
1580       memcpy (GST_BUFFER_DATA (data), context->extradata,
1581           context->extradata_size);
1582       gst_caps_set_simple (caps, "codec_data", GST_TYPE_BUFFER, data, NULL);
1583       gst_buffer_unref (data);
1584     }
1585
1586     /* palette */
1587     if (context) {
1588       gst_ffmpeg_set_palette (caps, context);
1589     }
1590
1591     GST_LOG ("caps for codec_id=%d: %" GST_PTR_FORMAT, codec_id, caps);
1592
1593   } else {
1594     GST_LOG ("No caps found for codec_id=%d", codec_id);
1595   }
1596
1597   return caps;
1598 }
1599
1600 /* Convert a FFMPEG Pixel Format and optional AVCodecContext
1601  * to a GstCaps. If the context is ommitted, no fixed values
1602  * for video/audio size will be included in the GstCaps
1603  *
1604  * See below for usefullness
1605  */
1606
1607 GstCaps *
1608 gst_ffmpeg_pixfmt_to_caps (enum PixelFormat pix_fmt, AVCodecContext * context,
1609     enum CodecID codec_id)
1610 {
1611   GstCaps *caps = NULL;
1612
1613   int bpp = 0, depth = 0, endianness = 0;
1614   gulong g_mask = 0, r_mask = 0, b_mask = 0, a_mask = 0;
1615   guint32 fmt = 0;
1616
1617   switch (pix_fmt) {
1618     case PIX_FMT_YUVJ420P:
1619     case PIX_FMT_YUV420P:
1620       fmt = GST_MAKE_FOURCC ('I', '4', '2', '0');
1621       break;
1622     case PIX_FMT_YUYV422:
1623       fmt = GST_MAKE_FOURCC ('Y', 'U', 'Y', '2');
1624       break;
1625     case PIX_FMT_RGB24:
1626       bpp = depth = 24;
1627       endianness = G_BIG_ENDIAN;
1628       r_mask = 0xff0000;
1629       g_mask = 0x00ff00;
1630       b_mask = 0x0000ff;
1631       break;
1632     case PIX_FMT_BGR24:
1633       bpp = depth = 24;
1634       endianness = G_BIG_ENDIAN;
1635       r_mask = 0x0000ff;
1636       g_mask = 0x00ff00;
1637       b_mask = 0xff0000;
1638       break;
1639     case PIX_FMT_YUVJ422P:
1640     case PIX_FMT_YUV422P:
1641       fmt = GST_MAKE_FOURCC ('Y', '4', '2', 'B');
1642       break;
1643     case PIX_FMT_YUVJ444P:
1644     case PIX_FMT_YUV444P:
1645       fmt = GST_MAKE_FOURCC ('Y', '4', '4', '4');
1646       break;
1647     case PIX_FMT_RGB32:
1648       bpp = 32;
1649       depth = 32;
1650       endianness = G_BIG_ENDIAN;
1651 #if (G_BYTE_ORDER == G_BIG_ENDIAN)
1652       r_mask = 0x00ff0000;
1653       g_mask = 0x0000ff00;
1654       b_mask = 0x000000ff;
1655       a_mask = 0xff000000;
1656 #else
1657       r_mask = 0x0000ff00;
1658       g_mask = 0x00ff0000;
1659       b_mask = 0xff000000;
1660       a_mask = 0x000000ff;
1661 #endif
1662       break;
1663     case PIX_FMT_YUV410P:
1664       fmt = GST_MAKE_FOURCC ('Y', 'U', 'V', '9');
1665       break;
1666     case PIX_FMT_YUV411P:
1667       fmt = GST_MAKE_FOURCC ('Y', '4', '1', 'B');
1668       break;
1669     case PIX_FMT_RGB565:
1670       bpp = depth = 16;
1671       endianness = G_BYTE_ORDER;
1672       r_mask = 0xf800;
1673       g_mask = 0x07e0;
1674       b_mask = 0x001f;
1675       break;
1676     case PIX_FMT_RGB555:
1677       bpp = 16;
1678       depth = 15;
1679       endianness = G_BYTE_ORDER;
1680       r_mask = 0x7c00;
1681       g_mask = 0x03e0;
1682       b_mask = 0x001f;
1683       break;
1684     case PIX_FMT_PAL8:
1685       bpp = depth = 8;
1686       endianness = G_BYTE_ORDER;
1687       break;
1688     case PIX_FMT_GRAY8:
1689       bpp = depth = 8;
1690       caps = gst_ff_vid_caps_new (context, codec_id, "video/x-raw-gray",
1691           "bpp", G_TYPE_INT, bpp, "depth", G_TYPE_INT, depth, NULL);
1692       break;
1693     default:
1694       /* give up ... */
1695       break;
1696   }
1697
1698   if (caps == NULL) {
1699     if (bpp != 0) {
1700       if (r_mask != 0) {
1701         if (a_mask) {
1702           caps = gst_ff_vid_caps_new (context, codec_id, "video/x-raw-rgb",
1703               "bpp", G_TYPE_INT, bpp,
1704               "depth", G_TYPE_INT, depth,
1705               "red_mask", G_TYPE_INT, r_mask,
1706               "green_mask", G_TYPE_INT, g_mask,
1707               "blue_mask", G_TYPE_INT, b_mask,
1708               "alpha_mask", G_TYPE_INT, a_mask,
1709               "endianness", G_TYPE_INT, endianness, NULL);
1710         } else {
1711           caps = gst_ff_vid_caps_new (context, codec_id, "video/x-raw-rgb",
1712               "bpp", G_TYPE_INT, bpp,
1713               "depth", G_TYPE_INT, depth,
1714               "red_mask", G_TYPE_INT, r_mask,
1715               "green_mask", G_TYPE_INT, g_mask,
1716               "blue_mask", G_TYPE_INT, b_mask,
1717               "endianness", G_TYPE_INT, endianness, NULL);
1718         }
1719       } else {
1720         caps = gst_ff_vid_caps_new (context, codec_id, "video/x-raw-rgb",
1721             "bpp", G_TYPE_INT, bpp,
1722             "depth", G_TYPE_INT, depth,
1723             "endianness", G_TYPE_INT, endianness, NULL);
1724         if (caps && context) {
1725           gst_ffmpeg_set_palette (caps, context);
1726         }
1727       }
1728     } else if (fmt) {
1729       caps = gst_ff_vid_caps_new (context, codec_id, "video/x-raw-yuv",
1730           "format", GST_TYPE_FOURCC, fmt, NULL);
1731     }
1732   }
1733
1734   if (caps != NULL) {
1735     GST_DEBUG ("caps for pix_fmt=%d: %" GST_PTR_FORMAT, pix_fmt, caps);
1736   } else {
1737     GST_LOG ("No caps found for pix_fmt=%d", pix_fmt);
1738   }
1739
1740   return caps;
1741 }
1742
1743 /* Convert a FFMPEG Sample Format and optional AVCodecContext
1744  * to a GstCaps. If the context is ommitted, no fixed values
1745  * for video/audio size will be included in the GstCaps
1746  *
1747  * See below for usefullness
1748  */
1749
1750 static GstCaps *
1751 gst_ffmpeg_smpfmt_to_caps (enum SampleFormat sample_fmt,
1752     AVCodecContext * context, enum CodecID codec_id)
1753 {
1754   GstCaps *caps = NULL;
1755
1756   int bpp = 0;
1757   gboolean integer = TRUE;
1758   gboolean signedness = FALSE;
1759
1760   switch (sample_fmt) {
1761     case SAMPLE_FMT_S16:
1762       signedness = TRUE;
1763       bpp = 16;
1764       break;
1765
1766     case SAMPLE_FMT_S32:
1767       signedness = TRUE;
1768       bpp = 32;
1769       break;
1770
1771     case SAMPLE_FMT_FLT:
1772       integer = FALSE;
1773       bpp = 32;
1774       break;
1775
1776     case SAMPLE_FMT_DBL:
1777       integer = FALSE;
1778       bpp = 64;
1779       break;
1780     default:
1781       /* .. */
1782       break;
1783   }
1784
1785   if (bpp) {
1786     if (integer) {
1787       caps = gst_ff_aud_caps_new (context, codec_id, "audio/x-raw-int",
1788           "signed", G_TYPE_BOOLEAN, signedness,
1789           "endianness", G_TYPE_INT, G_BYTE_ORDER,
1790           "width", G_TYPE_INT, bpp, "depth", G_TYPE_INT, bpp, NULL);
1791     } else {
1792       caps = gst_ff_aud_caps_new (context, codec_id, "audio/x-raw-float",
1793           "endianness", G_TYPE_INT, G_BYTE_ORDER,
1794           "width", G_TYPE_INT, bpp, NULL);
1795     }
1796   }
1797
1798   if (caps != NULL) {
1799     GST_LOG ("caps for sample_fmt=%d: %" GST_PTR_FORMAT, sample_fmt, caps);
1800   } else {
1801     GST_LOG ("No caps found for sample_fmt=%d", sample_fmt);
1802   }
1803
1804   return caps;
1805 }
1806
1807 GstCaps *
1808 gst_ffmpeg_codectype_to_audio_caps (AVCodecContext * context,
1809     enum CodecID codec_id, gboolean encode, AVCodec * codec)
1810 {
1811   GstCaps *caps = NULL;
1812
1813   GST_DEBUG ("context:%p, codec_id:%d, encode:%d, codec:%p",
1814       context, codec_id, encode, codec);
1815   if (codec)
1816     GST_DEBUG ("sample_fmts:%p, samplerates:%p",
1817         codec->sample_fmts, codec->supported_samplerates);
1818
1819   if (context) {
1820     /* Specific codec context */
1821     caps = gst_ffmpeg_smpfmt_to_caps (context->sample_fmt, context, codec_id);
1822   } else if (codec && codec->sample_fmts) {
1823     GstCaps *temp;
1824     int i;
1825
1826     caps = gst_caps_new_empty ();
1827     for (i = 0; codec->sample_fmts[i] != -1; i++) {
1828       temp =
1829           gst_ffmpeg_smpfmt_to_caps (codec->sample_fmts[i], context, codec_id);
1830       if (temp != NULL)
1831         gst_caps_append (caps, temp);
1832     }
1833   } else {
1834     GstCaps *temp;
1835     enum SampleFormat i;
1836     AVCodecContext ctx = { 0, };
1837
1838     ctx.channels = -1;
1839     caps = gst_caps_new_empty ();
1840     for (i = 0; i <= SAMPLE_FMT_DBL; i++) {
1841       temp = gst_ffmpeg_smpfmt_to_caps (i, encode ? &ctx : NULL, codec_id);
1842       if (temp != NULL) {
1843         gst_caps_append (caps, temp);
1844       }
1845     }
1846   }
1847   return caps;
1848 }
1849
1850 GstCaps *
1851 gst_ffmpeg_codectype_to_video_caps (AVCodecContext * context,
1852     enum CodecID codec_id, gboolean encode, AVCodec * codec)
1853 {
1854   GstCaps *caps;
1855
1856   GST_LOG ("context:%p, codec_id:%d, encode:%d, codec:%p",
1857       context, codec_id, encode, codec);
1858
1859   if (context) {
1860     caps = gst_ffmpeg_pixfmt_to_caps (context->pix_fmt, context, codec_id);
1861   } else {
1862     GstCaps *temp;
1863     enum PixelFormat i;
1864     AVCodecContext ctx = { 0, };
1865
1866     caps = gst_caps_new_empty ();
1867     for (i = 0; i < PIX_FMT_NB; i++) {
1868       ctx.width = -1;
1869       ctx.pix_fmt = i;
1870       temp = gst_ffmpeg_pixfmt_to_caps (i, encode ? &ctx : NULL, codec_id);
1871       if (temp != NULL) {
1872         gst_caps_append (caps, temp);
1873       }
1874     }
1875   }
1876   return caps;
1877 }
1878
1879 /* Convert a FFMPEG codec Type and optional AVCodecContext
1880  * to a GstCaps. If the context is ommitted, no fixed values
1881  * for video/audio size will be included in the GstCaps
1882  *
1883  * CodecType is primarily meant for uncompressed data GstCaps!
1884  */
1885
1886 GstCaps *
1887 gst_ffmpeg_codectype_to_caps (enum CodecType codec_type,
1888     AVCodecContext * context, enum CodecID codec_id, gboolean encode)
1889 {
1890   GstCaps *caps;
1891
1892   switch (codec_type) {
1893     case CODEC_TYPE_VIDEO:
1894       caps =
1895           gst_ffmpeg_codectype_to_video_caps (context, codec_id, encode, NULL);
1896       break;
1897     case CODEC_TYPE_AUDIO:
1898       caps =
1899           gst_ffmpeg_codectype_to_audio_caps (context, codec_id, encode, NULL);
1900       break;
1901     default:
1902       caps = NULL;
1903       break;
1904   }
1905
1906   return caps;
1907 }
1908
1909 /* Convert a GstCaps (audio/raw) to a FFMPEG SampleFmt
1910  * and other audio properties in a AVCodecContext.
1911  *
1912  * For usefullness, see below
1913  */
1914
1915 static void
1916 gst_ffmpeg_caps_to_smpfmt (const GstCaps * caps,
1917     AVCodecContext * context, gboolean raw)
1918 {
1919   GstStructure *structure;
1920   gint depth = 0, width = 0, endianness = 0;
1921   gboolean signedness = FALSE;
1922   const gchar *name;
1923
1924   g_return_if_fail (gst_caps_get_size (caps) == 1);
1925   structure = gst_caps_get_structure (caps, 0);
1926
1927   gst_structure_get_int (structure, "channels", &context->channels);
1928   gst_structure_get_int (structure, "rate", &context->sample_rate);
1929   gst_structure_get_int (structure, "block_align", &context->block_align);
1930   gst_structure_get_int (structure, "bitrate", &context->bit_rate);
1931
1932   if (!raw)
1933     return;
1934
1935   name = gst_structure_get_name (structure);
1936
1937   if (!strcmp (name, "audio/x-raw-float")) {
1938     /* FLOAT */
1939     if (gst_structure_get_int (structure, "width", &width) &&
1940         gst_structure_get_int (structure, "endianness", &endianness)) {
1941       if (endianness == G_BYTE_ORDER) {
1942         if (width == 32)
1943           context->sample_fmt = SAMPLE_FMT_FLT;
1944         else if (width == 64)
1945           context->sample_fmt = SAMPLE_FMT_DBL;
1946       }
1947     }
1948   } else {
1949     /* INT */
1950     if (gst_structure_get_int (structure, "width", &width) &&
1951         gst_structure_get_int (structure, "depth", &depth) &&
1952         gst_structure_get_boolean (structure, "signed", &signedness) &&
1953         gst_structure_get_int (structure, "endianness", &endianness)) {
1954       if ((endianness == G_BYTE_ORDER) && (signedness == TRUE)) {
1955         if ((width == 16) && (depth == 16))
1956           context->sample_fmt = SAMPLE_FMT_S16;
1957         else if ((width == 32) && (depth == 32))
1958           context->sample_fmt = SAMPLE_FMT_S32;
1959       }
1960     }
1961   }
1962 }
1963
1964
1965 /* Convert a GstCaps (video/raw) to a FFMPEG PixFmt
1966  * and other video properties in a AVCodecContext.
1967  *
1968  * For usefullness, see below
1969  */
1970
1971 static void
1972 gst_ffmpeg_caps_to_pixfmt (const GstCaps * caps,
1973     AVCodecContext * context, gboolean raw)
1974 {
1975   GstStructure *structure;
1976   const GValue *fps;
1977   const GValue *par = NULL;
1978
1979   GST_DEBUG ("converting caps %" GST_PTR_FORMAT, caps);
1980   g_return_if_fail (gst_caps_get_size (caps) == 1);
1981   structure = gst_caps_get_structure (caps, 0);
1982
1983   gst_structure_get_int (structure, "width", &context->width);
1984   gst_structure_get_int (structure, "height", &context->height);
1985   gst_structure_get_int (structure, "bpp", &context->bits_per_coded_sample);
1986
1987   fps = gst_structure_get_value (structure, "framerate");
1988   if (fps != NULL && GST_VALUE_HOLDS_FRACTION (fps)) {
1989
1990     /* somehow these seem mixed up.. */
1991     context->time_base.den = gst_value_get_fraction_numerator (fps);
1992     context->time_base.num = gst_value_get_fraction_denominator (fps);
1993     context->ticks_per_frame = 1;
1994
1995     GST_DEBUG ("setting framerate %d/%d = %lf",
1996         context->time_base.den, context->time_base.num,
1997         1. * context->time_base.den / context->time_base.num);
1998   }
1999
2000   par = gst_structure_get_value (structure, "pixel-aspect-ratio");
2001   if (par && GST_VALUE_HOLDS_FRACTION (par)) {
2002
2003     context->sample_aspect_ratio.num = gst_value_get_fraction_numerator (par);
2004     context->sample_aspect_ratio.den = gst_value_get_fraction_denominator (par);
2005
2006     GST_DEBUG ("setting pixel-aspect-ratio %d/%d = %lf",
2007         context->sample_aspect_ratio.den, context->sample_aspect_ratio.num,
2008         1. * context->sample_aspect_ratio.den /
2009         context->sample_aspect_ratio.num);
2010   }
2011
2012   if (!raw)
2013     return;
2014
2015   g_return_if_fail (fps != NULL && GST_VALUE_HOLDS_FRACTION (fps));
2016
2017   if (strcmp (gst_structure_get_name (structure), "video/x-raw-yuv") == 0) {
2018     guint32 fourcc;
2019
2020     if (gst_structure_get_fourcc (structure, "format", &fourcc)) {
2021       switch (fourcc) {
2022         case GST_MAKE_FOURCC ('Y', 'U', 'Y', '2'):
2023           context->pix_fmt = PIX_FMT_YUYV422;
2024           break;
2025         case GST_MAKE_FOURCC ('I', '4', '2', '0'):
2026           context->pix_fmt = PIX_FMT_YUV420P;
2027           break;
2028         case GST_MAKE_FOURCC ('Y', '4', '1', 'B'):
2029           context->pix_fmt = PIX_FMT_YUV411P;
2030           break;
2031         case GST_MAKE_FOURCC ('Y', '4', '2', 'B'):
2032           context->pix_fmt = PIX_FMT_YUV422P;
2033           break;
2034         case GST_MAKE_FOURCC ('Y', 'U', 'V', '9'):
2035           context->pix_fmt = PIX_FMT_YUV410P;
2036           break;
2037 #if 0
2038         case FIXME:
2039           context->pix_fmt = PIX_FMT_YUV444P;
2040           break;
2041 #endif
2042       }
2043     }
2044   } else if (strcmp (gst_structure_get_name (structure),
2045           "video/x-raw-rgb") == 0) {
2046     gint bpp = 0, rmask = 0, endianness = 0;
2047
2048     if (gst_structure_get_int (structure, "bpp", &bpp) &&
2049         gst_structure_get_int (structure, "endianness", &endianness)) {
2050       if (gst_structure_get_int (structure, "red_mask", &rmask)) {
2051         switch (bpp) {
2052           case 32:
2053 #if (G_BYTE_ORDER == G_BIG_ENDIAN)
2054             if (rmask == 0x00ff0000)
2055 #else
2056             if (rmask == 0x0000ff00)
2057 #endif
2058               context->pix_fmt = PIX_FMT_RGB32;
2059             break;
2060           case 24:
2061             if (rmask == 0x0000FF)
2062               context->pix_fmt = PIX_FMT_BGR24;
2063             else
2064               context->pix_fmt = PIX_FMT_RGB24;
2065             break;
2066           case 16:
2067             if (endianness == G_BYTE_ORDER)
2068               context->pix_fmt = PIX_FMT_RGB565;
2069             break;
2070           case 15:
2071             if (endianness == G_BYTE_ORDER)
2072               context->pix_fmt = PIX_FMT_RGB555;
2073             break;
2074           default:
2075             /* nothing */
2076             break;
2077         }
2078       } else {
2079         if (bpp == 8) {
2080           context->pix_fmt = PIX_FMT_PAL8;
2081           gst_ffmpeg_get_palette (caps, context);
2082         }
2083       }
2084     }
2085   } else if (strcmp (gst_structure_get_name (structure),
2086           "video/x-raw-gray") == 0) {
2087     gint bpp = 0;
2088
2089     if (gst_structure_get_int (structure, "bpp", &bpp)) {
2090       switch (bpp) {
2091         case 8:
2092           context->pix_fmt = PIX_FMT_GRAY8;
2093           break;
2094       }
2095     }
2096   }
2097 }
2098
2099 /* Convert a GstCaps and a FFMPEG codec Type to a
2100  * AVCodecContext. If the context is ommitted, no fixed values
2101  * for video/audio size will be included in the context
2102  *
2103  * CodecType is primarily meant for uncompressed data GstCaps!
2104  */
2105
2106 void
2107 gst_ffmpeg_caps_with_codectype (enum CodecType type,
2108     const GstCaps * caps, AVCodecContext * context)
2109 {
2110   if (context == NULL)
2111     return;
2112
2113   switch (type) {
2114     case CODEC_TYPE_VIDEO:
2115       gst_ffmpeg_caps_to_pixfmt (caps, context, TRUE);
2116       break;
2117
2118     case CODEC_TYPE_AUDIO:
2119       gst_ffmpeg_caps_to_smpfmt (caps, context, TRUE);
2120       break;
2121
2122     default:
2123       /* unknown */
2124       break;
2125   }
2126 }
2127
2128 #if 0
2129 static void
2130 nal_escape (guint8 * dst, guint8 * src, guint size, guint * destsize)
2131 {
2132   guint8 *dstp = dst;
2133   guint8 *srcp = src;
2134   guint8 *end = src + size;
2135   gint count = 0;
2136
2137   while (srcp < end) {
2138     if (count == 2 && *srcp <= 0x03) {
2139       GST_DEBUG ("added escape code");
2140       *dstp++ = 0x03;
2141       count = 0;
2142     }
2143     if (*srcp == 0)
2144       count++;
2145     else
2146       count = 0;
2147
2148     GST_DEBUG ("copy %02x, count %d", *srcp, count);
2149     *dstp++ = *srcp++;
2150   }
2151   *destsize = dstp - dst;
2152 }
2153
2154 /* copy the config, escaping NAL units as we iterate them, if something fails we
2155  * copy everything and hope for the best. */
2156 static void
2157 copy_config (guint8 * dst, guint8 * src, guint size, guint * destsize)
2158 {
2159   guint8 *dstp = dst;
2160   guint8 *srcp = src;
2161   gint cnt, i;
2162   guint nalsize, esize;
2163
2164   /* check size */
2165   if (size < 7)
2166     goto full_copy;
2167
2168   /* check version */
2169   if (*srcp != 1)
2170     goto full_copy;
2171
2172   cnt = *(srcp + 5) & 0x1f;     /* Number of sps */
2173
2174   GST_DEBUG ("num SPS %d", cnt);
2175
2176   memcpy (dstp, srcp, 6);
2177   srcp += 6;
2178   dstp += 6;
2179
2180   for (i = 0; i < cnt; i++) {
2181     GST_DEBUG ("copy SPS %d", i);
2182     nalsize = (srcp[0] << 8) | srcp[1];
2183     nal_escape (dstp + 2, srcp + 2, nalsize, &esize);
2184     dstp[0] = esize >> 8;
2185     dstp[1] = esize & 0xff;
2186     dstp += esize + 2;
2187     srcp += nalsize + 2;
2188   }
2189
2190   cnt = *(dstp++) = *(srcp++);  /* Number of pps */
2191
2192   GST_DEBUG ("num PPS %d", cnt);
2193
2194   for (i = 0; i < cnt; i++) {
2195     GST_DEBUG ("copy PPS %d", i);
2196     nalsize = (srcp[0] << 8) | srcp[1];
2197     nal_escape (dstp + 2, srcp + 2, nalsize, &esize);
2198     dstp[0] = esize >> 8;
2199     dstp[1] = esize & 0xff;
2200     dstp += esize + 2;
2201     srcp += nalsize + 2;
2202   }
2203   *destsize = dstp - dst;
2204
2205   return;
2206
2207 full_copy:
2208   {
2209     GST_DEBUG ("something unexpected, doing full copy");
2210     memcpy (dst, src, size);
2211     *destsize = size;
2212     return;
2213   }
2214 }
2215 #endif
2216
2217 /*
2218  * caps_with_codecid () transforms a GstCaps for a known codec
2219  * ID into a filled-in context.
2220  * codec_data from caps will override possible extradata already in the context
2221  */
2222
2223 void
2224 gst_ffmpeg_caps_with_codecid (enum CodecID codec_id,
2225     enum CodecType codec_type, const GstCaps * caps, AVCodecContext * context)
2226 {
2227   GstStructure *str;
2228   const GValue *value;
2229   const GstBuffer *buf;
2230
2231   GST_LOG ("codec_id:%d, codec_type:%d, caps:%" GST_PTR_FORMAT " context:%p",
2232       codec_id, codec_type, caps, context);
2233
2234   if (!context || !gst_caps_get_size (caps))
2235     return;
2236
2237   str = gst_caps_get_structure (caps, 0);
2238
2239   /* extradata parsing (esds [mpeg4], wma/wmv, msmpeg4v1/2/3, etc.) */
2240   if ((value = gst_structure_get_value (str, "codec_data"))) {
2241     guint size;
2242     guint8 *data;
2243
2244     buf = GST_BUFFER_CAST (gst_value_get_mini_object (value));
2245     size = GST_BUFFER_SIZE (buf);
2246     data = GST_BUFFER_DATA (buf);
2247
2248     /* free the old one if it is there */
2249     if (context->extradata)
2250       av_free (context->extradata);
2251
2252 #if 0
2253     if (codec_id == CODEC_ID_H264) {
2254       guint extrasize;
2255
2256       GST_DEBUG ("copy, escaping codec_data %d", size);
2257       /* ffmpeg h264 expects the codec_data to be escaped, there is no real
2258        * reason for this but let's just escape it for now. Start by allocating
2259        * enough space, x2 is more than enough.
2260        *
2261        * FIXME, we disabled escaping because some file already contain escaped
2262        * codec_data and then we escape twice and fail. It's better to leave it
2263        * as is, as that is what most players do. */
2264       context->extradata =
2265           av_mallocz (GST_ROUND_UP_16 (size * 2 +
2266               FF_INPUT_BUFFER_PADDING_SIZE));
2267       copy_config (context->extradata, data, size, &extrasize);
2268       GST_DEBUG ("escaped size: %d", extrasize);
2269       context->extradata_size = extrasize;
2270     } else
2271 #endif
2272     {
2273       /* allocate with enough padding */
2274       GST_DEBUG ("copy codec_data");
2275       context->extradata =
2276           av_mallocz (GST_ROUND_UP_16 (size + FF_INPUT_BUFFER_PADDING_SIZE));
2277       memcpy (context->extradata, data, size);
2278       context->extradata_size = size;
2279     }
2280
2281     /* Hack for VC1. Sometimes the first (length) byte is 0 for some files */
2282     if (codec_id == CODEC_ID_VC1 && size > 0 && data[0] == 0) {
2283       context->extradata[0] = (guint8) size;
2284     }
2285
2286     GST_DEBUG ("have codec data of size %d", size);
2287   } else if (context->extradata == NULL) {
2288     /* no extradata, alloc dummy with 0 sized, some codecs insist on reading
2289      * extradata anyway which makes then segfault. */
2290     context->extradata =
2291         av_mallocz (GST_ROUND_UP_16 (FF_INPUT_BUFFER_PADDING_SIZE));
2292     context->extradata_size = 0;
2293     GST_DEBUG ("no codec data");
2294   }
2295
2296   switch (codec_id) {
2297     case CODEC_ID_MPEG4:
2298     {
2299       const gchar *mime = gst_structure_get_name (str);
2300
2301       if (!strcmp (mime, "video/x-divx"))
2302         context->codec_tag = GST_MAKE_FOURCC ('D', 'I', 'V', 'X');
2303       else if (!strcmp (mime, "video/x-xvid"))
2304         context->codec_tag = GST_MAKE_FOURCC ('X', 'V', 'I', 'D');
2305       else if (!strcmp (mime, "video/x-3ivx"))
2306         context->codec_tag = GST_MAKE_FOURCC ('3', 'I', 'V', '1');
2307       else if (!strcmp (mime, "video/mpeg"))
2308         context->codec_tag = GST_MAKE_FOURCC ('m', 'p', '4', 'v');
2309     }
2310       break;
2311
2312     case CODEC_ID_SVQ3:
2313       /* FIXME: this is a workaround for older gst-plugins releases
2314        * (<= 0.8.9). This should be removed at some point, because
2315        * it causes wrong decoded frame order. */
2316       if (!context->extradata) {
2317         /* fix prevent defect */
2318         gint halfpel_flag = 0, thirdpel_flag = 0, low_delay = 0, unknown_svq3_flag = 0;
2319         guint16 flags;
2320
2321         if (gst_structure_get_int (str, "halfpel_flag", &halfpel_flag) ||
2322             gst_structure_get_int (str, "thirdpel_flag", &thirdpel_flag) ||
2323             gst_structure_get_int (str, "low_delay", &low_delay) ||
2324             gst_structure_get_int (str, "unknown_svq3_flag",
2325                 &unknown_svq3_flag)) {
2326           context->extradata = (guint8 *) av_mallocz (0x64);
2327           g_stpcpy ((gchar *) context->extradata, "SVQ3");
2328           flags = 1 << 3;
2329           flags |= low_delay;
2330           flags = flags << 2;
2331           flags |= unknown_svq3_flag;
2332           flags = flags << 6;
2333           flags |= halfpel_flag;
2334           flags = flags << 1;
2335           flags |= thirdpel_flag;
2336           flags = flags << 3;
2337
2338           flags = GUINT16_FROM_LE (flags);
2339
2340           memcpy ((gchar *) context->extradata + 0x62, &flags, 2);
2341           context->extradata_size = 0x64;
2342         }
2343       }
2344       break;
2345
2346     case CODEC_ID_MSRLE:
2347     case CODEC_ID_QTRLE:
2348     case CODEC_ID_TSCC:
2349     case CODEC_ID_APE:
2350     {
2351       gint depth;
2352
2353       if (gst_structure_get_int (str, "depth", &depth)) {
2354         context->bits_per_coded_sample = depth;
2355       } else {
2356         GST_WARNING ("No depth field in caps %" GST_PTR_FORMAT, caps);
2357       }
2358
2359     }
2360       break;
2361
2362     case CODEC_ID_RV10:
2363     case CODEC_ID_RV20:
2364     case CODEC_ID_RV30:
2365     case CODEC_ID_RV40:
2366     {
2367       gint format;
2368
2369       if (gst_structure_get_int (str, "format", &format))
2370         context->sub_id = format;
2371
2372       break;
2373     }
2374     case CODEC_ID_COOK:
2375     case CODEC_ID_RA_288:
2376     case CODEC_ID_RA_144:
2377     case CODEC_ID_SIPR:
2378     {
2379       gint leaf_size;
2380       gint bitrate;
2381
2382       if (gst_structure_get_int (str, "leaf_size", &leaf_size))
2383         context->block_align = leaf_size;
2384       if (gst_structure_get_int (str, "bitrate", &bitrate))
2385         context->bit_rate = bitrate;
2386     }
2387     case CODEC_ID_ALAC:
2388       gst_structure_get_int (str, "samplesize",
2389           &context->bits_per_coded_sample);
2390       break;
2391
2392     case CODEC_ID_DVVIDEO:
2393     {
2394       guint32 fourcc;
2395
2396       if (gst_structure_get_fourcc (str, "format", &fourcc))
2397         switch (fourcc) {
2398           case GST_MAKE_FOURCC ('Y', 'U', 'Y', '2'):
2399             context->pix_fmt = PIX_FMT_YUYV422;
2400             break;
2401           case GST_MAKE_FOURCC ('I', '4', '2', '0'):
2402             context->pix_fmt = PIX_FMT_YUV420P;
2403             break;
2404           case GST_MAKE_FOURCC ('Y', '4', '1', 'B'):
2405             context->pix_fmt = PIX_FMT_YUV411P;
2406             break;
2407           case GST_MAKE_FOURCC ('Y', '4', '2', 'B'):
2408             context->pix_fmt = PIX_FMT_YUV422P;
2409             break;
2410           case GST_MAKE_FOURCC ('Y', 'U', 'V', '9'):
2411             context->pix_fmt = PIX_FMT_YUV410P;
2412             break;
2413           default:
2414             GST_WARNING ("couldn't convert fourcc %" GST_FOURCC_FORMAT
2415                 " to a pixel format", GST_FOURCC_ARGS (fourcc));
2416             break;
2417         }
2418       break;
2419     }
2420     case CODEC_ID_H263P:
2421     {
2422       gboolean val;
2423
2424       if (!gst_structure_get_boolean (str, "annex-f", &val) || val)
2425         context->flags |= CODEC_FLAG_4MV;
2426       else
2427         context->flags &= ~CODEC_FLAG_4MV;
2428       if ((!gst_structure_get_boolean (str, "annex-i", &val) || val) &&
2429           (!gst_structure_get_boolean (str, "annex-t", &val) || val))
2430         context->flags |= CODEC_FLAG_AC_PRED;
2431       else
2432         context->flags &= ~CODEC_FLAG_AC_PRED;
2433       if (!gst_structure_get_boolean (str, "annex-j", &val) || val)
2434         context->flags |= CODEC_FLAG_LOOP_FILTER;
2435       else
2436         context->flags &= ~CODEC_FLAG_LOOP_FILTER;
2437       break;
2438     }
2439     case CODEC_ID_ADPCM_G726:
2440     {
2441       const gchar *layout;
2442
2443       if ((layout = gst_structure_get_string (str, "layout"))) {
2444         if (!strcmp (layout, "g721")) {
2445           context->sample_rate = 8000;
2446           context->channels = 1;
2447           context->bit_rate = 32000;
2448         }
2449       }
2450       break;
2451     }
2452     default:
2453       break;
2454   }
2455
2456   if (!gst_caps_is_fixed (caps))
2457     return;
2458
2459   /* common properties (width, height, fps) */
2460   switch (codec_type) {
2461     case CODEC_TYPE_VIDEO:
2462       gst_ffmpeg_caps_to_pixfmt (caps, context, codec_id == CODEC_ID_RAWVIDEO);
2463       gst_ffmpeg_get_palette (caps, context);
2464       break;
2465     case CODEC_TYPE_AUDIO:
2466       gst_ffmpeg_caps_to_smpfmt (caps, context, FALSE);
2467       break;
2468     default:
2469       break;
2470   }
2471
2472   /* fixup of default settings */
2473   switch (codec_id) {
2474     case CODEC_ID_QCELP:
2475       /* QCELP is always mono, no matter what the caps say */
2476       context->channels = 1;
2477       break;
2478     default:
2479       break;
2480   }
2481 }
2482
2483 /* _formatid_to_caps () is meant for muxers/demuxers, it
2484  * transforms a name (ffmpeg way of ID'ing these, why don't
2485  * they have unique numerical IDs?) to the corresponding
2486  * caps belonging to that mux-format
2487  *
2488  * Note: we don't need any additional info because the caps
2489  * isn't supposed to contain any useful info besides the
2490  * media type anyway
2491  */
2492
2493 GstCaps *
2494 gst_ffmpeg_formatid_to_caps (const gchar * format_name)
2495 {
2496   GstCaps *caps = NULL;
2497
2498   if (!strcmp (format_name, "mpeg")) {
2499     caps = gst_caps_new_simple ("video/mpeg",
2500         "systemstream", G_TYPE_BOOLEAN, TRUE, NULL);
2501   } else if (!strcmp (format_name, "mpegts")) {
2502     caps = gst_caps_new_simple ("video/mpegts",
2503         "systemstream", G_TYPE_BOOLEAN, TRUE, NULL);
2504   } else if (!strcmp (format_name, "rm")) {
2505     caps = gst_caps_new_simple ("application/x-pn-realmedia",
2506         "systemstream", G_TYPE_BOOLEAN, TRUE, NULL);
2507   } else if (!strcmp (format_name, "asf")) {
2508     caps = gst_caps_new_simple ("video/x-ms-asf", NULL);
2509   } else if (!strcmp (format_name, "avi")) {
2510     caps = gst_caps_new_simple ("video/x-msvideo", NULL);
2511   } else if (!strcmp (format_name, "wav")) {
2512     caps = gst_caps_new_simple ("audio/x-wav", NULL);
2513   } else if (!strcmp (format_name, "ape")) {
2514     caps = gst_caps_new_simple ("application/x-ape", NULL);
2515   } else if (!strcmp (format_name, "swf")) {
2516     caps = gst_caps_new_simple ("application/x-shockwave-flash", NULL);
2517   } else if (!strcmp (format_name, "au")) {
2518     caps = gst_caps_new_simple ("audio/x-au", NULL);
2519   } else if (!strcmp (format_name, "dv")) {
2520     caps = gst_caps_new_simple ("video/x-dv",
2521         "systemstream", G_TYPE_BOOLEAN, TRUE, NULL);
2522   } else if (!strcmp (format_name, "4xm")) {
2523     caps = gst_caps_new_simple ("video/x-4xm", NULL);
2524   } else if (!strcmp (format_name, "matroska")) {
2525     caps = gst_caps_new_simple ("video/x-matroska", NULL);
2526   } else if (!strcmp (format_name, "mp3")) {
2527     caps = gst_caps_new_simple ("application/x-id3", NULL);
2528   } else if (!strcmp (format_name, "flic")) {
2529     caps = gst_caps_new_simple ("video/x-fli", NULL);
2530   } else if (!strcmp (format_name, "flv")) {
2531     caps = gst_caps_new_simple ("video/x-flv", NULL);
2532   } else if (!strcmp (format_name, "tta")) {
2533     caps = gst_caps_new_simple ("audio/x-ttafile", NULL);
2534   } else if (!strcmp (format_name, "aiff")) {
2535     caps = gst_caps_new_simple ("audio/x-aiff", NULL);
2536   } else if (!strcmp (format_name, "mov_mp4_m4a_3gp_3g2")) {
2537     caps =
2538         gst_caps_from_string
2539         ("application/x-3gp; video/quicktime; audio/x-m4a");
2540   } else if (!strcmp (format_name, "mov")) {
2541     caps = gst_caps_from_string ("video/quicktime,variant=(string)apple");
2542   } else if (!strcmp (format_name, "mp4")) {
2543     caps = gst_caps_from_string ("video/quicktime,variant=(string)iso");
2544   } else if (!strcmp (format_name, "3gp")) {
2545     caps = gst_caps_from_string ("video/quicktime,variant=(string)3gpp");
2546   } else if (!strcmp (format_name, "3g2")) {
2547     caps = gst_caps_from_string ("video/quicktime,variant=(string)3g2");
2548   } else if (!strcmp (format_name, "psp")) {
2549     caps = gst_caps_from_string ("video/quicktime,variant=(string)psp");
2550   } else if (!strcmp (format_name, "ipod")) {
2551     caps = gst_caps_from_string ("video/quicktime,variant=(string)ipod");
2552   } else if (!strcmp (format_name, "aac")) {
2553     caps = gst_caps_new_simple ("audio/mpeg",
2554         "mpegversion", G_TYPE_INT, 4, NULL);
2555   } else if (!strcmp (format_name, "gif")) {
2556     caps = gst_caps_from_string ("image/gif");
2557   } else if (!strcmp (format_name, "ogg")) {
2558     caps = gst_caps_from_string ("application/ogg");
2559   } else if (!strcmp (format_name, "mxf") || !strcmp (format_name, "mxf_d10")) {
2560     caps = gst_caps_from_string ("application/mxf");
2561   } else if (!strcmp (format_name, "gxf")) {
2562     caps = gst_caps_from_string ("application/gxf");
2563   } else if (!strcmp (format_name, "yuv4mpegpipe")) {
2564     caps = gst_caps_new_simple ("application/x-yuv4mpeg",
2565         "y4mversion", G_TYPE_INT, 2, NULL);
2566   } else if (!strcmp (format_name, "mpc")) {
2567     caps = gst_caps_from_string ("audio/x-musepack, streamversion = (int) 7");
2568   } else if (!strcmp (format_name, "vqf")) {
2569     caps = gst_caps_from_string ("audio/x-vqf");
2570   } else if (!strcmp (format_name, "nsv")) {
2571     caps = gst_caps_from_string ("video/x-nsv");
2572   } else if (!strcmp (format_name, "amr")) {
2573     caps = gst_caps_from_string ("audio/x-amr-nb-sh");
2574   } else if (!strcmp (format_name, "webm")) {
2575     caps = gst_caps_from_string ("video/webm");
2576   } else {
2577     gchar *name;
2578
2579     GST_LOG ("Could not create stream format caps for %s", format_name);
2580     name = g_strdup_printf ("application/x-gst_ff-%s", format_name);
2581     caps = gst_caps_new_simple (name, NULL);
2582     g_free (name);
2583   }
2584
2585   return caps;
2586 }
2587
2588 gboolean
2589 gst_ffmpeg_formatid_get_codecids (const gchar * format_name,
2590     enum CodecID ** video_codec_list, enum CodecID ** audio_codec_list,
2591     AVOutputFormat * plugin)
2592 {
2593   static enum CodecID tmp_vlist[] = {
2594     CODEC_ID_NONE,
2595     CODEC_ID_NONE
2596   };
2597   static enum CodecID tmp_alist[] = {
2598     CODEC_ID_NONE,
2599     CODEC_ID_NONE
2600   };
2601
2602   GST_LOG ("format_name : %s", format_name);
2603
2604   if (!strcmp (format_name, "mp4")) {
2605     static enum CodecID mp4_video_list[] = {
2606       CODEC_ID_MPEG4, CODEC_ID_H264,
2607       CODEC_ID_MJPEG,
2608       CODEC_ID_NONE
2609     };
2610     static enum CodecID mp4_audio_list[] = {
2611       CODEC_ID_AAC, CODEC_ID_MP3,
2612       CODEC_ID_NONE
2613     };
2614
2615     *video_codec_list = mp4_video_list;
2616     *audio_codec_list = mp4_audio_list;
2617   } else if (!strcmp (format_name, "mpeg")) {
2618     static enum CodecID mpeg_video_list[] = { CODEC_ID_MPEG1VIDEO,
2619       CODEC_ID_MPEG2VIDEO,
2620       CODEC_ID_H264,
2621       CODEC_ID_NONE
2622     };
2623     static enum CodecID mpeg_audio_list[] = { CODEC_ID_MP1,
2624       CODEC_ID_MP2,
2625       CODEC_ID_MP3,
2626       CODEC_ID_NONE
2627     };
2628
2629     *video_codec_list = mpeg_video_list;
2630     *audio_codec_list = mpeg_audio_list;
2631   } else if (!strcmp (format_name, "dvd")) {
2632     static enum CodecID mpeg_video_list[] = { CODEC_ID_MPEG2VIDEO,
2633       CODEC_ID_NONE
2634     };
2635     static enum CodecID mpeg_audio_list[] = { CODEC_ID_MP2,
2636       CODEC_ID_AC3,
2637       CODEC_ID_DTS,
2638       CODEC_ID_PCM_S16BE,
2639       CODEC_ID_NONE
2640     };
2641
2642     *video_codec_list = mpeg_video_list;
2643     *audio_codec_list = mpeg_audio_list;
2644   } else if (!strcmp (format_name, "mpegts")) {
2645     static enum CodecID mpegts_video_list[] = { CODEC_ID_MPEG1VIDEO,
2646       CODEC_ID_MPEG2VIDEO,
2647       CODEC_ID_H264,
2648       CODEC_ID_NONE
2649     };
2650     static enum CodecID mpegts_audio_list[] = { CODEC_ID_MP2,
2651       CODEC_ID_MP3,
2652       CODEC_ID_AC3,
2653       CODEC_ID_DTS,
2654       CODEC_ID_AAC,
2655       CODEC_ID_NONE
2656     };
2657
2658     *video_codec_list = mpegts_video_list;
2659     *audio_codec_list = mpegts_audio_list;
2660   } else if (!strcmp (format_name, "vob")) {
2661     static enum CodecID vob_video_list[] =
2662         { CODEC_ID_MPEG2VIDEO, CODEC_ID_NONE };
2663     static enum CodecID vob_audio_list[] = { CODEC_ID_MP2, CODEC_ID_AC3,
2664       CODEC_ID_DTS, CODEC_ID_NONE
2665     };
2666
2667     *video_codec_list = vob_video_list;
2668     *audio_codec_list = vob_audio_list;
2669   } else if (!strcmp (format_name, "flv")) {
2670     static enum CodecID flv_video_list[] = { CODEC_ID_FLV1, CODEC_ID_NONE };
2671     static enum CodecID flv_audio_list[] = { CODEC_ID_MP3, CODEC_ID_NONE };
2672
2673     *video_codec_list = flv_video_list;
2674     *audio_codec_list = flv_audio_list;
2675   } else if (!strcmp (format_name, "asf")) {
2676     static enum CodecID asf_video_list[] =
2677         { CODEC_ID_WMV1, CODEC_ID_WMV2, CODEC_ID_MSMPEG4V3, CODEC_ID_NONE };
2678     static enum CodecID asf_audio_list[] =
2679         { CODEC_ID_WMAV1, CODEC_ID_WMAV2, CODEC_ID_MP3, CODEC_ID_NONE };
2680
2681     *video_codec_list = asf_video_list;
2682     *audio_codec_list = asf_audio_list;
2683   } else if (!strcmp (format_name, "dv")) {
2684     static enum CodecID dv_video_list[] = { CODEC_ID_DVVIDEO, CODEC_ID_NONE };
2685     static enum CodecID dv_audio_list[] = { CODEC_ID_PCM_S16LE, CODEC_ID_NONE };
2686
2687     *video_codec_list = dv_video_list;
2688     *audio_codec_list = dv_audio_list;
2689   } else if (!strcmp (format_name, "mov")) {
2690     static enum CodecID mov_video_list[] = {
2691       CODEC_ID_SVQ1, CODEC_ID_SVQ3, CODEC_ID_MPEG4,
2692       CODEC_ID_H263, CODEC_ID_H263P,
2693       CODEC_ID_H264, CODEC_ID_DVVIDEO,
2694       CODEC_ID_MJPEG,
2695       CODEC_ID_NONE
2696     };
2697     static enum CodecID mov_audio_list[] = {
2698       CODEC_ID_PCM_MULAW, CODEC_ID_PCM_ALAW, CODEC_ID_ADPCM_IMA_QT,
2699       CODEC_ID_MACE3, CODEC_ID_MACE6, CODEC_ID_AAC,
2700       CODEC_ID_AMR_NB, CODEC_ID_AMR_WB,
2701       CODEC_ID_PCM_S16BE, CODEC_ID_PCM_S16LE,
2702       CODEC_ID_MP3, CODEC_ID_NONE
2703     };
2704
2705     *video_codec_list = mov_video_list;
2706     *audio_codec_list = mov_audio_list;
2707   } else if ((!strcmp (format_name, "3gp") || !strcmp (format_name, "3g2"))) {
2708     static enum CodecID tgp_video_list[] = {
2709       CODEC_ID_MPEG4, CODEC_ID_H263, CODEC_ID_H263P, CODEC_ID_H264,
2710       CODEC_ID_NONE
2711     };
2712     static enum CodecID tgp_audio_list[] = {
2713       CODEC_ID_AMR_NB, CODEC_ID_AMR_WB,
2714       CODEC_ID_AAC,
2715       CODEC_ID_NONE
2716     };
2717
2718     *video_codec_list = tgp_video_list;
2719     *audio_codec_list = tgp_audio_list;
2720   } else if (!strcmp (format_name, "mmf")) {
2721     static enum CodecID mmf_audio_list[] = {
2722       CODEC_ID_ADPCM_YAMAHA, CODEC_ID_NONE
2723     };
2724     *video_codec_list = NULL;
2725     *audio_codec_list = mmf_audio_list;
2726   } else if (!strcmp (format_name, "amr")) {
2727     static enum CodecID amr_audio_list[] = {
2728       CODEC_ID_AMR_NB, CODEC_ID_AMR_WB,
2729       CODEC_ID_NONE
2730     };
2731     *video_codec_list = NULL;
2732     *audio_codec_list = amr_audio_list;
2733   } else if (!strcmp (format_name, "gif")) {
2734     static enum CodecID gif_image_list[] = {
2735       CODEC_ID_RAWVIDEO, CODEC_ID_NONE
2736     };
2737     *video_codec_list = gif_image_list;
2738     *audio_codec_list = NULL;
2739   } else if ((plugin->audio_codec != CODEC_ID_NONE) ||
2740       (plugin->video_codec != CODEC_ID_NONE)) {
2741     tmp_vlist[0] = plugin->video_codec;
2742     tmp_alist[0] = plugin->audio_codec;
2743
2744     *video_codec_list = tmp_vlist;
2745     *audio_codec_list = tmp_alist;
2746   } else {
2747     GST_LOG ("Format %s not found", format_name);
2748     return FALSE;
2749   }
2750
2751   return TRUE;
2752 }
2753
2754 /* Convert a GstCaps to a FFMPEG codec ID. Size et all
2755  * are omitted, that can be queried by the user itself,
2756  * we're not eating the GstCaps or anything
2757  * A pointer to an allocated context is also needed for
2758  * optional extra info
2759  */
2760
2761 enum CodecID
2762 gst_ffmpeg_caps_to_codecid (const GstCaps * caps, AVCodecContext * context)
2763 {
2764   enum CodecID id = CODEC_ID_NONE;
2765   const gchar *mimetype;
2766   const GstStructure *structure;
2767   gboolean video = FALSE, audio = FALSE;        /* we want to be sure! */
2768
2769   g_return_val_if_fail (caps != NULL, CODEC_ID_NONE);
2770   g_return_val_if_fail (gst_caps_get_size (caps) == 1, CODEC_ID_NONE);
2771   structure = gst_caps_get_structure (caps, 0);
2772
2773   mimetype = gst_structure_get_name (structure);
2774
2775   if (!strcmp (mimetype, "video/x-raw-rgb") ||
2776       !strcmp (mimetype, "video/x-raw-yuv")) {
2777     id = CODEC_ID_RAWVIDEO;
2778     video = TRUE;
2779   } else if (!strcmp (mimetype, "audio/x-raw-int")) {
2780     gint depth, width, endianness;
2781     gboolean signedness;
2782
2783     if (gst_structure_get_int (structure, "endianness", &endianness) &&
2784         gst_structure_get_boolean (structure, "signed", &signedness) &&
2785         gst_structure_get_int (structure, "width", &width) &&
2786         gst_structure_get_int (structure, "depth", &depth) && depth == width) {
2787       switch (depth) {
2788         case 8:
2789           if (signedness) {
2790             id = CODEC_ID_PCM_S8;
2791           } else {
2792             id = CODEC_ID_PCM_U8;
2793           }
2794           break;
2795         case 16:
2796           switch (endianness) {
2797             case G_BIG_ENDIAN:
2798               if (signedness) {
2799                 id = CODEC_ID_PCM_S16BE;
2800               } else {
2801                 id = CODEC_ID_PCM_U16BE;
2802               }
2803               break;
2804             case G_LITTLE_ENDIAN:
2805               if (signedness) {
2806                 id = CODEC_ID_PCM_S16LE;
2807               } else {
2808                 id = CODEC_ID_PCM_U16LE;
2809               }
2810               break;
2811           }
2812           break;
2813       }
2814       if (id != CODEC_ID_NONE)
2815         audio = TRUE;
2816     }
2817   } else if (!strcmp (mimetype, "audio/x-mulaw")) {
2818     id = CODEC_ID_PCM_MULAW;
2819     audio = TRUE;
2820   } else if (!strcmp (mimetype, "audio/x-alaw")) {
2821     id = CODEC_ID_PCM_ALAW;
2822     audio = TRUE;
2823   } else if (!strcmp (mimetype, "video/x-dv")) {
2824     gboolean sys_strm;
2825
2826     if (gst_structure_get_boolean (structure, "systemstream", &sys_strm) &&
2827         !sys_strm) {
2828       id = CODEC_ID_DVVIDEO;
2829       video = TRUE;
2830     }
2831   } else if (!strcmp (mimetype, "audio/x-dv")) {        /* ??? */
2832     id = CODEC_ID_DVAUDIO;
2833     audio = TRUE;
2834   } else if (!strcmp (mimetype, "video/x-h263")) {
2835     const gchar *h263version =
2836         gst_structure_get_string (structure, "h263version");
2837     if (h263version && !strcmp (h263version, "h263p"))
2838       id = CODEC_ID_H263P;
2839     else
2840       id = CODEC_ID_H263;
2841     video = TRUE;
2842   } else if (!strcmp (mimetype, "video/x-intel-h263")) {
2843     id = CODEC_ID_H263I;
2844     video = TRUE;
2845   } else if (!strcmp (mimetype, "video/x-h261")) {
2846     id = CODEC_ID_H261;
2847     video = TRUE;
2848   } else if (!strcmp (mimetype, "video/mpeg")) {
2849     gboolean sys_strm;
2850     gint mpegversion;
2851
2852     if (gst_structure_get_boolean (structure, "systemstream", &sys_strm) &&
2853         gst_structure_get_int (structure, "mpegversion", &mpegversion) &&
2854         !sys_strm) {
2855       switch (mpegversion) {
2856         case 1:
2857           id = CODEC_ID_MPEG1VIDEO;
2858           break;
2859         case 2:
2860           id = CODEC_ID_MPEG2VIDEO;
2861           break;
2862         case 4:
2863           id = CODEC_ID_MPEG4;
2864           break;
2865       }
2866     }
2867     if (id != CODEC_ID_NONE)
2868       video = TRUE;
2869   } else if (!strcmp (mimetype, "image/jpeg")) {
2870     id = CODEC_ID_MJPEG;        /* A... B... */
2871     video = TRUE;
2872   } else if (!strcmp (mimetype, "video/x-jpeg-b")) {
2873     id = CODEC_ID_MJPEGB;
2874     video = TRUE;
2875   } else if (!strcmp (mimetype, "video/x-wmv")) {
2876     gint wmvversion = 0;
2877
2878     if (gst_structure_get_int (structure, "wmvversion", &wmvversion)) {
2879       switch (wmvversion) {
2880         case 1:
2881           id = CODEC_ID_WMV1;
2882           break;
2883         case 2:
2884           id = CODEC_ID_WMV2;
2885           break;
2886         case 3:
2887         {
2888           guint32 fourcc;
2889
2890           /* WMV3 unless the fourcc exists and says otherwise */
2891           id = CODEC_ID_WMV3;
2892
2893           if (gst_structure_get_fourcc (structure, "format", &fourcc)) {
2894             if ((fourcc == GST_MAKE_FOURCC ('W', 'V', 'C', '1')) ||
2895                 (fourcc == GST_MAKE_FOURCC ('W', 'M', 'V', 'A'))) {
2896               id = CODEC_ID_VC1;
2897             }
2898           }
2899         }
2900           break;
2901       }
2902     }
2903     if (id != CODEC_ID_NONE)
2904       video = TRUE;
2905   } else if (!strcmp (mimetype, "audio/x-vorbis")) {
2906     id = CODEC_ID_VORBIS;
2907     audio = TRUE;
2908   } else if (!strcmp (mimetype, "audio/x-qdm2")) {
2909     id = CODEC_ID_QDM2;
2910     audio = TRUE;
2911   } else if (!strcmp (mimetype, "audio/mpeg")) {
2912     gint layer = 0;
2913     gint mpegversion = 0;
2914
2915     if (gst_structure_get_int (structure, "mpegversion", &mpegversion)) {
2916       switch (mpegversion) {
2917         case 2:                /* ffmpeg uses faad for both... */
2918         case 4:
2919           id = CODEC_ID_AAC;
2920           break;
2921         case 1:
2922           if (gst_structure_get_int (structure, "layer", &layer)) {
2923             switch (layer) {
2924               case 1:
2925                 id = CODEC_ID_MP1;
2926                 break;
2927               case 2:
2928                 id = CODEC_ID_MP2;
2929                 break;
2930               case 3:
2931                 id = CODEC_ID_MP3;
2932                 break;
2933             }
2934           }
2935       }
2936     }
2937     if (id != CODEC_ID_NONE)
2938       audio = TRUE;
2939   } else if (!strcmp (mimetype, "audio/x-musepack")) {
2940     gint streamversion = -1;
2941
2942     if (gst_structure_get_int (structure, "streamversion", &streamversion)) {
2943       if (streamversion == 7)
2944         id = CODEC_ID_MUSEPACK7;
2945     } else {
2946       id = CODEC_ID_MUSEPACK7;
2947     }
2948   } else if (!strcmp (mimetype, "audio/x-wma")) {
2949     gint wmaversion = 0;
2950
2951     if (gst_structure_get_int (structure, "wmaversion", &wmaversion)) {
2952       switch (wmaversion) {
2953         case 1:
2954           id = CODEC_ID_WMAV1;
2955           break;
2956         case 2:
2957           id = CODEC_ID_WMAV2;
2958           break;
2959         case 3:
2960           id = CODEC_ID_WMAPRO;
2961           break;
2962       }
2963     }
2964     if (id != CODEC_ID_NONE)
2965       audio = TRUE;
2966   } else if (!strcmp (mimetype, "audio/x-wms")) {
2967     id = CODEC_ID_WMAVOICE;
2968     audio = TRUE;
2969   } else if (!strcmp (mimetype, "audio/x-ac3")) {
2970     id = CODEC_ID_AC3;
2971     audio = TRUE;
2972   } else if (!strcmp (mimetype, "audio/x-eac3")) {
2973     id = CODEC_ID_EAC3;
2974     audio = TRUE;
2975   } else if (!strcmp (mimetype, "audio/x-vnd.sony.atrac3") ||
2976       !strcmp (mimetype, "audio/atrac3")) {
2977     id = CODEC_ID_ATRAC3;
2978     audio = TRUE;
2979   } else if (!strcmp (mimetype, "audio/x-dts")) {
2980     id = CODEC_ID_DTS;
2981     audio = TRUE;
2982   } else if (!strcmp (mimetype, "application/x-ape")) {
2983     id = CODEC_ID_APE;
2984     audio = TRUE;
2985   } else if (!strcmp (mimetype, "video/x-msmpeg")) {
2986     gint msmpegversion = 0;
2987
2988     if (gst_structure_get_int (structure, "msmpegversion", &msmpegversion)) {
2989       switch (msmpegversion) {
2990         case 41:
2991           id = CODEC_ID_MSMPEG4V1;
2992           break;
2993         case 42:
2994           id = CODEC_ID_MSMPEG4V2;
2995           break;
2996         case 43:
2997           id = CODEC_ID_MSMPEG4V3;
2998           break;
2999       }
3000     }
3001     if (id != CODEC_ID_NONE)
3002       video = TRUE;
3003   } else if (!strcmp (mimetype, "video/x-svq")) {
3004     gint svqversion = 0;
3005
3006     if (gst_structure_get_int (structure, "svqversion", &svqversion)) {
3007       switch (svqversion) {
3008         case 1:
3009           id = CODEC_ID_SVQ1;
3010           break;
3011         case 3:
3012           id = CODEC_ID_SVQ3;
3013           break;
3014       }
3015     }
3016     if (id != CODEC_ID_NONE)
3017       video = TRUE;
3018   } else if (!strcmp (mimetype, "video/x-huffyuv")) {
3019     id = CODEC_ID_HUFFYUV;
3020     video = TRUE;
3021   } else if (!strcmp (mimetype, "audio/x-mace")) {
3022     gint maceversion = 0;
3023
3024     if (gst_structure_get_int (structure, "maceversion", &maceversion)) {
3025       switch (maceversion) {
3026         case 3:
3027           id = CODEC_ID_MACE3;
3028           break;
3029         case 6:
3030           id = CODEC_ID_MACE6;
3031           break;
3032       }
3033     }
3034     if (id != CODEC_ID_NONE)
3035       audio = TRUE;
3036   } else if (!strcmp (mimetype, "video/x-theora")) {
3037     id = CODEC_ID_THEORA;
3038     video = TRUE;
3039   } else if (!strcmp (mimetype, "video/x-vp3")) {
3040     id = CODEC_ID_VP3;
3041     video = TRUE;
3042   } else if (!strcmp (mimetype, "video/x-vp5")) {
3043     id = CODEC_ID_VP5;
3044     video = TRUE;
3045   } else if (!strcmp (mimetype, "video/x-vp6")) {
3046     id = CODEC_ID_VP6;
3047     video = TRUE;
3048   } else if (!strcmp (mimetype, "video/x-vp6-flash")) {
3049     id = CODEC_ID_VP6F;
3050     video = TRUE;
3051   } else if (!strcmp (mimetype, "video/x-vp6-alpha")) {
3052     id = CODEC_ID_VP6A;
3053     video = TRUE;
3054   } else if (!strcmp (mimetype, "video/x-flash-screen")) {
3055     id = CODEC_ID_FLASHSV;
3056     video = TRUE;
3057   } else if (!strcmp (mimetype, "video/x-indeo")) {
3058     gint indeoversion = 0;
3059
3060     if (gst_structure_get_int (structure, "indeoversion", &indeoversion)) {
3061       switch (indeoversion) {
3062         case 5:
3063           id = CODEC_ID_INDEO5;
3064           break;
3065         case 3:
3066           id = CODEC_ID_INDEO3;
3067           break;
3068         case 2:
3069           id = CODEC_ID_INDEO2;
3070           break;
3071       }
3072       if (id != CODEC_ID_NONE)
3073         video = TRUE;
3074     }
3075   } else if (!strcmp (mimetype, "video/x-divx")) {
3076     gint divxversion = 0;
3077
3078     if (gst_structure_get_int (structure, "divxversion", &divxversion)) {
3079       switch (divxversion) {
3080         case 3:
3081           id = CODEC_ID_MSMPEG4V3;
3082           break;
3083         case 4:
3084         case 5:
3085           id = CODEC_ID_MPEG4;
3086           break;
3087       }
3088     }
3089     if (id != CODEC_ID_NONE)
3090       video = TRUE;
3091   } else if (!strcmp (mimetype, "video/x-3ivx")) {
3092     id = CODEC_ID_MPEG4;
3093     video = TRUE;
3094   } else if (!strcmp (mimetype, "video/x-xvid")) {
3095     id = CODEC_ID_MPEG4;
3096     video = TRUE;
3097   } else if (!strcmp (mimetype, "video/x-ffv")) {
3098     gint ffvversion = 0;
3099
3100     if (gst_structure_get_int (structure, "ffvversion", &ffvversion) &&
3101         ffvversion == 1) {
3102       id = CODEC_ID_FFV1;
3103       video = TRUE;
3104     }
3105   } else if (!strcmp (mimetype, "audio/x-adpcm")) {
3106     const gchar *layout;
3107
3108     layout = gst_structure_get_string (structure, "layout");
3109     if (layout == NULL) {
3110       /* break */
3111     } else if (!strcmp (layout, "quicktime")) {
3112       id = CODEC_ID_ADPCM_IMA_QT;
3113     } else if (!strcmp (layout, "microsoft")) {
3114       id = CODEC_ID_ADPCM_MS;
3115     } else if (!strcmp (layout, "dvi")) {
3116       id = CODEC_ID_ADPCM_IMA_WAV;
3117     } else if (!strcmp (layout, "4xm")) {
3118       id = CODEC_ID_ADPCM_4XM;
3119     } else if (!strcmp (layout, "smjpeg")) {
3120       id = CODEC_ID_ADPCM_IMA_SMJPEG;
3121     } else if (!strcmp (layout, "dk3")) {
3122       id = CODEC_ID_ADPCM_IMA_DK3;
3123     } else if (!strcmp (layout, "dk4")) {
3124       id = CODEC_ID_ADPCM_IMA_DK4;
3125     } else if (!strcmp (layout, "westwood")) {
3126       id = CODEC_ID_ADPCM_IMA_WS;
3127     } else if (!strcmp (layout, "iss")) {
3128       id = CODEC_ID_ADPCM_IMA_ISS;
3129     } else if (!strcmp (layout, "xa")) {
3130       id = CODEC_ID_ADPCM_XA;
3131     } else if (!strcmp (layout, "adx")) {
3132       id = CODEC_ID_ADPCM_ADX;
3133     } else if (!strcmp (layout, "ea")) {
3134       id = CODEC_ID_ADPCM_EA;
3135     } else if (!strcmp (layout, "g726")) {
3136       id = CODEC_ID_ADPCM_G726;
3137     } else if (!strcmp (layout, "g721")) {
3138       id = CODEC_ID_ADPCM_G726;
3139     } else if (!strcmp (layout, "ct")) {
3140       id = CODEC_ID_ADPCM_CT;
3141     } else if (!strcmp (layout, "swf")) {
3142       id = CODEC_ID_ADPCM_SWF;
3143     } else if (!strcmp (layout, "yamaha")) {
3144       id = CODEC_ID_ADPCM_YAMAHA;
3145     } else if (!strcmp (layout, "sbpro2")) {
3146       id = CODEC_ID_ADPCM_SBPRO_2;
3147     } else if (!strcmp (layout, "sbpro3")) {
3148       id = CODEC_ID_ADPCM_SBPRO_3;
3149     } else if (!strcmp (layout, "sbpro4")) {
3150       id = CODEC_ID_ADPCM_SBPRO_4;
3151     }
3152     if (id != CODEC_ID_NONE)
3153       audio = TRUE;
3154   } else if (!strcmp (mimetype, "video/x-4xm")) {
3155     id = CODEC_ID_4XM;
3156     video = TRUE;
3157   } else if (!strcmp (mimetype, "audio/x-dpcm")) {
3158     const gchar *layout;
3159
3160     layout = gst_structure_get_string (structure, "layout");
3161     if (!layout) {
3162       /* .. */
3163     } else if (!strcmp (layout, "roq")) {
3164       id = CODEC_ID_ROQ_DPCM;
3165     } else if (!strcmp (layout, "interplay")) {
3166       id = CODEC_ID_INTERPLAY_DPCM;
3167     } else if (!strcmp (layout, "xan")) {
3168       id = CODEC_ID_XAN_DPCM;
3169     } else if (!strcmp (layout, "sol")) {
3170       id = CODEC_ID_SOL_DPCM;
3171     }
3172     if (id != CODEC_ID_NONE)
3173       audio = TRUE;
3174   } else if (!strcmp (mimetype, "audio/x-flac")) {
3175     id = CODEC_ID_FLAC;
3176     audio = TRUE;
3177   } else if (!strcmp (mimetype, "audio/x-shorten")) {
3178     id = CODEC_ID_SHORTEN;
3179     audio = TRUE;
3180   } else if (!strcmp (mimetype, "audio/x-alac")) {
3181     id = CODEC_ID_ALAC;
3182     audio = TRUE;
3183   } else if (!strcmp (mimetype, "video/x-cinepak")) {
3184     id = CODEC_ID_CINEPAK;
3185     video = TRUE;
3186   } else if (!strcmp (mimetype, "video/x-pn-realvideo")) {
3187     gint rmversion;
3188
3189     if (gst_structure_get_int (structure, "rmversion", &rmversion)) {
3190       switch (rmversion) {
3191         case 1:
3192           id = CODEC_ID_RV10;
3193           break;
3194         case 2:
3195           id = CODEC_ID_RV20;
3196           break;
3197         case 3:
3198           id = CODEC_ID_RV30;
3199           break;
3200         case 4:
3201           id = CODEC_ID_RV40;
3202           break;
3203       }
3204     }
3205     if (id != CODEC_ID_NONE)
3206       video = TRUE;
3207   } else if (!strcmp (mimetype, "audio/x-sipro")) {
3208     id = CODEC_ID_SIPR;
3209     audio = TRUE;
3210   } else if (!strcmp (mimetype, "audio/x-pn-realaudio")) {
3211     gint raversion;
3212
3213     if (gst_structure_get_int (structure, "raversion", &raversion)) {
3214       switch (raversion) {
3215         case 1:
3216           id = CODEC_ID_RA_144;
3217           break;
3218         case 2:
3219           id = CODEC_ID_RA_288;
3220           break;
3221         case 8:
3222           id = CODEC_ID_COOK;
3223           break;
3224       }
3225     }
3226     if (id != CODEC_ID_NONE)
3227       audio = TRUE;
3228   } else if (!strcmp (mimetype, "video/x-rle")) {
3229     const gchar *layout;
3230
3231     if ((layout = gst_structure_get_string (structure, "layout"))) {
3232       if (!strcmp (layout, "microsoft")) {
3233         id = CODEC_ID_MSRLE;
3234         video = TRUE;
3235       }
3236     }
3237   } else if (!strcmp (mimetype, "video/x-xan")) {
3238     gint wcversion = 0;
3239
3240     if ((gst_structure_get_int (structure, "wcversion", &wcversion))) {
3241       switch (wcversion) {
3242         case 3:
3243           id = CODEC_ID_XAN_WC3;
3244           video = TRUE;
3245           break;
3246         case 4:
3247           id = CODEC_ID_XAN_WC4;
3248           video = TRUE;
3249           break;
3250         default:
3251           break;
3252       }
3253     }
3254   } else if (!strcmp (mimetype, "audio/AMR")) {
3255     audio = TRUE;
3256     id = CODEC_ID_AMR_NB;
3257   } else if (!strcmp (mimetype, "audio/AMR-WB")) {
3258     id = CODEC_ID_AMR_WB;
3259     audio = TRUE;
3260   } else if (!strcmp (mimetype, "audio/qcelp")) {
3261     id = CODEC_ID_QCELP;
3262     audio = TRUE;
3263   } else if (!strcmp (mimetype, "video/x-h264")) {
3264     id = CODEC_ID_H264;
3265     video = TRUE;
3266   } else if (!strcmp (mimetype, "video/x-flash-video")) {
3267     gint flvversion = 0;
3268
3269     if ((gst_structure_get_int (structure, "flvversion", &flvversion))) {
3270       switch (flvversion) {
3271         case 1:
3272           id = CODEC_ID_FLV1;
3273           video = TRUE;
3274           break;
3275         default:
3276           break;
3277       }
3278     }
3279
3280   } else if (!strcmp (mimetype, "audio/x-nellymoser")) {
3281     id = CODEC_ID_NELLYMOSER;
3282     audio = TRUE;
3283   } else if (!strncmp (mimetype, "audio/x-gst_ff-", 15)) {
3284     gchar ext[16];
3285     AVCodec *codec;
3286
3287     if (strlen (mimetype) <= 30 &&
3288         sscanf (mimetype, "audio/x-gst_ff-%s", ext) == 1) {
3289       if ((codec = avcodec_find_decoder_by_name (ext)) ||
3290           (codec = avcodec_find_encoder_by_name (ext))) {
3291         id = codec->id;
3292         audio = TRUE;
3293       }
3294     }
3295   } else if (!strncmp (mimetype, "video/x-gst_ff-", 15)) {
3296     gchar ext[16];
3297     AVCodec *codec;
3298
3299     if (strlen (mimetype) <= 30 &&
3300         sscanf (mimetype, "video/x-gst_ff-%s", ext) == 1) {
3301       if ((codec = avcodec_find_decoder_by_name (ext)) ||
3302           (codec = avcodec_find_encoder_by_name (ext))) {
3303         id = codec->id;
3304         video = TRUE;
3305       }
3306     }
3307   }
3308
3309   if (context != NULL) {
3310     if (video == TRUE) {
3311       context->codec_type = CODEC_TYPE_VIDEO;
3312     } else if (audio == TRUE) {
3313       context->codec_type = CODEC_TYPE_AUDIO;
3314     } else {
3315       context->codec_type = CODEC_TYPE_UNKNOWN;
3316     }
3317     context->codec_id = id;
3318     gst_ffmpeg_caps_with_codecid (id, context->codec_type, caps, context);
3319   }
3320
3321   if (id != CODEC_ID_NONE) {
3322     GST_DEBUG ("The id=%d belongs to the caps %" GST_PTR_FORMAT, id, caps);
3323   } else {
3324     GST_WARNING ("Couldn't figure out the id for caps %" GST_PTR_FORMAT, caps);
3325   }
3326
3327   return id;
3328 }