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