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   /* Only a single format */
2026   if (fmts[1] == -1) {
2027     format = gst_ffmpeg_smpfmt_to_audioformat (fmts[0]);
2028     if (format != GST_AUDIO_FORMAT_UNKNOWN)
2029       gst_caps_set_simple (caps, "format", G_TYPE_STRING,
2030           gst_audio_format_to_string (format), NULL);
2031     return;
2032   }
2033
2034   g_value_init (&va, GST_TYPE_LIST);
2035   g_value_init (&v, G_TYPE_STRING);
2036   while (*fmts != -1) {
2037     format = gst_ffmpeg_smpfmt_to_audioformat (*fmts);
2038     if (format != GST_AUDIO_FORMAT_UNKNOWN) {
2039       g_value_set_string (&v, gst_audio_format_to_string (format));
2040       gst_value_list_append_value (&va, &v);
2041     }
2042     fmts++;
2043   }
2044   if (gst_value_list_get_size (&va) > 0)
2045     gst_caps_set_value (caps, "format", &va);
2046   g_value_unset (&v);
2047   g_value_unset (&va);
2048 }
2049
2050 GstCaps *
2051 gst_ffmpeg_codectype_to_audio_caps (AVCodecContext * context,
2052     enum CodecID codec_id, gboolean encode, AVCodec * codec)
2053 {
2054   GstCaps *caps = NULL;
2055
2056   GST_DEBUG ("context:%p, codec_id:%d, encode:%d, codec:%p",
2057       context, codec_id, encode, codec);
2058   if (codec)
2059     GST_DEBUG ("sample_fmts:%p, samplerates:%p",
2060         codec->sample_fmts, codec->supported_samplerates);
2061
2062   if (context) {
2063     /* Specific codec context */
2064     caps =
2065         gst_ffmpeg_smpfmt_to_caps (context->sample_fmt, context, codec,
2066         codec_id);
2067   } else {
2068     caps = gst_ff_aud_caps_new (context, codec, codec_id, encode, "audio/x-raw",
2069         "layout", G_TYPE_STRING, "interleaved", NULL);
2070     gst_ffmpeg_audio_set_sample_fmts (caps, codec ? codec->sample_fmts : NULL);
2071   }
2072
2073   return caps;
2074 }
2075
2076 static void
2077 gst_ffmpeg_video_set_pix_fmts (GstCaps * caps, const enum AVPixelFormat *fmts)
2078 {
2079   GValue va = { 0, };
2080   GValue v = { 0, };
2081   GstVideoFormat format;
2082
2083   if (!fmts || fmts[0] == -1) {
2084     gint i;
2085
2086     g_value_init (&va, GST_TYPE_LIST);
2087     g_value_init (&v, G_TYPE_STRING);
2088     for (i = 0; i <= PIX_FMT_NB; i++) {
2089       format = gst_ffmpeg_pixfmt_to_videoformat (i);
2090       if (format == GST_VIDEO_FORMAT_UNKNOWN)
2091         continue;
2092       g_value_set_string (&v, gst_video_format_to_string (format));
2093       gst_value_list_append_value (&va, &v);
2094     }
2095     gst_caps_set_value (caps, "format", &va);
2096     g_value_unset (&v);
2097     g_value_unset (&va);
2098     return;
2099   }
2100
2101   /* Only a single format */
2102   if (fmts[1] == -1) {
2103     format = gst_ffmpeg_pixfmt_to_videoformat (fmts[0]);
2104     if (format != GST_VIDEO_FORMAT_UNKNOWN)
2105       gst_caps_set_simple (caps, "format", G_TYPE_STRING,
2106           gst_video_format_to_string (format), NULL);
2107     return;
2108   }
2109
2110   g_value_init (&va, GST_TYPE_LIST);
2111   g_value_init (&v, G_TYPE_STRING);
2112   while (*fmts != -1) {
2113     format = gst_ffmpeg_pixfmt_to_videoformat (*fmts);
2114     if (format != GST_VIDEO_FORMAT_UNKNOWN) {
2115       g_value_set_string (&v, gst_video_format_to_string (format));
2116       gst_value_list_append_value (&va, &v);
2117     }
2118     fmts++;
2119   }
2120   if (gst_value_list_get_size (&va) > 0)
2121     gst_caps_set_value (caps, "format", &va);
2122   g_value_unset (&v);
2123   g_value_unset (&va);
2124 }
2125
2126 GstCaps *
2127 gst_ffmpeg_codectype_to_video_caps (AVCodecContext * context,
2128     enum CodecID codec_id, gboolean encode, AVCodec * codec)
2129 {
2130   GstCaps *caps;
2131
2132   GST_LOG ("context:%p, codec_id:%d, encode:%d, codec:%p",
2133       context, codec_id, encode, codec);
2134
2135   if (context) {
2136     caps = gst_ffmpeg_pixfmt_to_caps (context->pix_fmt, context, codec_id);
2137   } else {
2138     caps =
2139         gst_ff_vid_caps_new (context, codec, codec_id, encode, "video/x-raw",
2140         NULL);
2141     gst_ffmpeg_video_set_pix_fmts (caps, codec ? codec->pix_fmts : NULL);
2142   }
2143   return caps;
2144 }
2145
2146 /* Convert a FFMPEG codec Type and optional AVCodecContext
2147  * to a GstCaps. If the context is ommitted, no fixed values
2148  * for video/audio size will be included in the GstCaps
2149  *
2150  * AVMediaType is primarily meant for uncompressed data GstCaps!
2151  */
2152
2153 GstCaps *
2154 gst_ffmpeg_codectype_to_caps (enum AVMediaType codec_type,
2155     AVCodecContext * context, enum CodecID codec_id, gboolean encode)
2156 {
2157   GstCaps *caps;
2158
2159   switch (codec_type) {
2160     case AVMEDIA_TYPE_VIDEO:
2161       caps =
2162           gst_ffmpeg_codectype_to_video_caps (context, codec_id, encode, NULL);
2163       break;
2164     case AVMEDIA_TYPE_AUDIO:
2165       caps =
2166           gst_ffmpeg_codectype_to_audio_caps (context, codec_id, encode, NULL);
2167       break;
2168     default:
2169       caps = NULL;
2170       break;
2171   }
2172
2173   return caps;
2174 }
2175
2176 /* Convert a GstCaps (audio/raw) to a FFMPEG SampleFmt
2177  * and other audio properties in a AVCodecContext.
2178  *
2179  * For usefullness, see below
2180  */
2181
2182 static void
2183 gst_ffmpeg_caps_to_smpfmt (const GstCaps * caps,
2184     AVCodecContext * context, gboolean raw)
2185 {
2186   GstStructure *structure;
2187   const gchar *fmt;
2188   GstAudioFormat format = GST_AUDIO_FORMAT_UNKNOWN;
2189
2190   g_return_if_fail (gst_caps_get_size (caps) == 1);
2191
2192   structure = gst_caps_get_structure (caps, 0);
2193
2194   gst_structure_get_int (structure, "channels", &context->channels);
2195   gst_structure_get_int (structure, "rate", &context->sample_rate);
2196   gst_structure_get_int (structure, "block_align", &context->block_align);
2197   gst_structure_get_int (structure, "bitrate", &context->bit_rate);
2198
2199   if (!raw)
2200     return;
2201
2202   if (gst_structure_has_name (structure, "audio/x-raw")) {
2203     if ((fmt = gst_structure_get_string (structure, "format"))) {
2204       format = gst_audio_format_from_string (fmt);
2205     }
2206   }
2207
2208   switch (format) {
2209     case GST_AUDIO_FORMAT_F32:
2210       context->sample_fmt = AV_SAMPLE_FMT_FLT;
2211       break;
2212     case GST_AUDIO_FORMAT_F64:
2213       context->sample_fmt = AV_SAMPLE_FMT_DBL;
2214       break;
2215     case GST_AUDIO_FORMAT_S32:
2216       context->sample_fmt = AV_SAMPLE_FMT_S32;
2217       break;
2218     case GST_AUDIO_FORMAT_S16:
2219       context->sample_fmt = AV_SAMPLE_FMT_S16;
2220       break;
2221     default:
2222       break;
2223   }
2224 }
2225
2226 /* Convert a GstCaps (video/raw) to a FFMPEG PixFmt
2227  * and other video properties in a AVCodecContext.
2228  *
2229  * For usefullness, see below
2230  */
2231
2232 static void
2233 gst_ffmpeg_caps_to_pixfmt (const GstCaps * caps,
2234     AVCodecContext * context, gboolean raw)
2235 {
2236   GstStructure *structure;
2237   const GValue *fps;
2238   const GValue *par = NULL;
2239   const gchar *fmt;
2240   GstVideoFormat format = GST_VIDEO_FORMAT_UNKNOWN;
2241
2242   GST_DEBUG ("converting caps %" GST_PTR_FORMAT, caps);
2243   g_return_if_fail (gst_caps_get_size (caps) == 1);
2244   structure = gst_caps_get_structure (caps, 0);
2245
2246   gst_structure_get_int (structure, "width", &context->width);
2247   gst_structure_get_int (structure, "height", &context->height);
2248   gst_structure_get_int (structure, "bpp", &context->bits_per_coded_sample);
2249
2250   fps = gst_structure_get_value (structure, "framerate");
2251   if (fps != NULL && GST_VALUE_HOLDS_FRACTION (fps)) {
2252
2253     /* somehow these seem mixed up.. */
2254     context->time_base.den = gst_value_get_fraction_numerator (fps);
2255     context->time_base.num = gst_value_get_fraction_denominator (fps);
2256     context->ticks_per_frame = 1;
2257
2258     GST_DEBUG ("setting framerate %d/%d = %lf",
2259         context->time_base.den, context->time_base.num,
2260         1. * context->time_base.den / context->time_base.num);
2261   }
2262
2263   par = gst_structure_get_value (structure, "pixel-aspect-ratio");
2264   if (par && GST_VALUE_HOLDS_FRACTION (par)) {
2265
2266     context->sample_aspect_ratio.num = gst_value_get_fraction_numerator (par);
2267     context->sample_aspect_ratio.den = gst_value_get_fraction_denominator (par);
2268
2269     GST_DEBUG ("setting pixel-aspect-ratio %d/%d = %lf",
2270         context->sample_aspect_ratio.den, context->sample_aspect_ratio.num,
2271         1. * context->sample_aspect_ratio.den /
2272         context->sample_aspect_ratio.num);
2273   }
2274
2275   if (!raw)
2276     return;
2277
2278   g_return_if_fail (fps != NULL && GST_VALUE_HOLDS_FRACTION (fps));
2279
2280   if (gst_structure_has_name (structure, "video/x-raw")) {
2281     if ((fmt = gst_structure_get_string (structure, "format"))) {
2282       format = gst_video_format_from_string (fmt);
2283     }
2284   }
2285
2286   switch (format) {
2287     case GST_VIDEO_FORMAT_YUY2:
2288       context->pix_fmt = PIX_FMT_YUYV422;
2289       break;
2290     case GST_VIDEO_FORMAT_I420:
2291       context->pix_fmt = PIX_FMT_YUV420P;
2292       break;
2293     case GST_VIDEO_FORMAT_A420:
2294       context->pix_fmt = PIX_FMT_YUVA420P;
2295       break;
2296     case GST_VIDEO_FORMAT_Y41B:
2297       context->pix_fmt = PIX_FMT_YUV411P;
2298       break;
2299     case GST_VIDEO_FORMAT_Y42B:
2300       context->pix_fmt = PIX_FMT_YUV422P;
2301       break;
2302     case GST_VIDEO_FORMAT_YUV9:
2303       context->pix_fmt = PIX_FMT_YUV410P;
2304       break;
2305     case GST_VIDEO_FORMAT_Y444:
2306       context->pix_fmt = PIX_FMT_YUV444P;
2307       break;
2308     case GST_VIDEO_FORMAT_GRAY8:
2309       context->pix_fmt = PIX_FMT_GRAY8;
2310       break;
2311     case GST_VIDEO_FORMAT_xRGB:
2312 #if (G_BYTE_ORDER == G_BIG_ENDIAN)
2313       context->pix_fmt = PIX_FMT_RGB32;
2314 #endif
2315       break;
2316     case GST_VIDEO_FORMAT_BGRx:
2317 #if (G_BYTE_ORDER == G_LITTLE_ENDIAN)
2318       context->pix_fmt = PIX_FMT_RGB32;
2319 #endif
2320       break;
2321     case GST_VIDEO_FORMAT_RGB:
2322       context->pix_fmt = PIX_FMT_RGB24;
2323       break;
2324     case GST_VIDEO_FORMAT_BGR:
2325       context->pix_fmt = PIX_FMT_BGR24;
2326       break;
2327     case GST_VIDEO_FORMAT_RGB16:
2328       context->pix_fmt = PIX_FMT_RGB565;
2329       break;
2330     case GST_VIDEO_FORMAT_RGB15:
2331       context->pix_fmt = PIX_FMT_RGB555;
2332       break;
2333     case GST_VIDEO_FORMAT_RGB8P:
2334       context->pix_fmt = PIX_FMT_PAL8;
2335       break;
2336     default:
2337       break;
2338   }
2339 }
2340
2341 typedef struct
2342 {
2343   GstVideoFormat format;
2344   enum PixelFormat pixfmt;
2345 } PixToFmt;
2346
2347 /* FIXME : FILLME */
2348 static const PixToFmt pixtofmttable[] = {
2349   /* GST_VIDEO_FORMAT_I420, */
2350   {GST_VIDEO_FORMAT_I420, PIX_FMT_YUV420P},
2351   /* Note : this should use a different chroma placement */
2352   {GST_VIDEO_FORMAT_I420, PIX_FMT_YUVJ420P},
2353
2354   /* GST_VIDEO_FORMAT_YV12, */
2355   /* GST_VIDEO_FORMAT_YUY2, */
2356   {GST_VIDEO_FORMAT_YUY2, PIX_FMT_YUYV422},
2357   /* GST_VIDEO_FORMAT_UYVY, */
2358   {GST_VIDEO_FORMAT_UYVY, PIX_FMT_UYVY422},
2359   /* GST_VIDEO_FORMAT_AYUV, */
2360   /* GST_VIDEO_FORMAT_RGBx, */
2361   /* GST_VIDEO_FORMAT_BGRx, */
2362   /* GST_VIDEO_FORMAT_xRGB, */
2363   /* GST_VIDEO_FORMAT_xBGR, */
2364   /* GST_VIDEO_FORMAT_RGBA, */
2365   {GST_VIDEO_FORMAT_RGBA, PIX_FMT_RGBA},
2366   /* GST_VIDEO_FORMAT_BGRA, */
2367   {GST_VIDEO_FORMAT_BGRA, PIX_FMT_BGRA},
2368   /* GST_VIDEO_FORMAT_ARGB, */
2369   {GST_VIDEO_FORMAT_ARGB, PIX_FMT_ARGB},
2370   /* GST_VIDEO_FORMAT_ABGR, */
2371   {GST_VIDEO_FORMAT_ABGR, PIX_FMT_ABGR},
2372   /* GST_VIDEO_FORMAT_RGB, */
2373   {GST_VIDEO_FORMAT_RGB, PIX_FMT_RGB24},
2374   /* GST_VIDEO_FORMAT_BGR, */
2375   {GST_VIDEO_FORMAT_BGR, PIX_FMT_BGR24},
2376   /* GST_VIDEO_FORMAT_Y41B, */
2377   {GST_VIDEO_FORMAT_Y41B, PIX_FMT_YUV411P},
2378   /* GST_VIDEO_FORMAT_Y42B, */
2379   {GST_VIDEO_FORMAT_Y42B, PIX_FMT_YUV422P},
2380   {GST_VIDEO_FORMAT_Y42B, PIX_FMT_YUVJ422P},
2381   /* GST_VIDEO_FORMAT_YVYU, */
2382   /* GST_VIDEO_FORMAT_Y444, */
2383   {GST_VIDEO_FORMAT_Y444, PIX_FMT_YUV444P},
2384   {GST_VIDEO_FORMAT_Y444, PIX_FMT_YUVJ444P},
2385   /* GST_VIDEO_FORMAT_v210, */
2386   /* GST_VIDEO_FORMAT_v216, */
2387   /* GST_VIDEO_FORMAT_NV12, */
2388   {GST_VIDEO_FORMAT_NV12, PIX_FMT_NV12},
2389   /* GST_VIDEO_FORMAT_NV21, */
2390   {GST_VIDEO_FORMAT_NV21, PIX_FMT_NV21},
2391   /* GST_VIDEO_FORMAT_GRAY8, */
2392   {GST_VIDEO_FORMAT_GRAY8, PIX_FMT_GRAY8},
2393   /* GST_VIDEO_FORMAT_GRAY16_BE, */
2394   {GST_VIDEO_FORMAT_GRAY16_BE, PIX_FMT_GRAY16BE},
2395   /* GST_VIDEO_FORMAT_GRAY16_LE, */
2396   {GST_VIDEO_FORMAT_GRAY16_LE, PIX_FMT_GRAY16LE},
2397   /* GST_VIDEO_FORMAT_v308, */
2398   /* GST_VIDEO_FORMAT_Y800, */
2399   /* GST_VIDEO_FORMAT_Y16, */
2400   /* GST_VIDEO_FORMAT_RGB16, */
2401   {GST_VIDEO_FORMAT_RGB16, PIX_FMT_RGB565},
2402   /* GST_VIDEO_FORMAT_BGR16, */
2403   /* GST_VIDEO_FORMAT_RGB15, */
2404   {GST_VIDEO_FORMAT_RGB15, PIX_FMT_RGB555},
2405   /* GST_VIDEO_FORMAT_BGR15, */
2406   /* GST_VIDEO_FORMAT_UYVP, */
2407   /* GST_VIDEO_FORMAT_A420, */
2408   {GST_VIDEO_FORMAT_A420, PIX_FMT_YUVA420P},
2409   /* GST_VIDEO_FORMAT_RGB8_PALETTED, */
2410   {GST_VIDEO_FORMAT_RGB8P, PIX_FMT_PAL8},
2411   /* GST_VIDEO_FORMAT_YUV9, */
2412   {GST_VIDEO_FORMAT_YUV9, PIX_FMT_YUV410P},
2413   /* GST_VIDEO_FORMAT_YVU9, */
2414   /* GST_VIDEO_FORMAT_IYU1, */
2415   /* GST_VIDEO_FORMAT_ARGB64, */
2416   /* GST_VIDEO_FORMAT_AYUV64, */
2417   /* GST_VIDEO_FORMAT_r210, */
2418   {GST_VIDEO_FORMAT_I420_10LE, PIX_FMT_YUV420P10LE},
2419   {GST_VIDEO_FORMAT_I420_10BE, PIX_FMT_YUV420P10BE},
2420   {GST_VIDEO_FORMAT_I422_10LE, PIX_FMT_YUV422P10LE},
2421   {GST_VIDEO_FORMAT_I422_10BE, PIX_FMT_YUV422P10BE},
2422   {GST_VIDEO_FORMAT_Y444_10LE, PIX_FMT_YUV444P10LE},
2423   {GST_VIDEO_FORMAT_Y444_10BE, PIX_FMT_YUV444P10BE},
2424   {GST_VIDEO_FORMAT_GBR, PIX_FMT_GBRP},
2425   {GST_VIDEO_FORMAT_GBR_10LE, PIX_FMT_GBRP10LE},
2426   {GST_VIDEO_FORMAT_GBR_10BE, PIX_FMT_GBRP10BE},
2427 };
2428
2429 GstVideoFormat
2430 gst_ffmpeg_pixfmt_to_videoformat (enum PixelFormat pixfmt)
2431 {
2432   guint i;
2433
2434   for (i = 0; i < G_N_ELEMENTS (pixtofmttable); i++)
2435     if (pixtofmttable[i].pixfmt == pixfmt)
2436       return pixtofmttable[i].format;
2437
2438   GST_WARNING ("Unknown pixel format %d", pixfmt);
2439   return GST_VIDEO_FORMAT_UNKNOWN;
2440 }
2441
2442 enum PixelFormat
2443 gst_ffmpeg_videoformat_to_pixfmt (GstVideoFormat format)
2444 {
2445   guint i;
2446
2447   for (i = 0; i < G_N_ELEMENTS (pixtofmttable); i++)
2448     if (pixtofmttable[i].format == format)
2449       return pixtofmttable[i].pixfmt;
2450   return PIX_FMT_NONE;
2451 }
2452
2453 void
2454 gst_ffmpeg_videoinfo_to_context (GstVideoInfo * info, AVCodecContext * context)
2455 {
2456   gint i, bpp = 0;
2457
2458   context->width = GST_VIDEO_INFO_WIDTH (info);
2459   context->height = GST_VIDEO_INFO_HEIGHT (info);
2460   for (i = 0; i < GST_VIDEO_INFO_N_COMPONENTS (info); i++)
2461     bpp += GST_VIDEO_INFO_COMP_DEPTH (info, i);
2462   context->bits_per_coded_sample = bpp;
2463
2464   context->ticks_per_frame = 1;
2465   context->time_base.den = GST_VIDEO_INFO_FPS_N (info);
2466   context->time_base.num = GST_VIDEO_INFO_FPS_D (info);
2467
2468   context->sample_aspect_ratio.num = GST_VIDEO_INFO_PAR_N (info);
2469   context->sample_aspect_ratio.den = GST_VIDEO_INFO_PAR_D (info);
2470
2471   context->pix_fmt =
2472       gst_ffmpeg_videoformat_to_pixfmt (GST_VIDEO_INFO_FORMAT (info));
2473 }
2474
2475 void
2476 gst_ffmpeg_audioinfo_to_context (GstAudioInfo * info, AVCodecContext * context)
2477 {
2478   const AVCodec *codec;
2479   const enum AVSampleFormat *smpl_fmts;
2480   enum AVSampleFormat smpl_fmt = -1;
2481
2482   context->channels = info->channels;
2483   context->sample_rate = info->rate;
2484   context->channel_layout =
2485       gst_ffmpeg_channel_positions_to_layout (info->position, info->channels);
2486
2487   codec = context->codec;
2488
2489   smpl_fmts = codec->sample_fmts;
2490
2491   switch (info->finfo->format) {
2492     case GST_AUDIO_FORMAT_F32:
2493       if (smpl_fmts) {
2494         while (*smpl_fmts != -1) {
2495           if (*smpl_fmts == AV_SAMPLE_FMT_FLT) {
2496             smpl_fmt = *smpl_fmts;
2497             break;
2498           } else if (*smpl_fmts == AV_SAMPLE_FMT_FLTP) {
2499             smpl_fmt = *smpl_fmts;
2500           }
2501
2502           smpl_fmts++;
2503         }
2504       } else {
2505         smpl_fmt = AV_SAMPLE_FMT_FLT;
2506       }
2507       break;
2508     case GST_AUDIO_FORMAT_F64:
2509       if (smpl_fmts) {
2510         while (*smpl_fmts != -1) {
2511           if (*smpl_fmts == AV_SAMPLE_FMT_DBL) {
2512             smpl_fmt = *smpl_fmts;
2513             break;
2514           } else if (*smpl_fmts == AV_SAMPLE_FMT_DBLP) {
2515             smpl_fmt = *smpl_fmts;
2516           }
2517
2518           smpl_fmts++;
2519         }
2520       } else {
2521         smpl_fmt = AV_SAMPLE_FMT_DBL;
2522       }
2523       break;
2524     case GST_AUDIO_FORMAT_S32:
2525       if (smpl_fmts) {
2526         while (*smpl_fmts != -1) {
2527           if (*smpl_fmts == AV_SAMPLE_FMT_S32) {
2528             smpl_fmt = *smpl_fmts;
2529             break;
2530           } else if (*smpl_fmts == AV_SAMPLE_FMT_S32P) {
2531             smpl_fmt = *smpl_fmts;
2532           }
2533
2534           smpl_fmts++;
2535         }
2536       } else {
2537         smpl_fmt = AV_SAMPLE_FMT_S32;
2538       }
2539       break;
2540     case GST_AUDIO_FORMAT_S16:
2541       if (smpl_fmts) {
2542         while (*smpl_fmts != -1) {
2543           if (*smpl_fmts == AV_SAMPLE_FMT_S16) {
2544             smpl_fmt = *smpl_fmts;
2545             break;
2546           } else if (*smpl_fmts == AV_SAMPLE_FMT_S16P) {
2547             smpl_fmt = *smpl_fmts;
2548           }
2549
2550           smpl_fmts++;
2551         }
2552       } else {
2553         smpl_fmt = AV_SAMPLE_FMT_S16;
2554       }
2555       break;
2556     case GST_AUDIO_FORMAT_U8:
2557       if (smpl_fmts) {
2558         while (*smpl_fmts != -1) {
2559           if (*smpl_fmts == AV_SAMPLE_FMT_U8) {
2560             smpl_fmt = *smpl_fmts;
2561             break;
2562           } else if (*smpl_fmts == AV_SAMPLE_FMT_U8P) {
2563             smpl_fmt = *smpl_fmts;
2564           }
2565
2566           smpl_fmts++;
2567         }
2568       } else {
2569         smpl_fmt = AV_SAMPLE_FMT_U8;
2570       }
2571       break;
2572     default:
2573       break;
2574   }
2575
2576   g_assert (smpl_fmt != -1);
2577
2578   context->sample_fmt = smpl_fmt;
2579 }
2580
2581 /* Convert a GstCaps and a FFMPEG codec Type to a
2582  * AVCodecContext. If the context is ommitted, no fixed values
2583  * for video/audio size will be included in the context
2584  *
2585  * AVMediaType is primarily meant for uncompressed data GstCaps!
2586  */
2587
2588 void
2589 gst_ffmpeg_caps_with_codectype (enum AVMediaType type,
2590     const GstCaps * caps, AVCodecContext * context)
2591 {
2592   if (context == NULL)
2593     return;
2594
2595   switch (type) {
2596     case AVMEDIA_TYPE_VIDEO:
2597       gst_ffmpeg_caps_to_pixfmt (caps, context, TRUE);
2598       break;
2599
2600     case AVMEDIA_TYPE_AUDIO:
2601       gst_ffmpeg_caps_to_smpfmt (caps, context, TRUE);
2602       break;
2603
2604     default:
2605       /* unknown */
2606       break;
2607   }
2608 }
2609
2610 #if 0
2611 static void
2612 nal_escape (guint8 * dst, guint8 * src, guint size, guint * destsize)
2613 {
2614   guint8 *dstp = dst;
2615   guint8 *srcp = src;
2616   guint8 *end = src + size;
2617   gint count = 0;
2618
2619   while (srcp < end) {
2620     if (count == 2 && *srcp <= 0x03) {
2621       GST_DEBUG ("added escape code");
2622       *dstp++ = 0x03;
2623       count = 0;
2624     }
2625     if (*srcp == 0)
2626       count++;
2627     else
2628       count = 0;
2629
2630     GST_DEBUG ("copy %02x, count %d", *srcp, count);
2631     *dstp++ = *srcp++;
2632   }
2633   *destsize = dstp - dst;
2634 }
2635
2636 /* copy the config, escaping NAL units as we iterate them, if something fails we
2637  * copy everything and hope for the best. */
2638 static void
2639 copy_config (guint8 * dst, guint8 * src, guint size, guint * destsize)
2640 {
2641   guint8 *dstp = dst;
2642   guint8 *srcp = src;
2643   gint cnt, i;
2644   guint nalsize, esize;
2645
2646   /* check size */
2647   if (size < 7)
2648     goto full_copy;
2649
2650   /* check version */
2651   if (*srcp != 1)
2652     goto full_copy;
2653
2654   cnt = *(srcp + 5) & 0x1f;     /* Number of sps */
2655
2656   GST_DEBUG ("num SPS %d", cnt);
2657
2658   memcpy (dstp, srcp, 6);
2659   srcp += 6;
2660   dstp += 6;
2661
2662   for (i = 0; i < cnt; i++) {
2663     GST_DEBUG ("copy SPS %d", i);
2664     nalsize = (srcp[0] << 8) | srcp[1];
2665     nal_escape (dstp + 2, srcp + 2, nalsize, &esize);
2666     dstp[0] = esize >> 8;
2667     dstp[1] = esize & 0xff;
2668     dstp += esize + 2;
2669     srcp += nalsize + 2;
2670   }
2671
2672   cnt = *(dstp++) = *(srcp++);  /* Number of pps */
2673
2674   GST_DEBUG ("num PPS %d", cnt);
2675
2676   for (i = 0; i < cnt; i++) {
2677     GST_DEBUG ("copy PPS %d", i);
2678     nalsize = (srcp[0] << 8) | srcp[1];
2679     nal_escape (dstp + 2, srcp + 2, nalsize, &esize);
2680     dstp[0] = esize >> 8;
2681     dstp[1] = esize & 0xff;
2682     dstp += esize + 2;
2683     srcp += nalsize + 2;
2684   }
2685   *destsize = dstp - dst;
2686
2687   return;
2688
2689 full_copy:
2690   {
2691     GST_DEBUG ("something unexpected, doing full copy");
2692     memcpy (dst, src, size);
2693     *destsize = size;
2694     return;
2695   }
2696 }
2697 #endif
2698
2699 /*
2700  * caps_with_codecid () transforms a GstCaps for a known codec
2701  * ID into a filled-in context.
2702  * codec_data from caps will override possible extradata already in the context
2703  */
2704
2705 void
2706 gst_ffmpeg_caps_with_codecid (enum CodecID codec_id,
2707     enum AVMediaType codec_type, const GstCaps * caps, AVCodecContext * context)
2708 {
2709   GstStructure *str;
2710   const GValue *value;
2711   GstBuffer *buf;
2712
2713   GST_LOG ("codec_id:%d, codec_type:%d, caps:%" GST_PTR_FORMAT " context:%p",
2714       codec_id, codec_type, caps, context);
2715
2716   if (!context || !gst_caps_get_size (caps))
2717     return;
2718
2719   str = gst_caps_get_structure (caps, 0);
2720
2721   /* extradata parsing (esds [mpeg4], wma/wmv, msmpeg4v1/2/3, etc.) */
2722   if ((value = gst_structure_get_value (str, "codec_data"))) {
2723     GstMapInfo map;
2724
2725     buf = gst_value_get_buffer (value);
2726     gst_buffer_map (buf, &map, GST_MAP_READ);
2727
2728     /* free the old one if it is there */
2729     if (context->extradata)
2730       av_free (context->extradata);
2731
2732 #if 0
2733     if (codec_id == CODEC_ID_H264) {
2734       guint extrasize;
2735
2736       GST_DEBUG ("copy, escaping codec_data %d", size);
2737       /* ffmpeg h264 expects the codec_data to be escaped, there is no real
2738        * reason for this but let's just escape it for now. Start by allocating
2739        * enough space, x2 is more than enough.
2740        *
2741        * FIXME, we disabled escaping because some file already contain escaped
2742        * codec_data and then we escape twice and fail. It's better to leave it
2743        * as is, as that is what most players do. */
2744       context->extradata =
2745           av_mallocz (GST_ROUND_UP_16 (size * 2 +
2746               FF_INPUT_BUFFER_PADDING_SIZE));
2747       copy_config (context->extradata, data, size, &extrasize);
2748       GST_DEBUG ("escaped size: %d", extrasize);
2749       context->extradata_size = extrasize;
2750     } else
2751 #endif
2752     {
2753       /* allocate with enough padding */
2754       GST_DEBUG ("copy codec_data");
2755       context->extradata =
2756           av_mallocz (GST_ROUND_UP_16 (map.size +
2757               FF_INPUT_BUFFER_PADDING_SIZE));
2758       memcpy (context->extradata, map.data, map.size);
2759       context->extradata_size = map.size;
2760     }
2761
2762     /* Hack for VC1. Sometimes the first (length) byte is 0 for some files */
2763     if (codec_id == CODEC_ID_VC1 && map.size > 0 && map.data[0] == 0) {
2764       context->extradata[0] = (guint8) map.size;
2765     }
2766
2767     GST_DEBUG ("have codec data of size %" G_GSIZE_FORMAT, map.size);
2768
2769     gst_buffer_unmap (buf, &map);
2770   } else if (context->extradata == NULL && codec_id != CODEC_ID_AAC_LATM &&
2771       codec_id != CODEC_ID_FLAC) {
2772     /* no extradata, alloc dummy with 0 sized, some codecs insist on reading
2773      * extradata anyway which makes then segfault. */
2774     context->extradata =
2775         av_mallocz (GST_ROUND_UP_16 (FF_INPUT_BUFFER_PADDING_SIZE));
2776     context->extradata_size = 0;
2777     GST_DEBUG ("no codec data");
2778   }
2779
2780   switch (codec_id) {
2781     case CODEC_ID_MPEG4:
2782     {
2783       const gchar *mime = gst_structure_get_name (str);
2784
2785       if (!strcmp (mime, "video/x-divx"))
2786         context->codec_tag = GST_MAKE_FOURCC ('D', 'I', 'V', 'X');
2787       else if (!strcmp (mime, "video/x-xvid"))
2788         context->codec_tag = GST_MAKE_FOURCC ('X', 'V', 'I', 'D');
2789       else if (!strcmp (mime, "video/x-3ivx"))
2790         context->codec_tag = GST_MAKE_FOURCC ('3', 'I', 'V', '1');
2791       else if (!strcmp (mime, "video/mpeg"))
2792         context->codec_tag = GST_MAKE_FOURCC ('m', 'p', '4', 'v');
2793     }
2794       break;
2795
2796     case CODEC_ID_SVQ3:
2797       /* FIXME: this is a workaround for older gst-plugins releases
2798        * (<= 0.8.9). This should be removed at some point, because
2799        * it causes wrong decoded frame order. */
2800       if (!context->extradata) {
2801         gint halfpel_flag, thirdpel_flag, low_delay, unknown_svq3_flag;
2802         guint16 flags;
2803
2804         if (gst_structure_get_int (str, "halfpel_flag", &halfpel_flag) ||
2805             gst_structure_get_int (str, "thirdpel_flag", &thirdpel_flag) ||
2806             gst_structure_get_int (str, "low_delay", &low_delay) ||
2807             gst_structure_get_int (str, "unknown_svq3_flag",
2808                 &unknown_svq3_flag)) {
2809           context->extradata = (guint8 *) av_mallocz (0x64);
2810           g_stpcpy ((gchar *) context->extradata, "SVQ3");
2811           flags = 1 << 3;
2812           flags |= low_delay;
2813           flags = flags << 2;
2814           flags |= unknown_svq3_flag;
2815           flags = flags << 6;
2816           flags |= halfpel_flag;
2817           flags = flags << 1;
2818           flags |= thirdpel_flag;
2819           flags = flags << 3;
2820
2821           flags = GUINT16_FROM_LE (flags);
2822
2823           memcpy ((gchar *) context->extradata + 0x62, &flags, 2);
2824           context->extradata_size = 0x64;
2825         }
2826       }
2827       break;
2828
2829     case CODEC_ID_MSRLE:
2830     case CODEC_ID_QTRLE:
2831     case CODEC_ID_TSCC:
2832     case CODEC_ID_CSCD:
2833     case CODEC_ID_APE:
2834     {
2835       gint depth;
2836
2837       if (gst_structure_get_int (str, "depth", &depth)) {
2838         context->bits_per_coded_sample = depth;
2839       } else {
2840         GST_WARNING ("No depth field in caps %" GST_PTR_FORMAT, caps);
2841       }
2842
2843     }
2844       break;
2845
2846     case CODEC_ID_RV10:
2847     case CODEC_ID_RV20:
2848     case CODEC_ID_RV30:
2849     case CODEC_ID_RV40:
2850     {
2851       gint format;
2852
2853       if (gst_structure_get_int (str, "format", &format))
2854         context->sub_id = format;
2855
2856       break;
2857     }
2858     case CODEC_ID_COOK:
2859     case CODEC_ID_RA_288:
2860     case CODEC_ID_RA_144:
2861     case CODEC_ID_SIPR:
2862     {
2863       gint leaf_size;
2864       gint bitrate;
2865
2866       if (gst_structure_get_int (str, "leaf_size", &leaf_size))
2867         context->block_align = leaf_size;
2868       if (gst_structure_get_int (str, "bitrate", &bitrate))
2869         context->bit_rate = bitrate;
2870     }
2871     case CODEC_ID_ALAC:
2872       gst_structure_get_int (str, "samplesize",
2873           &context->bits_per_coded_sample);
2874       break;
2875
2876     case CODEC_ID_DVVIDEO:
2877     {
2878       const gchar *format;
2879
2880       if ((format = gst_structure_get_string (str, "format"))) {
2881
2882         if (g_str_equal (format, "YUY2"))
2883           context->pix_fmt = PIX_FMT_YUYV422;
2884         else if (g_str_equal (format, "I420"))
2885           context->pix_fmt = PIX_FMT_YUV420P;
2886         else if (g_str_equal (format, "A420"))
2887           context->pix_fmt = PIX_FMT_YUVA420P;
2888         else if (g_str_equal (format, "Y41B"))
2889           context->pix_fmt = PIX_FMT_YUV411P;
2890         else if (g_str_equal (format, "Y42B"))
2891           context->pix_fmt = PIX_FMT_YUV422P;
2892         else if (g_str_equal (format, "YUV9"))
2893           context->pix_fmt = PIX_FMT_YUV410P;
2894         else {
2895           GST_WARNING ("couldn't convert format %s" " to a pixel format",
2896               format);
2897         }
2898       } else
2899         GST_WARNING ("No specified format");
2900       break;
2901     }
2902     case CODEC_ID_H263P:
2903     {
2904       gboolean val;
2905
2906       if (!gst_structure_get_boolean (str, "annex-f", &val) || val)
2907         context->flags |= CODEC_FLAG_4MV;
2908       else
2909         context->flags &= ~CODEC_FLAG_4MV;
2910       if ((!gst_structure_get_boolean (str, "annex-i", &val) || val) &&
2911           (!gst_structure_get_boolean (str, "annex-t", &val) || val))
2912         context->flags |= CODEC_FLAG_AC_PRED;
2913       else
2914         context->flags &= ~CODEC_FLAG_AC_PRED;
2915       if (!gst_structure_get_boolean (str, "annex-j", &val) || val)
2916         context->flags |= CODEC_FLAG_LOOP_FILTER;
2917       else
2918         context->flags &= ~CODEC_FLAG_LOOP_FILTER;
2919       break;
2920     }
2921     case CODEC_ID_ADPCM_G726:
2922     {
2923       const gchar *layout;
2924
2925       if ((layout = gst_structure_get_string (str, "layout"))) {
2926         if (!strcmp (layout, "g721")) {
2927           context->sample_rate = 8000;
2928           context->channels = 1;
2929           context->bit_rate = 32000;
2930         }
2931       }
2932       break;
2933     }
2934     default:
2935       break;
2936   }
2937
2938   if (!gst_caps_is_fixed (caps))
2939     return;
2940
2941   /* common properties (width, height, fps) */
2942   switch (codec_type) {
2943     case AVMEDIA_TYPE_VIDEO:
2944       gst_ffmpeg_caps_to_pixfmt (caps, context, codec_id == CODEC_ID_RAWVIDEO);
2945       break;
2946     case AVMEDIA_TYPE_AUDIO:
2947       gst_ffmpeg_caps_to_smpfmt (caps, context, FALSE);
2948       break;
2949     default:
2950       break;
2951   }
2952
2953   /* fixup of default settings */
2954   switch (codec_id) {
2955     case CODEC_ID_QCELP:
2956       /* QCELP is always mono, no matter what the caps say */
2957       context->channels = 1;
2958       break;
2959     default:
2960       break;
2961   }
2962 }
2963
2964 /* _formatid_to_caps () is meant for muxers/demuxers, it
2965  * transforms a name (ffmpeg way of ID'ing these, why don't
2966  * they have unique numerical IDs?) to the corresponding
2967  * caps belonging to that mux-format
2968  *
2969  * Note: we don't need any additional info because the caps
2970  * isn't supposed to contain any useful info besides the
2971  * media type anyway
2972  */
2973
2974 GstCaps *
2975 gst_ffmpeg_formatid_to_caps (const gchar * format_name)
2976 {
2977   GstCaps *caps = NULL;
2978
2979   if (!strcmp (format_name, "mpeg")) {
2980     caps = gst_caps_new_simple ("video/mpeg",
2981         "systemstream", G_TYPE_BOOLEAN, TRUE, NULL);
2982   } else if (!strcmp (format_name, "mpegts")) {
2983     caps = gst_caps_new_simple ("video/mpegts",
2984         "systemstream", G_TYPE_BOOLEAN, TRUE, NULL);
2985   } else if (!strcmp (format_name, "rm")) {
2986     caps = gst_caps_new_simple ("application/x-pn-realmedia",
2987         "systemstream", G_TYPE_BOOLEAN, TRUE, NULL);
2988   } else if (!strcmp (format_name, "asf")) {
2989     caps = gst_caps_new_empty_simple ("video/x-ms-asf");
2990   } else if (!strcmp (format_name, "avi")) {
2991     caps = gst_caps_new_empty_simple ("video/x-msvideo");
2992   } else if (!strcmp (format_name, "wav")) {
2993     caps = gst_caps_new_empty_simple ("audio/x-wav");
2994   } else if (!strcmp (format_name, "ape")) {
2995     caps = gst_caps_new_empty_simple ("application/x-ape");
2996   } else if (!strcmp (format_name, "swf")) {
2997     caps = gst_caps_new_empty_simple ("application/x-shockwave-flash");
2998   } else if (!strcmp (format_name, "au")) {
2999     caps = gst_caps_new_empty_simple ("audio/x-au");
3000   } else if (!strcmp (format_name, "dv")) {
3001     caps = gst_caps_new_simple ("video/x-dv",
3002         "systemstream", G_TYPE_BOOLEAN, TRUE, NULL);
3003   } else if (!strcmp (format_name, "4xm")) {
3004     caps = gst_caps_new_empty_simple ("video/x-4xm");
3005   } else if (!strcmp (format_name, "matroska")) {
3006     caps = gst_caps_new_empty_simple ("video/x-matroska");
3007   } else if (!strcmp (format_name, "mp3")) {
3008     caps = gst_caps_new_empty_simple ("application/x-id3");
3009   } else if (!strcmp (format_name, "flic")) {
3010     caps = gst_caps_new_empty_simple ("video/x-fli");
3011   } else if (!strcmp (format_name, "flv")) {
3012     caps = gst_caps_new_empty_simple ("video/x-flv");
3013   } else if (!strcmp (format_name, "tta")) {
3014     caps = gst_caps_new_empty_simple ("audio/x-ttafile");
3015   } else if (!strcmp (format_name, "aiff")) {
3016     caps = gst_caps_new_empty_simple ("audio/x-aiff");
3017   } else if (!strcmp (format_name, "mov_mp4_m4a_3gp_3g2")) {
3018     caps =
3019         gst_caps_from_string
3020         ("application/x-3gp; video/quicktime; audio/x-m4a");
3021   } else if (!strcmp (format_name, "mov")) {
3022     caps = gst_caps_from_string ("video/quicktime,variant=(string)apple");
3023   } else if (!strcmp (format_name, "mp4")) {
3024     caps = gst_caps_from_string ("video/quicktime,variant=(string)iso");
3025   } else if (!strcmp (format_name, "3gp")) {
3026     caps = gst_caps_from_string ("video/quicktime,variant=(string)3gpp");
3027   } else if (!strcmp (format_name, "3g2")) {
3028     caps = gst_caps_from_string ("video/quicktime,variant=(string)3g2");
3029   } else if (!strcmp (format_name, "psp")) {
3030     caps = gst_caps_from_string ("video/quicktime,variant=(string)psp");
3031   } else if (!strcmp (format_name, "ipod")) {
3032     caps = gst_caps_from_string ("video/quicktime,variant=(string)ipod");
3033   } else if (!strcmp (format_name, "aac")) {
3034     caps = gst_caps_new_simple ("audio/mpeg",
3035         "mpegversion", G_TYPE_INT, 4, NULL);
3036   } else if (!strcmp (format_name, "gif")) {
3037     caps = gst_caps_from_string ("image/gif");
3038   } else if (!strcmp (format_name, "ogg")) {
3039     caps = gst_caps_from_string ("application/ogg");
3040   } else if (!strcmp (format_name, "mxf") || !strcmp (format_name, "mxf_d10")) {
3041     caps = gst_caps_from_string ("application/mxf");
3042   } else if (!strcmp (format_name, "gxf")) {
3043     caps = gst_caps_from_string ("application/gxf");
3044   } else if (!strcmp (format_name, "yuv4mpegpipe")) {
3045     caps = gst_caps_new_simple ("application/x-yuv4mpeg",
3046         "y4mversion", G_TYPE_INT, 2, NULL);
3047   } else if (!strcmp (format_name, "mpc")) {
3048     caps = gst_caps_from_string ("audio/x-musepack, streamversion = (int) 7");
3049   } else if (!strcmp (format_name, "vqf")) {
3050     caps = gst_caps_from_string ("audio/x-vqf");
3051   } else if (!strcmp (format_name, "nsv")) {
3052     caps = gst_caps_from_string ("video/x-nsv");
3053   } else if (!strcmp (format_name, "amr")) {
3054     caps = gst_caps_from_string ("audio/x-amr-nb-sh");
3055   } else if (!strcmp (format_name, "webm")) {
3056     caps = gst_caps_from_string ("video/webm");
3057   } else if (!strcmp (format_name, "voc")) {
3058     caps = gst_caps_from_string ("audio/x-voc");
3059   } else {
3060     gchar *name;
3061
3062     GST_LOG ("Could not create stream format caps for %s", format_name);
3063     name = g_strdup_printf ("application/x-gst-av-%s", format_name);
3064     caps = gst_caps_new_empty_simple (name);
3065     g_free (name);
3066   }
3067
3068   return caps;
3069 }
3070
3071 gboolean
3072 gst_ffmpeg_formatid_get_codecids (const gchar * format_name,
3073     enum CodecID ** video_codec_list, enum CodecID ** audio_codec_list,
3074     AVOutputFormat * plugin)
3075 {
3076   static enum CodecID tmp_vlist[] = {
3077     CODEC_ID_NONE,
3078     CODEC_ID_NONE
3079   };
3080   static enum CodecID tmp_alist[] = {
3081     CODEC_ID_NONE,
3082     CODEC_ID_NONE
3083   };
3084
3085   GST_LOG ("format_name : %s", format_name);
3086
3087   if (!strcmp (format_name, "mp4")) {
3088     static enum CodecID mp4_video_list[] = {
3089       CODEC_ID_MPEG4, CODEC_ID_H264,
3090       CODEC_ID_MJPEG,
3091       CODEC_ID_NONE
3092     };
3093     static enum CodecID mp4_audio_list[] = {
3094       CODEC_ID_AAC, CODEC_ID_MP3,
3095       CODEC_ID_NONE
3096     };
3097
3098     *video_codec_list = mp4_video_list;
3099     *audio_codec_list = mp4_audio_list;
3100   } else if (!strcmp (format_name, "mpeg")) {
3101     static enum CodecID mpeg_video_list[] = { CODEC_ID_MPEG1VIDEO,
3102       CODEC_ID_MPEG2VIDEO,
3103       CODEC_ID_H264,
3104       CODEC_ID_NONE
3105     };
3106     static enum CodecID mpeg_audio_list[] = { CODEC_ID_MP1,
3107       CODEC_ID_MP2,
3108       CODEC_ID_MP3,
3109       CODEC_ID_NONE
3110     };
3111
3112     *video_codec_list = mpeg_video_list;
3113     *audio_codec_list = mpeg_audio_list;
3114   } else if (!strcmp (format_name, "dvd")) {
3115     static enum CodecID mpeg_video_list[] = { CODEC_ID_MPEG2VIDEO,
3116       CODEC_ID_NONE
3117     };
3118     static enum CodecID mpeg_audio_list[] = { CODEC_ID_MP2,
3119       CODEC_ID_AC3,
3120       CODEC_ID_DTS,
3121       CODEC_ID_PCM_S16BE,
3122       CODEC_ID_NONE
3123     };
3124
3125     *video_codec_list = mpeg_video_list;
3126     *audio_codec_list = mpeg_audio_list;
3127   } else if (!strcmp (format_name, "mpegts")) {
3128     static enum CodecID mpegts_video_list[] = { CODEC_ID_MPEG1VIDEO,
3129       CODEC_ID_MPEG2VIDEO,
3130       CODEC_ID_H264,
3131       CODEC_ID_NONE
3132     };
3133     static enum CodecID mpegts_audio_list[] = { CODEC_ID_MP2,
3134       CODEC_ID_MP3,
3135       CODEC_ID_AC3,
3136       CODEC_ID_DTS,
3137       CODEC_ID_AAC,
3138       CODEC_ID_NONE
3139     };
3140
3141     *video_codec_list = mpegts_video_list;
3142     *audio_codec_list = mpegts_audio_list;
3143   } else if (!strcmp (format_name, "vob")) {
3144     static enum CodecID vob_video_list[] =
3145         { CODEC_ID_MPEG2VIDEO, CODEC_ID_NONE };
3146     static enum CodecID vob_audio_list[] = { CODEC_ID_MP2, CODEC_ID_AC3,
3147       CODEC_ID_DTS, CODEC_ID_NONE
3148     };
3149
3150     *video_codec_list = vob_video_list;
3151     *audio_codec_list = vob_audio_list;
3152   } else if (!strcmp (format_name, "flv")) {
3153     static enum CodecID flv_video_list[] = { CODEC_ID_FLV1, CODEC_ID_NONE };
3154     static enum CodecID flv_audio_list[] = { CODEC_ID_MP3, CODEC_ID_NONE };
3155
3156     *video_codec_list = flv_video_list;
3157     *audio_codec_list = flv_audio_list;
3158   } else if (!strcmp (format_name, "asf")) {
3159     static enum CodecID asf_video_list[] =
3160         { CODEC_ID_WMV1, CODEC_ID_WMV2, CODEC_ID_MSMPEG4V3, CODEC_ID_NONE };
3161     static enum CodecID asf_audio_list[] =
3162         { CODEC_ID_WMAV1, CODEC_ID_WMAV2, CODEC_ID_MP3, CODEC_ID_NONE };
3163
3164     *video_codec_list = asf_video_list;
3165     *audio_codec_list = asf_audio_list;
3166   } else if (!strcmp (format_name, "dv")) {
3167     static enum CodecID dv_video_list[] = { CODEC_ID_DVVIDEO, CODEC_ID_NONE };
3168     static enum CodecID dv_audio_list[] = { CODEC_ID_PCM_S16LE, CODEC_ID_NONE };
3169
3170     *video_codec_list = dv_video_list;
3171     *audio_codec_list = dv_audio_list;
3172   } else if (!strcmp (format_name, "mov")) {
3173     static enum CodecID mov_video_list[] = {
3174       CODEC_ID_SVQ1, CODEC_ID_SVQ3, CODEC_ID_MPEG4,
3175       CODEC_ID_H263, CODEC_ID_H263P,
3176       CODEC_ID_H264, CODEC_ID_DVVIDEO,
3177       CODEC_ID_MJPEG,
3178       CODEC_ID_NONE
3179     };
3180     static enum CodecID mov_audio_list[] = {
3181       CODEC_ID_PCM_MULAW, CODEC_ID_PCM_ALAW, CODEC_ID_ADPCM_IMA_QT,
3182       CODEC_ID_MACE3, CODEC_ID_MACE6, CODEC_ID_AAC,
3183       CODEC_ID_AMR_NB, CODEC_ID_AMR_WB,
3184       CODEC_ID_PCM_S16BE, CODEC_ID_PCM_S16LE,
3185       CODEC_ID_MP3, CODEC_ID_NONE
3186     };
3187
3188     *video_codec_list = mov_video_list;
3189     *audio_codec_list = mov_audio_list;
3190   } else if ((!strcmp (format_name, "3gp") || !strcmp (format_name, "3g2"))) {
3191     static enum CodecID tgp_video_list[] = {
3192       CODEC_ID_MPEG4, CODEC_ID_H263, CODEC_ID_H263P, CODEC_ID_H264,
3193       CODEC_ID_NONE
3194     };
3195     static enum CodecID tgp_audio_list[] = {
3196       CODEC_ID_AMR_NB, CODEC_ID_AMR_WB,
3197       CODEC_ID_AAC,
3198       CODEC_ID_NONE
3199     };
3200
3201     *video_codec_list = tgp_video_list;
3202     *audio_codec_list = tgp_audio_list;
3203   } else if (!strcmp (format_name, "mmf")) {
3204     static enum CodecID mmf_audio_list[] = {
3205       CODEC_ID_ADPCM_YAMAHA, CODEC_ID_NONE
3206     };
3207     *video_codec_list = NULL;
3208     *audio_codec_list = mmf_audio_list;
3209   } else if (!strcmp (format_name, "amr")) {
3210     static enum CodecID amr_audio_list[] = {
3211       CODEC_ID_AMR_NB, CODEC_ID_AMR_WB,
3212       CODEC_ID_NONE
3213     };
3214     *video_codec_list = NULL;
3215     *audio_codec_list = amr_audio_list;
3216   } else if (!strcmp (format_name, "gif")) {
3217     static enum CodecID gif_image_list[] = {
3218       CODEC_ID_RAWVIDEO, CODEC_ID_NONE
3219     };
3220     *video_codec_list = gif_image_list;
3221     *audio_codec_list = NULL;
3222   } else if ((plugin->audio_codec != CODEC_ID_NONE) ||
3223       (plugin->video_codec != CODEC_ID_NONE)) {
3224     tmp_vlist[0] = plugin->video_codec;
3225     tmp_alist[0] = plugin->audio_codec;
3226
3227     *video_codec_list = tmp_vlist;
3228     *audio_codec_list = tmp_alist;
3229   } else {
3230     GST_LOG ("Format %s not found", format_name);
3231     return FALSE;
3232   }
3233
3234   return TRUE;
3235 }
3236
3237 /* Convert a GstCaps to a FFMPEG codec ID. Size et all
3238  * are omitted, that can be queried by the user itself,
3239  * we're not eating the GstCaps or anything
3240  * A pointer to an allocated context is also needed for
3241  * optional extra info
3242  */
3243
3244 enum CodecID
3245 gst_ffmpeg_caps_to_codecid (const GstCaps * caps, AVCodecContext * context)
3246 {
3247   enum CodecID id = CODEC_ID_NONE;
3248   const gchar *mimetype;
3249   const GstStructure *structure;
3250   gboolean video = FALSE, audio = FALSE;        /* we want to be sure! */
3251
3252   g_return_val_if_fail (caps != NULL, CODEC_ID_NONE);
3253   g_return_val_if_fail (gst_caps_get_size (caps) == 1, CODEC_ID_NONE);
3254   structure = gst_caps_get_structure (caps, 0);
3255
3256   mimetype = gst_structure_get_name (structure);
3257
3258   if (!strcmp (mimetype, "video/x-raw")) {
3259     id = CODEC_ID_RAWVIDEO;
3260     video = TRUE;
3261   } else if (!strcmp (mimetype, "audio/x-raw")) {
3262     GstAudioInfo info;
3263
3264     if (gst_audio_info_from_caps (&info, caps)) {
3265       switch (GST_AUDIO_INFO_FORMAT (&info)) {
3266         case GST_AUDIO_FORMAT_S8:
3267           id = CODEC_ID_PCM_S8;
3268           break;
3269         case GST_AUDIO_FORMAT_U8:
3270           id = CODEC_ID_PCM_U8;
3271           break;
3272         case GST_AUDIO_FORMAT_S16LE:
3273           id = CODEC_ID_PCM_S16LE;
3274           break;
3275         case GST_AUDIO_FORMAT_S16BE:
3276           id = CODEC_ID_PCM_S16BE;
3277           break;
3278         case GST_AUDIO_FORMAT_U16LE:
3279           id = CODEC_ID_PCM_U16LE;
3280           break;
3281         case GST_AUDIO_FORMAT_U16BE:
3282           id = CODEC_ID_PCM_U16BE;
3283           break;
3284         default:
3285           break;
3286       }
3287       if (id != CODEC_ID_NONE)
3288         audio = TRUE;
3289     }
3290   } else if (!strcmp (mimetype, "audio/x-mulaw")) {
3291     id = CODEC_ID_PCM_MULAW;
3292     audio = TRUE;
3293   } else if (!strcmp (mimetype, "audio/x-alaw")) {
3294     id = CODEC_ID_PCM_ALAW;
3295     audio = TRUE;
3296   } else if (!strcmp (mimetype, "video/x-dv")) {
3297     gboolean sys_strm;
3298
3299     if (gst_structure_get_boolean (structure, "systemstream", &sys_strm) &&
3300         !sys_strm) {
3301       id = CODEC_ID_DVVIDEO;
3302       video = TRUE;
3303     }
3304   } else if (!strcmp (mimetype, "audio/x-dv")) {        /* ??? */
3305     id = CODEC_ID_DVAUDIO;
3306     audio = TRUE;
3307   } else if (!strcmp (mimetype, "video/x-h263")) {
3308     const gchar *h263version =
3309         gst_structure_get_string (structure, "h263version");
3310     if (h263version && !strcmp (h263version, "h263p"))
3311       id = CODEC_ID_H263P;
3312     else
3313       id = CODEC_ID_H263;
3314     video = TRUE;
3315   } else if (!strcmp (mimetype, "video/x-intel-h263")) {
3316     id = CODEC_ID_H263I;
3317     video = TRUE;
3318   } else if (!strcmp (mimetype, "video/x-h261")) {
3319     id = CODEC_ID_H261;
3320     video = TRUE;
3321   } else if (!strcmp (mimetype, "video/mpeg")) {
3322     gboolean sys_strm;
3323     gint mpegversion;
3324
3325     if (gst_structure_get_boolean (structure, "systemstream", &sys_strm) &&
3326         gst_structure_get_int (structure, "mpegversion", &mpegversion) &&
3327         !sys_strm) {
3328       switch (mpegversion) {
3329         case 1:
3330           id = CODEC_ID_MPEG1VIDEO;
3331           break;
3332         case 2:
3333           id = CODEC_ID_MPEG2VIDEO;
3334           break;
3335         case 4:
3336           id = CODEC_ID_MPEG4;
3337           break;
3338       }
3339     }
3340     if (id != CODEC_ID_NONE)
3341       video = TRUE;
3342   } else if (!strcmp (mimetype, "image/jpeg")) {
3343     id = CODEC_ID_MJPEG;        /* A... B... */
3344     video = TRUE;
3345   } else if (!strcmp (mimetype, "video/x-jpeg-b")) {
3346     id = CODEC_ID_MJPEGB;
3347     video = TRUE;
3348   } else if (!strcmp (mimetype, "video/x-wmv")) {
3349     gint wmvversion = 0;
3350
3351     if (gst_structure_get_int (structure, "wmvversion", &wmvversion)) {
3352       switch (wmvversion) {
3353         case 1:
3354           id = CODEC_ID_WMV1;
3355           break;
3356         case 2:
3357           id = CODEC_ID_WMV2;
3358           break;
3359         case 3:
3360         {
3361           const gchar *format;
3362
3363           /* WMV3 unless the fourcc exists and says otherwise */
3364           id = CODEC_ID_WMV3;
3365
3366           if ((format = gst_structure_get_string (structure, "format")) &&
3367               (g_str_equal (format, "WVC1") || g_str_equal (format, "WMVA")))
3368             id = CODEC_ID_VC1;
3369
3370           break;
3371         }
3372       }
3373     }
3374     if (id != CODEC_ID_NONE)
3375       video = TRUE;
3376   } else if (!strcmp (mimetype, "audio/x-vorbis")) {
3377     id = CODEC_ID_VORBIS;
3378     audio = TRUE;
3379   } else if (!strcmp (mimetype, "audio/x-qdm2")) {
3380     id = CODEC_ID_QDM2;
3381     audio = TRUE;
3382   } else if (!strcmp (mimetype, "audio/mpeg")) {
3383     gint layer = 0;
3384     gint mpegversion = 0;
3385
3386     if (gst_structure_get_int (structure, "mpegversion", &mpegversion)) {
3387       switch (mpegversion) {
3388         case 2:                /* ffmpeg uses faad for both... */
3389         case 4:
3390           id = CODEC_ID_AAC;
3391           break;
3392         case 1:
3393           if (gst_structure_get_int (structure, "layer", &layer)) {
3394             switch (layer) {
3395               case 1:
3396                 id = CODEC_ID_MP1;
3397                 break;
3398               case 2:
3399                 id = CODEC_ID_MP2;
3400                 break;
3401               case 3:
3402                 id = CODEC_ID_MP3;
3403                 break;
3404             }
3405           }
3406       }
3407     }
3408     if (id != CODEC_ID_NONE)
3409       audio = TRUE;
3410   } else if (!strcmp (mimetype, "audio/x-musepack")) {
3411     gint streamversion = -1;
3412
3413     if (gst_structure_get_int (structure, "streamversion", &streamversion)) {
3414       if (streamversion == 7)
3415         id = CODEC_ID_MUSEPACK7;
3416     } else {
3417       id = CODEC_ID_MUSEPACK7;
3418     }
3419   } else if (!strcmp (mimetype, "audio/x-wma")) {
3420     gint wmaversion = 0;
3421
3422     if (gst_structure_get_int (structure, "wmaversion", &wmaversion)) {
3423       switch (wmaversion) {
3424         case 1:
3425           id = CODEC_ID_WMAV1;
3426           break;
3427         case 2:
3428           id = CODEC_ID_WMAV2;
3429           break;
3430         case 3:
3431           id = CODEC_ID_WMAPRO;
3432           break;
3433       }
3434     }
3435     if (id != CODEC_ID_NONE)
3436       audio = TRUE;
3437   } else if (!strcmp (mimetype, "audio/x-wms")) {
3438     id = CODEC_ID_WMAVOICE;
3439     audio = TRUE;
3440   } else if (!strcmp (mimetype, "audio/x-ac3")) {
3441     id = CODEC_ID_AC3;
3442     audio = TRUE;
3443   } else if (!strcmp (mimetype, "audio/x-eac3")) {
3444     id = CODEC_ID_EAC3;
3445     audio = TRUE;
3446   } else if (!strcmp (mimetype, "audio/x-vnd.sony.atrac3") ||
3447       !strcmp (mimetype, "audio/atrac3")) {
3448     id = CODEC_ID_ATRAC3;
3449     audio = TRUE;
3450   } else if (!strcmp (mimetype, "audio/x-dts")) {
3451     id = CODEC_ID_DTS;
3452     audio = TRUE;
3453   } else if (!strcmp (mimetype, "application/x-ape")) {
3454     id = CODEC_ID_APE;
3455     audio = TRUE;
3456   } else if (!strcmp (mimetype, "video/x-msmpeg")) {
3457     gint msmpegversion = 0;
3458
3459     if (gst_structure_get_int (structure, "msmpegversion", &msmpegversion)) {
3460       switch (msmpegversion) {
3461         case 41:
3462           id = CODEC_ID_MSMPEG4V1;
3463           break;
3464         case 42:
3465           id = CODEC_ID_MSMPEG4V2;
3466           break;
3467         case 43:
3468           id = CODEC_ID_MSMPEG4V3;
3469           break;
3470       }
3471     }
3472     if (id != CODEC_ID_NONE)
3473       video = TRUE;
3474   } else if (!strcmp (mimetype, "video/x-svq")) {
3475     gint svqversion = 0;
3476
3477     if (gst_structure_get_int (structure, "svqversion", &svqversion)) {
3478       switch (svqversion) {
3479         case 1:
3480           id = CODEC_ID_SVQ1;
3481           break;
3482         case 3:
3483           id = CODEC_ID_SVQ3;
3484           break;
3485       }
3486     }
3487     if (id != CODEC_ID_NONE)
3488       video = TRUE;
3489   } else if (!strcmp (mimetype, "video/x-huffyuv")) {
3490     id = CODEC_ID_HUFFYUV;
3491     video = TRUE;
3492   } else if (!strcmp (mimetype, "audio/x-mace")) {
3493     gint maceversion = 0;
3494
3495     if (gst_structure_get_int (structure, "maceversion", &maceversion)) {
3496       switch (maceversion) {
3497         case 3:
3498           id = CODEC_ID_MACE3;
3499           break;
3500         case 6:
3501           id = CODEC_ID_MACE6;
3502           break;
3503       }
3504     }
3505     if (id != CODEC_ID_NONE)
3506       audio = TRUE;
3507   } else if (!strcmp (mimetype, "video/x-theora")) {
3508     id = CODEC_ID_THEORA;
3509     video = TRUE;
3510   } else if (!strcmp (mimetype, "video/x-vp3")) {
3511     id = CODEC_ID_VP3;
3512     video = TRUE;
3513   } else if (!strcmp (mimetype, "video/x-vp5")) {
3514     id = CODEC_ID_VP5;
3515     video = TRUE;
3516   } else if (!strcmp (mimetype, "video/x-vp6")) {
3517     id = CODEC_ID_VP6;
3518     video = TRUE;
3519   } else if (!strcmp (mimetype, "video/x-vp6-flash")) {
3520     id = CODEC_ID_VP6F;
3521     video = TRUE;
3522   } else if (!strcmp (mimetype, "video/x-vp6-alpha")) {
3523     id = CODEC_ID_VP6A;
3524     video = TRUE;
3525   } else if (!strcmp (mimetype, "video/x-vp8")) {
3526     id = CODEC_ID_VP8;
3527     video = TRUE;
3528   } else if (!strcmp (mimetype, "video/x-flash-screen")) {
3529     id = CODEC_ID_FLASHSV;
3530     video = TRUE;
3531   } else if (!strcmp (mimetype, "video/x-indeo")) {
3532     gint indeoversion = 0;
3533
3534     if (gst_structure_get_int (structure, "indeoversion", &indeoversion)) {
3535       switch (indeoversion) {
3536         case 5:
3537           id = CODEC_ID_INDEO5;
3538           break;
3539         case 4:
3540           id = CODEC_ID_INDEO4;
3541           break;
3542         case 3:
3543           id = CODEC_ID_INDEO3;
3544           break;
3545         case 2:
3546           id = CODEC_ID_INDEO2;
3547           break;
3548       }
3549       if (id != CODEC_ID_NONE)
3550         video = TRUE;
3551     }
3552   } else if (!strcmp (mimetype, "video/x-divx")) {
3553     gint divxversion = 0;
3554
3555     if (gst_structure_get_int (structure, "divxversion", &divxversion)) {
3556       switch (divxversion) {
3557         case 3:
3558           id = CODEC_ID_MSMPEG4V3;
3559           break;
3560         case 4:
3561         case 5:
3562           id = CODEC_ID_MPEG4;
3563           break;
3564       }
3565     }
3566     if (id != CODEC_ID_NONE)
3567       video = TRUE;
3568   } else if (!strcmp (mimetype, "video/x-3ivx")) {
3569     id = CODEC_ID_MPEG4;
3570     video = TRUE;
3571   } else if (!strcmp (mimetype, "video/x-xvid")) {
3572     id = CODEC_ID_MPEG4;
3573     video = TRUE;
3574   } else if (!strcmp (mimetype, "video/x-ffv")) {
3575     gint ffvversion = 0;
3576
3577     if (gst_structure_get_int (structure, "ffvversion", &ffvversion) &&
3578         ffvversion == 1) {
3579       id = CODEC_ID_FFV1;
3580       video = TRUE;
3581     }
3582   } else if (!strcmp (mimetype, "audio/x-adpcm")) {
3583     const gchar *layout;
3584
3585     layout = gst_structure_get_string (structure, "layout");
3586     if (layout == NULL) {
3587       /* break */
3588     } else if (!strcmp (layout, "quicktime")) {
3589       id = CODEC_ID_ADPCM_IMA_QT;
3590     } else if (!strcmp (layout, "microsoft")) {
3591       id = CODEC_ID_ADPCM_MS;
3592     } else if (!strcmp (layout, "dvi")) {
3593       id = CODEC_ID_ADPCM_IMA_WAV;
3594     } else if (!strcmp (layout, "4xm")) {
3595       id = CODEC_ID_ADPCM_4XM;
3596     } else if (!strcmp (layout, "smjpeg")) {
3597       id = CODEC_ID_ADPCM_IMA_SMJPEG;
3598     } else if (!strcmp (layout, "dk3")) {
3599       id = CODEC_ID_ADPCM_IMA_DK3;
3600     } else if (!strcmp (layout, "dk4")) {
3601       id = CODEC_ID_ADPCM_IMA_DK4;
3602     } else if (!strcmp (layout, "westwood")) {
3603       id = CODEC_ID_ADPCM_IMA_WS;
3604     } else if (!strcmp (layout, "iss")) {
3605       id = CODEC_ID_ADPCM_IMA_ISS;
3606     } else if (!strcmp (layout, "xa")) {
3607       id = CODEC_ID_ADPCM_XA;
3608     } else if (!strcmp (layout, "adx")) {
3609       id = CODEC_ID_ADPCM_ADX;
3610     } else if (!strcmp (layout, "ea")) {
3611       id = CODEC_ID_ADPCM_EA;
3612     } else if (!strcmp (layout, "g726")) {
3613       id = CODEC_ID_ADPCM_G726;
3614     } else if (!strcmp (layout, "g721")) {
3615       id = CODEC_ID_ADPCM_G726;
3616     } else if (!strcmp (layout, "ct")) {
3617       id = CODEC_ID_ADPCM_CT;
3618     } else if (!strcmp (layout, "swf")) {
3619       id = CODEC_ID_ADPCM_SWF;
3620     } else if (!strcmp (layout, "yamaha")) {
3621       id = CODEC_ID_ADPCM_YAMAHA;
3622     } else if (!strcmp (layout, "sbpro2")) {
3623       id = CODEC_ID_ADPCM_SBPRO_2;
3624     } else if (!strcmp (layout, "sbpro3")) {
3625       id = CODEC_ID_ADPCM_SBPRO_3;
3626     } else if (!strcmp (layout, "sbpro4")) {
3627       id = CODEC_ID_ADPCM_SBPRO_4;
3628     }
3629     if (id != CODEC_ID_NONE)
3630       audio = TRUE;
3631   } else if (!strcmp (mimetype, "video/x-4xm")) {
3632     id = CODEC_ID_4XM;
3633     video = TRUE;
3634   } else if (!strcmp (mimetype, "audio/x-dpcm")) {
3635     const gchar *layout;
3636
3637     layout = gst_structure_get_string (structure, "layout");
3638     if (!layout) {
3639       /* .. */
3640     } else if (!strcmp (layout, "roq")) {
3641       id = CODEC_ID_ROQ_DPCM;
3642     } else if (!strcmp (layout, "interplay")) {
3643       id = CODEC_ID_INTERPLAY_DPCM;
3644     } else if (!strcmp (layout, "xan")) {
3645       id = CODEC_ID_XAN_DPCM;
3646     } else if (!strcmp (layout, "sol")) {
3647       id = CODEC_ID_SOL_DPCM;
3648     }
3649     if (id != CODEC_ID_NONE)
3650       audio = TRUE;
3651   } else if (!strcmp (mimetype, "audio/x-flac")) {
3652     id = CODEC_ID_FLAC;
3653     audio = TRUE;
3654   } else if (!strcmp (mimetype, "audio/x-shorten")) {
3655     id = CODEC_ID_SHORTEN;
3656     audio = TRUE;
3657   } else if (!strcmp (mimetype, "audio/x-alac")) {
3658     id = CODEC_ID_ALAC;
3659     audio = TRUE;
3660   } else if (!strcmp (mimetype, "video/x-cinepak")) {
3661     id = CODEC_ID_CINEPAK;
3662     video = TRUE;
3663   } else if (!strcmp (mimetype, "video/x-pn-realvideo")) {
3664     gint rmversion;
3665
3666     if (gst_structure_get_int (structure, "rmversion", &rmversion)) {
3667       switch (rmversion) {
3668         case 1:
3669           id = CODEC_ID_RV10;
3670           break;
3671         case 2:
3672           id = CODEC_ID_RV20;
3673           break;
3674         case 3:
3675           id = CODEC_ID_RV30;
3676           break;
3677         case 4:
3678           id = CODEC_ID_RV40;
3679           break;
3680       }
3681     }
3682     if (id != CODEC_ID_NONE)
3683       video = TRUE;
3684   } else if (!strcmp (mimetype, "audio/x-sipro")) {
3685     id = CODEC_ID_SIPR;
3686     audio = TRUE;
3687   } else if (!strcmp (mimetype, "audio/x-pn-realaudio")) {
3688     gint raversion;
3689
3690     if (gst_structure_get_int (structure, "raversion", &raversion)) {
3691       switch (raversion) {
3692         case 1:
3693           id = CODEC_ID_RA_144;
3694           break;
3695         case 2:
3696           id = CODEC_ID_RA_288;
3697           break;
3698         case 8:
3699           id = CODEC_ID_COOK;
3700           break;
3701       }
3702     }
3703     if (id != CODEC_ID_NONE)
3704       audio = TRUE;
3705   } else if (!strcmp (mimetype, "video/x-rle")) {
3706     const gchar *layout;
3707
3708     if ((layout = gst_structure_get_string (structure, "layout"))) {
3709       if (!strcmp (layout, "microsoft")) {
3710         id = CODEC_ID_MSRLE;
3711         video = TRUE;
3712       }
3713     }
3714   } else if (!strcmp (mimetype, "video/x-xan")) {
3715     gint wcversion = 0;
3716
3717     if ((gst_structure_get_int (structure, "wcversion", &wcversion))) {
3718       switch (wcversion) {
3719         case 3:
3720           id = CODEC_ID_XAN_WC3;
3721           video = TRUE;
3722           break;
3723         case 4:
3724           id = CODEC_ID_XAN_WC4;
3725           video = TRUE;
3726           break;
3727         default:
3728           break;
3729       }
3730     }
3731   } else if (!strcmp (mimetype, "audio/AMR")) {
3732     audio = TRUE;
3733     id = CODEC_ID_AMR_NB;
3734   } else if (!strcmp (mimetype, "audio/AMR-WB")) {
3735     id = CODEC_ID_AMR_WB;
3736     audio = TRUE;
3737   } else if (!strcmp (mimetype, "audio/qcelp")) {
3738     id = CODEC_ID_QCELP;
3739     audio = TRUE;
3740   } else if (!strcmp (mimetype, "video/x-h264")) {
3741     id = CODEC_ID_H264;
3742     video = TRUE;
3743   } else if (!strcmp (mimetype, "video/x-flash-video")) {
3744     gint flvversion = 0;
3745
3746     if ((gst_structure_get_int (structure, "flvversion", &flvversion))) {
3747       switch (flvversion) {
3748         case 1:
3749           id = CODEC_ID_FLV1;
3750           video = TRUE;
3751           break;
3752         default:
3753           break;
3754       }
3755     }
3756
3757   } else if (!strcmp (mimetype, "audio/x-nellymoser")) {
3758     id = CODEC_ID_NELLYMOSER;
3759     audio = TRUE;
3760   } else if (!strncmp (mimetype, "audio/x-gst-av-", 15)) {
3761     gchar ext[16];
3762     AVCodec *codec;
3763
3764     if (strlen (mimetype) <= 30 &&
3765         sscanf (mimetype, "audio/x-gst-av-%s", ext) == 1) {
3766       if ((codec = avcodec_find_decoder_by_name (ext)) ||
3767           (codec = avcodec_find_encoder_by_name (ext))) {
3768         id = codec->id;
3769         audio = TRUE;
3770       }
3771     }
3772   } else if (!strncmp (mimetype, "video/x-gst-av-", 15)) {
3773     gchar ext[16];
3774     AVCodec *codec;
3775
3776     if (strlen (mimetype) <= 30 &&
3777         sscanf (mimetype, "video/x-gst-av-%s", ext) == 1) {
3778       if ((codec = avcodec_find_decoder_by_name (ext)) ||
3779           (codec = avcodec_find_encoder_by_name (ext))) {
3780         id = codec->id;
3781         video = TRUE;
3782       }
3783     }
3784   }
3785
3786   if (context != NULL) {
3787     if (video == TRUE) {
3788       context->codec_type = AVMEDIA_TYPE_VIDEO;
3789     } else if (audio == TRUE) {
3790       context->codec_type = AVMEDIA_TYPE_AUDIO;
3791     } else {
3792       context->codec_type = AVMEDIA_TYPE_UNKNOWN;
3793     }
3794     context->codec_id = id;
3795     gst_ffmpeg_caps_with_codecid (id, context->codec_type, caps, context);
3796   }
3797
3798   if (id != CODEC_ID_NONE) {
3799     GST_DEBUG ("The id=%d belongs to the caps %" GST_PTR_FORMAT, id, caps);
3800   } else {
3801     GST_WARNING ("Couldn't figure out the id for caps %" GST_PTR_FORMAT, caps);
3802   }
3803
3804   return id;
3805 }