gstffmpegcodecmap.c 101 KB
Newer Older
1 2
/* GStreamer
 * 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 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Library General Public
 * License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Library General Public License for more details.
 *
 * You should have received a copy of the GNU Library General Public
 * License along with this library; if not, write to the
 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
 * Boston, MA 02111-1307, USA.
 */

22
#ifdef HAVE_CONFIG_H
23
#include "config.h"
24
#endif
25
#include <gst/gst.h>
26 27 28
#ifdef HAVE_FFMPEG_UNINSTALLED
#include <avcodec.h>
#else
29
#include <libavcodec/avcodec.h>
30
#endif
31
#include <string.h>
32

33
#include "gstffmpeg.h"
34 35
#include "gstffmpegcodecmap.h"

36 37 38 39 40
/*
 * Read a palette from a caps.
 */

static void
41
gst_ffmpeg_get_palette (const GstCaps * caps, AVCodecContext * context)
42 43 44 45 46 47
{
  GstStructure *str = gst_caps_get_structure (caps, 0);
  const GValue *palette_v;
  const GstBuffer *palette;

  /* do we have a palette? */
48
  if ((palette_v = gst_structure_get_value (str, "palette_data")) && context) {
49
    palette = gst_value_get_buffer (palette_v);
50
    if (GST_BUFFER_SIZE (palette) >= AVPALETTE_SIZE) {
51 52 53 54 55 56 57 58 59 60 61
      if (context->palctrl)
        av_free (context->palctrl);
      context->palctrl = av_malloc (sizeof (AVPaletteControl));
      context->palctrl->palette_changed = 1;
      memcpy (context->palctrl->palette, GST_BUFFER_DATA (palette),
          AVPALETTE_SIZE);
    }
  }
}

static void
62
gst_ffmpeg_set_palette (GstCaps * caps, AVCodecContext * context)
63 64
{
  if (context->palctrl) {
65
    GstBuffer *palette = gst_buffer_new_and_alloc (AVPALETTE_SIZE);
66 67 68

    memcpy (GST_BUFFER_DATA (palette), context->palctrl->palette,
        AVPALETTE_SIZE);
69
    gst_caps_set_simple (caps, "palette_data", GST_TYPE_BUFFER, palette, NULL);
70 71 72
  }
}

73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141
/* IMPORTANT: Keep this sorted by the ffmpeg channel masks */
static const struct
{
  guint64 ff;
  GstAudioChannelPosition gst;
} _ff_to_gst_layout[] = {
  {
  CH_FRONT_LEFT, GST_AUDIO_CHANNEL_POSITION_FRONT_LEFT}, {
  CH_FRONT_RIGHT, GST_AUDIO_CHANNEL_POSITION_FRONT_RIGHT}, {
  CH_FRONT_CENTER, GST_AUDIO_CHANNEL_POSITION_FRONT_CENTER}, {
  CH_LOW_FREQUENCY, GST_AUDIO_CHANNEL_POSITION_LFE}, {
  CH_BACK_LEFT, GST_AUDIO_CHANNEL_POSITION_REAR_LEFT}, {
  CH_BACK_RIGHT, GST_AUDIO_CHANNEL_POSITION_REAR_RIGHT}, {
  CH_FRONT_LEFT_OF_CENTER, GST_AUDIO_CHANNEL_POSITION_FRONT_LEFT_OF_CENTER}, {
  CH_FRONT_RIGHT_OF_CENTER, GST_AUDIO_CHANNEL_POSITION_FRONT_RIGHT_OF_CENTER}, {
  CH_BACK_CENTER, GST_AUDIO_CHANNEL_POSITION_REAR_CENTER}, {
  CH_SIDE_LEFT, GST_AUDIO_CHANNEL_POSITION_SIDE_LEFT}, {
  CH_SIDE_RIGHT, GST_AUDIO_CHANNEL_POSITION_SIDE_RIGHT}, {
  CH_TOP_CENTER, GST_AUDIO_CHANNEL_POSITION_NONE}, {
  CH_TOP_FRONT_LEFT, GST_AUDIO_CHANNEL_POSITION_NONE}, {
  CH_TOP_FRONT_CENTER, GST_AUDIO_CHANNEL_POSITION_NONE}, {
  CH_TOP_FRONT_RIGHT, GST_AUDIO_CHANNEL_POSITION_NONE}, {
  CH_TOP_BACK_LEFT, GST_AUDIO_CHANNEL_POSITION_NONE}, {
  CH_TOP_BACK_CENTER, GST_AUDIO_CHANNEL_POSITION_NONE}, {
  CH_TOP_BACK_RIGHT, GST_AUDIO_CHANNEL_POSITION_NONE}, {
  CH_STEREO_LEFT, GST_AUDIO_CHANNEL_POSITION_FRONT_LEFT}, {
  CH_STEREO_RIGHT, GST_AUDIO_CHANNEL_POSITION_FRONT_RIGHT}
};

static GstAudioChannelPosition *
gst_ff_channel_layout_to_gst (guint64 channel_layout, guint channels)
{
  guint nchannels = 0, i, j;
  GstAudioChannelPosition *pos = NULL;
  gboolean none_layout = FALSE;

  for (i = 0; i < 64; i++) {
    if ((channel_layout & (G_GUINT64_CONSTANT (1) << i)) != 0) {
      nchannels++;
    }
  }

  if (channel_layout == 0) {
    nchannels = channels;
    none_layout = TRUE;
  }

  if (nchannels != channels) {
    GST_ERROR ("Number of channels is different (%u != %u)", channels,
        nchannels);
    return NULL;
  }

  pos = g_new (GstAudioChannelPosition, nchannels);

  for (i = 0, j = 0; i < G_N_ELEMENTS (_ff_to_gst_layout); i++) {
    if ((channel_layout & _ff_to_gst_layout[i].ff) != 0) {
      pos[j++] = _ff_to_gst_layout[i].gst;

      if (_ff_to_gst_layout[i].gst == GST_AUDIO_CHANNEL_POSITION_NONE)
        none_layout = TRUE;
    }
  }

  if (j != nchannels) {
    GST_WARNING ("Unknown channels in channel layout - assuming NONE layout");
    none_layout = TRUE;
  }

142 143 144
  if (!none_layout && !gst_audio_check_channel_positions (pos, nchannels)) {
    GST_ERROR ("Invalid channel layout %" G_GUINT64_FORMAT
        " - assuming NONE layout", channel_layout);
145 146 147 148 149 150 151 152 153
    none_layout = TRUE;
  }

  if (none_layout) {
    if (nchannels == 1) {
      pos[0] = GST_AUDIO_CHANNEL_POSITION_FRONT_MONO;
    } else if (nchannels == 2) {
      pos[0] = GST_AUDIO_CHANNEL_POSITION_FRONT_LEFT;
      pos[1] = GST_AUDIO_CHANNEL_POSITION_FRONT_RIGHT;
154 155 156
    } else if (channel_layout == 0) {
      g_free (pos);
      pos = NULL;
157 158 159 160 161 162
    } else {
      for (i = 0; i < nchannels; i++)
        pos[i] = GST_AUDIO_CHANNEL_POSITION_NONE;
    }
  }

163 164 165 166 167 168 169 170 171 172
  if (nchannels == 1 && pos[0] == GST_AUDIO_CHANNEL_POSITION_FRONT_CENTER) {
    GST_DEBUG ("mono common case; won't set channel positions");
    g_free (pos);
    pos = NULL;
  } else if (nchannels == 2 && pos[0] == GST_AUDIO_CHANNEL_POSITION_FRONT_LEFT
      && pos[1] == GST_AUDIO_CHANNEL_POSITION_FRONT_RIGHT) {
    GST_DEBUG ("stereo common case; won't set channel positions");
    g_free (pos);
    pos = NULL;
  }
173 174 175 176

  return pos;
}

177 178 179 180
/* this macro makes a caps width fixed or unfixed width/height
 * properties depending on whether we've got a context.
 *
 * See below for why we use this.
181 182 183
 *
 * We should actually do this stuff at the end, like in riff-media.c,
 * but I'm too lazy today. Maybe later.
184
 */
185
static GstCaps *
186 187
gst_ff_vid_caps_new (AVCodecContext * context, enum CodecID codec_id,
    const char *mimetype, const char *fieldname, ...)
188 189 190 191
{
  GstStructure *structure = NULL;
  GstCaps *caps = NULL;
  va_list var_args;
192
  gint i;
193

194 195
  GST_LOG ("context:%p, codec_id:%d, mimetype:%s", context, codec_id, mimetype);

196 197
  /* fixed, non probing context */
  if (context != NULL && context->width != -1) {
198 199
    gint num, denom;

200 201
    caps = gst_caps_new_simple (mimetype,
        "width", G_TYPE_INT, context->width,
202 203 204 205 206 207 208 209 210 211 212 213 214
        "height", G_TYPE_INT, context->height, NULL);

    num = context->time_base.den / context->ticks_per_frame;
    denom = context->time_base.num;

    if (gst_util_fraction_compare (num, denom, 1000, 1) > 0) {
      GST_LOG ("excessive framerate: %d/%d, -> 0/1", num, denom);
      num = 0;
      denom = 1;
    }
    GST_LOG ("setting framerate: %d/%d", num, denom);
    gst_caps_set_simple (caps,
        "framerate", GST_TYPE_FRACTION, num, denom, NULL);
215
  } else {
216
    /* so we are after restricted caps in this case */
217
    switch (codec_id) {
218 219 220 221 222 223 224 225 226 227 228 229
      case CODEC_ID_H261:
      {
        caps = gst_caps_new_simple (mimetype,
            "width", G_TYPE_INT, 352,
            "height", G_TYPE_INT, 288,
            "framerate", GST_TYPE_FRACTION_RANGE, 0, 1, G_MAXINT, 1, NULL);
        gst_caps_append (caps, gst_caps_new_simple (mimetype,
                "width", G_TYPE_INT, 176,
                "height", G_TYPE_INT, 144,
                "framerate", GST_TYPE_FRACTION_RANGE, 0, 1, G_MAXINT, 1, NULL));
        break;
      }
230 231 232 233 234 235 236 237 238
      case CODEC_ID_H263:
      {
        /* 128x96, 176x144, 352x288, 704x576, and 1408x1152. slightly reordered
         * because we want automatic negotiation to go as close to 320x240 as
         * possible. */
        const static gint widths[] = { 352, 704, 176, 1408, 128 };
        const static gint heights[] = { 288, 576, 144, 1152, 96 };
        GstCaps *temp;
        gint n_sizes = G_N_ELEMENTS (widths);
239

240 241 242 243 244 245
        caps = gst_caps_new_empty ();
        for (i = 0; i < n_sizes; i++) {
          temp = gst_caps_new_simple (mimetype,
              "width", G_TYPE_INT, widths[i],
              "height", G_TYPE_INT, heights[i],
              "framerate", GST_TYPE_FRACTION_RANGE, 0, 1, G_MAXINT, 1, NULL);
246

247 248 249 250
          gst_caps_append (caps, temp);
        }
        break;
      }
251 252
      case CODEC_ID_DVVIDEO:
      {
253 254 255 256 257 258 259 260 261 262 263 264 265 266 267
        static struct
        {
          guint32 csp;
          gint width, height;
          gint par_n, par_d;
          gint framerate_n, framerate_d;
        } profiles[] = {
          {
          GST_MAKE_FOURCC ('Y', '4', '1', 'B'), 720, 480, 10, 11, 30000, 1001}, {
          GST_MAKE_FOURCC ('Y', '4', '1', 'B'), 720, 480, 40, 33, 30000, 1001}, {
          GST_MAKE_FOURCC ('I', '4', '2', '0'), 720, 576, 59, 54, 25, 1}, {
          GST_MAKE_FOURCC ('I', '4', '2', '0'), 720, 576, 118, 81, 25, 1}, {
          GST_MAKE_FOURCC ('Y', '4', '1', 'B'), 720, 576, 59, 54, 25, 1}, {
          GST_MAKE_FOURCC ('Y', '4', '1', 'B'), 720, 576, 118, 81, 25, 1}
        };
268
        GstCaps *temp;
269
        gint n_sizes = G_N_ELEMENTS (profiles);
270 271 272 273

        caps = gst_caps_new_empty ();
        for (i = 0; i < n_sizes; i++) {
          temp = gst_caps_new_simple (mimetype,
274 275 276 277 278
              "width", G_TYPE_INT, profiles[i].width,
              "height", G_TYPE_INT, profiles[i].height,
              "framerate", GST_TYPE_FRACTION, profiles[i].framerate_n,
              profiles[i].framerate_d, "pixel-aspect-ratio", GST_TYPE_FRACTION,
              profiles[i].par_n, profiles[i].par_d, NULL);
279 280

          gst_caps_append (caps, temp);
281
        }
282 283
        break;
      }
284 285
      case CODEC_ID_DNXHD:
      {
286
        caps = gst_caps_new_simple (mimetype,
287 288
            "width", G_TYPE_INT, 1920,
            "height", G_TYPE_INT, 1080,
289
            "framerate", GST_TYPE_FRACTION_RANGE, 0, 1, G_MAXINT, 1, NULL);
290 291 292 293 294 295 296
        gst_caps_append (caps, gst_caps_new_simple (mimetype,
                "width", G_TYPE_INT, 1280,
                "height", G_TYPE_INT, 720,
                "framerate", GST_TYPE_FRACTION_RANGE, 0, 1, G_MAXINT, 1, NULL));
        break;
      }
      default:
297 298 299 300
        break;
    }
  }

301 302
  /* no fixed caps or special restrictions applied;
   * default unfixed setting */
303 304
  if (!caps) {
    GST_DEBUG ("Creating default caps");
305 306 307 308
    caps = gst_caps_new_simple (mimetype,
        "width", GST_TYPE_INT_RANGE, 16, 4096,
        "height", GST_TYPE_INT_RANGE, 16, 4096,
        "framerate", GST_TYPE_FRACTION_RANGE, 0, 1, G_MAXINT, 1, NULL);
309
  }
310

311
  for (i = 0; i < gst_caps_get_size (caps); i++) {
312
    va_start (var_args, fieldname);
313
    structure = gst_caps_get_structure (caps, i);
314 315 316 317 318 319
    gst_structure_set_valist (structure, fieldname, var_args);
    va_end (var_args);
  }

  return caps;
}
320 321 322

/* same for audio - now with channels/sample rate
 */
323
static GstCaps *
324 325
gst_ff_aud_caps_new (AVCodecContext * context, enum CodecID codec_id,
    const char *mimetype, const char *fieldname, ...)
326 327 328
{
  GstCaps *caps = NULL;
  GstStructure *structure = NULL;
329
  gint i;
330 331
  va_list var_args;

332 333
  /* fixed, non-probing context */
  if (context != NULL && context->channels != -1) {
334
    GstAudioChannelPosition *pos;
335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354
    guint64 channel_layout = context->channel_layout;

    if (channel_layout == 0) {
      const guint64 default_channel_set[] = {
        0, 0, CH_LAYOUT_SURROUND, CH_LAYOUT_QUAD, CH_LAYOUT_5POINT0,
        CH_LAYOUT_5POINT1, 0, CH_LAYOUT_7POINT1
      };

      switch (codec_id) {
        case CODEC_ID_EAC3:
        case CODEC_ID_AC3:
        case CODEC_ID_DTS:
          if (context->channels > 0
              && context->channels < G_N_ELEMENTS (default_channel_set))
            channel_layout = default_channel_set[context->channels - 1];
          break;
        default:
          break;
      }
    }
355

356 357
    caps = gst_caps_new_simple (mimetype,
        "rate", G_TYPE_INT, context->sample_rate,
358
        "channels", G_TYPE_INT, context->channels, NULL);
359

360
    pos = gst_ff_channel_layout_to_gst (channel_layout, context->channels);
361 362 363 364
    if (pos != NULL) {
      gst_audio_set_channel_positions (gst_caps_get_structure (caps, 0), pos);
      g_free (pos);
    }
365
  } else {
366 367 368
    gint maxchannels = 2;
    const gint *rates = NULL;
    gint n_rates = 0;
369

370
    if (context) {
371 372 373 374 375 376 377 378 379 380
      /* so we must be after restricted caps in this particular case */
      switch (codec_id) {
        case CODEC_ID_MP2:
        {
          const static gint l_rates[] =
              { 48000, 44100, 32000, 24000, 22050, 16000 };
          n_rates = G_N_ELEMENTS (l_rates);
          rates = l_rates;
          break;
        }
381
        case CODEC_ID_EAC3:
382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405
        case CODEC_ID_AC3:
        {
          const static gint l_rates[] = { 48000, 44100, 32000 };
          n_rates = G_N_ELEMENTS (l_rates);
          rates = l_rates;
          break;
        }
        case CODEC_ID_ADPCM_SWF:
        {
          const static gint l_rates[] = { 11025, 22050, 44100 };
          n_rates = G_N_ELEMENTS (l_rates);
          rates = l_rates;
          break;
        }
        case CODEC_ID_ROQ_DPCM:
        {
          const static gint l_rates[] = { 22050 };
          n_rates = G_N_ELEMENTS (l_rates);
          rates = l_rates;
          break;
        }
        case CODEC_ID_ADPCM_G726:
          maxchannels = 1;
          break;
406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421
        case CODEC_ID_AMR_NB:
        {
          const static gint l_rates[] = { 8000 };
          maxchannels = 1;
          n_rates = G_N_ELEMENTS (l_rates);
          rates = l_rates;
          break;
        }
        case CODEC_ID_AMR_WB:
        {
          const static gint l_rates[] = { 16000 };
          maxchannels = 1;
          n_rates = G_N_ELEMENTS (l_rates);
          rates = l_rates;
          break;
        }
422 423 424
        default:
          break;
      }
425 426 427 428 429

      /* TODO: handle context->channel_layouts here to set
       * the list of channel layouts supported by the encoder.
       * Unfortunately no encoder uses this yet....
       */
430 431 432 433 434 435 436
    }

    /* regardless of encode/decode, open up channels if applicable */
    /* Until decoders/encoders expose the maximum number of channels
     * they support, we whitelist them here. */
    switch (codec_id) {
      case CODEC_ID_AC3:
437
      case CODEC_ID_EAC3:
438 439 440 441
      case CODEC_ID_AAC:
      case CODEC_ID_DTS:
        maxchannels = 6;
        break;
442 443 444 445
      case CODEC_ID_WMAPRO:
      case CODEC_ID_TRUEHD:
        maxchannels = 8;
        break;
446 447 448
      default:
        break;
    }
449

450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472
    if (maxchannels == 1)
      caps = gst_caps_new_simple (mimetype,
          "channels", G_TYPE_INT, maxchannels, NULL);
    else
      caps = gst_caps_new_simple (mimetype,
          "channels", GST_TYPE_INT_RANGE, 1, maxchannels, NULL);
    if (n_rates) {
      GValue list = { 0, };
      GstStructure *structure;

      g_value_init (&list, GST_TYPE_LIST);
      for (i = 0; i < n_rates; i++) {
        GValue v = { 0, };

        g_value_init (&v, G_TYPE_INT);
        g_value_set_int (&v, rates[i]);
        gst_value_list_append_value (&list, &v);
        g_value_unset (&v);
      }
      structure = gst_caps_get_structure (caps, 0);
      gst_structure_set_value (structure, "rate", &list);
      g_value_unset (&list);
    } else
473
      gst_caps_set_simple (caps, "rate", GST_TYPE_INT_RANGE, 4000, 96000, NULL);
474 475
  }

476
  for (i = 0; i < gst_caps_get_size (caps); i++) {
477
    va_start (var_args, fieldname);
478
    structure = gst_caps_get_structure (caps, i);
479 480 481 482 483 484
    gst_structure_set_valist (structure, fieldname, var_args);
    va_end (var_args);
  }

  return caps;
}
485 486 487 488 489 490

/* Convert a FFMPEG codec ID and optional AVCodecContext
 * to a GstCaps. If the context is ommitted, no fixed values
 * for video/audio size will be included in the GstCaps
 *
 * CodecID is primarily meant for compressed data GstCaps!
491 492 493 494 495 496 497 498 499
 *
 * encode is a special parameter. gstffmpegdec will say
 * FALSE, gstffmpegenc will say TRUE. The output caps
 * depends on this, in such a way that it will be very
 * specific, defined, fixed and correct caps for encoders,
 * yet very wide, "forgiving" caps for decoders. Example
 * for mp3: decode: audio/mpeg,mpegversion=1,layer=[1-3]
 * but encode: audio/mpeg,mpegversion=1,layer=3,bitrate=x,
 * rate=x,channels=x.
500 501
 */

502
GstCaps *
Thomas Vander Stichele's avatar
indent  
Thomas Vander Stichele committed
503 504
gst_ffmpeg_codecid_to_caps (enum CodecID codec_id,
    AVCodecContext * context, gboolean encode)
505
{
506
  GstCaps *caps = NULL;
507
  gboolean buildcaps = FALSE;
508

509 510
  GST_LOG ("codec_id:%d, context:%p, encode:%d", codec_id, context, encode);

511
  switch (codec_id) {
512
    case CODEC_ID_MPEG1VIDEO:
513 514 515 516
      /* FIXME: bitrate */
      caps = gst_ff_vid_caps_new (context, codec_id, "video/mpeg",
          "mpegversion", G_TYPE_INT, 1,
          "systemstream", G_TYPE_BOOLEAN, FALSE, NULL);
517 518 519 520 521
      break;

    case CODEC_ID_MPEG2VIDEO:
      if (encode) {
        /* FIXME: bitrate */
522
        caps = gst_ff_vid_caps_new (context, codec_id, "video/mpeg",
Thomas Vander Stichele's avatar
indent  
Thomas Vander Stichele committed
523 524
            "mpegversion", G_TYPE_INT, 2,
            "systemstream", G_TYPE_BOOLEAN, FALSE, NULL);
525 526 527 528
      } else {
        /* decode both MPEG-1 and MPEG-2; width/height/fps are all in
         * the MPEG video stream headers, so may be omitted from caps. */
        caps = gst_caps_new_simple ("video/mpeg",
Thomas Vander Stichele's avatar
indent  
Thomas Vander Stichele committed
529 530
            "mpegversion", GST_TYPE_INT_RANGE, 1, 2,
            "systemstream", G_TYPE_BOOLEAN, FALSE, NULL);
531
      }
532
      break;
533 534 535 536 537 538

    case CODEC_ID_MPEG2VIDEO_XVMC:
      /* this is a special ID - don't need it in GStreamer, I think */
      break;

    case CODEC_ID_H263:
539
      if (encode) {
540
        caps = gst_ff_vid_caps_new (context, codec_id, "video/x-h263",
541 542 543
            "variant", G_TYPE_STRING, "itu",
            "h263version", G_TYPE_STRING, "h263", NULL);
      } else {
544 545 546 547
        /* don't pass codec_id, we can decode other variants with the H263
         * decoder that don't have specific size requirements
         */
        caps = gst_ff_vid_caps_new (context, CODEC_ID_NONE, "video/x-h263",
548 549
            "variant", G_TYPE_STRING, "itu", NULL);
      }
550 551 552
      break;

    case CODEC_ID_H263P:
553
      caps = gst_ff_vid_caps_new (context, codec_id, "video/x-h263",
554 555
          "variant", G_TYPE_STRING, "itu",
          "h263version", G_TYPE_STRING, "h263p", NULL);
556 557 558 559 560 561 562 563 564
      if (encode && context) {

        gst_caps_set_simple (caps,
            "annex-f", G_TYPE_BOOLEAN, context->flags & CODEC_FLAG_4MV,
            "annex-j", G_TYPE_BOOLEAN, context->flags & CODEC_FLAG_LOOP_FILTER,
            "annex-i", G_TYPE_BOOLEAN, context->flags & CODEC_FLAG_AC_PRED,
            "annex-t", G_TYPE_BOOLEAN, context->flags & CODEC_FLAG_AC_PRED,
            NULL);
      }
565
      break;
566

567
    case CODEC_ID_H263I:
568
      caps = gst_ff_vid_caps_new (context, codec_id, "video/x-intel-h263",
569
          "variant", G_TYPE_STRING, "intel", NULL);
570 571
      break;

572
    case CODEC_ID_H261:
573
      caps = gst_ff_vid_caps_new (context, codec_id, "video/x-h261", NULL);
574 575
      break;

576
    case CODEC_ID_RV10:
577
    case CODEC_ID_RV20:
578
    case CODEC_ID_RV30:
579
    case CODEC_ID_RV40:
580 581
    {
      gint version;
582

583 584 585 586
      switch (codec_id) {
        case CODEC_ID_RV40:
          version = 4;
          break;
587 588 589
        case CODEC_ID_RV30:
          version = 3;
          break;
590 591 592 593 594 595 596
        case CODEC_ID_RV20:
          version = 2;
          break;
        default:
          version = 1;
          break;
      }
597

598 599 600 601 602
      /* FIXME: context->sub_id must be filled in during decoding */
      caps = gst_ff_vid_caps_new (context, codec_id, "video/x-pn-realvideo",
          "systemstream", G_TYPE_BOOLEAN, FALSE,
          "rmversion", G_TYPE_INT, version, NULL);
      if (context) {
603
        gst_caps_set_simple (caps, "format", G_TYPE_INT, context->sub_id, NULL);
604 605
        if (context->extradata_size >= 8) {
          gst_caps_set_simple (caps,
606 607 608
              "subformat", G_TYPE_INT, GST_READ_UINT32_BE (context->extradata),
              NULL);
        }
609
      }
610
    }
611
      break;
612

613 614 615 616 617 618
    case CODEC_ID_MP1:
      /* FIXME: bitrate */
      caps = gst_ff_aud_caps_new (context, codec_id, "audio/mpeg",
          "mpegversion", G_TYPE_INT, 1, "layer", G_TYPE_INT, 1, NULL);
      break;

619
    case CODEC_ID_MP2:
620 621 622
      /* FIXME: bitrate */
      caps = gst_ff_aud_caps_new (context, codec_id, "audio/mpeg",
          "mpegversion", G_TYPE_INT, 1, "layer", G_TYPE_INT, 2, NULL);
623
      break;
624

625 626 627
    case CODEC_ID_MP3:
      if (encode) {
        /* FIXME: bitrate */
628
        caps = gst_ff_aud_caps_new (context, codec_id, "audio/mpeg",
Thomas Vander Stichele's avatar
indent  
Thomas Vander Stichele committed
629
            "mpegversion", G_TYPE_INT, 1, "layer", G_TYPE_INT, 3, NULL);
630 631 632 633
      } else {
        /* Decodes MPEG-1 layer 1/2/3. Samplerate, channels et al are
         * in the MPEG audio header, so may be omitted from caps. */
        caps = gst_caps_new_simple ("audio/mpeg",
Thomas Vander Stichele's avatar
indent  
Thomas Vander Stichele committed
634 635
            "mpegversion", G_TYPE_INT, 1,
            "layer", GST_TYPE_INT_RANGE, 1, 3, NULL);
636
      }
637
      break;
638

639 640 641 642 643 644 645
    case CODEC_ID_MUSEPACK7:
      caps =
          gst_ff_aud_caps_new (context, codec_id,
          "audio/x-ffmpeg-parsed-musepack", "streamversion", G_TYPE_INT, 7,
          NULL);
      break;

646 647 648 649 650 651 652
    case CODEC_ID_MUSEPACK8:
      caps =
          gst_ff_aud_caps_new (context, codec_id,
          "audio/x-ffmpeg-parsed-musepack", "streamversion", G_TYPE_INT, 8,
          NULL);
      break;

653 654 655
    case CODEC_ID_AC3:
      /* FIXME: bitrate */
      caps = gst_ff_aud_caps_new (context, codec_id, "audio/x-ac3", NULL);
656
      break;
657

658 659 660 661 662
    case CODEC_ID_EAC3:
      /* FIXME: bitrate */
      caps = gst_ff_aud_caps_new (context, codec_id, "audio/x-eac3", NULL);
      break;

663 664 665 666 667
    case CODEC_ID_TRUEHD:
      caps = gst_ff_aud_caps_new (context, codec_id, "audio/x-true-hd", NULL);
      break;

    case CODEC_ID_ATRAC1:
668
      caps =
669
          gst_ff_aud_caps_new (context, codec_id, "audio/x-vnd.sony.atrac1",
670
          NULL);
671
      break;
672

673 674
    case CODEC_ID_ATRAC3:
      caps =
675
          gst_ff_aud_caps_new (context, codec_id, "audio/x-vnd.sony.atrac3",
676 677 678
          NULL);
      break;

679
    case CODEC_ID_DTS:
680
      caps = gst_ff_aud_caps_new (context, codec_id, "audio/x-dts", NULL);
681
      break;
682

683 684 685 686 687 688
    case CODEC_ID_APE:
      caps =
          gst_ff_aud_caps_new (context, codec_id, "audio/x-ffmpeg-parsed-ape",
          NULL);
      if (context) {
        gst_caps_set_simple (caps,
689
            "depth", G_TYPE_INT, context->bits_per_coded_sample, NULL);
690 691 692
      }
      break;

693 694 695
    case CODEC_ID_MLP:
      caps = gst_ff_aud_caps_new (context, codec_id, "audio/x-mlp", NULL);
      break;
696

697 698 699
    case CODEC_ID_IMC:
      caps = gst_ff_aud_caps_new (context, codec_id, "audio/x-imc", NULL);
      break;
700

Thomas Vander Stichele's avatar
indent  
Thomas Vander Stichele committed
701 702 703 704 705
      /* MJPEG is normal JPEG, Motion-JPEG and Quicktime MJPEG-A. MJPEGB
       * is Quicktime's MJPEG-B. LJPEG is lossless JPEG. I don't know what
       * sp5x is, but it's apparently something JPEG... We don't separate
       * between those in GStreamer. Should we (at least between MJPEG,
       * MJPEG-B and sp5x decoding...)? */
706
    case CODEC_ID_MJPEG:
707
    case CODEC_ID_LJPEG:
708
      caps = gst_ff_vid_caps_new (context, codec_id, "image/jpeg", NULL);
Wim Taymans's avatar
Wim Taymans committed
709
      break;
710

711
    case CODEC_ID_SP5X:
712
      caps = gst_ff_vid_caps_new (context, codec_id, "video/sp5x", NULL);
713 714
      break;

715
    case CODEC_ID_MJPEGB:
716
      caps = gst_ff_vid_caps_new (context, codec_id, "video/x-mjpeg-b", NULL);
717 718
      break;

719
    case CODEC_ID_MPEG4:
720
      if (encode && context != NULL) {
721 722
        /* I'm not exactly sure what ffmpeg outputs... ffmpeg itself uses
         * the AVI fourcc 'DIVX', but 'mp4v' for Quicktime... */
723
        switch (context->codec_tag) {
724
          case GST_MAKE_FOURCC ('D', 'I', 'V', 'X'):
725
            caps = gst_ff_vid_caps_new (context, codec_id, "video/x-divx",
Thomas Vander Stichele's avatar
Thomas Vander Stichele committed
726
                "divxversion", G_TYPE_INT, 5, NULL);
727 728 729 730
            break;
          case GST_MAKE_FOURCC ('m', 'p', '4', 'v'):
          default:
            /* FIXME: bitrate */
731
            caps = gst_ff_vid_caps_new (context, codec_id, "video/mpeg",
732 733 734 735
                "systemstream", G_TYPE_BOOLEAN, FALSE,
                "mpegversion", G_TYPE_INT, 4, NULL);
            break;
        }
736 737
      } else {
        /* The trick here is to separate xvid, divx, mpeg4, 3ivx et al */
738
        caps = gst_ff_vid_caps_new (context, codec_id, "video/mpeg",
Thomas Vander Stichele's avatar
indent  
Thomas Vander Stichele committed
739 740
            "mpegversion", G_TYPE_INT, 4,
            "systemstream", G_TYPE_BOOLEAN, FALSE, NULL);
741
        if (encode) {
742 743
          gst_caps_append (caps, gst_ff_vid_caps_new (context, codec_id,
                  "video/x-divx", "divxversion", G_TYPE_INT, 5, NULL));
744
        } else {
745 746 747 748 749 750 751
          gst_caps_append (caps, gst_ff_vid_caps_new (context, codec_id,
                  "video/x-divx", "divxversion", GST_TYPE_INT_RANGE, 4, 5,
                  NULL));
          gst_caps_append (caps, gst_ff_vid_caps_new (context, codec_id,
                  "video/x-xvid", NULL));
          gst_caps_append (caps, gst_ff_vid_caps_new (context, codec_id,
                  "video/x-3ivx", NULL));
752
        }
753
      }
754
      break;
755

756
    case CODEC_ID_RAWVIDEO:
757 758
      caps = gst_ffmpeg_codectype_to_caps (CODEC_TYPE_VIDEO, context, codec_id,
          encode);
759
      break;
760

761
    case CODEC_ID_MSMPEG4V1:
762 763
    case CODEC_ID_MSMPEG4V2:
    case CODEC_ID_MSMPEG4V3:
764 765 766 767 768 769 770 771 772
    {
      gint version = 41 + codec_id - CODEC_ID_MSMPEG4V1;

      /* encode-FIXME: bitrate */
      caps = gst_ff_vid_caps_new (context, codec_id, "video/x-msmpeg",
          "msmpegversion", G_TYPE_INT, version, NULL);
      if (!encode && codec_id == CODEC_ID_MSMPEG4V3) {
        gst_caps_append (caps, gst_ff_vid_caps_new (context, codec_id,
                "video/x-divx", "divxversion", G_TYPE_INT, 3, NULL));
773
      }
774
    }
775
      break;
776

777
    case CODEC_ID_WMV1:
778
    case CODEC_ID_WMV2:
779 780
    {
      gint version = (codec_id == CODEC_ID_WMV1) ? 1 : 2;
781

782 783 784
      caps = gst_ff_vid_caps_new (context, codec_id, "video/x-wmv",
          "wmvversion", G_TYPE_INT, version, NULL);
    }
785
      break;
786

787
    case CODEC_ID_FLV1:
788 789
      caps = gst_ff_vid_caps_new (context, codec_id, "video/x-flash-video",
          "flvversion", G_TYPE_INT, 1, NULL);
790
      break;
791

792
    case CODEC_ID_SVQ1:
793
      caps = gst_ff_vid_caps_new (context, codec_id, "video/x-svq",
Thomas Vander Stichele's avatar
indent  
Thomas Vander Stichele committed
794
          "svqversion", G_TYPE_INT, 1, NULL);
795
      break;
796 797

    case CODEC_ID_SVQ3:
798
      caps = gst_ff_vid_caps_new (context, codec_id, "video/x-svq",
799
          "svqversion", G_TYPE_INT, 3, NULL);
800
      break;
801

802
    case CODEC_ID_DVAUDIO:
803
      caps = gst_ff_aud_caps_new (context, codec_id, "audio/x-dv", NULL);
804
      break;
805

806
    case CODEC_ID_DVVIDEO:
807 808 809 810 811
    {
      if (encode && context) {
        guint32 fourcc;

        switch (context->pix_fmt) {
812
          case PIX_FMT_YUYV422:
813 814 815 816 817
            fourcc = GST_MAKE_FOURCC ('Y', 'U', 'Y', '2');
            break;
          case PIX_FMT_YUV420P:
            fourcc = GST_MAKE_FOURCC ('I', '4', '2', '0');
            break;
818 819 820
          case PIX_FMT_YUVA420P:
            fourcc = GST_MAKE_FOURCC ('A', '4', '2', '0');
            break;
821 822 823 824 825 826 827 828 829 830 831 832 833 834 835 836 837 838 839 840 841 842
          case PIX_FMT_YUV411P:
            fourcc = GST_MAKE_FOURCC ('Y', '4', '1', 'B');
            break;
          case PIX_FMT_YUV422P:
            fourcc = GST_MAKE_FOURCC ('Y', '4', '2', 'B');
            break;
          case PIX_FMT_YUV410P:
            fourcc = GST_MAKE_FOURCC ('Y', 'U', 'V', '9');
            break;
          default:
            GST_WARNING
                ("Couldnt' find fourcc for pixfmt %d, defaulting to I420",
                context->pix_fmt);
            fourcc = GST_MAKE_FOURCC ('I', '4', '2', '0');
            break;
        }
        caps = gst_ff_vid_caps_new (context, codec_id, "video/x-dv",
            "systemstream", G_TYPE_BOOLEAN, FALSE,
            "format", GST_TYPE_FOURCC, fourcc, NULL);
      } else {
        caps = gst_ff_vid_caps_new (context, codec_id, "video/x-dv",
            "systemstream", G_TYPE_BOOLEAN, FALSE, NULL);
843
      }
844
    }
845
      break;
846

847 848
    case CODEC_ID_WMAV1:
    case CODEC_ID_WMAV2:
849 850
    {
      gint version = (codec_id == CODEC_ID_WMAV1) ? 1 : 2;
851

852 853 854 855 856 857 858 859 860 861
      if (context) {
        caps = gst_ff_aud_caps_new (context, codec_id, "audio/x-wma",
            "wmaversion", G_TYPE_INT, version,
            "block_align", G_TYPE_INT, context->block_align,
            "bitrate", G_TYPE_INT, context->bit_rate, NULL);
      } else {
        caps = gst_ff_aud_caps_new (context, codec_id, "audio/x-wma",
            "wmaversion", G_TYPE_INT, version,
            "block_align", GST_TYPE_INT_RANGE, 0, G_MAXINT,
            "bitrate", GST_TYPE_INT_RANGE, 0, G_MAXINT, NULL);
862
      }
863
    }
864
      break;
865 866 867 868 869 870
    case CODEC_ID_WMAPRO:
    {
      caps = gst_ff_aud_caps_new (context, codec_id, "audio/x-wma",
          "wmaversion", G_TYPE_INT, 3, NULL);
      break;
    }
871

872 873 874 875 876 877
    case CODEC_ID_WMAVOICE:
    {
      caps = gst_ff_aud_caps_new (context, codec_id, "audio/x-wms", NULL);
      break;
    }

878 879
    case CODEC_ID_MACE3:
    case CODEC_ID_MACE6:
880 881
    {
      gint version = (codec_id == CODEC_ID_MACE3) ? 3 : 6;
882

883 884 885
      caps = gst_ff_aud_caps_new (context, codec_id, "audio/x-mace",
          "maceversion", G_TYPE_INT, version, NULL);
    }
886
      break;
887

Wim Taymans's avatar
Wim Taymans committed
888
    case CODEC_ID_HUFFYUV:
889
      caps = gst_ff_vid_caps_new (context, codec_id, "video/x-huffyuv", NULL);
890 891
      if (context) {
        gst_caps_set_simple (caps,
892
            "bpp", G_TYPE_INT, context->bits_per_coded_sample, NULL);
893
      }
894 895 896
      break;

    case CODEC_ID_CYUV:
897 898 899
      caps =
          gst_ff_vid_caps_new (context, codec_id, "video/x-compressed-yuv",
          NULL);
900 901 902
      break;

    case CODEC_ID_H264:
903
      caps = gst_ff_vid_caps_new (context, codec_id, "video/x-h264", NULL);
904 905
      break;

906 907 908 909 910
    case CODEC_ID_INDEO5:
      caps = gst_ff_vid_caps_new (context, codec_id, "video/x-indeo",
          "indeoversion", G_TYPE_INT, 5, NULL);
      break;

911
    case CODEC_ID_INDEO3:
912
      caps = gst_ff_vid_caps_new (context, codec_id, "video/x-indeo",
Thomas Vander Stichele's avatar
indent  
Thomas Vander Stichele committed
913
          "indeoversion", G_TYPE_INT, 3, NULL);
914 915
      break;

916
    case CODEC_ID_INDEO2:
917
      caps = gst_ff_vid_caps_new (context, codec_id, "video/x-indeo",
918 919 920
          "indeoversion", G_TYPE_INT, 2, NULL);
      break;

921
    case CODEC_ID_FLASHSV:
922 923
      caps =
          gst_ff_vid_caps_new (context, codec_id, "video/x-flash-screen", NULL);
924 925
      break;

926
    case CODEC_ID_VP3:
927
      caps = gst_ff_vid_caps_new (context, codec_id, "video/x-vp3", NULL);
928 929
      break;

930
    case CODEC_ID_VP5:
931
      caps = gst_ff_vid_caps_new (context, codec_id, "video/x-vp5", NULL);
932 933 934
      break;

    case CODEC_ID_VP6:
935
      caps = gst_ff_vid_caps_new (context, codec_id, "video/x-vp6", NULL);
936 937 938
      break;

    case CODEC_ID_VP6F:
939
      caps = gst_ff_vid_caps_new (context, codec_id, "video/x-vp6-flash", NULL);
940 941
      break;

942 943 944 945
    case CODEC_ID_VP6A:
      caps = gst_ff_vid_caps_new (context, codec_id, "video/x-vp6-alpha", NULL);
      break;

946 947 948 949
    case CODEC_ID_VP8:
      caps = gst_ff_vid_caps_new (context, codec_id, "video/x-vp8", NULL);
      break;

950
    case CODEC_ID_THEORA:
951
      caps = gst_ff_vid_caps_new (context, codec_id, "video/x-theora", NULL);
952 953
      break;

954
    case CODEC_ID_AAC:
955
      caps = gst_ff_aud_caps_new (context, codec_id, "audio/mpeg",
956
          "mpegversion", G_TYPE_INT, 4, NULL);
957 958 959
      break;

    case CODEC_ID_ASV1:
960 961
      caps = gst_ff_vid_caps_new (context, codec_id, "video/x-asus",
          "asusversion", G_TYPE_INT, 1, NULL);
962
      break;
963
    case CODEC_ID_ASV2:
964 965
      caps = gst_ff_vid_caps_new (context, codec_id, "video/x-asus",
          "asusversion", G_TYPE_INT, 2, NULL);
966 967
      break;

968
    case CODEC_ID_FFV1:
969
      caps = gst_ff_vid_caps_new (context, codec_id, "video/x-ffv",
Thomas Vander Stichele's avatar
indent  
Thomas Vander Stichele committed
970
          "ffvversion", G_TYPE_INT, 1, NULL);
971 972 973
      break;

    case CODEC_ID_4XM:
974
      caps = gst_ff_vid_caps_new (context, codec_id, "video/x-4xm", NULL);
975 976
      break;

977 978
    case CODEC_ID_XAN_WC3:
    case CODEC_ID_XAN_WC4:
979
      caps = gst_ff_vid_caps_new (context, codec_id, "video/x-xan",
980 981 982
          "wcversion", G_TYPE_INT, 3 - CODEC_ID_XAN_WC3 + codec_id, NULL);
      break;

983
    case CODEC_ID_CLJR:
984 985 986
      caps =
          gst_ff_vid_caps_new (context, codec_id,
          "video/x-cirrus-logic-accupak", NULL);
987 988 989
      break;

    case CODEC_ID_FRAPS:
990 991 992
      caps = gst_ff_vid_caps_new (context, codec_id, "video/x-fraps", NULL);
      break;

993 994 995 996 997 998
    case CODEC_ID_MDEC:
    case CODEC_ID_ROQ:
    case CODEC_ID_INTERPLAY_VIDEO:
      buildcaps = TRUE;
      break;

999
    case CODEC_ID_VCR1:
1000 1001
      caps = gst_ff_vid_caps_new (context, codec_id, "video/x-ati-vcr",
          "vcrversion", G_TYPE_INT, 1, NULL);
1002 1003
      break;

1004
    case CODEC_ID_RPZA:
1005 1006
      caps =
          gst_ff_vid_caps_new (context, codec_id, "video/x-apple-video", NULL);
1007 1008
      break;

1009
    case CODEC_ID_CINEPAK:
1010
      caps = gst_ff_vid_caps_new (context, codec_id, "video/x-cinepak", NULL);
1011 1012
      break;