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