← Back to branch summary

~ubuntu-branches/ubuntu/saucy/gst-libav1.0/saucy-proposed

« back to all changes in this revision

Viewing changes to ext/libav/gstavcodecmap.c

  • Committer: Package Import Robot
  • Author(s): Sebastian Dröge
  • Date: 2013-07-30 09:00:15 UTC
  • mfrom: (1.1.16) (7.1.7 experimental)
  • Revision ID: package-import@ubuntu.com-20130730090015-sc1ou2yssu7q5w4e
Tags: 1.1.3-1
* New upstream development snapshot:
  + debian/control:
    - Build depend on GStreamer and gst-plugins-base >= 1.1.3.

Show diffs side-by-side

added added

removed removed

Lines of Context:
ext/libav/gstavcodecmap.c
15
15
 *
16
16
 * You should have received a copy of the GNU Library General Public
17
17
 * License along with this library; if not, write to the
18
 
 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
19
 
 * Boston, MA 02111-1307, USA.
 
18
 * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
 
19
 * Boston, MA 02110-1301, USA.
20
20
 */
21
21
 
22
22
#ifdef HAVE_CONFIG_H
27
27
 
28
28
#include <gst/gst.h>
29
29
#include <libavcodec/avcodec.h>
 
30
#include <libavutil/channel_layout.h>
30
31
 
31
32
#include "gstav.h"
32
33
#include "gstavcodecmap.h"
35
36
#include <gst/audio/audio.h>
36
37
#include <gst/pbutils/codec-utils.h>
37
38
 
38
 
/*
39
 
 * Read a palette from a caps.
40
 
 */
41
 
 
42
 
static void
43
 
gst_ffmpeg_get_palette (const GstCaps * caps, AVCodecContext * context)
44
 
{
45
 
  GstStructure *str = gst_caps_get_structure (caps, 0);
46
 
  const GValue *palette_v;
47
 
  GstBuffer *palette;
48
 
 
49
 
  /* do we have a palette? */
50
 
  if ((palette_v = gst_structure_get_value (str, "palette_data")) && context) {
51
 
    palette = gst_value_get_buffer (palette_v);
52
 
    GST_DEBUG ("got palette data %p", palette);
53
 
    if (gst_buffer_get_size (palette) >= AVPALETTE_SIZE) {
54
 
      if (context->palctrl)
55
 
        av_free (context->palctrl);
56
 
      context->palctrl = av_malloc (sizeof (AVPaletteControl));
57
 
      context->palctrl->palette_changed = 1;
58
 
      gst_buffer_extract (palette, 0, context->palctrl->palette,
59
 
          AVPALETTE_SIZE);
60
 
      GST_DEBUG ("extracted palette data");
61
 
    }
62
 
  }
63
 
}
64
 
 
65
 
static void
66
 
gst_ffmpeg_set_palette (GstCaps * caps, AVCodecContext * context)
67
 
{
68
 
  if (context->palctrl) {
69
 
    GstBuffer *palette = gst_buffer_new_and_alloc (AVPALETTE_SIZE);
70
 
 
71
 
    gst_buffer_fill (palette, 0, context->palctrl->palette, AVPALETTE_SIZE);
72
 
    gst_caps_set_simple (caps, "palette_data", GST_TYPE_BUFFER, palette, NULL);
73
 
  }
74
 
}
75
 
 
76
39
/* IMPORTANT: Keep this sorted by the ffmpeg channel masks */
77
40
static const struct
78
41
{
80
43
  GstAudioChannelPosition gst;
81
44
} _ff_to_gst_layout[] = {
82
45
  {
83
 
  CH_FRONT_LEFT, GST_AUDIO_CHANNEL_POSITION_FRONT_LEFT}, {
84
 
  CH_FRONT_RIGHT, GST_AUDIO_CHANNEL_POSITION_FRONT_RIGHT}, {
85
 
  CH_FRONT_CENTER, GST_AUDIO_CHANNEL_POSITION_FRONT_CENTER}, {
86
 
  CH_LOW_FREQUENCY, GST_AUDIO_CHANNEL_POSITION_LFE1}, {
87
 
  CH_BACK_LEFT, GST_AUDIO_CHANNEL_POSITION_REAR_LEFT}, {
88
 
  CH_BACK_RIGHT, GST_AUDIO_CHANNEL_POSITION_REAR_RIGHT}, {
89
 
  CH_FRONT_LEFT_OF_CENTER, GST_AUDIO_CHANNEL_POSITION_FRONT_LEFT_OF_CENTER}, {
90
 
  CH_FRONT_RIGHT_OF_CENTER, GST_AUDIO_CHANNEL_POSITION_FRONT_RIGHT_OF_CENTER}, {
91
 
  CH_BACK_CENTER, GST_AUDIO_CHANNEL_POSITION_REAR_CENTER}, {
92
 
  CH_SIDE_LEFT, GST_AUDIO_CHANNEL_POSITION_SIDE_LEFT}, {
93
 
  CH_SIDE_RIGHT, GST_AUDIO_CHANNEL_POSITION_SIDE_RIGHT}, {
94
 
  CH_TOP_CENTER, GST_AUDIO_CHANNEL_POSITION_TOP_CENTER}, {
95
 
  CH_TOP_FRONT_LEFT, GST_AUDIO_CHANNEL_POSITION_TOP_FRONT_LEFT}, {
96
 
  CH_TOP_FRONT_CENTER, GST_AUDIO_CHANNEL_POSITION_TOP_FRONT_CENTER}, {
97
 
  CH_TOP_FRONT_RIGHT, GST_AUDIO_CHANNEL_POSITION_TOP_FRONT_RIGHT}, {
98
 
  CH_TOP_BACK_LEFT, GST_AUDIO_CHANNEL_POSITION_TOP_REAR_LEFT}, {
99
 
  CH_TOP_BACK_CENTER, GST_AUDIO_CHANNEL_POSITION_TOP_REAR_CENTER}, {
100
 
  CH_TOP_BACK_RIGHT, GST_AUDIO_CHANNEL_POSITION_TOP_REAR_RIGHT}, {
101
 
  CH_STEREO_LEFT, GST_AUDIO_CHANNEL_POSITION_FRONT_LEFT}, {
102
 
  CH_STEREO_RIGHT, GST_AUDIO_CHANNEL_POSITION_FRONT_RIGHT}
 
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}
103
67
};
104
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[j].ff;
 
84
        channels_found++;
 
85
        break;
 
86
      }
 
87
    }
 
88
  }
 
89
 
 
90
  if (channels_found != channels)
 
91
    return 0;
 
92
  return ret;
 
93
}
 
94
 
105
95
gboolean
106
 
gst_ffmpeg_channel_layout_to_gst (AVCodecContext * context,
 
96
gst_ffmpeg_channel_layout_to_gst (guint64 channel_layout, gint channels,
107
97
    GstAudioChannelPosition * pos)
108
98
{
109
 
  guint nchannels = 0, channels = context->channels;
110
 
  guint64 channel_layout = context->channel_layout;
 
99
  guint nchannels = 0;
111
100
  gboolean none_layout = FALSE;
112
101
 
113
102
  if (channel_layout == 0) {
170
159
  return TRUE;
171
160
}
172
161
 
 
162
static void
 
163
gst_ffmpeg_video_set_pix_fmts (GstCaps * caps, const enum AVPixelFormat *fmts)
 
164
{
 
165
  GValue va = { 0, };
 
166
  GValue v = { 0, };
 
167
  GstVideoFormat format;
 
168
 
 
169
  if (!fmts || fmts[0] == -1) {
 
170
    gint i;
 
171
 
 
172
    g_value_init (&va, GST_TYPE_LIST);
 
173
    g_value_init (&v, G_TYPE_STRING);
 
174
    for (i = 0; i <= PIX_FMT_NB; i++) {
 
175
      format = gst_ffmpeg_pixfmt_to_videoformat (i);
 
176
      if (format == GST_VIDEO_FORMAT_UNKNOWN)
 
177
        continue;
 
178
      g_value_set_string (&v, gst_video_format_to_string (format));
 
179
      gst_value_list_append_value (&va, &v);
 
180
    }
 
181
    gst_caps_set_value (caps, "format", &va);
 
182
    g_value_unset (&v);
 
183
    g_value_unset (&va);
 
184
    return;
 
185
  }
 
186
 
 
187
  /* Only a single format */
 
188
  g_value_init (&va, GST_TYPE_LIST);
 
189
  g_value_init (&v, G_TYPE_STRING);
 
190
  while (*fmts != -1) {
 
191
    format = gst_ffmpeg_pixfmt_to_videoformat (*fmts);
 
192
    if (format != GST_VIDEO_FORMAT_UNKNOWN) {
 
193
      g_value_set_string (&v, gst_video_format_to_string (format));
 
194
      gst_value_list_append_value (&va, &v);
 
195
    }
 
196
    fmts++;
 
197
  }
 
198
  if (gst_value_list_get_size (&va) == 1) {
 
199
    /* The single value is still in v */
 
200
    gst_caps_set_value (caps, "format", &v);
 
201
  } else if (gst_value_list_get_size (&va) > 1) {
 
202
    gst_caps_set_value (caps, "format", &va);
 
203
  }
 
204
  g_value_unset (&v);
 
205
  g_value_unset (&va);
 
206
}
 
207
 
173
208
/* this macro makes a caps width fixed or unfixed width/height
174
209
 * properties depending on whether we've got a context.
175
210
 *
179
214
 * but I'm too lazy today. Maybe later.
180
215
 */
181
216
static GstCaps *
182
 
gst_ff_vid_caps_new (AVCodecContext * context, enum CodecID codec_id,
183
 
    gboolean encode, const char *mimetype, const char *fieldname, ...)
 
217
gst_ff_vid_caps_new (AVCodecContext * context, AVCodec * codec,
 
218
    enum CodecID codec_id, gboolean encode, const char *mimetype,
 
219
    const char *fieldname, ...)
184
220
{
185
 
  GstStructure *structure = NULL;
186
221
  GstCaps *caps = NULL;
187
222
  va_list var_args;
188
223
  gint i;
215
250
  } else if (encode) {
216
251
    /* so we are after restricted caps in this case */
217
252
    switch (codec_id) {
218
 
      case CODEC_ID_H261:
 
253
      case AV_CODEC_ID_H261:
219
254
      {
220
255
        caps = gst_caps_new_simple (mimetype,
221
256
            "width", G_TYPE_INT, 352,
227
262
                "framerate", GST_TYPE_FRACTION_RANGE, 0, 1, G_MAXINT, 1, NULL));
228
263
        break;
229
264
      }
230
 
      case CODEC_ID_H263:
 
265
      case AV_CODEC_ID_H263:
231
266
      {
232
267
        /* 128x96, 176x144, 352x288, 704x576, and 1408x1152. slightly reordered
233
268
         * because we want automatic negotiation to go as close to 320x240 as
248
283
        }
249
284
        break;
250
285
      }
251
 
      case CODEC_ID_DVVIDEO:
 
286
      case AV_CODEC_ID_DVVIDEO:
252
287
      {
253
288
        static struct
254
289
        {
255
 
          guint32 csp;
 
290
          const gchar *csp;
256
291
          gint width, height;
257
292
          gint par_n, par_d;
258
293
          gint framerate_n, framerate_d;
259
294
        } profiles[] = {
260
295
          {
261
 
          GST_MAKE_FOURCC ('Y', '4', '1', 'B'), 720, 480, 10, 11, 30000, 1001}, {
262
 
          GST_MAKE_FOURCC ('Y', '4', '1', 'B'), 720, 480, 40, 33, 30000, 1001}, {
263
 
          GST_MAKE_FOURCC ('I', '4', '2', '0'), 720, 576, 59, 54, 25, 1}, {
264
 
          GST_MAKE_FOURCC ('I', '4', '2', '0'), 720, 576, 118, 81, 25, 1}, {
265
 
          GST_MAKE_FOURCC ('Y', '4', '1', 'B'), 720, 576, 59, 54, 25, 1}, {
266
 
          GST_MAKE_FOURCC ('Y', '4', '1', 'B'), 720, 576, 118, 81, 25, 1}
267
 
        };
 
296
          "Y41B", 720, 480, 8, 9, 30000, 1001}, {
 
297
          "Y41B", 720, 480, 32, 27, 30000, 1001}, {
 
298
          "Y42B", 720, 480, 8, 9, 30000, 1001}, {
 
299
          "Y42B", 720, 480, 32, 27, 30000, 1001}, {
 
300
          "I420", 720, 576, 16, 15, 25, 1}, {
 
301
          "I420", 720, 576, 64, 45, 25, 1}, {
 
302
          "Y41B", 720, 576, 16, 15, 25, 1}, {
 
303
          "Y41B", 720, 576, 64, 45, 25, 1}, {
 
304
          "Y42B", 720, 576, 16, 15, 25, 1}, {
 
305
          "Y42B", 720, 576, 64, 45, 25, 1}, {
 
306
          "Y42B", 1280, 1080, 1, 1, 30000, 1001}, {
 
307
          "Y42B", 1280, 1080, 3, 2, 30000, 1001}, {
 
308
          "Y42B", 1440, 1080, 1, 1, 25, 1}, {
 
309
          "Y42B", 1440, 1080, 4, 3, 25, 1}, {
 
310
          "Y42B", 960, 720, 1, 1, 60000, 1001}, {
 
311
          "Y42B", 960, 720, 4, 3, 60000, 1001}, {
 
312
          "Y42B", 960, 720, 1, 1, 50, 1}, {
 
313
        "Y42B", 960, 720, 4, 3, 50, 1},};
268
314
        GstCaps *temp;
269
315
        gint n_sizes = G_N_ELEMENTS (profiles);
270
316
 
271
 
        caps = gst_caps_new_empty ();
272
 
        for (i = 0; i < n_sizes; i++) {
273
 
          temp = gst_caps_new_simple (mimetype,
274
 
              "width", G_TYPE_INT, profiles[i].width,
275
 
              "height", G_TYPE_INT, profiles[i].height,
276
 
              "framerate", GST_TYPE_FRACTION, profiles[i].framerate_n,
277
 
              profiles[i].framerate_d, "pixel-aspect-ratio", GST_TYPE_FRACTION,
278
 
              profiles[i].par_n, profiles[i].par_d, NULL);
279
 
 
280
 
          gst_caps_append (caps, temp);
 
317
        if (strcmp (mimetype, "video/x-raw") == 0) {
 
318
          caps = gst_caps_new_empty ();
 
319
          for (i = 0; i < n_sizes; i++) {
 
320
            temp = gst_caps_new_simple (mimetype,
 
321
                "format", G_TYPE_STRING, profiles[i].csp,
 
322
                "width", G_TYPE_INT, profiles[i].width,
 
323
                "height", G_TYPE_INT, profiles[i].height,
 
324
                "framerate", GST_TYPE_FRACTION, profiles[i].framerate_n,
 
325
                profiles[i].framerate_d, "pixel-aspect-ratio",
 
326
                GST_TYPE_FRACTION, profiles[i].par_n, profiles[i].par_d, NULL);
 
327
 
 
328
            gst_caps_append (caps, temp);
 
329
          }
 
330
        } else {
 
331
          caps = gst_caps_new_empty ();
 
332
          for (i = 0; i < n_sizes; i++) {
 
333
            temp = gst_caps_new_simple (mimetype,
 
334
                "width", G_TYPE_INT, profiles[i].width,
 
335
                "height", G_TYPE_INT, profiles[i].height,
 
336
                "framerate", GST_TYPE_FRACTION, profiles[i].framerate_n,
 
337
                profiles[i].framerate_d, "pixel-aspect-ratio",
 
338
                GST_TYPE_FRACTION, profiles[i].par_n, profiles[i].par_d, NULL);
 
339
 
 
340
            gst_caps_append (caps, temp);
 
341
          }
281
342
        }
282
343
        break;
283
344
      }
284
 
      case CODEC_ID_DNXHD:
 
345
      case AV_CODEC_ID_DNXHD:
285
346
      {
286
347
        caps = gst_caps_new_simple (mimetype,
287
348
            "width", G_TYPE_INT, 1920,
294
355
        break;
295
356
      }
296
357
      default:
 
358
      {
 
359
        if (codec && codec->supported_framerates
 
360
            && codec->supported_framerates[0].num != 0
 
361
            && codec->supported_framerates[0].den != 0) {
 
362
          GValue va = { 0, };
 
363
          GValue v = { 0, };
 
364
          const AVRational *rates = codec->supported_framerates;
 
365
 
 
366
          if (rates[1].num == 0 && rates[1].den == 0) {
 
367
            caps =
 
368
                gst_caps_new_simple (mimetype, "framerate", GST_TYPE_FRACTION,
 
369
                rates[0].num, rates[0].den, NULL);
 
370
          } else {
 
371
            g_value_init (&va, GST_TYPE_LIST);
 
372
            g_value_init (&v, GST_TYPE_FRACTION);
 
373
 
 
374
            while (rates->num != 0 && rates->den != 0) {
 
375
              gst_value_set_fraction (&v, rates->num, rates->den);
 
376
              gst_value_list_append_value (&va, &v);
 
377
              rates++;
 
378
            }
 
379
 
 
380
            caps = gst_caps_new_simple (mimetype, NULL, NULL, NULL);
 
381
            gst_caps_set_value (caps, "framerate", &va);
 
382
            g_value_unset (&va);
 
383
            g_value_unset (&v);
 
384
          }
 
385
 
 
386
        } else {
 
387
          caps = gst_caps_new_empty_simple (mimetype);
 
388
        }
 
389
 
297
390
        break;
 
391
      }
298
392
    }
299
393
  }
300
394
 
302
396
   * default unfixed setting */
303
397
  if (!caps) {
304
398
    GST_DEBUG ("Creating default caps");
305
 
    caps = gst_caps_new_simple (mimetype, NULL, NULL, NULL);
 
399
    caps = gst_caps_new_empty_simple (mimetype);
306
400
  }
307
401
 
308
 
  for (i = 0; i < gst_caps_get_size (caps); i++) {
309
 
    va_start (var_args, fieldname);
310
 
    structure = gst_caps_get_structure (caps, i);
311
 
    gst_structure_set_valist (structure, fieldname, var_args);
312
 
    va_end (var_args);
313
 
  }
 
402
  va_start (var_args, fieldname);
 
403
  gst_caps_set_simple_valist (caps, fieldname, var_args);
 
404
  va_end (var_args);
314
405
 
315
406
  return caps;
316
407
}
317
408
 
 
409
static gint
 
410
get_nbits_set (guint64 n)
 
411
{
 
412
  gint i, x;
 
413
 
 
414
  x = 0;
 
415
  for (i = 0; i < 64; i++) {
 
416
    if ((n & (G_GUINT64_CONSTANT (1) << i)))
 
417
      x++;
 
418
  }
 
419
 
 
420
  return x;
 
421
}
 
422
 
 
423
static void
 
424
gst_ffmpeg_audio_set_sample_fmts (GstCaps * caps,
 
425
    const enum AVSampleFormat *fmts)
 
426
{
 
427
  GValue va = { 0, };
 
428
  GValue v = { 0, };
 
429
  GstAudioFormat format;
 
430
 
 
431
  if (!fmts || fmts[0] == -1) {
 
432
    gint i;
 
433
 
 
434
    g_value_init (&va, GST_TYPE_LIST);
 
435
    g_value_init (&v, G_TYPE_STRING);
 
436
    for (i = 0; i <= AV_SAMPLE_FMT_DBL; i++) {
 
437
      format = gst_ffmpeg_smpfmt_to_audioformat (i);
 
438
      if (format == GST_AUDIO_FORMAT_UNKNOWN)
 
439
        continue;
 
440
      g_value_set_string (&v, gst_audio_format_to_string (format));
 
441
      gst_value_list_append_value (&va, &v);
 
442
    }
 
443
    gst_caps_set_value (caps, "format", &va);
 
444
    g_value_unset (&v);
 
445
    g_value_unset (&va);
 
446
    return;
 
447
  }
 
448
 
 
449
  g_value_init (&va, GST_TYPE_LIST);
 
450
  g_value_init (&v, G_TYPE_STRING);
 
451
  while (*fmts != -1) {
 
452
    format = gst_ffmpeg_smpfmt_to_audioformat (*fmts);
 
453
    if (format != GST_AUDIO_FORMAT_UNKNOWN) {
 
454
      g_value_set_string (&v, gst_audio_format_to_string (format));
 
455
      gst_value_list_append_value (&va, &v);
 
456
    }
 
457
    fmts++;
 
458
  }
 
459
  if (gst_value_list_get_size (&va) == 1) {
 
460
    /* The single value is still in v */
 
461
    gst_caps_set_value (caps, "format", &v);
 
462
  } else if (gst_value_list_get_size (&va) > 1) {
 
463
    gst_caps_set_value (caps, "format", &va);
 
464
  }
 
465
  g_value_unset (&v);
 
466
  g_value_unset (&va);
 
467
}
 
468
 
318
469
/* same for audio - now with channels/sample rate
319
470
 */
320
471
static GstCaps *
321
 
gst_ff_aud_caps_new (AVCodecContext * context, enum CodecID codec_id,
322
 
    gboolean encode, const char *mimetype, const char *fieldname, ...)
 
472
gst_ff_aud_caps_new (AVCodecContext * context, AVCodec * codec,
 
473
    enum CodecID codec_id, gboolean encode, const char *mimetype,
 
474
    const char *fieldname, ...)
323
475
{
324
476
  GstCaps *caps = NULL;
325
 
  GstStructure *structure = NULL;
326
477
  gint i;
327
478
  va_list var_args;
328
479
 
334
485
        "rate", G_TYPE_INT, context->sample_rate,
335
486
        "channels", G_TYPE_INT, context->channels, NULL);
336
487
 
337
 
    if (gst_ffmpeg_channel_layout_to_gst (context, pos)) {
 
488
    if (gst_ffmpeg_channel_layout_to_gst (context->channel_layout,
 
489
            context->channels, pos)) {
338
490
      guint64 mask;
339
491
 
340
492
      if (gst_audio_channel_positions_to_mask (pos, context->channels, FALSE,
350
502
 
351
503
    /* so we must be after restricted caps in this case */
352
504
    switch (codec_id) {
353
 
      case CODEC_ID_AAC:
354
 
      case CODEC_ID_AAC_LATM:
355
 
      case CODEC_ID_DTS:
 
505
      case AV_CODEC_ID_AAC:
 
506
      case AV_CODEC_ID_AAC_LATM:
 
507
      case AV_CODEC_ID_DTS:
356
508
        maxchannels = 6;
357
509
        break;
358
 
      case CODEC_ID_MP2:
 
510
      case AV_CODEC_ID_MP2:
359
511
      {
360
512
        const static gint l_rates[] =
361
513
            { 48000, 44100, 32000, 24000, 22050, 16000 };
363
515
        rates = l_rates;
364
516
        break;
365
517
      }
366
 
      case CODEC_ID_EAC3:
367
 
      case CODEC_ID_AC3:
 
518
      case AV_CODEC_ID_EAC3:
 
519
      case AV_CODEC_ID_AC3:
368
520
      {
369
521
        const static gint l_rates[] = { 48000, 44100, 32000 };
370
522
        maxchannels = 6;
372
524
        rates = l_rates;
373
525
        break;
374
526
      }
375
 
      case CODEC_ID_ADPCM_G722:
 
527
      case AV_CODEC_ID_ADPCM_G722:
376
528
      {
377
529
        const static gint l_rates[] = { 16000 };
378
530
        n_rates = G_N_ELEMENTS (l_rates);
380
532
        maxchannels = 1;
381
533
        break;
382
534
      }
383
 
      case CODEC_ID_ADPCM_G726:
 
535
      case AV_CODEC_ID_ADPCM_G726:
384
536
      {
385
537
        const static gint l_rates[] = { 8000 };
386
538
        n_rates = G_N_ELEMENTS (l_rates);
388
540
        maxchannels = 1;
389
541
        break;
390
542
      }
391
 
      case CODEC_ID_ADPCM_SWF:
 
543
      case AV_CODEC_ID_ADPCM_SWF:
392
544
      {
393
545
        const static gint l_rates[] = { 11025, 22050, 44100 };
394
546
        n_rates = G_N_ELEMENTS (l_rates);
395
547
        rates = l_rates;
396
548
        break;
397
549
      }
398
 
      case CODEC_ID_ROQ_DPCM:
 
550
      case AV_CODEC_ID_ROQ_DPCM:
399
551
      {
400
552
        const static gint l_rates[] = { 22050 };
401
553
        n_rates = G_N_ELEMENTS (l_rates);
402
554
        rates = l_rates;
403
555
        break;
404
556
      }
405
 
      case CODEC_ID_AMR_NB:
 
557
      case AV_CODEC_ID_AMR_NB:
406
558
      {
407
559
        const static gint l_rates[] = { 8000 };
408
560
        maxchannels = 1;
410
562
        rates = l_rates;
411
563
        break;
412
564
      }
413
 
      case CODEC_ID_AMR_WB:
 
565
      case AV_CODEC_ID_AMR_WB:
414
566
      {
415
567
        const static gint l_rates[] = { 16000 };
416
568
        maxchannels = 1;
422
574
        break;
423
575
    }
424
576
 
425
 
    /* TODO: handle context->channel_layouts here to set
426
 
     * the list of channel layouts supported by the encoder.
427
 
     * Unfortunately no encoder uses this yet....
428
 
     */
429
577
    /* regardless of encode/decode, open up channels if applicable */
430
578
    /* Until decoders/encoders expose the maximum number of channels
431
579
     * they support, we whitelist them here. */
432
580
    switch (codec_id) {
433
 
      case CODEC_ID_WMAPRO:
434
 
      case CODEC_ID_TRUEHD:
 
581
      case AV_CODEC_ID_WMAPRO:
 
582
      case AV_CODEC_ID_TRUEHD:
435
583
        maxchannels = 8;
436
584
        break;
437
585
      default:
438
586
        break;
439
587
    }
440
588
 
441
 
    if (maxchannels == 1)
442
 
      caps = gst_caps_new_simple (mimetype,
443
 
          "channels", G_TYPE_INT, maxchannels, NULL);
444
 
    else
445
 
      caps = gst_caps_new_simple (mimetype,
446
 
          "channels", GST_TYPE_INT_RANGE, 1, maxchannels, NULL);
 
589
    if (codec && codec->channel_layouts) {
 
590
      const uint64_t *layouts = codec->channel_layouts;
 
591
      GstAudioChannelPosition pos[64];
 
592
 
 
593
      caps = gst_caps_new_empty ();
 
594
      while (*layouts) {
 
595
        gint nbits_set = get_nbits_set (*layouts);
 
596
 
 
597
        if (gst_ffmpeg_channel_layout_to_gst (*layouts, nbits_set, pos)) {
 
598
          guint64 mask;
 
599
 
 
600
          if (gst_audio_channel_positions_to_mask (pos, nbits_set, FALSE,
 
601
                  &mask)) {
 
602
            GstCaps *tmp =
 
603
                gst_caps_new_simple (mimetype, "channel-mask", GST_TYPE_BITMASK,
 
604
                mask,
 
605
                "channels", G_TYPE_INT, nbits_set, NULL);
 
606
 
 
607
            gst_caps_append (caps, tmp);
 
608
          }
 
609
        }
 
610
        layouts++;
 
611
      }
 
612
    } else {
 
613
      if (maxchannels == 1)
 
614
        caps = gst_caps_new_simple (mimetype,
 
615
            "channels", G_TYPE_INT, maxchannels, NULL);
 
616
      else
 
617
        caps = gst_caps_new_simple (mimetype,
 
618
            "channels", GST_TYPE_INT_RANGE, 1, maxchannels, NULL);
 
619
    }
 
620
 
447
621
    if (n_rates) {
448
622
      GValue list = { 0, };
449
 
      GstStructure *structure;
450
623
 
451
624
      g_value_init (&list, GST_TYPE_LIST);
452
625
      for (i = 0; i < n_rates; i++) {
457
630
        gst_value_list_append_value (&list, &v);
458
631
        g_value_unset (&v);
459
632
      }
460
 
      structure = gst_caps_get_structure (caps, 0);
461
 
      gst_structure_set_value (structure, "rate", &list);
 
633
      gst_caps_set_value (caps, "rate", &list);
462
634
      g_value_unset (&list);
463
 
    } else
 
635
    } else if (codec && codec->supported_samplerates
 
636
        && codec->supported_samplerates[0]) {
 
637
      GValue va = { 0, };
 
638
      GValue v = { 0, };
 
639
 
 
640
      if (!codec->supported_samplerates[1]) {
 
641
        gst_caps_set_simple (caps, "rate", G_TYPE_INT,
 
642
            codec->supported_samplerates[0], NULL);
 
643
      } else {
 
644
        const int *rates = codec->supported_samplerates;
 
645
 
 
646
        g_value_init (&va, GST_TYPE_LIST);
 
647
        g_value_init (&v, G_TYPE_INT);
 
648
 
 
649
        while (*rates) {
 
650
          g_value_set_int (&v, *rates);
 
651
          gst_value_list_append_value (&va, &v);
 
652
          rates++;
 
653
        }
 
654
        gst_caps_set_value (caps, "rate", &va);
 
655
        g_value_unset (&va);
 
656
        g_value_unset (&v);
 
657
      }
 
658
    } else {
464
659
      gst_caps_set_simple (caps, "rate", GST_TYPE_INT_RANGE, 4000, 96000, NULL);
 
660
    }
465
661
  } else {
466
662
    caps = gst_caps_new_empty_simple (mimetype);
467
663
  }
468
664
 
469
 
  for (i = 0; i < gst_caps_get_size (caps); i++) {
470
 
    va_start (var_args, fieldname);
471
 
    structure = gst_caps_get_structure (caps, i);
472
 
    gst_structure_set_valist (structure, fieldname, var_args);
473
 
    va_end (var_args);
474
 
  }
 
665
  va_start (var_args, fieldname);
 
666
  gst_caps_set_simple_valist (caps, fieldname, var_args);
 
667
  va_end (var_args);
475
668
 
476
669
  return caps;
477
670
}
502
695
  GST_LOG ("codec_id:%d, context:%p, encode:%d", codec_id, context, encode);
503
696
 
504
697
  switch (codec_id) {
505
 
    case CODEC_ID_MPEG1VIDEO:
 
698
    case AV_CODEC_ID_MPEG1VIDEO:
506
699
      /* FIXME: bitrate */
507
 
      caps = gst_ff_vid_caps_new (context, codec_id, encode, "video/mpeg",
 
700
      caps = gst_ff_vid_caps_new (context, NULL, codec_id, encode, "video/mpeg",
508
701
          "mpegversion", G_TYPE_INT, 1,
509
702
          "systemstream", G_TYPE_BOOLEAN, FALSE, NULL);
510
703
      break;
511
704
 
512
 
    case CODEC_ID_MPEG2VIDEO:
 
705
    case AV_CODEC_ID_MPEG2VIDEO:
513
706
      if (encode) {
514
707
        /* FIXME: bitrate */
515
 
        caps = gst_ff_vid_caps_new (context, codec_id, encode, "video/mpeg",
516
 
            "mpegversion", G_TYPE_INT, 2,
517
 
            "systemstream", G_TYPE_BOOLEAN, FALSE, NULL);
 
708
        caps =
 
709
            gst_ff_vid_caps_new (context, NULL, codec_id, encode, "video/mpeg",
 
710
            "mpegversion", G_TYPE_INT, 2, "systemstream", G_TYPE_BOOLEAN, FALSE,
 
711
            NULL);
518
712
      } else {
519
713
        /* decode both MPEG-1 and MPEG-2; width/height/fps are all in
520
714
         * the MPEG video stream headers, so may be omitted from caps. */
524
718
      }
525
719
      break;
526
720
 
527
 
    case CODEC_ID_MPEG2VIDEO_XVMC:
 
721
    case AV_CODEC_ID_MPEG2VIDEO_XVMC:
528
722
      /* this is a special ID - don't need it in GStreamer, I think */
529
723
      break;
530
724
 
531
 
    case CODEC_ID_H263:
 
725
    case AV_CODEC_ID_H263:
532
726
      if (encode) {
533
 
        caps = gst_ff_vid_caps_new (context, codec_id, encode, "video/x-h263",
534
 
            "variant", G_TYPE_STRING, "itu",
535
 
            "h263version", G_TYPE_STRING, "h263", NULL);
 
727
        caps =
 
728
            gst_ff_vid_caps_new (context, NULL, codec_id, encode,
 
729
            "video/x-h263", "variant", G_TYPE_STRING, "itu", "h263version",
 
730
            G_TYPE_STRING, "h263", NULL);
536
731
      } else {
537
732
        /* don't pass codec_id, we can decode other variants with the H263
538
733
         * decoder that don't have specific size requirements
539
734
         */
540
735
        caps =
541
 
            gst_ff_vid_caps_new (context, CODEC_ID_NONE, encode, "video/x-h263",
542
 
            "variant", G_TYPE_STRING, "itu", NULL);
 
736
            gst_ff_vid_caps_new (context, NULL, AV_CODEC_ID_NONE, encode,
 
737
            "video/x-h263", "variant", G_TYPE_STRING, "itu", NULL);
543
738
      }
544
739
      break;
545
740
 
546
 
    case CODEC_ID_H263P:
547
 
      caps = gst_ff_vid_caps_new (context, codec_id, encode, "video/x-h263",
548
 
          "variant", G_TYPE_STRING, "itu",
549
 
          "h263version", G_TYPE_STRING, "h263p", NULL);
 
741
    case AV_CODEC_ID_H263P:
 
742
      caps =
 
743
          gst_ff_vid_caps_new (context, NULL, codec_id, encode, "video/x-h263",
 
744
          "variant", G_TYPE_STRING, "itu", "h263version", G_TYPE_STRING,
 
745
          "h263p", NULL);
550
746
      if (encode && context) {
551
747
 
552
748
        gst_caps_set_simple (caps,
558
754
      }
559
755
      break;
560
756
 
561
 
    case CODEC_ID_H263I:
562
 
      caps =
563
 
          gst_ff_vid_caps_new (context, codec_id, encode, "video/x-intel-h263",
564
 
          "variant", G_TYPE_STRING, "intel", NULL);
565
 
      break;
566
 
 
567
 
    case CODEC_ID_H261:
568
 
      caps =
569
 
          gst_ff_vid_caps_new (context, codec_id, encode, "video/x-h261", NULL);
570
 
      break;
571
 
 
572
 
    case CODEC_ID_RV10:
573
 
    case CODEC_ID_RV20:
574
 
    case CODEC_ID_RV30:
575
 
    case CODEC_ID_RV40:
 
757
    case AV_CODEC_ID_H263I:
 
758
      caps =
 
759
          gst_ff_vid_caps_new (context, NULL, codec_id, encode,
 
760
          "video/x-intel-h263", "variant", G_TYPE_STRING, "intel", NULL);
 
761
      break;
 
762
 
 
763
    case AV_CODEC_ID_H261:
 
764
      caps =
 
765
          gst_ff_vid_caps_new (context, NULL, codec_id, encode, "video/x-h261",
 
766
          NULL);
 
767
      break;
 
768
 
 
769
    case AV_CODEC_ID_RV10:
 
770
    case AV_CODEC_ID_RV20:
 
771
    case AV_CODEC_ID_RV30:
 
772
    case AV_CODEC_ID_RV40:
576
773
    {
577
774
      gint version;
578
775
 
579
776
      switch (codec_id) {
580
 
        case CODEC_ID_RV40:
 
777
        case AV_CODEC_ID_RV40:
581
778
          version = 4;
582
779
          break;
583
 
        case CODEC_ID_RV30:
 
780
        case AV_CODEC_ID_RV30:
584
781
          version = 3;
585
782
          break;
586
 
        case CODEC_ID_RV20:
 
783
        case AV_CODEC_ID_RV20:
587
784
          version = 2;
588
785
          break;
589
786
        default:
593
790
 
594
791
      /* FIXME: context->sub_id must be filled in during decoding */
595
792
      caps =
596
 
          gst_ff_vid_caps_new (context, codec_id, encode,
597
 
          "video/x-pn-realvideo", "systemstream", G_TYPE_BOOLEAN, FALSE,
598
 
          "rmversion", G_TYPE_INT, version, NULL);
 
793
          gst_ff_vid_caps_new (context, NULL, codec_id, encode,
 
794
          "video/x-pn-realvideo", "rmversion", G_TYPE_INT, version, NULL);
599
795
      if (context) {
600
796
        gst_caps_set_simple (caps, "format", G_TYPE_INT, context->sub_id, NULL);
601
797
        if (context->extradata_size >= 8) {
607
803
    }
608
804
      break;
609
805
 
610
 
    case CODEC_ID_MP1:
 
806
    case AV_CODEC_ID_MP1:
611
807
      /* FIXME: bitrate */
612
 
      caps = gst_ff_aud_caps_new (context, codec_id, encode, "audio/mpeg",
 
808
      caps = gst_ff_aud_caps_new (context, NULL, codec_id, encode, "audio/mpeg",
613
809
          "mpegversion", G_TYPE_INT, 1, "layer", G_TYPE_INT, 1, NULL);
614
810
      break;
615
811
 
616
 
    case CODEC_ID_MP2:
 
812
    case AV_CODEC_ID_MP2:
617
813
      /* FIXME: bitrate */
618
 
      caps = gst_ff_aud_caps_new (context, codec_id, encode, "audio/mpeg",
 
814
      caps = gst_ff_aud_caps_new (context, NULL, codec_id, encode, "audio/mpeg",
619
815
          "mpegversion", G_TYPE_INT, 1, "layer", G_TYPE_INT, 2, NULL);
620
816
      break;
621
817
 
622
 
    case CODEC_ID_MP3:
 
818
    case AV_CODEC_ID_MP3:
623
819
      if (encode) {
624
820
        /* FIXME: bitrate */
625
 
        caps = gst_ff_aud_caps_new (context, codec_id, encode, "audio/mpeg",
 
821
        caps =
 
822
            gst_ff_aud_caps_new (context, NULL, codec_id, encode, "audio/mpeg",
626
823
            "mpegversion", G_TYPE_INT, 1, "layer", G_TYPE_INT, 3, NULL);
627
824
      } else {
628
825
        /* Decodes MPEG-1 layer 1/2/3. Samplerate, channels et al are
633
830
      }
634
831
      break;
635
832
 
636
 
    case CODEC_ID_MUSEPACK7:
 
833
    case AV_CODEC_ID_MUSEPACK7:
637
834
      caps =
638
 
          gst_ff_aud_caps_new (context, codec_id, encode,
 
835
          gst_ff_aud_caps_new (context, NULL, codec_id, encode,
639
836
          "audio/x-ffmpeg-parsed-musepack", "streamversion", G_TYPE_INT, 7,
640
837
          NULL);
641
838
      break;
642
839
 
643
 
    case CODEC_ID_MUSEPACK8:
 
840
    case AV_CODEC_ID_MUSEPACK8:
644
841
      caps =
645
 
          gst_ff_aud_caps_new (context, codec_id, encode,
 
842
          gst_ff_aud_caps_new (context, NULL, codec_id, encode,
646
843
          "audio/x-ffmpeg-parsed-musepack", "streamversion", G_TYPE_INT, 8,
647
844
          NULL);
648
845
      break;
649
846
 
650
 
    case CODEC_ID_AC3:
651
 
      /* FIXME: bitrate */
652
 
      caps =
653
 
          gst_ff_aud_caps_new (context, codec_id, encode, "audio/x-ac3", NULL);
654
 
      break;
655
 
 
656
 
    case CODEC_ID_EAC3:
657
 
      /* FIXME: bitrate */
658
 
      caps =
659
 
          gst_ff_aud_caps_new (context, codec_id, encode, "audio/x-eac3", NULL);
660
 
      break;
661
 
 
662
 
    case CODEC_ID_TRUEHD:
663
 
      caps =
664
 
          gst_ff_aud_caps_new (context, codec_id, encode, "audio/x-true-hd",
665
 
          NULL);
666
 
      break;
667
 
 
668
 
    case CODEC_ID_ATRAC1:
669
 
      caps =
670
 
          gst_ff_aud_caps_new (context, codec_id, encode,
 
847
    case AV_CODEC_ID_AC3:
 
848
      /* FIXME: bitrate */
 
849
      caps =
 
850
          gst_ff_aud_caps_new (context, NULL, codec_id, encode, "audio/x-ac3",
 
851
          NULL);
 
852
      break;
 
853
 
 
854
    case AV_CODEC_ID_EAC3:
 
855
      /* FIXME: bitrate */
 
856
      caps =
 
857
          gst_ff_aud_caps_new (context, NULL, codec_id, encode, "audio/x-eac3",
 
858
          NULL);
 
859
      break;
 
860
 
 
861
    case AV_CODEC_ID_TRUEHD:
 
862
      caps =
 
863
          gst_ff_aud_caps_new (context, NULL, codec_id, encode,
 
864
          "audio/x-true-hd", NULL);
 
865
      break;
 
866
 
 
867
    case AV_CODEC_ID_ATRAC1:
 
868
      caps =
 
869
          gst_ff_aud_caps_new (context, NULL, codec_id, encode,
671
870
          "audio/x-vnd.sony.atrac1", NULL);
672
871
      break;
673
872
 
674
 
    case CODEC_ID_ATRAC3:
 
873
    case AV_CODEC_ID_ATRAC3:
675
874
      caps =
676
 
          gst_ff_aud_caps_new (context, codec_id, encode,
 
875
          gst_ff_aud_caps_new (context, NULL, codec_id, encode,
677
876
          "audio/x-vnd.sony.atrac3", NULL);
678
877
      break;
679
878
 
680
 
    case CODEC_ID_DTS:
 
879
    case AV_CODEC_ID_DTS:
681
880
      caps =
682
 
          gst_ff_aud_caps_new (context, codec_id, encode, "audio/x-dts", NULL);
 
881
          gst_ff_aud_caps_new (context, NULL, codec_id, encode, "audio/x-dts",
 
882
          NULL);
683
883
      break;
684
884
 
685
 
    case CODEC_ID_APE:
 
885
    case AV_CODEC_ID_APE:
686
886
      caps =
687
 
          gst_ff_aud_caps_new (context, codec_id, encode,
 
887
          gst_ff_aud_caps_new (context, NULL, codec_id, encode,
688
888
          "audio/x-ffmpeg-parsed-ape", NULL);
689
889
      if (context) {
690
890
        gst_caps_set_simple (caps,
692
892
      }
693
893
      break;
694
894
 
695
 
    case CODEC_ID_MLP:
 
895
    case AV_CODEC_ID_MLP:
696
896
      caps =
697
 
          gst_ff_aud_caps_new (context, codec_id, encode, "audio/x-mlp", NULL);
 
897
          gst_ff_aud_caps_new (context, NULL, codec_id, encode, "audio/x-mlp",
 
898
          NULL);
698
899
      break;
699
900
 
700
 
    case CODEC_ID_IMC:
 
901
    case AV_CODEC_ID_IMC:
701
902
      caps =
702
 
          gst_ff_aud_caps_new (context, codec_id, encode, "audio/x-imc", NULL);
 
903
          gst_ff_aud_caps_new (context, NULL, codec_id, encode, "audio/x-imc",
 
904
          NULL);
703
905
      break;
704
906
 
705
907
      /* MJPEG is normal JPEG, Motion-JPEG and Quicktime MJPEG-A. MJPEGB
707
909
       * sp5x is, but it's apparently something JPEG... We don't separate
708
910
       * between those in GStreamer. Should we (at least between MJPEG,
709
911
       * MJPEG-B and sp5x decoding...)? */
710
 
    case CODEC_ID_MJPEG:
711
 
    case CODEC_ID_LJPEG:
712
 
      caps =
713
 
          gst_ff_vid_caps_new (context, codec_id, encode, "image/jpeg", NULL);
714
 
      break;
715
 
 
716
 
    case CODEC_ID_SP5X:
717
 
      caps =
718
 
          gst_ff_vid_caps_new (context, codec_id, encode, "video/sp5x", NULL);
719
 
      break;
720
 
 
721
 
    case CODEC_ID_MJPEGB:
722
 
      caps =
723
 
          gst_ff_vid_caps_new (context, codec_id, encode, "video/x-mjpeg-b",
724
 
          NULL);
725
 
      break;
726
 
 
727
 
    case CODEC_ID_MPEG4:
 
912
    case AV_CODEC_ID_MJPEG:
 
913
    case AV_CODEC_ID_LJPEG:
 
914
      caps =
 
915
          gst_ff_vid_caps_new (context, NULL, codec_id, encode, "image/jpeg",
 
916
          NULL);
 
917
      break;
 
918
 
 
919
    case AV_CODEC_ID_SP5X:
 
920
      caps =
 
921
          gst_ff_vid_caps_new (context, NULL, codec_id, encode, "video/sp5x",
 
922
          NULL);
 
923
      break;
 
924
 
 
925
    case AV_CODEC_ID_MJPEGB:
 
926
      caps =
 
927
          gst_ff_vid_caps_new (context, NULL, codec_id, encode,
 
928
          "video/x-mjpeg-b", NULL);
 
929
      break;
 
930
 
 
931
    case AV_CODEC_ID_MPEG4:
728
932
      if (encode && context != NULL) {
729
933
        /* I'm not exactly sure what ffmpeg outputs... ffmpeg itself uses
730
934
         * the AVI fourcc 'DIVX', but 'mp4v' for Quicktime... */
731
935
        switch (context->codec_tag) {
732
936
          case GST_MAKE_FOURCC ('D', 'I', 'V', 'X'):
733
937
            caps =
734
 
                gst_ff_vid_caps_new (context, codec_id, encode, "video/x-divx",
735
 
                "divxversion", G_TYPE_INT, 5, NULL);
 
938
                gst_ff_vid_caps_new (context, NULL, codec_id, encode,
 
939
                "video/x-divx", "divxversion", G_TYPE_INT, 5, NULL);
736
940
            break;
737
941
          case GST_MAKE_FOURCC ('m', 'p', '4', 'v'):
738
942
          default:
739
943
            /* FIXME: bitrate */
740
 
            caps = gst_ff_vid_caps_new (context, codec_id, encode, "video/mpeg",
741
 
                "systemstream", G_TYPE_BOOLEAN, FALSE,
 
944
            caps =
 
945
                gst_ff_vid_caps_new (context, NULL, codec_id, encode,
 
946
                "video/mpeg", "systemstream", G_TYPE_BOOLEAN, FALSE,
742
947
                "mpegversion", G_TYPE_INT, 4, NULL);
743
948
            break;
744
949
        }
745
950
      } else {
746
951
        /* The trick here is to separate xvid, divx, mpeg4, 3ivx et al */
747
 
        caps = gst_ff_vid_caps_new (context, codec_id, encode, "video/mpeg",
748
 
            "mpegversion", G_TYPE_INT, 4,
749
 
            "systemstream", G_TYPE_BOOLEAN, FALSE, NULL);
 
952
        caps =
 
953
            gst_ff_vid_caps_new (context, NULL, codec_id, encode, "video/mpeg",
 
954
            "mpegversion", G_TYPE_INT, 4, "systemstream", G_TYPE_BOOLEAN, FALSE,
 
955
            NULL);
750
956
        if (encode) {
751
 
          gst_caps_append (caps, gst_ff_vid_caps_new (context, codec_id, encode,
752
 
                  "video/x-divx", "divxversion", G_TYPE_INT, 5, NULL));
 
957
          gst_caps_append (caps, gst_ff_vid_caps_new (context, NULL, codec_id,
 
958
                  encode, "video/x-divx", "divxversion", G_TYPE_INT, 5, NULL));
753
959
        } else {
754
 
          gst_caps_append (caps, gst_ff_vid_caps_new (context, codec_id, encode,
755
 
                  "video/x-divx", "divxversion", GST_TYPE_INT_RANGE, 4, 5,
756
 
                  NULL));
757
 
          gst_caps_append (caps, gst_ff_vid_caps_new (context, codec_id, encode,
758
 
                  "video/x-xvid", NULL));
759
 
          gst_caps_append (caps, gst_ff_vid_caps_new (context, codec_id, encode,
760
 
                  "video/x-3ivx", NULL));
 
960
          gst_caps_append (caps, gst_ff_vid_caps_new (context, NULL, codec_id,
 
961
                  encode, "video/x-divx", "divxversion", GST_TYPE_INT_RANGE, 4,
 
962
                  5, NULL));
 
963
          gst_caps_append (caps, gst_ff_vid_caps_new (context, NULL, codec_id,
 
964
                  encode, "video/x-xvid", NULL));
 
965
          gst_caps_append (caps, gst_ff_vid_caps_new (context, NULL, codec_id,
 
966
                  encode, "video/x-3ivx", NULL));
761
967
        }
762
968
      }
763
969
      break;
764
970
 
765
 
    case CODEC_ID_RAWVIDEO:
 
971
    case AV_CODEC_ID_RAWVIDEO:
766
972
      caps =
767
 
          gst_ffmpeg_codectype_to_caps (AVMEDIA_TYPE_VIDEO, context, codec_id,
768
 
          encode);
 
973
          gst_ffmpeg_codectype_to_video_caps (context, codec_id, encode, NULL);
769
974
      break;
770
975
 
771
 
    case CODEC_ID_MSMPEG4V1:
772
 
    case CODEC_ID_MSMPEG4V2:
773
 
    case CODEC_ID_MSMPEG4V3:
 
976
    case AV_CODEC_ID_MSMPEG4V1:
 
977
    case AV_CODEC_ID_MSMPEG4V2:
 
978
    case AV_CODEC_ID_MSMPEG4V3:
774
979
    {
775
 
      gint version = 41 + codec_id - CODEC_ID_MSMPEG4V1;
 
980
      gint version = 41 + codec_id - AV_CODEC_ID_MSMPEG4V1;
776
981
 
777
982
      /* encode-FIXME: bitrate */
778
 
      caps = gst_ff_vid_caps_new (context, codec_id, encode, "video/x-msmpeg",
779
 
          "msmpegversion", G_TYPE_INT, version, NULL);
780
 
      if (!encode && codec_id == CODEC_ID_MSMPEG4V3) {
781
 
        gst_caps_append (caps, gst_ff_vid_caps_new (context, codec_id, encode,
782
 
                "video/x-divx", "divxversion", G_TYPE_INT, 3, NULL));
 
983
      caps =
 
984
          gst_ff_vid_caps_new (context, NULL, codec_id, encode,
 
985
          "video/x-msmpeg", "msmpegversion", G_TYPE_INT, version, NULL);
 
986
      if (!encode && codec_id == AV_CODEC_ID_MSMPEG4V3) {
 
987
        gst_caps_append (caps, gst_ff_vid_caps_new (context, NULL, codec_id,
 
988
                encode, "video/x-divx", "divxversion", G_TYPE_INT, 3, NULL));
783
989
      }
784
990
    }
785
991
      break;
786
992
 
787
 
    case CODEC_ID_WMV1:
788
 
    case CODEC_ID_WMV2:
 
993
    case AV_CODEC_ID_WMV1:
 
994
    case AV_CODEC_ID_WMV2:
789
995
    {
790
 
      gint version = (codec_id == CODEC_ID_WMV1) ? 1 : 2;
 
996
      gint version = (codec_id == AV_CODEC_ID_WMV1) ? 1 : 2;
791
997
 
792
 
      caps = gst_ff_vid_caps_new (context, codec_id, encode, "video/x-wmv",
 
998
      caps =
 
999
          gst_ff_vid_caps_new (context, NULL, codec_id, encode, "video/x-wmv",
793
1000
          "wmvversion", G_TYPE_INT, version, NULL);
794
1001
    }
795
1002
      break;
796
1003
 
797
 
    case CODEC_ID_FLV1:
 
1004
    case AV_CODEC_ID_FLV1:
798
1005
      caps =
799
 
          gst_ff_vid_caps_new (context, codec_id, encode, "video/x-flash-video",
800
 
          "flvversion", G_TYPE_INT, 1, NULL);
 
1006
          gst_ff_vid_caps_new (context, NULL, codec_id, encode,
 
1007
          "video/x-flash-video", "flvversion", G_TYPE_INT, 1, NULL);
801
1008
      break;
802
1009
 
803
 
    case CODEC_ID_SVQ1:
804
 
      caps = gst_ff_vid_caps_new (context, codec_id, encode, "video/x-svq",
 
1010
    case AV_CODEC_ID_SVQ1:
 
1011
      caps =
 
1012
          gst_ff_vid_caps_new (context, NULL, codec_id, encode, "video/x-svq",
805
1013
          "svqversion", G_TYPE_INT, 1, NULL);
806
1014
      break;
807
1015
 
808
 
    case CODEC_ID_SVQ3:
809
 
      caps = gst_ff_vid_caps_new (context, codec_id, encode, "video/x-svq",
 
1016
    case AV_CODEC_ID_SVQ3:
 
1017
      caps =
 
1018
          gst_ff_vid_caps_new (context, NULL, codec_id, encode, "video/x-svq",
810
1019
          "svqversion", G_TYPE_INT, 3, NULL);
811
1020
      break;
812
1021
 
813
 
    case CODEC_ID_DVAUDIO:
 
1022
    case AV_CODEC_ID_DVAUDIO:
814
1023
      caps =
815
 
          gst_ff_aud_caps_new (context, codec_id, encode, "audio/x-dv", NULL);
 
1024
          gst_ff_aud_caps_new (context, NULL, codec_id, encode, "audio/x-dv",
 
1025
          NULL);
816
1026
      break;
817
1027
 
818
 
    case CODEC_ID_DVVIDEO:
 
1028
    case AV_CODEC_ID_DVVIDEO:
819
1029
    {
820
1030
      if (encode && context) {
821
1031
        const gchar *format;
846
1056
            format = "I420";
847
1057
            break;
848
1058
        }
849
 
        caps = gst_ff_vid_caps_new (context, codec_id, encode, "video/x-dv",
850
 
            "systemstream", G_TYPE_BOOLEAN, FALSE,
851
 
            "format", G_TYPE_STRING, format, NULL);
 
1059
        caps =
 
1060
            gst_ff_vid_caps_new (context, NULL, codec_id, encode, "video/x-dv",
 
1061
            "systemstream", G_TYPE_BOOLEAN, FALSE, "format", G_TYPE_STRING,
 
1062
            format, NULL);
852
1063
      } else {
853
 
        caps = gst_ff_vid_caps_new (context, codec_id, encode, "video/x-dv",
 
1064
        caps =
 
1065
            gst_ff_vid_caps_new (context, NULL, codec_id, encode, "video/x-dv",
854
1066
            "systemstream", G_TYPE_BOOLEAN, FALSE, NULL);
855
1067
      }
856
1068
    }
857
1069
      break;
858
1070
 
859
 
    case CODEC_ID_WMAV1:
860
 
    case CODEC_ID_WMAV2:
 
1071
    case AV_CODEC_ID_WMAV1:
 
1072
    case AV_CODEC_ID_WMAV2:
861
1073
    {
862
 
      gint version = (codec_id == CODEC_ID_WMAV1) ? 1 : 2;
 
1074
      gint version = (codec_id == AV_CODEC_ID_WMAV1) ? 1 : 2;
863
1075
 
864
1076
      if (context) {
865
 
        caps = gst_ff_aud_caps_new (context, codec_id, encode, "audio/x-wma",
866
 
            "wmaversion", G_TYPE_INT, version,
867
 
            "block_align", G_TYPE_INT, context->block_align,
868
 
            "bitrate", G_TYPE_INT, context->bit_rate, NULL);
 
1077
        caps =
 
1078
            gst_ff_aud_caps_new (context, NULL, codec_id, encode, "audio/x-wma",
 
1079
            "wmaversion", G_TYPE_INT, version, "block_align", G_TYPE_INT,
 
1080
            context->block_align, "bitrate", G_TYPE_INT, context->bit_rate,
 
1081
            NULL);
869
1082
      } else {
870
 
        caps = gst_ff_aud_caps_new (context, codec_id, encode, "audio/x-wma",
871
 
            "wmaversion", G_TYPE_INT, version,
872
 
            "block_align", GST_TYPE_INT_RANGE, 0, G_MAXINT,
873
 
            "bitrate", GST_TYPE_INT_RANGE, 0, G_MAXINT, NULL);
 
1083
        caps =
 
1084
            gst_ff_aud_caps_new (context, NULL, codec_id, encode, "audio/x-wma",
 
1085
            "wmaversion", G_TYPE_INT, version, "block_align",
 
1086
            GST_TYPE_INT_RANGE, 0, G_MAXINT, "bitrate", GST_TYPE_INT_RANGE, 0,
 
1087
            G_MAXINT, NULL);
874
1088
      }
875
1089
    }
876
1090
      break;
877
 
    case CODEC_ID_WMAPRO:
 
1091
    case AV_CODEC_ID_WMAPRO:
878
1092
    {
879
 
      caps = gst_ff_aud_caps_new (context, codec_id, encode, "audio/x-wma",
 
1093
      caps =
 
1094
          gst_ff_aud_caps_new (context, NULL, codec_id, encode, "audio/x-wma",
880
1095
          "wmaversion", G_TYPE_INT, 3, NULL);
881
1096
      break;
882
1097
    }
883
 
 
884
 
    case CODEC_ID_WMAVOICE:
885
 
    {
886
 
      caps =
887
 
          gst_ff_aud_caps_new (context, codec_id, encode, "audio/x-wms", NULL);
888
 
      break;
889
 
    }
890
 
 
891
 
    case CODEC_ID_MACE3:
892
 
    case CODEC_ID_MACE6:
893
 
    {
894
 
      gint version = (codec_id == CODEC_ID_MACE3) ? 3 : 6;
895
 
 
896
 
      caps = gst_ff_aud_caps_new (context, codec_id, encode, "audio/x-mace",
 
1098
    case AV_CODEC_ID_WMALOSSLESS:
 
1099
    {
 
1100
      /* libav only supports a depth of 16 at the moment */
 
1101
      caps =
 
1102
          gst_ff_aud_caps_new (context, NULL, codec_id, encode, "audio/x-wma",
 
1103
          "wmaversion", G_TYPE_INT, 4, "depth", G_TYPE_INT, 16, NULL);
 
1104
      break;
 
1105
    }
 
1106
    case AV_CODEC_ID_WMAVOICE:
 
1107
    {
 
1108
      caps =
 
1109
          gst_ff_aud_caps_new (context, NULL, codec_id, encode, "audio/x-wms",
 
1110
          NULL);
 
1111
      break;
 
1112
    }
 
1113
 
 
1114
    case AV_CODEC_ID_MACE3:
 
1115
    case AV_CODEC_ID_MACE6:
 
1116
    {
 
1117
      gint version = (codec_id == AV_CODEC_ID_MACE3) ? 3 : 6;
 
1118
 
 
1119
      caps =
 
1120
          gst_ff_aud_caps_new (context, NULL, codec_id, encode, "audio/x-mace",
897
1121
          "maceversion", G_TYPE_INT, version, NULL);
898
1122
    }
899
1123
      break;
900
1124
 
901
 
    case CODEC_ID_HUFFYUV:
 
1125
    case AV_CODEC_ID_HUFFYUV:
902
1126
      caps =
903
 
          gst_ff_vid_caps_new (context, codec_id, encode, "video/x-huffyuv",
904
 
          NULL);
 
1127
          gst_ff_vid_caps_new (context, NULL, codec_id, encode,
 
1128
          "video/x-huffyuv", NULL);
905
1129
      if (context) {
906
1130
        gst_caps_set_simple (caps,
907
1131
            "bpp", G_TYPE_INT, context->bits_per_coded_sample, NULL);
908
1132
      }
909
1133
      break;
910
1134
 
911
 
    case CODEC_ID_CYUV:
 
1135
    case AV_CODEC_ID_CYUV:
912
1136
      caps =
913
 
          gst_ff_vid_caps_new (context, codec_id, encode,
 
1137
          gst_ff_vid_caps_new (context, NULL, codec_id, encode,
914
1138
          "video/x-compressed-yuv", NULL);
915
1139
      break;
916
1140
 
917
 
    case CODEC_ID_H264:
 
1141
    case AV_CODEC_ID_H264:
918
1142
      caps =
919
 
          gst_ff_vid_caps_new (context, codec_id, encode, "video/x-h264",
 
1143
          gst_ff_vid_caps_new (context, NULL, codec_id, encode, "video/x-h264",
920
1144
          "alignment", G_TYPE_STRING, "au", NULL);
921
1145
      break;
922
1146
 
923
 
    case CODEC_ID_INDEO5:
924
 
      caps = gst_ff_vid_caps_new (context, codec_id, encode, "video/x-indeo",
 
1147
    case AV_CODEC_ID_INDEO5:
 
1148
      caps =
 
1149
          gst_ff_vid_caps_new (context, NULL, codec_id, encode, "video/x-indeo",
925
1150
          "indeoversion", G_TYPE_INT, 5, NULL);
926
1151
      break;
927
1152
 
928
 
    case CODEC_ID_INDEO4:
929
 
      caps = gst_ff_vid_caps_new (context, codec_id, encode, "video/x-indeo",
 
1153
    case AV_CODEC_ID_INDEO4:
 
1154
      caps =
 
1155
          gst_ff_vid_caps_new (context, NULL, codec_id, encode, "video/x-indeo",
930
1156
          "indeoversion", G_TYPE_INT, 4, NULL);
931
1157
      break;
932
1158
 
933
 
    case CODEC_ID_INDEO3:
934
 
      caps = gst_ff_vid_caps_new (context, codec_id, encode, "video/x-indeo",
 
1159
    case AV_CODEC_ID_INDEO3:
 
1160
      caps =
 
1161
          gst_ff_vid_caps_new (context, NULL, codec_id, encode, "video/x-indeo",
935
1162
          "indeoversion", G_TYPE_INT, 3, NULL);
936
1163
      break;
937
1164
 
938
 
    case CODEC_ID_INDEO2:
939
 
      caps = gst_ff_vid_caps_new (context, codec_id, encode, "video/x-indeo",
 
1165
    case AV_CODEC_ID_INDEO2:
 
1166
      caps =
 
1167
          gst_ff_vid_caps_new (context, NULL, codec_id, encode, "video/x-indeo",
940
1168
          "indeoversion", G_TYPE_INT, 2, NULL);
941
1169
      break;
942
1170
 
943
 
    case CODEC_ID_FLASHSV:
 
1171
    case AV_CODEC_ID_FLASHSV:
944
1172
      caps =
945
 
          gst_ff_vid_caps_new (context, codec_id, encode,
 
1173
          gst_ff_vid_caps_new (context, NULL, codec_id, encode,
946
1174
          "video/x-flash-screen", NULL);
947
1175
      break;
948
1176
 
949
 
    case CODEC_ID_VP3:
950
 
      caps =
951
 
          gst_ff_vid_caps_new (context, codec_id, encode, "video/x-vp3", NULL);
952
 
      break;
953
 
 
954
 
    case CODEC_ID_VP5:
955
 
      caps =
956
 
          gst_ff_vid_caps_new (context, codec_id, encode, "video/x-vp5", NULL);
957
 
      break;
958
 
 
959
 
    case CODEC_ID_VP6:
960
 
      caps =
961
 
          gst_ff_vid_caps_new (context, codec_id, encode, "video/x-vp6", NULL);
962
 
      break;
963
 
 
964
 
    case CODEC_ID_VP6F:
965
 
      caps =
966
 
          gst_ff_vid_caps_new (context, codec_id, encode, "video/x-vp6-flash",
967
 
          NULL);
968
 
      break;
969
 
 
970
 
    case CODEC_ID_VP6A:
971
 
      caps =
972
 
          gst_ff_vid_caps_new (context, codec_id, encode, "video/x-vp6-alpha",
973
 
          NULL);
974
 
      break;
975
 
 
976
 
    case CODEC_ID_VP8:
977
 
      caps =
978
 
          gst_ff_vid_caps_new (context, codec_id, encode, "video/x-vp8", NULL);
979
 
      break;
980
 
 
981
 
    case CODEC_ID_THEORA:
982
 
      caps =
983
 
          gst_ff_vid_caps_new (context, codec_id, encode, "video/x-theora",
984
 
          NULL);
985
 
      break;
986
 
 
987
 
    case CODEC_ID_AAC:
 
1177
    case AV_CODEC_ID_VP3:
 
1178
      caps =
 
1179
          gst_ff_vid_caps_new (context, NULL, codec_id, encode, "video/x-vp3",
 
1180
          NULL);
 
1181
      break;
 
1182
 
 
1183
    case AV_CODEC_ID_VP5:
 
1184
      caps =
 
1185
          gst_ff_vid_caps_new (context, NULL, codec_id, encode, "video/x-vp5",
 
1186
          NULL);
 
1187
      break;
 
1188
 
 
1189
    case AV_CODEC_ID_VP6:
 
1190
      caps =
 
1191
          gst_ff_vid_caps_new (context, NULL, codec_id, encode, "video/x-vp6",
 
1192
          NULL);
 
1193
      break;
 
1194
 
 
1195
    case AV_CODEC_ID_VP6F:
 
1196
      caps =
 
1197
          gst_ff_vid_caps_new (context, NULL, codec_id, encode,
 
1198
          "video/x-vp6-flash", NULL);
 
1199
      break;
 
1200
 
 
1201
    case AV_CODEC_ID_VP6A:
 
1202
      caps =
 
1203
          gst_ff_vid_caps_new (context, NULL, codec_id, encode,
 
1204
          "video/x-vp6-alpha", NULL);
 
1205
      break;
 
1206
 
 
1207
    case AV_CODEC_ID_VP8:
 
1208
      caps =
 
1209
          gst_ff_vid_caps_new (context, NULL, codec_id, encode, "video/x-vp8",
 
1210
          NULL);
 
1211
      break;
 
1212
 
 
1213
    case AV_CODEC_ID_THEORA:
 
1214
      caps =
 
1215
          gst_ff_vid_caps_new (context, NULL, codec_id, encode,
 
1216
          "video/x-theora", NULL);
 
1217
      break;
 
1218
 
 
1219
    case AV_CODEC_ID_AAC:
988
1220
    {
989
1221
      caps =
990
 
          gst_ff_aud_caps_new (context, codec_id, encode, "audio/mpeg", NULL);
 
1222
          gst_ff_aud_caps_new (context, NULL, codec_id, encode, "audio/mpeg",
 
1223
          NULL);
991
1224
 
992
1225
      if (!encode) {
993
1226
        GValue arr = { 0, };
1028
1261
 
1029
1262
      break;
1030
1263
    }
1031
 
    case CODEC_ID_AAC_LATM:    /* LATM/LOAS AAC syntax */
1032
 
      caps = gst_ff_aud_caps_new (context, codec_id, encode, "audio/mpeg",
 
1264
    case AV_CODEC_ID_AAC_LATM: /* LATM/LOAS AAC syntax */
 
1265
      caps = gst_ff_aud_caps_new (context, NULL, codec_id, encode, "audio/mpeg",
1033
1266
          "mpegversion", G_TYPE_INT, 4, "stream-format", G_TYPE_STRING, "loas",
1034
1267
          NULL);
1035
1268
      break;
1036
1269
 
1037
 
    case CODEC_ID_ASV1:
1038
 
      caps = gst_ff_vid_caps_new (context, codec_id, encode, "video/x-asus",
 
1270
    case AV_CODEC_ID_ASV1:
 
1271
      caps =
 
1272
          gst_ff_vid_caps_new (context, NULL, codec_id, encode, "video/x-asus",
1039
1273
          "asusversion", G_TYPE_INT, 1, NULL);
1040
1274
      break;
1041
 
    case CODEC_ID_ASV2:
1042
 
      caps = gst_ff_vid_caps_new (context, codec_id, encode, "video/x-asus",
 
1275
    case AV_CODEC_ID_ASV2:
 
1276
      caps =
 
1277
          gst_ff_vid_caps_new (context, NULL, codec_id, encode, "video/x-asus",
1043
1278
          "asusversion", G_TYPE_INT, 2, NULL);
1044
1279
      break;
1045
1280
 
1046
 
    case CODEC_ID_FFV1:
1047
 
      caps = gst_ff_vid_caps_new (context, codec_id, encode, "video/x-ffv",
 
1281
    case AV_CODEC_ID_FFV1:
 
1282
      caps =
 
1283
          gst_ff_vid_caps_new (context, NULL, codec_id, encode, "video/x-ffv",
1048
1284
          "ffvversion", G_TYPE_INT, 1, NULL);
1049
1285
      break;
1050
1286
 
1051
 
    case CODEC_ID_4XM:
1052
 
      caps =
1053
 
          gst_ff_vid_caps_new (context, codec_id, encode, "video/x-4xm", NULL);
1054
 
      break;
1055
 
 
1056
 
    case CODEC_ID_XAN_WC3:
1057
 
    case CODEC_ID_XAN_WC4:
1058
 
      caps = gst_ff_vid_caps_new (context, codec_id, encode, "video/x-xan",
1059
 
          "wcversion", G_TYPE_INT, 3 - CODEC_ID_XAN_WC3 + codec_id, NULL);
1060
 
      break;
1061
 
 
1062
 
    case CODEC_ID_CLJR:
1063
 
      caps =
1064
 
          gst_ff_vid_caps_new (context, codec_id, encode,
 
1287
    case AV_CODEC_ID_4XM:
 
1288
      caps =
 
1289
          gst_ff_vid_caps_new (context, NULL, codec_id, encode, "video/x-4xm",
 
1290
          NULL);
 
1291
      break;
 
1292
 
 
1293
    case AV_CODEC_ID_XAN_WC3:
 
1294
    case AV_CODEC_ID_XAN_WC4:
 
1295
      caps =
 
1296
          gst_ff_vid_caps_new (context, NULL, codec_id, encode, "video/x-xan",
 
1297
          "wcversion", G_TYPE_INT, 3 - AV_CODEC_ID_XAN_WC3 + codec_id, NULL);
 
1298
      break;
 
1299
 
 
1300
    case AV_CODEC_ID_CLJR:
 
1301
      caps =
 
1302
          gst_ff_vid_caps_new (context, NULL, codec_id, encode,
1065
1303
          "video/x-cirrus-logic-accupak", NULL);
1066
1304
      break;
1067
1305
 
1068
 
    case CODEC_ID_FRAPS:
 
1306
    case AV_CODEC_ID_FRAPS:
1069
1307
      caps =
1070
 
          gst_ff_vid_caps_new (context, codec_id, encode, "video/x-fraps",
 
1308
          gst_ff_vid_caps_new (context, NULL, codec_id, encode, "video/x-fraps",
1071
1309
          NULL);
1072
1310
      break;
1073
1311
 
1074
 
    case CODEC_ID_MDEC:
1075
 
    case CODEC_ID_ROQ:
1076
 
    case CODEC_ID_INTERPLAY_VIDEO:
 
1312
    case AV_CODEC_ID_MDEC:
 
1313
    case AV_CODEC_ID_ROQ:
 
1314
    case AV_CODEC_ID_INTERPLAY_VIDEO:
1077
1315
      buildcaps = TRUE;
1078
1316
      break;
1079
1317
 
1080
 
    case CODEC_ID_VCR1:
1081
 
      caps = gst_ff_vid_caps_new (context, codec_id, encode, "video/x-ati-vcr",
1082
 
          "vcrversion", G_TYPE_INT, 1, NULL);
1083
 
      break;
1084
 
 
1085
 
    case CODEC_ID_RPZA:
1086
 
      caps =
1087
 
          gst_ff_vid_caps_new (context, codec_id, encode, "video/x-apple-video",
1088
 
          NULL);
1089
 
      break;
1090
 
 
1091
 
    case CODEC_ID_CINEPAK:
1092
 
      caps =
1093
 
          gst_ff_vid_caps_new (context, codec_id, encode, "video/x-cinepak",
1094
 
          NULL);
 
1318
    case AV_CODEC_ID_VCR1:
 
1319
      caps =
 
1320
          gst_ff_vid_caps_new (context, NULL, codec_id, encode,
 
1321
          "video/x-ati-vcr", "vcrversion", G_TYPE_INT, 1, NULL);
 
1322
      break;
 
1323
 
 
1324
    case AV_CODEC_ID_RPZA:
 
1325
      caps =
 
1326
          gst_ff_vid_caps_new (context, NULL, codec_id, encode,
 
1327
          "video/x-apple-video", NULL);
 
1328
      break;
 
1329
 
 
1330
    case AV_CODEC_ID_CINEPAK:
 
1331
      caps =
 
1332
          gst_ff_vid_caps_new (context, NULL, codec_id, encode,
 
1333
          "video/x-cinepak", NULL);
1095
1334
      break;
1096
1335
 
1097
1336
      /* WS_VQA belogns here (order) */
1098
1337
 
1099
 
    case CODEC_ID_MSRLE:
1100
 
      caps = gst_ff_vid_caps_new (context, codec_id, encode, "video/x-rle",
 
1338
    case AV_CODEC_ID_MSRLE:
 
1339
      caps =
 
1340
          gst_ff_vid_caps_new (context, NULL, codec_id, encode, "video/x-rle",
1101
1341
          "layout", G_TYPE_STRING, "microsoft", NULL);
1102
1342
      if (context) {
1103
1343
        gst_caps_set_simple (caps,
1107
1347
      }
1108
1348
      break;
1109
1349
 
1110
 
    case CODEC_ID_QTRLE:
1111
 
      caps = gst_ff_vid_caps_new (context, codec_id, encode, "video/x-rle",
 
1350
    case AV_CODEC_ID_QTRLE:
 
1351
      caps =
 
1352
          gst_ff_vid_caps_new (context, NULL, codec_id, encode, "video/x-rle",
1112
1353
          "layout", G_TYPE_STRING, "quicktime", NULL);
1113
1354
      if (context) {
1114
1355
        gst_caps_set_simple (caps,
1118
1359
      }
1119
1360
      break;
1120
1361
 
1121
 
    case CODEC_ID_MSVIDEO1:
 
1362
    case AV_CODEC_ID_MSVIDEO1:
1122
1363
      caps =
1123
 
          gst_ff_vid_caps_new (context, codec_id, encode,
 
1364
          gst_ff_vid_caps_new (context, NULL, codec_id, encode,
1124
1365
          "video/x-msvideocodec", "msvideoversion", G_TYPE_INT, 1, NULL);
1125
1366
      break;
1126
1367
 
1127
 
    case CODEC_ID_WMV3:
1128
 
      caps = gst_ff_vid_caps_new (context, codec_id, encode, "video/x-wmv",
1129
 
          "wmvversion", G_TYPE_INT, 3, NULL);
 
1368
    case AV_CODEC_ID_WMV3:
 
1369
      caps =
 
1370
          gst_ff_vid_caps_new (context, NULL, codec_id, encode, "video/x-wmv",
 
1371
          "wmvversion", G_TYPE_INT, 3, "format", G_TYPE_STRING, "WMV3", NULL);
1130
1372
      break;
1131
 
    case CODEC_ID_VC1:
1132
 
      caps = gst_ff_vid_caps_new (context, codec_id, encode, "video/x-wmv",
 
1373
    case AV_CODEC_ID_VC1:
 
1374
      caps =
 
1375
          gst_ff_vid_caps_new (context, NULL, codec_id, encode, "video/x-wmv",
1133
1376
          "wmvversion", G_TYPE_INT, 3, "format", G_TYPE_STRING, "WVC1", NULL);
1134
1377
      break;
1135
 
    case CODEC_ID_QDM2:
1136
 
      caps =
1137
 
          gst_ff_aud_caps_new (context, codec_id, encode, "audio/x-qdm2", NULL);
1138
 
      break;
1139
 
 
1140
 
    case CODEC_ID_MSZH:
1141
 
      caps =
1142
 
          gst_ff_vid_caps_new (context, codec_id, encode, "video/x-mszh", NULL);
1143
 
      break;
1144
 
 
1145
 
    case CODEC_ID_ZLIB:
1146
 
      caps =
1147
 
          gst_ff_vid_caps_new (context, codec_id, encode, "video/x-zlib", NULL);
1148
 
      break;
1149
 
 
1150
 
    case CODEC_ID_TRUEMOTION1:
1151
 
      caps =
1152
 
          gst_ff_vid_caps_new (context, codec_id, encode, "video/x-truemotion",
1153
 
          "trueversion", G_TYPE_INT, 1, NULL);
1154
 
      break;
1155
 
    case CODEC_ID_TRUEMOTION2:
1156
 
      caps =
1157
 
          gst_ff_vid_caps_new (context, codec_id, encode, "video/x-truemotion",
1158
 
          "trueversion", G_TYPE_INT, 2, NULL);
1159
 
      break;
1160
 
 
1161
 
    case CODEC_ID_ULTI:
1162
 
      caps =
1163
 
          gst_ff_vid_caps_new (context, codec_id, encode, "video/x-ultimotion",
1164
 
          NULL);
1165
 
      break;
1166
 
 
1167
 
    case CODEC_ID_TSCC:
1168
 
      caps =
1169
 
          gst_ff_vid_caps_new (context, codec_id, encode, "video/x-camtasia",
1170
 
          NULL);
 
1378
    case AV_CODEC_ID_QDM2:
 
1379
      caps =
 
1380
          gst_ff_aud_caps_new (context, NULL, codec_id, encode, "audio/x-qdm2",
 
1381
          NULL);
 
1382
      break;
 
1383
 
 
1384
    case AV_CODEC_ID_MSZH:
 
1385
      caps =
 
1386
          gst_ff_vid_caps_new (context, NULL, codec_id, encode, "video/x-mszh",
 
1387
          NULL);
 
1388
      break;
 
1389
 
 
1390
    case AV_CODEC_ID_ZLIB:
 
1391
      caps =
 
1392
          gst_ff_vid_caps_new (context, NULL, codec_id, encode, "video/x-zlib",
 
1393
          NULL);
 
1394
      break;
 
1395
 
 
1396
    case AV_CODEC_ID_TRUEMOTION1:
 
1397
      caps =
 
1398
          gst_ff_vid_caps_new (context, NULL, codec_id, encode,
 
1399
          "video/x-truemotion", "trueversion", G_TYPE_INT, 1, NULL);
 
1400
      break;
 
1401
    case AV_CODEC_ID_TRUEMOTION2:
 
1402
      caps =
 
1403
          gst_ff_vid_caps_new (context, NULL, codec_id, encode,
 
1404
          "video/x-truemotion", "trueversion", G_TYPE_INT, 2, NULL);
 
1405
      break;
 
1406
 
 
1407
    case AV_CODEC_ID_ULTI:
 
1408
      caps =
 
1409
          gst_ff_vid_caps_new (context, NULL, codec_id, encode,
 
1410
          "video/x-ultimotion", NULL);
 
1411
      break;
 
1412
 
 
1413
    case AV_CODEC_ID_TSCC:
 
1414
      caps =
 
1415
          gst_ff_vid_caps_new (context, NULL, codec_id, encode,
 
1416
          "video/x-camtasia", NULL);
1171
1417
      if (context) {
1172
1418
        gst_caps_set_simple (caps,
1173
1419
            "depth", G_TYPE_INT, (gint) context->bits_per_coded_sample, NULL);
1176
1422
      }
1177
1423
      break;
1178
1424
 
1179
 
    case CODEC_ID_KMVC:
1180
 
      caps =
1181
 
          gst_ff_vid_caps_new (context, codec_id, encode, "video/x-kmvc", NULL);
1182
 
      break;
1183
 
 
1184
 
    case CODEC_ID_NUV:
1185
 
      caps =
1186
 
          gst_ff_vid_caps_new (context, codec_id, encode, "video/x-nuv", NULL);
1187
 
      break;
1188
 
 
1189
 
    case CODEC_ID_GIF:
1190
 
      caps = gst_ff_vid_caps_new (context, codec_id, encode, "image/gif", NULL);
1191
 
      break;
1192
 
 
1193
 
    case CODEC_ID_PNG:
1194
 
      caps = gst_ff_vid_caps_new (context, codec_id, encode, "image/png", NULL);
1195
 
      break;
1196
 
 
1197
 
    case CODEC_ID_PPM:
1198
 
      caps = gst_ff_vid_caps_new (context, codec_id, encode, "image/ppm", NULL);
1199
 
      break;
1200
 
 
1201
 
    case CODEC_ID_PBM:
1202
 
      caps = gst_ff_vid_caps_new (context, codec_id, encode, "image/pbm", NULL);
1203
 
      break;
1204
 
 
1205
 
    case CODEC_ID_PAM:
1206
 
      caps =
1207
 
          gst_ff_vid_caps_new (context, codec_id, encode,
 
1425
    case AV_CODEC_ID_KMVC:
 
1426
      caps =
 
1427
          gst_ff_vid_caps_new (context, NULL, codec_id, encode, "video/x-kmvc",
 
1428
          NULL);
 
1429
      break;
 
1430
 
 
1431
    case AV_CODEC_ID_NUV:
 
1432
      caps =
 
1433
          gst_ff_vid_caps_new (context, NULL, codec_id, encode, "video/x-nuv",
 
1434
          NULL);
 
1435
      break;
 
1436
 
 
1437
    case AV_CODEC_ID_GIF:
 
1438
      caps =
 
1439
          gst_ff_vid_caps_new (context, NULL, codec_id, encode, "image/gif",
 
1440
          NULL);
 
1441
      break;
 
1442
 
 
1443
    case AV_CODEC_ID_PNG:
 
1444
      caps =
 
1445
          gst_ff_vid_caps_new (context, NULL, codec_id, encode, "image/png",
 
1446
          NULL);
 
1447
      break;
 
1448
 
 
1449
    case AV_CODEC_ID_PPM:
 
1450
      caps =
 
1451
          gst_ff_vid_caps_new (context, NULL, codec_id, encode, "image/ppm",
 
1452
          NULL);
 
1453
      break;
 
1454
 
 
1455
    case AV_CODEC_ID_PBM:
 
1456
      caps =
 
1457
          gst_ff_vid_caps_new (context, NULL, codec_id, encode, "image/pbm",
 
1458
          NULL);
 
1459
      break;
 
1460
 
 
1461
    case AV_CODEC_ID_PAM:
 
1462
      caps =
 
1463
          gst_ff_vid_caps_new (context, NULL, codec_id, encode,
1208
1464
          "image/x-portable-anymap", NULL);
1209
1465
      break;
1210
1466
 
1211
 
    case CODEC_ID_PGM:
 
1467
    case AV_CODEC_ID_PGM:
1212
1468
      caps =
1213
 
          gst_ff_vid_caps_new (context, codec_id, encode,
 
1469
          gst_ff_vid_caps_new (context, NULL, codec_id, encode,
1214
1470
          "image/x-portable-graymap", NULL);
1215
1471
      break;
1216
1472
 
1217
 
    case CODEC_ID_PCX:
1218
 
      caps =
1219
 
          gst_ff_vid_caps_new (context, codec_id, encode, "image/x-pcx", NULL);
1220
 
      break;
1221
 
 
1222
 
    case CODEC_ID_SGI:
1223
 
      caps =
1224
 
          gst_ff_vid_caps_new (context, codec_id, encode, "image/x-sgi", NULL);
1225
 
      break;
1226
 
 
1227
 
    case CODEC_ID_TARGA:
1228
 
      caps =
1229
 
          gst_ff_vid_caps_new (context, codec_id, encode, "image/x-tga", NULL);
1230
 
      break;
1231
 
 
1232
 
    case CODEC_ID_TIFF:
1233
 
      caps =
1234
 
          gst_ff_vid_caps_new (context, codec_id, encode, "image/tiff", NULL);
1235
 
      break;
1236
 
 
1237
 
    case CODEC_ID_SUNRAST:
1238
 
      caps =
1239
 
          gst_ff_vid_caps_new (context, codec_id, encode, "image/x-sun-raster",
1240
 
          NULL);
1241
 
      break;
1242
 
 
1243
 
    case CODEC_ID_SMC:
1244
 
      caps =
1245
 
          gst_ff_vid_caps_new (context, codec_id, encode, "video/x-smc", NULL);
1246
 
      break;
1247
 
 
1248
 
    case CODEC_ID_QDRAW:
1249
 
      caps =
1250
 
          gst_ff_vid_caps_new (context, codec_id, encode, "video/x-qdrw", NULL);
1251
 
      break;
1252
 
 
1253
 
    case CODEC_ID_DNXHD:
1254
 
      caps =
1255
 
          gst_ff_vid_caps_new (context, codec_id, encode, "video/x-dnxhd",
1256
 
          NULL);
1257
 
      break;
1258
 
 
1259
 
    case CODEC_ID_PRORES:
1260
 
      caps =
1261
 
          gst_ff_vid_caps_new (context, codec_id, encode, "video/x-prores",
1262
 
          NULL);
1263
 
      break;
1264
 
 
1265
 
    case CODEC_ID_MIMIC:
1266
 
      caps =
1267
 
          gst_ff_vid_caps_new (context, codec_id, encode, "video/x-mimic",
1268
 
          NULL);
1269
 
      break;
1270
 
 
1271
 
    case CODEC_ID_VMNC:
1272
 
      caps =
1273
 
          gst_ff_vid_caps_new (context, codec_id, encode, "video/x-vmnc", NULL);
1274
 
      break;
1275
 
 
1276
 
    case CODEC_ID_TRUESPEECH:
1277
 
      caps =
1278
 
          gst_ff_aud_caps_new (context, codec_id, encode, "audio/x-truespeech",
1279
 
          NULL);
1280
 
      break;
1281
 
 
1282
 
    case CODEC_ID_QCELP:
1283
 
      caps =
1284
 
          gst_ff_aud_caps_new (context, codec_id, encode, "audio/qcelp", NULL);
1285
 
      break;
1286
 
 
1287
 
    case CODEC_ID_AMV:
1288
 
      caps =
1289
 
          gst_ff_vid_caps_new (context, codec_id, encode, "video/x-amv", NULL);
1290
 
      break;
1291
 
 
1292
 
    case CODEC_ID_AASC:
1293
 
      caps =
1294
 
          gst_ff_vid_caps_new (context, codec_id, encode, "video/x-aasc", NULL);
1295
 
      break;
1296
 
 
1297
 
    case CODEC_ID_LOCO:
1298
 
      caps =
1299
 
          gst_ff_vid_caps_new (context, codec_id, encode, "video/x-loco", NULL);
1300
 
      break;
1301
 
 
1302
 
    case CODEC_ID_ZMBV:
1303
 
      caps =
1304
 
          gst_ff_vid_caps_new (context, codec_id, encode, "video/x-zmbv", NULL);
1305
 
      break;
1306
 
 
1307
 
    case CODEC_ID_LAGARITH:
1308
 
      caps =
1309
 
          gst_ff_vid_caps_new (context, codec_id, encode, "video/x-lagarith",
1310
 
          NULL);
1311
 
      break;
1312
 
 
1313
 
    case CODEC_ID_CSCD:
1314
 
      caps =
1315
 
          gst_ff_vid_caps_new (context, codec_id, encode, "video/x-camstudio",
1316
 
          NULL);
 
1473
    case AV_CODEC_ID_PCX:
 
1474
      caps =
 
1475
          gst_ff_vid_caps_new (context, NULL, codec_id, encode, "image/x-pcx",
 
1476
          NULL);
 
1477
      break;
 
1478
 
 
1479
    case AV_CODEC_ID_SGI:
 
1480
      caps =
 
1481
          gst_ff_vid_caps_new (context, NULL, codec_id, encode, "image/x-sgi",
 
1482
          NULL);
 
1483
      break;
 
1484
 
 
1485
    case AV_CODEC_ID_TARGA:
 
1486
      caps =
 
1487
          gst_ff_vid_caps_new (context, NULL, codec_id, encode, "image/x-tga",
 
1488
          NULL);
 
1489
      break;
 
1490
 
 
1491
    case AV_CODEC_ID_TIFF:
 
1492
      caps =
 
1493
          gst_ff_vid_caps_new (context, NULL, codec_id, encode, "image/tiff",
 
1494
          NULL);
 
1495
      break;
 
1496
 
 
1497
    case AV_CODEC_ID_SUNRAST:
 
1498
      caps =
 
1499
          gst_ff_vid_caps_new (context, NULL, codec_id, encode,
 
1500
          "image/x-sun-raster", NULL);
 
1501
      break;
 
1502
 
 
1503
    case AV_CODEC_ID_SMC:
 
1504
      caps =
 
1505
          gst_ff_vid_caps_new (context, NULL, codec_id, encode, "video/x-smc",
 
1506
          NULL);
 
1507
      break;
 
1508
 
 
1509
    case AV_CODEC_ID_QDRAW:
 
1510
      caps =
 
1511
          gst_ff_vid_caps_new (context, NULL, codec_id, encode, "video/x-qdrw",
 
1512
          NULL);
 
1513
      break;
 
1514
 
 
1515
    case AV_CODEC_ID_DNXHD:
 
1516
      caps =
 
1517
          gst_ff_vid_caps_new (context, NULL, codec_id, encode, "video/x-dnxhd",
 
1518
          NULL);
 
1519
      break;
 
1520
 
 
1521
    case AV_CODEC_ID_PRORES:
 
1522
      caps =
 
1523
          gst_ff_vid_caps_new (context, NULL, codec_id, encode,
 
1524
          "video/x-prores", NULL);
 
1525
      break;
 
1526
 
 
1527
    case AV_CODEC_ID_MIMIC:
 
1528
      caps =
 
1529
          gst_ff_vid_caps_new (context, NULL, codec_id, encode, "video/x-mimic",
 
1530
          NULL);
 
1531
      break;
 
1532
 
 
1533
    case AV_CODEC_ID_VMNC:
 
1534
      caps =
 
1535
          gst_ff_vid_caps_new (context, NULL, codec_id, encode, "video/x-vmnc",
 
1536
          NULL);
 
1537
      break;
 
1538
 
 
1539
    case AV_CODEC_ID_TRUESPEECH:
 
1540
      caps =
 
1541
          gst_ff_aud_caps_new (context, NULL, codec_id, encode,
 
1542
          "audio/x-truespeech", NULL);
 
1543
      break;
 
1544
 
 
1545
    case AV_CODEC_ID_QCELP:
 
1546
      caps =
 
1547
          gst_ff_aud_caps_new (context, NULL, codec_id, encode, "audio/qcelp",
 
1548
          NULL);
 
1549
      break;
 
1550
 
 
1551
    case AV_CODEC_ID_AMV:
 
1552
      caps =
 
1553
          gst_ff_vid_caps_new (context, NULL, codec_id, encode, "video/x-amv",
 
1554
          NULL);
 
1555
      break;
 
1556
 
 
1557
    case AV_CODEC_ID_AASC:
 
1558
      caps =
 
1559
          gst_ff_vid_caps_new (context, NULL, codec_id, encode, "video/x-aasc",
 
1560
          NULL);
 
1561
      break;
 
1562
 
 
1563
    case AV_CODEC_ID_LOCO:
 
1564
      caps =
 
1565
          gst_ff_vid_caps_new (context, NULL, codec_id, encode, "video/x-loco",
 
1566
          NULL);
 
1567
      break;
 
1568
 
 
1569
    case AV_CODEC_ID_ZMBV:
 
1570
      caps =
 
1571
          gst_ff_vid_caps_new (context, NULL, codec_id, encode, "video/x-zmbv",
 
1572
          NULL);
 
1573
      break;
 
1574
 
 
1575
    case AV_CODEC_ID_LAGARITH:
 
1576
      caps =
 
1577
          gst_ff_vid_caps_new (context, NULL, codec_id, encode,
 
1578
          "video/x-lagarith", NULL);
 
1579
      break;
 
1580
 
 
1581
    case AV_CODEC_ID_CSCD:
 
1582
      caps =
 
1583
          gst_ff_vid_caps_new (context, NULL, codec_id, encode,
 
1584
          "video/x-camstudio", NULL);
1317
1585
      if (context) {
1318
1586
        gst_caps_set_simple (caps,
1319
1587
            "depth", G_TYPE_INT, (gint) context->bits_per_coded_sample, NULL);
1322
1590
      }
1323
1591
      break;
1324
1592
 
1325
 
    case CODEC_ID_WS_VQA:
1326
 
    case CODEC_ID_IDCIN:
1327
 
    case CODEC_ID_8BPS:
1328
 
    case CODEC_ID_FLIC:
1329
 
    case CODEC_ID_VMDVIDEO:
1330
 
    case CODEC_ID_VMDAUDIO:
1331
 
    case CODEC_ID_SONIC:
1332
 
    case CODEC_ID_SONIC_LS:
1333
 
    case CODEC_ID_SNOW:
1334
 
    case CODEC_ID_VIXL:
1335
 
    case CODEC_ID_QPEG:
1336
 
    case CODEC_ID_PGMYUV:
1337
 
    case CODEC_ID_FFVHUFF:
1338
 
    case CODEC_ID_WNV1:
1339
 
    case CODEC_ID_MP3ADU:
1340
 
    case CODEC_ID_MP3ON4:
1341
 
    case CODEC_ID_WESTWOOD_SND1:
1342
 
    case CODEC_ID_MMVIDEO:
1343
 
    case CODEC_ID_AVS:
1344
 
    case CODEC_ID_CAVS:
 
1593
    case AV_CODEC_ID_WS_VQA:
 
1594
    case AV_CODEC_ID_IDCIN:
 
1595
    case AV_CODEC_ID_8BPS:
 
1596
    case AV_CODEC_ID_FLIC:
 
1597
    case AV_CODEC_ID_VMDVIDEO:
 
1598
    case AV_CODEC_ID_VMDAUDIO:
 
1599
    case AV_CODEC_ID_SNOW:
 
1600
    case AV_CODEC_ID_VIXL:
 
1601
    case AV_CODEC_ID_QPEG:
 
1602
    case AV_CODEC_ID_PGMYUV:
 
1603
    case AV_CODEC_ID_FFVHUFF:
 
1604
    case AV_CODEC_ID_WNV1:
 
1605
    case AV_CODEC_ID_MP3ADU:
 
1606
    case AV_CODEC_ID_MP3ON4:
 
1607
    case AV_CODEC_ID_WESTWOOD_SND1:
 
1608
    case AV_CODEC_ID_MMVIDEO:
 
1609
    case AV_CODEC_ID_AVS:
 
1610
    case AV_CODEC_ID_CAVS:
1345
1611
      buildcaps = TRUE;
1346
1612
      break;
1347
1613
 
1348
1614
      /* weird quasi-codecs for the demuxers only */
1349
 
    case CODEC_ID_PCM_S16LE:
1350
 
    case CODEC_ID_PCM_S16BE:
1351
 
    case CODEC_ID_PCM_U16LE:
1352
 
    case CODEC_ID_PCM_U16BE:
1353
 
    case CODEC_ID_PCM_S8:
1354
 
    case CODEC_ID_PCM_U8:
 
1615
    case AV_CODEC_ID_PCM_S16LE:
 
1616
    case AV_CODEC_ID_PCM_S16BE:
 
1617
    case AV_CODEC_ID_PCM_U16LE:
 
1618
    case AV_CODEC_ID_PCM_U16BE:
 
1619
    case AV_CODEC_ID_PCM_S8:
 
1620
    case AV_CODEC_ID_PCM_U8:
1355
1621
    {
1356
1622
      GstAudioFormat format;
1357
1623
 
1358
1624
      switch (codec_id) {
1359
 
        case CODEC_ID_PCM_S16LE:
 
1625
        case AV_CODEC_ID_PCM_S16LE:
1360
1626
          format = GST_AUDIO_FORMAT_S16LE;
1361
1627
          break;
1362
 
        case CODEC_ID_PCM_S16BE:
 
1628
        case AV_CODEC_ID_PCM_S16BE:
1363
1629
          format = GST_AUDIO_FORMAT_S16BE;
1364
1630
          break;
1365
 
        case CODEC_ID_PCM_U16LE:
 
1631
        case AV_CODEC_ID_PCM_U16LE:
1366
1632
          format = GST_AUDIO_FORMAT_U16LE;
1367
1633
          break;
1368
 
        case CODEC_ID_PCM_U16BE:
 
1634
        case AV_CODEC_ID_PCM_U16BE:
1369
1635
          format = GST_AUDIO_FORMAT_U16BE;
1370
1636
          break;
1371
 
        case CODEC_ID_PCM_S8:
 
1637
        case AV_CODEC_ID_PCM_S8:
1372
1638
          format = GST_AUDIO_FORMAT_S8;
1373
1639
          break;
1374
 
        case CODEC_ID_PCM_U8:
 
1640
        case AV_CODEC_ID_PCM_U8:
1375
1641
          format = GST_AUDIO_FORMAT_U8;
1376
1642
          break;
1377
1643
        default:
1379
1645
          break;
1380
1646
      }
1381
1647
 
1382
 
      caps = gst_ff_aud_caps_new (context, codec_id, encode, "audio/x-raw",
 
1648
      caps =
 
1649
          gst_ff_aud_caps_new (context, NULL, codec_id, encode, "audio/x-raw",
1383
1650
          "format", G_TYPE_STRING, gst_audio_format_to_string (format),
1384
1651
          "layout", G_TYPE_STRING, "interleaved", NULL);
1385
1652
    }
1386
1653
      break;
1387
1654
 
1388
 
    case CODEC_ID_PCM_MULAW:
1389
 
      caps =
1390
 
          gst_ff_aud_caps_new (context, codec_id, encode, "audio/x-mulaw",
1391
 
          NULL);
1392
 
      break;
1393
 
 
1394
 
    case CODEC_ID_PCM_ALAW:
1395
 
      caps =
1396
 
          gst_ff_aud_caps_new (context, codec_id, encode, "audio/x-alaw", NULL);
1397
 
      break;
1398
 
 
1399
 
    case CODEC_ID_ADPCM_G722:
1400
 
      caps =
1401
 
          gst_ff_aud_caps_new (context, codec_id, encode, "audio/G722", NULL);
 
1655
    case AV_CODEC_ID_PCM_MULAW:
 
1656
      caps =
 
1657
          gst_ff_aud_caps_new (context, NULL, codec_id, encode, "audio/x-mulaw",
 
1658
          NULL);
 
1659
      break;
 
1660
 
 
1661
    case AV_CODEC_ID_PCM_ALAW:
 
1662
      caps =
 
1663
          gst_ff_aud_caps_new (context, NULL, codec_id, encode, "audio/x-alaw",
 
1664
          NULL);
 
1665
      break;
 
1666
 
 
1667
    case AV_CODEC_ID_ADPCM_G722:
 
1668
      caps =
 
1669
          gst_ff_aud_caps_new (context, NULL, codec_id, encode, "audio/G722",
 
1670
          NULL);
1402
1671
      if (context)
1403
1672
        gst_caps_set_simple (caps,
1404
1673
            "block_align", G_TYPE_INT, context->block_align,
1405
1674
            "bitrate", G_TYPE_INT, context->bit_rate, NULL);
1406
1675
      break;
1407
1676
 
1408
 
    case CODEC_ID_ADPCM_G726:
 
1677
    case AV_CODEC_ID_ADPCM_G726:
1409
1678
    {
1410
1679
      /* the G726 decoder can also handle G721 */
1411
 
      caps = gst_ff_aud_caps_new (context, codec_id, encode, "audio/x-adpcm",
 
1680
      caps =
 
1681
          gst_ff_aud_caps_new (context, NULL, codec_id, encode, "audio/x-adpcm",
1412
1682
          "layout", G_TYPE_STRING, "g726", NULL);
1413
1683
      if (context)
1414
1684
        gst_caps_set_simple (caps,
1422
1692
      }
1423
1693
      break;
1424
1694
    }
1425
 
    case CODEC_ID_ADPCM_IMA_QT:
1426
 
    case CODEC_ID_ADPCM_IMA_WAV:
1427
 
    case CODEC_ID_ADPCM_IMA_DK3:
1428
 
    case CODEC_ID_ADPCM_IMA_DK4:
1429
 
    case CODEC_ID_ADPCM_IMA_WS:
1430
 
    case CODEC_ID_ADPCM_IMA_SMJPEG:
1431
 
    case CODEC_ID_ADPCM_IMA_AMV:
1432
 
    case CODEC_ID_ADPCM_IMA_ISS:
1433
 
    case CODEC_ID_ADPCM_IMA_EA_EACS:
1434
 
    case CODEC_ID_ADPCM_IMA_EA_SEAD:
1435
 
    case CODEC_ID_ADPCM_MS:
1436
 
    case CODEC_ID_ADPCM_4XM:
1437
 
    case CODEC_ID_ADPCM_XA:
1438
 
    case CODEC_ID_ADPCM_ADX:
1439
 
    case CODEC_ID_ADPCM_EA:
1440
 
    case CODEC_ID_ADPCM_CT:
1441
 
    case CODEC_ID_ADPCM_SWF:
1442
 
    case CODEC_ID_ADPCM_YAMAHA:
1443
 
    case CODEC_ID_ADPCM_SBPRO_2:
1444
 
    case CODEC_ID_ADPCM_SBPRO_3:
1445
 
    case CODEC_ID_ADPCM_SBPRO_4:
1446
 
    case CODEC_ID_ADPCM_EA_R1:
1447
 
    case CODEC_ID_ADPCM_EA_R2:
1448
 
    case CODEC_ID_ADPCM_EA_R3:
1449
 
    case CODEC_ID_ADPCM_EA_MAXIS_XA:
1450
 
    case CODEC_ID_ADPCM_EA_XAS:
1451
 
    case CODEC_ID_ADPCM_THP:
 
1695
    case AV_CODEC_ID_ADPCM_IMA_QT:
 
1696
    case AV_CODEC_ID_ADPCM_IMA_WAV:
 
1697
    case AV_CODEC_ID_ADPCM_IMA_DK3:
 
1698
    case AV_CODEC_ID_ADPCM_IMA_DK4:
 
1699
    case AV_CODEC_ID_ADPCM_IMA_WS:
 
1700
    case AV_CODEC_ID_ADPCM_IMA_SMJPEG:
 
1701
    case AV_CODEC_ID_ADPCM_IMA_AMV:
 
1702
    case AV_CODEC_ID_ADPCM_IMA_ISS:
 
1703
    case AV_CODEC_ID_ADPCM_IMA_EA_EACS:
 
1704
    case AV_CODEC_ID_ADPCM_IMA_EA_SEAD:
 
1705
    case AV_CODEC_ID_ADPCM_MS:
 
1706
    case AV_CODEC_ID_ADPCM_4XM:
 
1707
    case AV_CODEC_ID_ADPCM_XA:
 
1708
    case AV_CODEC_ID_ADPCM_ADX:
 
1709
    case AV_CODEC_ID_ADPCM_EA:
 
1710
    case AV_CODEC_ID_ADPCM_CT:
 
1711
    case AV_CODEC_ID_ADPCM_SWF:
 
1712
    case AV_CODEC_ID_ADPCM_YAMAHA:
 
1713
    case AV_CODEC_ID_ADPCM_SBPRO_2:
 
1714
    case AV_CODEC_ID_ADPCM_SBPRO_3:
 
1715
    case AV_CODEC_ID_ADPCM_SBPRO_4:
 
1716
    case AV_CODEC_ID_ADPCM_EA_R1:
 
1717
    case AV_CODEC_ID_ADPCM_EA_R2:
 
1718
    case AV_CODEC_ID_ADPCM_EA_R3:
 
1719
    case AV_CODEC_ID_ADPCM_EA_MAXIS_XA:
 
1720
    case AV_CODEC_ID_ADPCM_EA_XAS:
 
1721
    case AV_CODEC_ID_ADPCM_THP:
1452
1722
    {
1453
1723
      const gchar *layout = NULL;
1454
1724
 
1455
1725
      switch (codec_id) {
1456
 
        case CODEC_ID_ADPCM_IMA_QT:
 
1726
        case AV_CODEC_ID_ADPCM_IMA_QT:
1457
1727
          layout = "quicktime";
1458
1728
          break;
1459
 
        case CODEC_ID_ADPCM_IMA_WAV:
 
1729
        case AV_CODEC_ID_ADPCM_IMA_WAV:
1460
1730
          layout = "dvi";
1461
1731
          break;
1462
 
        case CODEC_ID_ADPCM_IMA_DK3:
 
1732
        case AV_CODEC_ID_ADPCM_IMA_DK3:
1463
1733
          layout = "dk3";
1464
1734
          break;
1465
 
        case CODEC_ID_ADPCM_IMA_DK4:
 
1735
        case AV_CODEC_ID_ADPCM_IMA_DK4:
1466
1736
          layout = "dk4";
1467
1737
          break;
1468
 
        case CODEC_ID_ADPCM_IMA_WS:
 
1738
        case AV_CODEC_ID_ADPCM_IMA_WS:
1469
1739
          layout = "westwood";
1470
1740
          break;
1471
 
        case CODEC_ID_ADPCM_IMA_SMJPEG:
 
1741
        case AV_CODEC_ID_ADPCM_IMA_SMJPEG:
1472
1742
          layout = "smjpeg";
1473
1743
          break;
1474
 
        case CODEC_ID_ADPCM_IMA_AMV:
 
1744
        case AV_CODEC_ID_ADPCM_IMA_AMV:
1475
1745
          layout = "amv";
1476
1746
          break;
1477
 
        case CODEC_ID_ADPCM_IMA_ISS:
 
1747
        case AV_CODEC_ID_ADPCM_IMA_ISS:
1478
1748
          layout = "iss";
1479
1749
          break;
1480
 
        case CODEC_ID_ADPCM_IMA_EA_EACS:
 
1750
        case AV_CODEC_ID_ADPCM_IMA_EA_EACS:
1481
1751
          layout = "ea-eacs";
1482
1752
          break;
1483
 
        case CODEC_ID_ADPCM_IMA_EA_SEAD:
 
1753
        case AV_CODEC_ID_ADPCM_IMA_EA_SEAD:
1484
1754
          layout = "ea-sead";
1485
1755
          break;
1486
 
        case CODEC_ID_ADPCM_MS:
 
1756
        case AV_CODEC_ID_ADPCM_MS:
1487
1757
          layout = "microsoft";
1488
1758
          break;
1489
 
        case CODEC_ID_ADPCM_4XM:
 
1759
        case AV_CODEC_ID_ADPCM_4XM:
1490
1760
          layout = "4xm";
1491
1761
          break;
1492
 
        case CODEC_ID_ADPCM_XA:
 
1762
        case AV_CODEC_ID_ADPCM_XA:
1493
1763
          layout = "xa";
1494
1764
          break;
1495
 
        case CODEC_ID_ADPCM_ADX:
 
1765
        case AV_CODEC_ID_ADPCM_ADX:
1496
1766
          layout = "adx";
1497
1767
          break;
1498
 
        case CODEC_ID_ADPCM_EA:
 
1768
        case AV_CODEC_ID_ADPCM_EA:
1499
1769
          layout = "ea";
1500
1770
          break;
1501
 
        case CODEC_ID_ADPCM_CT:
 
1771
        case AV_CODEC_ID_ADPCM_CT:
1502
1772
          layout = "ct";
1503
1773
          break;
1504
 
        case CODEC_ID_ADPCM_SWF:
 
1774
        case AV_CODEC_ID_ADPCM_SWF:
1505
1775
          layout = "swf";
1506
1776
          break;
1507
 
        case CODEC_ID_ADPCM_YAMAHA:
 
1777
        case AV_CODEC_ID_ADPCM_YAMAHA:
1508
1778
          layout = "yamaha";
1509
1779
          break;
1510
 
        case CODEC_ID_ADPCM_SBPRO_2:
 
1780
        case AV_CODEC_ID_ADPCM_SBPRO_2:
1511
1781
          layout = "sbpro2";
1512
1782
          break;
1513
 
        case CODEC_ID_ADPCM_SBPRO_3:
 
1783
        case AV_CODEC_ID_ADPCM_SBPRO_3:
1514
1784
          layout = "sbpro3";
1515
1785
          break;
1516
 
        case CODEC_ID_ADPCM_SBPRO_4:
 
1786
        case AV_CODEC_ID_ADPCM_SBPRO_4:
1517
1787
          layout = "sbpro4";
1518
1788
          break;
1519
 
        case CODEC_ID_ADPCM_EA_R1:
 
1789
        case AV_CODEC_ID_ADPCM_EA_R1:
1520
1790
          layout = "ea-r1";
1521
1791
          break;
1522
 
        case CODEC_ID_ADPCM_EA_R2:
1523
 
          layout = "ea-r3";
1524
 
          break;
1525
 
        case CODEC_ID_ADPCM_EA_R3:
1526
 
          layout = "ea-r3";
1527
 
          break;
1528
 
        case CODEC_ID_ADPCM_EA_MAXIS_XA:
 
1792
        case AV_CODEC_ID_ADPCM_EA_R2:
 
1793
          layout = "ea-r3";
 
1794
          break;
 
1795
        case AV_CODEC_ID_ADPCM_EA_R3:
 
1796
          layout = "ea-r3";
 
1797
          break;
 
1798
        case AV_CODEC_ID_ADPCM_EA_MAXIS_XA:
1529
1799
          layout = "ea-maxis-xa";
1530
1800
          break;
1531
 
        case CODEC_ID_ADPCM_EA_XAS:
 
1801
        case AV_CODEC_ID_ADPCM_EA_XAS:
1532
1802
          layout = "ea-xas";
1533
1803
          break;
1534
 
        case CODEC_ID_ADPCM_THP:
 
1804
        case AV_CODEC_ID_ADPCM_THP:
1535
1805
          layout = "thp";
1536
1806
          break;
1537
1807
        default:
1541
1811
 
1542
1812
      /* FIXME: someone please check whether we need additional properties
1543
1813
       * in this caps definition. */
1544
 
      caps = gst_ff_aud_caps_new (context, codec_id, encode, "audio/x-adpcm",
 
1814
      caps =
 
1815
          gst_ff_aud_caps_new (context, NULL, codec_id, encode, "audio/x-adpcm",
1545
1816
          "layout", G_TYPE_STRING, layout, NULL);
1546
1817
      if (context)
1547
1818
        gst_caps_set_simple (caps,
1550
1821
    }
1551
1822
      break;
1552
1823
 
1553
 
    case CODEC_ID_AMR_NB:
1554
 
      caps = gst_ff_aud_caps_new (context, codec_id, encode, "audio/AMR", NULL);
1555
 
      break;
1556
 
 
1557
 
    case CODEC_ID_AMR_WB:
1558
 
      caps =
1559
 
          gst_ff_aud_caps_new (context, codec_id, encode, "audio/AMR-WB", NULL);
1560
 
      break;
1561
 
 
1562
 
    case CODEC_ID_GSM:
1563
 
      caps =
1564
 
          gst_ff_aud_caps_new (context, codec_id, encode, "audio/x-gsm", NULL);
1565
 
      break;
1566
 
 
1567
 
    case CODEC_ID_GSM_MS:
1568
 
      caps =
1569
 
          gst_ff_aud_caps_new (context, codec_id, encode, "audio/ms-gsm", NULL);
1570
 
      break;
1571
 
 
1572
 
    case CODEC_ID_NELLYMOSER:
1573
 
      caps =
1574
 
          gst_ff_aud_caps_new (context, codec_id, encode, "audio/x-nellymoser",
1575
 
          NULL);
1576
 
      break;
1577
 
 
1578
 
    case CODEC_ID_SIPR:
 
1824
    case AV_CODEC_ID_AMR_NB:
 
1825
      caps =
 
1826
          gst_ff_aud_caps_new (context, NULL, codec_id, encode, "audio/AMR",
 
1827
          NULL);
 
1828
      break;
 
1829
 
 
1830
    case AV_CODEC_ID_AMR_WB:
 
1831
      caps =
 
1832
          gst_ff_aud_caps_new (context, NULL, codec_id, encode, "audio/AMR-WB",
 
1833
          NULL);
 
1834
      break;
 
1835
 
 
1836
    case AV_CODEC_ID_GSM:
 
1837
      caps =
 
1838
          gst_ff_aud_caps_new (context, NULL, codec_id, encode, "audio/x-gsm",
 
1839
          NULL);
 
1840
      break;
 
1841
 
 
1842
    case AV_CODEC_ID_GSM_MS:
 
1843
      caps =
 
1844
          gst_ff_aud_caps_new (context, NULL, codec_id, encode, "audio/ms-gsm",
 
1845
          NULL);
 
1846
      break;
 
1847
 
 
1848
    case AV_CODEC_ID_NELLYMOSER:
 
1849
      caps =
 
1850
          gst_ff_aud_caps_new (context, NULL, codec_id, encode,
 
1851
          "audio/x-nellymoser", NULL);
 
1852
      break;
 
1853
 
 
1854
    case AV_CODEC_ID_SIPR:
1579
1855
    {
1580
1856
      caps =
1581
 
          gst_ff_aud_caps_new (context, codec_id, encode, "audio/x-sipro",
 
1857
          gst_ff_aud_caps_new (context, NULL, codec_id, encode, "audio/x-sipro",
1582
1858
          NULL);
1583
1859
      if (context) {
1584
1860
        gst_caps_set_simple (caps,
1588
1864
    }
1589
1865
      break;
1590
1866
 
1591
 
    case CODEC_ID_RA_144:
1592
 
    case CODEC_ID_RA_288:
1593
 
    case CODEC_ID_COOK:
 
1867
    case AV_CODEC_ID_RA_144:
 
1868
    case AV_CODEC_ID_RA_288:
 
1869
    case AV_CODEC_ID_COOK:
1594
1870
    {
1595
1871
      gint version = 0;
1596
1872
 
1597
1873
      switch (codec_id) {
1598
 
        case CODEC_ID_RA_144:
 
1874
        case AV_CODEC_ID_RA_144:
1599
1875
          version = 1;
1600
1876
          break;
1601
 
        case CODEC_ID_RA_288:
 
1877
        case AV_CODEC_ID_RA_288:
1602
1878
          version = 2;
1603
1879
          break;
1604
 
        case CODEC_ID_COOK:
 
1880
        case AV_CODEC_ID_COOK:
1605
1881
          version = 8;
1606
1882
          break;
1607
1883
        default:
1610
1886
 
1611
1887
      /* FIXME: properties? */
1612
1888
      caps =
1613
 
          gst_ff_aud_caps_new (context, codec_id, encode,
 
1889
          gst_ff_aud_caps_new (context, NULL, codec_id, encode,
1614
1890
          "audio/x-pn-realaudio", "raversion", G_TYPE_INT, version, NULL);
1615
1891
      if (context) {
1616
1892
        gst_caps_set_simple (caps,
1620
1896
    }
1621
1897
      break;
1622
1898
 
1623
 
    case CODEC_ID_ROQ_DPCM:
1624
 
    case CODEC_ID_INTERPLAY_DPCM:
1625
 
    case CODEC_ID_XAN_DPCM:
1626
 
    case CODEC_ID_SOL_DPCM:
 
1899
    case AV_CODEC_ID_ROQ_DPCM:
 
1900
    case AV_CODEC_ID_INTERPLAY_DPCM:
 
1901
    case AV_CODEC_ID_XAN_DPCM:
 
1902
    case AV_CODEC_ID_SOL_DPCM:
1627
1903
    {
1628
1904
      const gchar *layout = NULL;
1629
1905
 
1630
1906
      switch (codec_id) {
1631
 
        case CODEC_ID_ROQ_DPCM:
 
1907
        case AV_CODEC_ID_ROQ_DPCM:
1632
1908
          layout = "roq";
1633
1909
          break;
1634
 
        case CODEC_ID_INTERPLAY_DPCM:
 
1910
        case AV_CODEC_ID_INTERPLAY_DPCM:
1635
1911
          layout = "interplay";
1636
1912
          break;
1637
 
        case CODEC_ID_XAN_DPCM:
 
1913
        case AV_CODEC_ID_XAN_DPCM:
1638
1914
          layout = "xan";
1639
1915
          break;
1640
 
        case CODEC_ID_SOL_DPCM:
 
1916
        case AV_CODEC_ID_SOL_DPCM:
1641
1917
          layout = "sol";
1642
1918
          break;
1643
1919
        default:
1647
1923
 
1648
1924
      /* FIXME: someone please check whether we need additional properties
1649
1925
       * in this caps definition. */
1650
 
      caps = gst_ff_aud_caps_new (context, codec_id, encode, "audio/x-dpcm",
 
1926
      caps =
 
1927
          gst_ff_aud_caps_new (context, NULL, codec_id, encode, "audio/x-dpcm",
1651
1928
          "layout", G_TYPE_STRING, layout, NULL);
1652
1929
      if (context)
1653
1930
        gst_caps_set_simple (caps,
1656
1933
    }
1657
1934
      break;
1658
1935
 
1659
 
    case CODEC_ID_SHORTEN:
 
1936
    case AV_CODEC_ID_SHORTEN:
1660
1937
      caps = gst_caps_new_empty_simple ("audio/x-shorten");
1661
1938
      break;
1662
1939
 
1663
 
    case CODEC_ID_ALAC:
 
1940
    case AV_CODEC_ID_ALAC:
1664
1941
      caps =
1665
 
          gst_ff_aud_caps_new (context, codec_id, encode, "audio/x-alac", NULL);
 
1942
          gst_ff_aud_caps_new (context, NULL, codec_id, encode, "audio/x-alac",
 
1943
          NULL);
1666
1944
      if (context) {
1667
1945
        gst_caps_set_simple (caps,
1668
1946
            "samplesize", G_TYPE_INT, context->bits_per_coded_sample, NULL);
1669
1947
      }
1670
1948
      break;
1671
1949
 
1672
 
    case CODEC_ID_FLAC:
 
1950
    case AV_CODEC_ID_FLAC:
1673
1951
      /* Note that ffmpeg has no encoder yet, but just for safety. In the
1674
1952
       * encoder case, we want to add things like samplerate, channels... */
1675
1953
      if (!encode) {
1677
1955
      }
1678
1956
      break;
1679
1957
 
1680
 
    case CODEC_ID_DVD_SUBTITLE:
1681
 
    case CODEC_ID_DVB_SUBTITLE:
 
1958
    case AV_CODEC_ID_S302M:
 
1959
      caps = gst_caps_new_empty_simple ("audio/x-smpte-302m");
 
1960
      break;
 
1961
 
 
1962
    case AV_CODEC_ID_DVD_SUBTITLE:
 
1963
    case AV_CODEC_ID_DVB_SUBTITLE:
1682
1964
      caps = NULL;
1683
1965
      break;
1684
 
    case CODEC_ID_BMP:
 
1966
    case AV_CODEC_ID_BMP:
1685
1967
      caps = gst_caps_new_empty_simple ("image/bmp");
1686
1968
      break;
1687
 
    case CODEC_ID_TTA:
 
1969
    case AV_CODEC_ID_TTA:
1688
1970
      caps =
1689
 
          gst_ff_aud_caps_new (context, codec_id, encode, "audio/x-tta", NULL);
 
1971
          gst_ff_aud_caps_new (context, NULL, codec_id, encode, "audio/x-tta",
 
1972
          NULL);
1690
1973
      if (context) {
1691
1974
        gst_caps_set_simple (caps,
1692
1975
            "samplesize", G_TYPE_INT, context->bits_per_coded_sample, NULL);
1693
1976
      }
1694
1977
      break;
1695
 
    case CODEC_ID_TWINVQ:
 
1978
    case AV_CODEC_ID_TWINVQ:
1696
1979
      caps =
1697
 
          gst_ff_aud_caps_new (context, codec_id, encode, "audio/x-twin-vq",
1698
 
          NULL);
 
1980
          gst_ff_aud_caps_new (context, NULL, codec_id, encode,
 
1981
          "audio/x-twin-vq", NULL);
1699
1982
      break;
1700
1983
    default:
1701
1984
      GST_DEBUG ("Unknown codec ID %d, please add mapping here", codec_id);
1714
1997
      switch (codec->type) {
1715
1998
        case AVMEDIA_TYPE_VIDEO:
1716
1999
          mime = g_strdup_printf ("video/x-gst-av-%s", codec->name);
1717
 
          caps = gst_ff_vid_caps_new (context, codec_id, encode, mime, NULL);
 
2000
          caps =
 
2001
              gst_ff_vid_caps_new (context, NULL, codec_id, encode, mime, NULL);
1718
2002
          g_free (mime);
1719
2003
          break;
1720
2004
        case AVMEDIA_TYPE_AUDIO:
1721
2005
          mime = g_strdup_printf ("audio/x-gst-av-%s", codec->name);
1722
 
          caps = gst_ff_aud_caps_new (context, codec_id, encode, mime, NULL);
 
2006
          caps =
 
2007
              gst_ff_aud_caps_new (context, NULL, codec_id, encode, mime, NULL);
1723
2008
          if (context)
1724
2009
            gst_caps_set_simple (caps,
1725
2010
                "block_align", G_TYPE_INT, context->block_align,
1743
2028
      gst_buffer_unref (data);
1744
2029
    }
1745
2030
 
1746
 
    /* palette */
1747
 
    if (context) {
1748
 
      gst_ffmpeg_set_palette (caps, context);
1749
 
    }
1750
 
 
1751
2031
    GST_LOG ("caps for codec_id=%d: %" GST_PTR_FORMAT, codec_id, caps);
1752
2032
 
1753
2033
  } else {
1764
2044
 * See below for usefullness
1765
2045
 */
1766
2046
 
1767
 
GstCaps *
 
2047
static GstCaps *
1768
2048
gst_ffmpeg_pixfmt_to_caps (enum PixelFormat pix_fmt, AVCodecContext * context,
1769
2049
    enum CodecID codec_id)
1770
2050
{
1774
2054
  format = gst_ffmpeg_pixfmt_to_videoformat (pix_fmt);
1775
2055
 
1776
2056
  if (format != GST_VIDEO_FORMAT_UNKNOWN) {
1777
 
    caps = gst_ff_vid_caps_new (context, codec_id, TRUE, "video/x-raw",
 
2057
    caps = gst_ff_vid_caps_new (context, NULL, codec_id, TRUE, "video/x-raw",
1778
2058
        "format", G_TYPE_STRING, gst_video_format_to_string (format), NULL);
1779
2059
  }
1780
2060
 
1787
2067
  return caps;
1788
2068
}
1789
2069
 
1790
 
/* Convert a FFMPEG Sample Format and optional AVCodecContext
1791
 
 * to a GstCaps. If the context is ommitted, no fixed values
1792
 
 * for video/audio size will be included in the GstCaps
1793
 
 *
1794
 
 * See below for usefullness
1795
 
 */
1796
 
 
1797
 
static GstCaps *
1798
 
gst_ffmpeg_smpfmt_to_caps (enum AVSampleFormat sample_fmt,
1799
 
    AVCodecContext * context, enum CodecID codec_id)
 
2070
GstAudioFormat
 
2071
gst_ffmpeg_smpfmt_to_audioformat (enum AVSampleFormat sample_fmt)
1800
2072
{
1801
 
  GstCaps *caps = NULL;
1802
 
  GstAudioFormat format;
1803
 
 
1804
2073
  switch (sample_fmt) {
 
2074
    case AV_SAMPLE_FMT_U8:
 
2075
    case AV_SAMPLE_FMT_U8P:
 
2076
      return GST_AUDIO_FORMAT_U8;
 
2077
      break;
1805
2078
    case AV_SAMPLE_FMT_S16:
1806
 
      format = GST_AUDIO_FORMAT_S16;
 
2079
    case AV_SAMPLE_FMT_S16P:
 
2080
      return GST_AUDIO_FORMAT_S16;
1807
2081
      break;
1808
2082
    case AV_SAMPLE_FMT_S32:
1809
 
      format = GST_AUDIO_FORMAT_S32;
 
2083
    case AV_SAMPLE_FMT_S32P:
 
2084
      return GST_AUDIO_FORMAT_S32;
1810
2085
      break;
1811
2086
    case AV_SAMPLE_FMT_FLT:
1812
 
      format = GST_AUDIO_FORMAT_F32;
 
2087
    case AV_SAMPLE_FMT_FLTP:
 
2088
      return GST_AUDIO_FORMAT_F32;
1813
2089
      break;
1814
2090
    case AV_SAMPLE_FMT_DBL:
1815
 
      format = GST_AUDIO_FORMAT_F64;
 
2091
    case AV_SAMPLE_FMT_DBLP:
 
2092
      return GST_AUDIO_FORMAT_F64;
1816
2093
      break;
1817
2094
    default:
1818
2095
      /* .. */
1819
 
      format = GST_AUDIO_FORMAT_UNKNOWN;
 
2096
      return GST_AUDIO_FORMAT_UNKNOWN;
1820
2097
      break;
1821
2098
  }
 
2099
}
 
2100
 
 
2101
/* Convert a FFMPEG Sample Format and optional AVCodecContext
 
2102
 * to a GstCaps. If the context is ommitted, no fixed values
 
2103
 * for video/audio size will be included in the GstCaps
 
2104
 *
 
2105
 * See below for usefullness
 
2106
 */
 
2107
 
 
2108
static GstCaps *
 
2109
gst_ffmpeg_smpfmt_to_caps (enum AVSampleFormat sample_fmt,
 
2110
    AVCodecContext * context, AVCodec * codec, enum CodecID codec_id)
 
2111
{
 
2112
  GstCaps *caps = NULL;
 
2113
  GstAudioFormat format;
 
2114
 
 
2115
  format = gst_ffmpeg_smpfmt_to_audioformat (sample_fmt);
1822
2116
 
1823
2117
  if (format != GST_AUDIO_FORMAT_UNKNOWN) {
1824
 
    caps = gst_ff_aud_caps_new (context, codec_id, TRUE, "audio/x-raw",
 
2118
    caps = gst_ff_aud_caps_new (context, codec, codec_id, TRUE, "audio/x-raw",
1825
2119
        "format", G_TYPE_STRING, gst_audio_format_to_string (format),
1826
2120
        "layout", G_TYPE_STRING, "interleaved", NULL);
1827
2121
    GST_LOG ("caps for sample_fmt=%d: %" GST_PTR_FORMAT, sample_fmt, caps);
1832
2126
  return caps;
1833
2127
}
1834
2128
 
 
2129
static gboolean
 
2130
caps_has_field (GstCaps * caps, const gchar * field)
 
2131
{
 
2132
  guint i, n;
 
2133
 
 
2134
  n = gst_caps_get_size (caps);
 
2135
  for (i = 0; i < n; i++) {
 
2136
    GstStructure *s = gst_caps_get_structure (caps, i);
 
2137
 
 
2138
    if (gst_structure_has_field (s, field))
 
2139
      return TRUE;
 
2140
  }
 
2141
 
 
2142
  return FALSE;
 
2143
}
 
2144
 
1835
2145
GstCaps *
1836
2146
gst_ffmpeg_codectype_to_audio_caps (AVCodecContext * context,
1837
2147
    enum CodecID codec_id, gboolean encode, AVCodec * codec)
1846
2156
 
1847
2157
  if (context) {
1848
2158
    /* Specific codec context */
1849
 
    caps = gst_ffmpeg_smpfmt_to_caps (context->sample_fmt, context, codec_id);
1850
 
  } else if (codec && codec->sample_fmts) {
1851
 
    GstCaps *temp;
1852
 
    int i;
1853
 
 
1854
 
    caps = gst_caps_new_empty ();
1855
 
    for (i = 0; codec->sample_fmts[i] != -1; i++) {
1856
 
      temp =
1857
 
          gst_ffmpeg_smpfmt_to_caps (codec->sample_fmts[i], context, codec_id);
1858
 
      if (temp != NULL)
1859
 
        gst_caps_append (caps, temp);
1860
 
    }
 
2159
    caps =
 
2160
        gst_ffmpeg_smpfmt_to_caps (context->sample_fmt, context, codec,
 
2161
        codec_id);
1861
2162
  } else {
1862
 
    GstCaps *temp;
1863
 
    enum AVSampleFormat i;
1864
 
    AVCodecContext ctx = { 0, };
1865
 
 
1866
 
    ctx.channels = -1;
1867
 
    caps = gst_caps_new_empty ();
1868
 
    for (i = 0; i <= AV_SAMPLE_FMT_DBL; i++) {
1869
 
      temp = gst_ffmpeg_smpfmt_to_caps (i, encode ? &ctx : NULL, codec_id);
1870
 
      if (temp != NULL) {
1871
 
        gst_caps_append (caps, temp);
1872
 
      }
1873
 
    }
 
2163
    caps = gst_ff_aud_caps_new (context, codec, codec_id, encode, "audio/x-raw",
 
2164
        "layout", G_TYPE_STRING, "interleaved", NULL);
 
2165
    if (!caps_has_field (caps, "format"))
 
2166
      gst_ffmpeg_audio_set_sample_fmts (caps,
 
2167
          codec ? codec->sample_fmts : NULL);
1874
2168
  }
 
2169
 
1875
2170
  return caps;
1876
2171
}
1877
2172
 
1887
2182
  if (context) {
1888
2183
    caps = gst_ffmpeg_pixfmt_to_caps (context->pix_fmt, context, codec_id);
1889
2184
  } else {
1890
 
    GstCaps *temp;
1891
 
    enum PixelFormat i;
1892
 
    AVCodecContext ctx = { 0, };
1893
 
 
1894
 
    caps = gst_caps_new_empty ();
1895
 
    for (i = 0; i < PIX_FMT_NB; i++) {
1896
 
      ctx.width = -1;
1897
 
      ctx.pix_fmt = i;
1898
 
      temp = gst_ffmpeg_pixfmt_to_caps (i, encode ? &ctx : NULL, codec_id);
1899
 
      if (temp != NULL) {
1900
 
        gst_caps_append (caps, temp);
1901
 
      }
1902
 
    }
1903
 
  }
1904
 
  return caps;
1905
 
}
1906
 
 
1907
 
/* Convert a FFMPEG codec Type and optional AVCodecContext
1908
 
 * to a GstCaps. If the context is ommitted, no fixed values
1909
 
 * for video/audio size will be included in the GstCaps
1910
 
 *
1911
 
 * AVMediaType is primarily meant for uncompressed data GstCaps!
1912
 
 */
1913
 
 
1914
 
GstCaps *
1915
 
gst_ffmpeg_codectype_to_caps (enum AVMediaType codec_type,
1916
 
    AVCodecContext * context, enum CodecID codec_id, gboolean encode)
1917
 
{
1918
 
  GstCaps *caps;
1919
 
 
1920
 
  switch (codec_type) {
1921
 
    case AVMEDIA_TYPE_VIDEO:
1922
 
      caps =
1923
 
          gst_ffmpeg_codectype_to_video_caps (context, codec_id, encode, NULL);
1924
 
      break;
1925
 
    case AVMEDIA_TYPE_AUDIO:
1926
 
      caps =
1927
 
          gst_ffmpeg_codectype_to_audio_caps (context, codec_id, encode, NULL);
1928
 
      break;
1929
 
    default:
1930
 
      caps = NULL;
1931
 
      break;
1932
 
  }
1933
 
 
 
2185
    caps =
 
2186
        gst_ff_vid_caps_new (context, codec, codec_id, encode, "video/x-raw",
 
2187
        NULL);
 
2188
    if (!caps_has_field (caps, "format"))
 
2189
      gst_ffmpeg_video_set_pix_fmts (caps, codec ? codec->pix_fmts : NULL);
 
2190
  }
1934
2191
  return caps;
1935
2192
}
1936
2193
 
2033
2290
        context->sample_aspect_ratio.num);
2034
2291
  }
2035
2292
 
2036
 
  gst_ffmpeg_get_palette (caps, context);
2037
 
 
2038
2293
  if (!raw)
2039
2294
    return;
2040
2295
 
2182
2437
  {GST_VIDEO_FORMAT_I420_10BE, PIX_FMT_YUV420P10BE},
2183
2438
  {GST_VIDEO_FORMAT_I422_10LE, PIX_FMT_YUV422P10LE},
2184
2439
  {GST_VIDEO_FORMAT_I422_10BE, PIX_FMT_YUV422P10BE},
 
2440
  {GST_VIDEO_FORMAT_Y444_10LE, PIX_FMT_YUV444P10LE},
 
2441
  {GST_VIDEO_FORMAT_Y444_10BE, PIX_FMT_YUV444P10BE},
 
2442
  {GST_VIDEO_FORMAT_GBR, PIX_FMT_GBRP},
 
2443
  {GST_VIDEO_FORMAT_GBR_10LE, PIX_FMT_GBRP10LE},
 
2444
  {GST_VIDEO_FORMAT_GBR_10BE, PIX_FMT_GBRP10BE},
2185
2445
};
2186
2446
 
2187
2447
GstVideoFormat
2193
2453
    if (pixtofmttable[i].pixfmt == pixfmt)
2194
2454
      return pixtofmttable[i].format;
2195
2455
 
2196
 
  GST_WARNING ("Unknown pixel format %d", pixfmt);
 
2456
  GST_DEBUG ("Unknown pixel format %d", pixfmt);
2197
2457
  return GST_VIDEO_FORMAT_UNKNOWN;
2198
2458
}
2199
2459
 
2230
2490
      gst_ffmpeg_videoformat_to_pixfmt (GST_VIDEO_INFO_FORMAT (info));
2231
2491
}
2232
2492
 
 
2493
void
 
2494
gst_ffmpeg_audioinfo_to_context (GstAudioInfo * info, AVCodecContext * context)
 
2495
{
 
2496
  const AVCodec *codec;
 
2497
  const enum AVSampleFormat *smpl_fmts;
 
2498
  enum AVSampleFormat smpl_fmt = -1;
 
2499
 
 
2500
  context->channels = info->channels;
 
2501
  context->sample_rate = info->rate;
 
2502
  context->channel_layout =
 
2503
      gst_ffmpeg_channel_positions_to_layout (info->position, info->channels);
 
2504
 
 
2505
  codec = context->codec;
 
2506
 
 
2507
  smpl_fmts = codec->sample_fmts;
 
2508
 
 
2509
  switch (info->finfo->format) {
 
2510
    case GST_AUDIO_FORMAT_F32:
 
2511
      if (smpl_fmts) {
 
2512
        while (*smpl_fmts != -1) {
 
2513
          if (*smpl_fmts == AV_SAMPLE_FMT_FLT) {
 
2514
            smpl_fmt = *smpl_fmts;
 
2515
            break;
 
2516
          } else if (*smpl_fmts == AV_SAMPLE_FMT_FLTP) {
 
2517
            smpl_fmt = *smpl_fmts;
 
2518
          }
 
2519
 
 
2520
          smpl_fmts++;
 
2521
        }
 
2522
      } else {
 
2523
        smpl_fmt = AV_SAMPLE_FMT_FLT;
 
2524
      }
 
2525
      break;
 
2526
    case GST_AUDIO_FORMAT_F64:
 
2527
      if (smpl_fmts) {
 
2528
        while (*smpl_fmts != -1) {
 
2529
          if (*smpl_fmts == AV_SAMPLE_FMT_DBL) {
 
2530
            smpl_fmt = *smpl_fmts;
 
2531
            break;
 
2532
          } else if (*smpl_fmts == AV_SAMPLE_FMT_DBLP) {
 
2533
            smpl_fmt = *smpl_fmts;
 
2534
          }
 
2535
 
 
2536
          smpl_fmts++;
 
2537
        }
 
2538
      } else {
 
2539
        smpl_fmt = AV_SAMPLE_FMT_DBL;
 
2540
      }
 
2541
      break;
 
2542
    case GST_AUDIO_FORMAT_S32:
 
2543
      if (smpl_fmts) {
 
2544
        while (*smpl_fmts != -1) {
 
2545
          if (*smpl_fmts == AV_SAMPLE_FMT_S32) {
 
2546
            smpl_fmt = *smpl_fmts;
 
2547
            break;
 
2548
          } else if (*smpl_fmts == AV_SAMPLE_FMT_S32P) {
 
2549
            smpl_fmt = *smpl_fmts;
 
2550
          }
 
2551
 
 
2552
          smpl_fmts++;
 
2553
        }
 
2554
      } else {
 
2555
        smpl_fmt = AV_SAMPLE_FMT_S32;
 
2556
      }
 
2557
      break;
 
2558
    case GST_AUDIO_FORMAT_S16:
 
2559
      if (smpl_fmts) {
 
2560
        while (*smpl_fmts != -1) {
 
2561
          if (*smpl_fmts == AV_SAMPLE_FMT_S16) {
 
2562
            smpl_fmt = *smpl_fmts;
 
2563
            break;
 
2564
          } else if (*smpl_fmts == AV_SAMPLE_FMT_S16P) {
 
2565
            smpl_fmt = *smpl_fmts;
 
2566
          }
 
2567
 
 
2568
          smpl_fmts++;
 
2569
        }
 
2570
      } else {
 
2571
        smpl_fmt = AV_SAMPLE_FMT_S16;
 
2572
      }
 
2573
      break;
 
2574
    case GST_AUDIO_FORMAT_U8:
 
2575
      if (smpl_fmts) {
 
2576
        while (*smpl_fmts != -1) {
 
2577
          if (*smpl_fmts == AV_SAMPLE_FMT_U8) {
 
2578
            smpl_fmt = *smpl_fmts;
 
2579
            break;
 
2580
          } else if (*smpl_fmts == AV_SAMPLE_FMT_U8P) {
 
2581
            smpl_fmt = *smpl_fmts;
 
2582
          }
 
2583
 
 
2584
          smpl_fmts++;
 
2585
        }
 
2586
      } else {
 
2587
        smpl_fmt = AV_SAMPLE_FMT_U8;
 
2588
      }
 
2589
      break;
 
2590
    default:
 
2591
      break;
 
2592
  }
 
2593
 
 
2594
  g_assert (smpl_fmt != -1);
 
2595
 
 
2596
  context->sample_fmt = smpl_fmt;
 
2597
}
 
2598
 
2233
2599
/* Convert a GstCaps and a FFMPEG codec Type to a
2234
2600
 * AVCodecContext. If the context is ommitted, no fixed values
2235
2601
 * for video/audio size will be included in the context
2382
2748
      av_free (context->extradata);
2383
2749
 
2384
2750
#if 0
2385
 
    if (codec_id == CODEC_ID_H264) {
 
2751
    if (codec_id == AV_CODEC_ID_H264) {
2386
2752
      guint extrasize;
2387
2753
 
2388
2754
      GST_DEBUG ("copy, escaping codec_data %d", size);
2412
2778
    }
2413
2779
 
2414
2780
    /* Hack for VC1. Sometimes the first (length) byte is 0 for some files */
2415
 
    if (codec_id == CODEC_ID_VC1 && map.size > 0 && map.data[0] == 0) {
 
2781
    if (codec_id == AV_CODEC_ID_VC1 && map.size > 0 && map.data[0] == 0) {
2416
2782
      context->extradata[0] = (guint8) map.size;
2417
2783
    }
2418
2784
 
2419
2785
    GST_DEBUG ("have codec data of size %" G_GSIZE_FORMAT, map.size);
2420
2786
 
2421
2787
    gst_buffer_unmap (buf, &map);
2422
 
  } else if (context->extradata == NULL && codec_id != CODEC_ID_AAC_LATM &&
2423
 
      codec_id != CODEC_ID_FLAC) {
 
2788
  } else if (context->extradata == NULL && codec_id != AV_CODEC_ID_AAC_LATM &&
 
2789
      codec_id != AV_CODEC_ID_FLAC) {
2424
2790
    /* no extradata, alloc dummy with 0 sized, some codecs insist on reading
2425
2791
     * extradata anyway which makes then segfault. */
2426
2792
    context->extradata =
2430
2796
  }
2431
2797
 
2432
2798
  switch (codec_id) {
2433
 
    case CODEC_ID_MPEG4:
 
2799
    case AV_CODEC_ID_MPEG4:
2434
2800
    {
2435
2801
      const gchar *mime = gst_structure_get_name (str);
2436
2802
 
2445
2811
    }
2446
2812
      break;
2447
2813
 
2448
 
    case CODEC_ID_SVQ3:
 
2814
    case AV_CODEC_ID_SVQ3:
2449
2815
      /* FIXME: this is a workaround for older gst-plugins releases
2450
2816
       * (<= 0.8.9). This should be removed at some point, because
2451
2817
       * it causes wrong decoded frame order. */
2478
2844
      }
2479
2845
      break;
2480
2846
 
2481
 
    case CODEC_ID_MSRLE:
2482
 
    case CODEC_ID_QTRLE:
2483
 
    case CODEC_ID_TSCC:
2484
 
    case CODEC_ID_CSCD:
2485
 
    case CODEC_ID_APE:
 
2847
    case AV_CODEC_ID_MSRLE:
 
2848
    case AV_CODEC_ID_QTRLE:
 
2849
    case AV_CODEC_ID_TSCC:
 
2850
    case AV_CODEC_ID_CSCD:
 
2851
    case AV_CODEC_ID_APE:
2486
2852
    {
2487
2853
      gint depth;
2488
2854
 
2495
2861
    }
2496
2862
      break;
2497
2863
 
2498
 
    case CODEC_ID_RV10:
2499
 
    case CODEC_ID_RV20:
2500
 
    case CODEC_ID_RV30:
2501
 
    case CODEC_ID_RV40:
 
2864
    case AV_CODEC_ID_RV10:
 
2865
    case AV_CODEC_ID_RV20:
 
2866
    case AV_CODEC_ID_RV30:
 
2867
    case AV_CODEC_ID_RV40:
2502
2868
    {
2503
2869
      gint format;
2504
2870
 
2507
2873
 
2508
2874
      break;
2509
2875
    }
2510
 
    case CODEC_ID_COOK:
2511
 
    case CODEC_ID_RA_288:
2512
 
    case CODEC_ID_RA_144:
2513
 
    case CODEC_ID_SIPR:
 
2876
    case AV_CODEC_ID_COOK:
 
2877
    case AV_CODEC_ID_RA_288:
 
2878
    case AV_CODEC_ID_RA_144:
 
2879
    case AV_CODEC_ID_SIPR:
2514
2880
    {
2515
2881
      gint leaf_size;
2516
2882
      gint bitrate;
2520
2886
      if (gst_structure_get_int (str, "bitrate", &bitrate))
2521
2887
        context->bit_rate = bitrate;
2522
2888
    }
2523
 
    case CODEC_ID_ALAC:
 
2889
    case AV_CODEC_ID_ALAC:
2524
2890
      gst_structure_get_int (str, "samplesize",
2525
2891
          &context->bits_per_coded_sample);
2526
2892
      break;
2527
2893
 
2528
 
    case CODEC_ID_DVVIDEO:
 
2894
    case AV_CODEC_ID_DVVIDEO:
2529
2895
    {
2530
2896
      const gchar *format;
2531
2897
 
2551
2917
        GST_WARNING ("No specified format");
2552
2918
      break;
2553
2919
    }
2554
 
    case CODEC_ID_H263P:
 
2920
    case AV_CODEC_ID_H263P:
2555
2921
    {
2556
2922
      gboolean val;
2557
2923
 
2570
2936
        context->flags &= ~CODEC_FLAG_LOOP_FILTER;
2571
2937
      break;
2572
2938
    }
2573
 
    case CODEC_ID_ADPCM_G726:
 
2939
    case AV_CODEC_ID_ADPCM_G726:
2574
2940
    {
2575
2941
      const gchar *layout;
2576
2942
 
2593
2959
  /* common properties (width, height, fps) */
2594
2960
  switch (codec_type) {
2595
2961
    case AVMEDIA_TYPE_VIDEO:
2596
 
      gst_ffmpeg_caps_to_pixfmt (caps, context, codec_id == CODEC_ID_RAWVIDEO);
 
2962
      gst_ffmpeg_caps_to_pixfmt (caps, context,
 
2963
          codec_id == AV_CODEC_ID_RAWVIDEO);
2597
2964
      break;
2598
2965
    case AVMEDIA_TYPE_AUDIO:
2599
2966
      gst_ffmpeg_caps_to_smpfmt (caps, context, FALSE);
2604
2971
 
2605
2972
  /* fixup of default settings */
2606
2973
  switch (codec_id) {
2607
 
    case CODEC_ID_QCELP:
 
2974
    case AV_CODEC_ID_QCELP:
2608
2975
      /* QCELP is always mono, no matter what the caps say */
2609
2976
      context->channels = 1;
2610
2977
      break;
2611
 
    case CODEC_ID_ADPCM_G726:
 
2978
    case AV_CODEC_ID_ADPCM_G726:
2612
2979
      if (context->sample_rate && context->bit_rate)
2613
2980
        context->bits_per_coded_sample =
2614
2981
            context->bit_rate / context->sample_rate;
2731
3098
    AVOutputFormat * plugin)
2732
3099
{
2733
3100
  static enum CodecID tmp_vlist[] = {
2734
 
    CODEC_ID_NONE,
2735
 
    CODEC_ID_NONE
 
3101
    AV_CODEC_ID_NONE,
 
3102
    AV_CODEC_ID_NONE
2736
3103
  };
2737
3104
  static enum CodecID tmp_alist[] = {
2738
 
    CODEC_ID_NONE,
2739
 
    CODEC_ID_NONE
 
3105
    AV_CODEC_ID_NONE,
 
3106
    AV_CODEC_ID_NONE
2740
3107
  };
2741
3108
 
2742
3109
  GST_LOG ("format_name : %s", format_name);
2743
3110
 
2744
3111
  if (!strcmp (format_name, "mp4")) {
2745
3112
    static enum CodecID mp4_video_list[] = {
2746
 
      CODEC_ID_MPEG4, CODEC_ID_H264,
2747
 
      CODEC_ID_MJPEG,
2748
 
      CODEC_ID_NONE
 
3113
      AV_CODEC_ID_MPEG4, AV_CODEC_ID_H264,
 
3114
      AV_CODEC_ID_MJPEG,
 
3115
      AV_CODEC_ID_NONE
2749
3116
    };
2750
3117
    static enum CodecID mp4_audio_list[] = {
2751
 
      CODEC_ID_AAC, CODEC_ID_MP3,
2752
 
      CODEC_ID_NONE
 
3118
      AV_CODEC_ID_AAC, AV_CODEC_ID_MP3,
 
3119
      AV_CODEC_ID_NONE
2753
3120
    };
2754
3121
 
2755
3122
    *video_codec_list = mp4_video_list;
2756
3123
    *audio_codec_list = mp4_audio_list;
2757
3124
  } else if (!strcmp (format_name, "mpeg")) {
2758
 
    static enum CodecID mpeg_video_list[] = { CODEC_ID_MPEG1VIDEO,
2759
 
      CODEC_ID_MPEG2VIDEO,
2760
 
      CODEC_ID_H264,
2761
 
      CODEC_ID_NONE
 
3125
    static enum CodecID mpeg_video_list[] = { AV_CODEC_ID_MPEG1VIDEO,
 
3126
      AV_CODEC_ID_MPEG2VIDEO,
 
3127
      AV_CODEC_ID_H264,
 
3128
      AV_CODEC_ID_NONE
2762
3129
    };
2763
 
    static enum CodecID mpeg_audio_list[] = { CODEC_ID_MP1,
2764
 
      CODEC_ID_MP2,
2765
 
      CODEC_ID_MP3,
2766
 
      CODEC_ID_NONE
 
3130
    static enum CodecID mpeg_audio_list[] = { AV_CODEC_ID_MP1,
 
3131
      AV_CODEC_ID_MP2,
 
3132
      AV_CODEC_ID_MP3,
 
3133
      AV_CODEC_ID_NONE
2767
3134
    };
2768
3135
 
2769
3136
    *video_codec_list = mpeg_video_list;
2770
3137
    *audio_codec_list = mpeg_audio_list;
2771
3138
  } else if (!strcmp (format_name, "dvd")) {
2772
 
    static enum CodecID mpeg_video_list[] = { CODEC_ID_MPEG2VIDEO,
2773
 
      CODEC_ID_NONE
 
3139
    static enum CodecID mpeg_video_list[] = { AV_CODEC_ID_MPEG2VIDEO,
 
3140
      AV_CODEC_ID_NONE
2774
3141
    };
2775
 
    static enum CodecID mpeg_audio_list[] = { CODEC_ID_MP2,
2776
 
      CODEC_ID_AC3,
2777
 
      CODEC_ID_DTS,
2778
 
      CODEC_ID_PCM_S16BE,
2779
 
      CODEC_ID_NONE
 
3142
    static enum CodecID mpeg_audio_list[] = { AV_CODEC_ID_MP2,
 
3143
      AV_CODEC_ID_AC3,
 
3144
      AV_CODEC_ID_DTS,
 
3145
      AV_CODEC_ID_PCM_S16BE,
 
3146
      AV_CODEC_ID_NONE
2780
3147
    };
2781
3148
 
2782
3149
    *video_codec_list = mpeg_video_list;
2783
3150
    *audio_codec_list = mpeg_audio_list;
2784
3151
  } else if (!strcmp (format_name, "mpegts")) {
2785
 
    static enum CodecID mpegts_video_list[] = { CODEC_ID_MPEG1VIDEO,
2786
 
      CODEC_ID_MPEG2VIDEO,
2787
 
      CODEC_ID_H264,
2788
 
      CODEC_ID_NONE
 
3152
    static enum CodecID mpegts_video_list[] = { AV_CODEC_ID_MPEG1VIDEO,
 
3153
      AV_CODEC_ID_MPEG2VIDEO,
 
3154
      AV_CODEC_ID_H264,
 
3155
      AV_CODEC_ID_NONE
2789
3156
    };
2790
 
    static enum CodecID mpegts_audio_list[] = { CODEC_ID_MP2,
2791
 
      CODEC_ID_MP3,
2792
 
      CODEC_ID_AC3,
2793
 
      CODEC_ID_DTS,
2794
 
      CODEC_ID_AAC,
2795
 
      CODEC_ID_NONE
 
3157
    static enum CodecID mpegts_audio_list[] = { AV_CODEC_ID_MP2,
 
3158
      AV_CODEC_ID_MP3,
 
3159
      AV_CODEC_ID_AC3,
 
3160
      AV_CODEC_ID_DTS,
 
3161
      AV_CODEC_ID_AAC,
 
3162
      AV_CODEC_ID_NONE
2796
3163
    };
2797
3164
 
2798
3165
    *video_codec_list = mpegts_video_list;
2799
3166
    *audio_codec_list = mpegts_audio_list;
2800
3167
  } else if (!strcmp (format_name, "vob")) {
2801
3168
    static enum CodecID vob_video_list[] =
2802
 
        { CODEC_ID_MPEG2VIDEO, CODEC_ID_NONE };
2803
 
    static enum CodecID vob_audio_list[] = { CODEC_ID_MP2, CODEC_ID_AC3,
2804
 
      CODEC_ID_DTS, CODEC_ID_NONE
 
3169
        { AV_CODEC_ID_MPEG2VIDEO, AV_CODEC_ID_NONE };
 
3170
    static enum CodecID vob_audio_list[] = { AV_CODEC_ID_MP2, AV_CODEC_ID_AC3,
 
3171
      AV_CODEC_ID_DTS, AV_CODEC_ID_NONE
2805
3172
    };
2806
3173
 
2807
3174
    *video_codec_list = vob_video_list;
2808
3175
    *audio_codec_list = vob_audio_list;
2809
3176
  } else if (!strcmp (format_name, "flv")) {
2810
 
    static enum CodecID flv_video_list[] = { CODEC_ID_FLV1, CODEC_ID_NONE };
2811
 
    static enum CodecID flv_audio_list[] = { CODEC_ID_MP3, CODEC_ID_NONE };
 
3177
    static enum CodecID flv_video_list[] =
 
3178
        { AV_CODEC_ID_FLV1, AV_CODEC_ID_NONE };
 
3179
    static enum CodecID flv_audio_list[] =
 
3180
        { AV_CODEC_ID_MP3, AV_CODEC_ID_NONE };
2812
3181
 
2813
3182
    *video_codec_list = flv_video_list;
2814
3183
    *audio_codec_list = flv_audio_list;
2815
3184
  } else if (!strcmp (format_name, "asf")) {
2816
3185
    static enum CodecID asf_video_list[] =
2817
 
        { CODEC_ID_WMV1, CODEC_ID_WMV2, CODEC_ID_MSMPEG4V3, CODEC_ID_NONE };
 
3186
        { AV_CODEC_ID_WMV1, AV_CODEC_ID_WMV2, AV_CODEC_ID_MSMPEG4V3,
 
3187
      AV_CODEC_ID_NONE
 
3188
    };
2818
3189
    static enum CodecID asf_audio_list[] =
2819
 
        { CODEC_ID_WMAV1, CODEC_ID_WMAV2, CODEC_ID_MP3, CODEC_ID_NONE };
 
3190
        { AV_CODEC_ID_WMAV1, AV_CODEC_ID_WMAV2, AV_CODEC_ID_MP3,
 
3191
      AV_CODEC_ID_NONE
 
3192
    };
2820
3193
 
2821
3194
    *video_codec_list = asf_video_list;
2822
3195
    *audio_codec_list = asf_audio_list;
2823
3196
  } else if (!strcmp (format_name, "dv")) {
2824
 
    static enum CodecID dv_video_list[] = { CODEC_ID_DVVIDEO, CODEC_ID_NONE };
2825
 
    static enum CodecID dv_audio_list[] = { CODEC_ID_PCM_S16LE, CODEC_ID_NONE };
 
3197
    static enum CodecID dv_video_list[] =
 
3198
        { AV_CODEC_ID_DVVIDEO, AV_CODEC_ID_NONE };
 
3199
    static enum CodecID dv_audio_list[] =
 
3200
        { AV_CODEC_ID_PCM_S16LE, AV_CODEC_ID_NONE };
2826
3201
 
2827
3202
    *video_codec_list = dv_video_list;
2828
3203
    *audio_codec_list = dv_audio_list;
2829
3204
  } else if (!strcmp (format_name, "mov")) {
2830
3205
    static enum CodecID mov_video_list[] = {
2831
 
      CODEC_ID_SVQ1, CODEC_ID_SVQ3, CODEC_ID_MPEG4,
2832
 
      CODEC_ID_H263, CODEC_ID_H263P,
2833
 
      CODEC_ID_H264, CODEC_ID_DVVIDEO,
2834
 
      CODEC_ID_MJPEG,
2835
 
      CODEC_ID_NONE
 
3206
      AV_CODEC_ID_SVQ1, AV_CODEC_ID_SVQ3, AV_CODEC_ID_MPEG4,
 
3207
      AV_CODEC_ID_H263, AV_CODEC_ID_H263P,
 
3208
      AV_CODEC_ID_H264, AV_CODEC_ID_DVVIDEO,
 
3209
      AV_CODEC_ID_MJPEG,
 
3210
      AV_CODEC_ID_NONE
2836
3211
    };
2837
3212
    static enum CodecID mov_audio_list[] = {
2838
 
      CODEC_ID_PCM_MULAW, CODEC_ID_PCM_ALAW, CODEC_ID_ADPCM_IMA_QT,
2839
 
      CODEC_ID_MACE3, CODEC_ID_MACE6, CODEC_ID_AAC,
2840
 
      CODEC_ID_AMR_NB, CODEC_ID_AMR_WB,
2841
 
      CODEC_ID_PCM_S16BE, CODEC_ID_PCM_S16LE,
2842
 
      CODEC_ID_MP3, CODEC_ID_NONE
 
3213
      AV_CODEC_ID_PCM_MULAW, AV_CODEC_ID_PCM_ALAW, AV_CODEC_ID_ADPCM_IMA_QT,
 
3214
      AV_CODEC_ID_MACE3, AV_CODEC_ID_MACE6, AV_CODEC_ID_AAC,
 
3215
      AV_CODEC_ID_AMR_NB, AV_CODEC_ID_AMR_WB,
 
3216
      AV_CODEC_ID_PCM_S16BE, AV_CODEC_ID_PCM_S16LE,
 
3217
      AV_CODEC_ID_MP3, AV_CODEC_ID_NONE
2843
3218
    };
2844
3219
 
2845
3220
    *video_codec_list = mov_video_list;
2846
3221
    *audio_codec_list = mov_audio_list;
2847
3222
  } else if ((!strcmp (format_name, "3gp") || !strcmp (format_name, "3g2"))) {
2848
3223
    static enum CodecID tgp_video_list[] = {
2849
 
      CODEC_ID_MPEG4, CODEC_ID_H263, CODEC_ID_H263P, CODEC_ID_H264,
2850
 
      CODEC_ID_NONE
 
3224
      AV_CODEC_ID_MPEG4, AV_CODEC_ID_H263, AV_CODEC_ID_H263P, AV_CODEC_ID_H264,
 
3225
      AV_CODEC_ID_NONE
2851
3226
    };
2852
3227
    static enum CodecID tgp_audio_list[] = {
2853
 
      CODEC_ID_AMR_NB, CODEC_ID_AMR_WB,
2854
 
      CODEC_ID_AAC,
2855
 
      CODEC_ID_NONE
 
3228
      AV_CODEC_ID_AMR_NB, AV_CODEC_ID_AMR_WB,
 
3229
      AV_CODEC_ID_AAC,
 
3230
      AV_CODEC_ID_NONE
2856
3231
    };
2857
3232
 
2858
3233
    *video_codec_list = tgp_video_list;
2859
3234
    *audio_codec_list = tgp_audio_list;
2860
3235
  } else if (!strcmp (format_name, "mmf")) {
2861
3236
    static enum CodecID mmf_audio_list[] = {
2862
 
      CODEC_ID_ADPCM_YAMAHA, CODEC_ID_NONE
 
3237
      AV_CODEC_ID_ADPCM_YAMAHA, AV_CODEC_ID_NONE
2863
3238
    };
2864
3239
    *video_codec_list = NULL;
2865
3240
    *audio_codec_list = mmf_audio_list;
2866
3241
  } else if (!strcmp (format_name, "amr")) {
2867
3242
    static enum CodecID amr_audio_list[] = {
2868
 
      CODEC_ID_AMR_NB, CODEC_ID_AMR_WB,
2869
 
      CODEC_ID_NONE
 
3243
      AV_CODEC_ID_AMR_NB, AV_CODEC_ID_AMR_WB,
 
3244
      AV_CODEC_ID_NONE
2870
3245
    };
2871
3246
    *video_codec_list = NULL;
2872
3247
    *audio_codec_list = amr_audio_list;
2873
3248
  } else if (!strcmp (format_name, "gif")) {
2874
3249
    static enum CodecID gif_image_list[] = {
2875
 
      CODEC_ID_RAWVIDEO, CODEC_ID_NONE
 
3250
      AV_CODEC_ID_RAWVIDEO, AV_CODEC_ID_NONE
2876
3251
    };
2877
3252
    *video_codec_list = gif_image_list;
2878
3253
    *audio_codec_list = NULL;
2879
 
  } else if ((plugin->audio_codec != CODEC_ID_NONE) ||
2880
 
      (plugin->video_codec != CODEC_ID_NONE)) {
 
3254
  } else if ((plugin->audio_codec != AV_CODEC_ID_NONE) ||
 
3255
      (plugin->video_codec != AV_CODEC_ID_NONE)) {
2881
3256
    tmp_vlist[0] = plugin->video_codec;
2882
3257
    tmp_alist[0] = plugin->audio_codec;
2883
3258
 
2901
3276
enum CodecID
2902
3277
gst_ffmpeg_caps_to_codecid (const GstCaps * caps, AVCodecContext * context)
2903
3278
{
2904
 
  enum CodecID id = CODEC_ID_NONE;
 
3279
  enum CodecID id = AV_CODEC_ID_NONE;
2905
3280
  const gchar *mimetype;
2906
3281
  const GstStructure *structure;
2907
3282
  gboolean video = FALSE, audio = FALSE;        /* we want to be sure! */
2908
3283
 
2909
 
  g_return_val_if_fail (caps != NULL, CODEC_ID_NONE);
2910
 
  g_return_val_if_fail (gst_caps_get_size (caps) == 1, CODEC_ID_NONE);
 
3284
  g_return_val_if_fail (caps != NULL, AV_CODEC_ID_NONE);
 
3285
  g_return_val_if_fail (gst_caps_get_size (caps) == 1, AV_CODEC_ID_NONE);
2911
3286
  structure = gst_caps_get_structure (caps, 0);
2912
3287
 
2913
3288
  mimetype = gst_structure_get_name (structure);
2914
3289
 
2915
3290
  if (!strcmp (mimetype, "video/x-raw")) {
2916
 
    id = CODEC_ID_RAWVIDEO;
 
3291
    id = AV_CODEC_ID_RAWVIDEO;
2917
3292
    video = TRUE;
2918
3293
  } else if (!strcmp (mimetype, "audio/x-raw")) {
2919
3294
    GstAudioInfo info;
2921
3296
    if (gst_audio_info_from_caps (&info, caps)) {
2922
3297
      switch (GST_AUDIO_INFO_FORMAT (&info)) {
2923
3298
        case GST_AUDIO_FORMAT_S8:
2924
 
          id = CODEC_ID_PCM_S8;
 
3299
          id = AV_CODEC_ID_PCM_S8;
2925
3300
          break;
2926
3301
        case GST_AUDIO_FORMAT_U8:
2927
 
          id = CODEC_ID_PCM_U8;
 
3302
          id = AV_CODEC_ID_PCM_U8;
2928
3303
          break;
2929
3304
        case GST_AUDIO_FORMAT_S16LE:
2930
 
          id = CODEC_ID_PCM_S16LE;
 
3305
          id = AV_CODEC_ID_PCM_S16LE;
2931
3306
          break;
2932
3307
        case GST_AUDIO_FORMAT_S16BE:
2933
 
          id = CODEC_ID_PCM_S16BE;
 
3308
          id = AV_CODEC_ID_PCM_S16BE;
2934
3309
          break;
2935
3310
        case GST_AUDIO_FORMAT_U16LE:
2936
 
          id = CODEC_ID_PCM_U16LE;
 
3311
          id = AV_CODEC_ID_PCM_U16LE;
2937
3312
          break;
2938
3313
        case GST_AUDIO_FORMAT_U16BE:
2939
 
          id = CODEC_ID_PCM_U16BE;
 
3314
          id = AV_CODEC_ID_PCM_U16BE;
2940
3315
          break;
2941
3316
        default:
2942
3317
          break;
2943
3318
      }
2944
 
      if (id != CODEC_ID_NONE)
 
3319
      if (id != AV_CODEC_ID_NONE)
2945
3320
        audio = TRUE;
2946
3321
    }
2947
3322
  } else if (!strcmp (mimetype, "audio/x-mulaw")) {
2948
 
    id = CODEC_ID_PCM_MULAW;
 
3323
    id = AV_CODEC_ID_PCM_MULAW;
2949
3324
    audio = TRUE;
2950
3325
  } else if (!strcmp (mimetype, "audio/x-alaw")) {
2951
 
    id = CODEC_ID_PCM_ALAW;
 
3326
    id = AV_CODEC_ID_PCM_ALAW;
2952
3327
    audio = TRUE;
2953
3328
  } else if (!strcmp (mimetype, "video/x-dv")) {
2954
3329
    gboolean sys_strm;
2955
3330
 
2956
3331
    if (gst_structure_get_boolean (structure, "systemstream", &sys_strm) &&
2957
3332
        !sys_strm) {
2958
 
      id = CODEC_ID_DVVIDEO;
 
3333
      id = AV_CODEC_ID_DVVIDEO;
2959
3334
      video = TRUE;
2960
3335
    }
2961
3336
  } else if (!strcmp (mimetype, "audio/x-dv")) {        /* ??? */
2962
 
    id = CODEC_ID_DVAUDIO;
 
3337
    id = AV_CODEC_ID_DVAUDIO;
2963
3338
    audio = TRUE;
2964
3339
  } else if (!strcmp (mimetype, "video/x-h263")) {
2965
3340
    const gchar *h263version =
2966
3341
        gst_structure_get_string (structure, "h263version");
2967
3342
    if (h263version && !strcmp (h263version, "h263p"))
2968
 
      id = CODEC_ID_H263P;
 
3343
      id = AV_CODEC_ID_H263P;
2969
3344
    else
2970
 
      id = CODEC_ID_H263;
 
3345
      id = AV_CODEC_ID_H263;
2971
3346
    video = TRUE;
2972
3347
  } else if (!strcmp (mimetype, "video/x-intel-h263")) {
2973
 
    id = CODEC_ID_H263I;
 
3348
    id = AV_CODEC_ID_H263I;
2974
3349
    video = TRUE;
2975
3350
  } else if (!strcmp (mimetype, "video/x-h261")) {
2976
 
    id = CODEC_ID_H261;
 
3351
    id = AV_CODEC_ID_H261;
2977
3352
    video = TRUE;
2978
3353
  } else if (!strcmp (mimetype, "video/mpeg")) {
2979
3354
    gboolean sys_strm;
2984
3359
        !sys_strm) {
2985
3360
      switch (mpegversion) {
2986
3361
        case 1:
2987
 
          id = CODEC_ID_MPEG1VIDEO;
 
3362
          id = AV_CODEC_ID_MPEG1VIDEO;
2988
3363
          break;
2989
3364
        case 2:
2990
 
          id = CODEC_ID_MPEG2VIDEO;
 
3365
          id = AV_CODEC_ID_MPEG2VIDEO;
2991
3366
          break;
2992
3367
        case 4:
2993
 
          id = CODEC_ID_MPEG4;
 
3368
          id = AV_CODEC_ID_MPEG4;
2994
3369
          break;
2995
3370
      }
2996
3371
    }
2997
 
    if (id != CODEC_ID_NONE)
 
3372
    if (id != AV_CODEC_ID_NONE)
2998
3373
      video = TRUE;
2999
3374
  } else if (!strcmp (mimetype, "image/jpeg")) {
3000
 
    id = CODEC_ID_MJPEG;        /* A... B... */
 
3375
    id = AV_CODEC_ID_MJPEG;     /* A... B... */
3001
3376
    video = TRUE;
3002
3377
  } else if (!strcmp (mimetype, "video/x-jpeg-b")) {
3003
 
    id = CODEC_ID_MJPEGB;
 
3378
    id = AV_CODEC_ID_MJPEGB;
3004
3379
    video = TRUE;
3005
3380
  } else if (!strcmp (mimetype, "video/x-wmv")) {
3006
3381
    gint wmvversion = 0;
3008
3383
    if (gst_structure_get_int (structure, "wmvversion", &wmvversion)) {
3009
3384
      switch (wmvversion) {
3010
3385
        case 1:
3011
 
          id = CODEC_ID_WMV1;
 
3386
          id = AV_CODEC_ID_WMV1;
3012
3387
          break;
3013
3388
        case 2:
3014
 
          id = CODEC_ID_WMV2;
 
3389
          id = AV_CODEC_ID_WMV2;
3015
3390
          break;
3016
3391
        case 3:
3017
3392
        {
3018
3393
          const gchar *format;
3019
3394
 
3020
3395
          /* WMV3 unless the fourcc exists and says otherwise */
3021
 
          id = CODEC_ID_WMV3;
 
3396
          id = AV_CODEC_ID_WMV3;
3022
3397
 
3023
3398
          if ((format = gst_structure_get_string (structure, "format")) &&
3024
3399
              (g_str_equal (format, "WVC1") || g_str_equal (format, "WMVA")))
3025
 
            id = CODEC_ID_VC1;
 
3400
            id = AV_CODEC_ID_VC1;
3026
3401
 
3027
3402
          break;
3028
3403
        }
3029
3404
      }
3030
3405
    }
3031
 
    if (id != CODEC_ID_NONE)
 
3406
    if (id != AV_CODEC_ID_NONE)
3032
3407
      video = TRUE;
3033
3408
  } else if (!strcmp (mimetype, "audio/x-vorbis")) {
3034
 
    id = CODEC_ID_VORBIS;
 
3409
    id = AV_CODEC_ID_VORBIS;
3035
3410
    audio = TRUE;
3036
3411
  } else if (!strcmp (mimetype, "audio/x-qdm2")) {
3037
 
    id = CODEC_ID_QDM2;
 
3412
    id = AV_CODEC_ID_QDM2;
3038
3413
    audio = TRUE;
3039
3414
  } else if (!strcmp (mimetype, "audio/mpeg")) {
3040
3415
    gint layer = 0;
3044
3419
      switch (mpegversion) {
3045
3420
        case 2:                /* ffmpeg uses faad for both... */
3046
3421
        case 4:
3047
 
          id = CODEC_ID_AAC;
 
3422
          id = AV_CODEC_ID_AAC;
3048
3423
          break;
3049
3424
        case 1:
3050
3425
          if (gst_structure_get_int (structure, "layer", &layer)) {
3051
3426
            switch (layer) {
3052
3427
              case 1:
3053
 
                id = CODEC_ID_MP1;
 
3428
                id = AV_CODEC_ID_MP1;
3054
3429
                break;
3055
3430
              case 2:
3056
 
                id = CODEC_ID_MP2;
 
3431
                id = AV_CODEC_ID_MP2;
3057
3432
                break;
3058
3433
              case 3:
3059
 
                id = CODEC_ID_MP3;
 
3434
                id = AV_CODEC_ID_MP3;
3060
3435
                break;
3061
3436
            }
3062
3437
          }
3063
3438
      }
3064
3439
    }
3065
 
    if (id != CODEC_ID_NONE)
 
3440
    if (id != AV_CODEC_ID_NONE)
3066
3441
      audio = TRUE;
3067
3442
  } else if (!strcmp (mimetype, "audio/x-musepack")) {
3068
3443
    gint streamversion = -1;
3069
3444
 
3070
3445
    if (gst_structure_get_int (structure, "streamversion", &streamversion)) {
3071
3446
      if (streamversion == 7)
3072
 
        id = CODEC_ID_MUSEPACK7;
 
3447
        id = AV_CODEC_ID_MUSEPACK7;
3073
3448
    } else {
3074
 
      id = CODEC_ID_MUSEPACK7;
 
3449
      id = AV_CODEC_ID_MUSEPACK7;
3075
3450
    }
3076
3451
  } else if (!strcmp (mimetype, "audio/x-wma")) {
3077
3452
    gint wmaversion = 0;
3079
3454
    if (gst_structure_get_int (structure, "wmaversion", &wmaversion)) {
3080
3455
      switch (wmaversion) {
3081
3456
        case 1:
3082
 
          id = CODEC_ID_WMAV1;
 
3457
          id = AV_CODEC_ID_WMAV1;
3083
3458
          break;
3084
3459
        case 2:
3085
 
          id = CODEC_ID_WMAV2;
 
3460
          id = AV_CODEC_ID_WMAV2;
3086
3461
          break;
3087
3462
        case 3:
3088
 
          id = CODEC_ID_WMAPRO;
 
3463
          id = AV_CODEC_ID_WMAPRO;
3089
3464
          break;
3090
3465
      }
3091
3466
    }
3092
 
    if (id != CODEC_ID_NONE)
 
3467
    if (id != AV_CODEC_ID_NONE)
3093
3468
      audio = TRUE;
3094
3469
  } else if (!strcmp (mimetype, "audio/x-wms")) {
3095
 
    id = CODEC_ID_WMAVOICE;
 
3470
    id = AV_CODEC_ID_WMAVOICE;
3096
3471
    audio = TRUE;
3097
3472
  } else if (!strcmp (mimetype, "audio/x-ac3")) {
3098
 
    id = CODEC_ID_AC3;
 
3473
    id = AV_CODEC_ID_AC3;
3099
3474
    audio = TRUE;
3100
3475
  } else if (!strcmp (mimetype, "audio/x-eac3")) {
3101
 
    id = CODEC_ID_EAC3;
 
3476
    id = AV_CODEC_ID_EAC3;
3102
3477
    audio = TRUE;
3103
3478
  } else if (!strcmp (mimetype, "audio/x-vnd.sony.atrac3") ||
3104
3479
      !strcmp (mimetype, "audio/atrac3")) {
3105
 
    id = CODEC_ID_ATRAC3;
 
3480
    id = AV_CODEC_ID_ATRAC3;
3106
3481
    audio = TRUE;
3107
3482
  } else if (!strcmp (mimetype, "audio/x-dts")) {
3108
 
    id = CODEC_ID_DTS;
 
3483
    id = AV_CODEC_ID_DTS;
3109
3484
    audio = TRUE;
3110
3485
  } else if (!strcmp (mimetype, "application/x-ape")) {
3111
 
    id = CODEC_ID_APE;
 
3486
    id = AV_CODEC_ID_APE;
3112
3487
    audio = TRUE;
3113
3488
  } else if (!strcmp (mimetype, "video/x-msmpeg")) {
3114
3489
    gint msmpegversion = 0;
3116
3491
    if (gst_structure_get_int (structure, "msmpegversion", &msmpegversion)) {
3117
3492
      switch (msmpegversion) {
3118
3493
        case 41:
3119
 
          id = CODEC_ID_MSMPEG4V1;
 
3494
          id = AV_CODEC_ID_MSMPEG4V1;
3120
3495
          break;
3121
3496
        case 42:
3122
 
          id = CODEC_ID_MSMPEG4V2;
 
3497
          id = AV_CODEC_ID_MSMPEG4V2;
3123
3498
          break;
3124
3499
        case 43:
3125
 
          id = CODEC_ID_MSMPEG4V3;
 
3500
          id = AV_CODEC_ID_MSMPEG4V3;
3126
3501
          break;
3127
3502
      }
3128
3503
    }
3129
 
    if (id != CODEC_ID_NONE)
 
3504
    if (id != AV_CODEC_ID_NONE)
3130
3505
      video = TRUE;
3131
3506
  } else if (!strcmp (mimetype, "video/x-svq")) {
3132
3507
    gint svqversion = 0;
3134
3509
    if (gst_structure_get_int (structure, "svqversion", &svqversion)) {
3135
3510
      switch (svqversion) {
3136
3511
        case 1:
3137
 
          id = CODEC_ID_SVQ1;
 
3512
          id = AV_CODEC_ID_SVQ1;
3138
3513
          break;
3139
3514
        case 3:
3140
 
          id = CODEC_ID_SVQ3;
 
3515
          id = AV_CODEC_ID_SVQ3;
3141
3516
          break;
3142
3517
      }
3143
3518
    }
3144
 
    if (id != CODEC_ID_NONE)
 
3519
    if (id != AV_CODEC_ID_NONE)
3145
3520
      video = TRUE;
3146
3521
  } else if (!strcmp (mimetype, "video/x-huffyuv")) {
3147
 
    id = CODEC_ID_HUFFYUV;
 
3522
    id = AV_CODEC_ID_HUFFYUV;
3148
3523
    video = TRUE;
3149
3524
  } else if (!strcmp (mimetype, "audio/x-mace")) {
3150
3525
    gint maceversion = 0;
3152
3527
    if (gst_structure_get_int (structure, "maceversion", &maceversion)) {
3153
3528
      switch (maceversion) {
3154
3529
        case 3:
3155
 
          id = CODEC_ID_MACE3;
 
3530
          id = AV_CODEC_ID_MACE3;
3156
3531
          break;
3157
3532
        case 6:
3158
 
          id = CODEC_ID_MACE6;
 
3533
          id = AV_CODEC_ID_MACE6;
3159
3534
          break;
3160
3535
      }
3161
3536
    }
3162
 
    if (id != CODEC_ID_NONE)
 
3537
    if (id != AV_CODEC_ID_NONE)
3163
3538
      audio = TRUE;
3164
3539
  } else if (!strcmp (mimetype, "video/x-theora")) {
3165
 
    id = CODEC_ID_THEORA;
 
3540
    id = AV_CODEC_ID_THEORA;
3166
3541
    video = TRUE;
3167
3542
  } else if (!strcmp (mimetype, "video/x-vp3")) {
3168
 
    id = CODEC_ID_VP3;
 
3543
    id = AV_CODEC_ID_VP3;
3169
3544
    video = TRUE;
3170
3545
  } else if (!strcmp (mimetype, "video/x-vp5")) {
3171
 
    id = CODEC_ID_VP5;
 
3546
    id = AV_CODEC_ID_VP5;
3172
3547
    video = TRUE;
3173
3548
  } else if (!strcmp (mimetype, "video/x-vp6")) {
3174
 
    id = CODEC_ID_VP6;
 
3549
    id = AV_CODEC_ID_VP6;
3175
3550
    video = TRUE;
3176
3551
  } else if (!strcmp (mimetype, "video/x-vp6-flash")) {
3177
 
    id = CODEC_ID_VP6F;
 
3552
    id = AV_CODEC_ID_VP6F;
3178
3553
    video = TRUE;
3179
3554
  } else if (!strcmp (mimetype, "video/x-vp6-alpha")) {
3180
 
    id = CODEC_ID_VP6A;
 
3555
    id = AV_CODEC_ID_VP6A;
3181
3556
    video = TRUE;
3182
3557
  } else if (!strcmp (mimetype, "video/x-vp8")) {
3183
 
    id = CODEC_ID_VP8;
 
3558
    id = AV_CODEC_ID_VP8;
3184
3559
    video = TRUE;
3185
3560
  } else if (!strcmp (mimetype, "video/x-flash-screen")) {
3186
 
    id = CODEC_ID_FLASHSV;
 
3561
    id = AV_CODEC_ID_FLASHSV;
3187
3562
    video = TRUE;
3188
3563
  } else if (!strcmp (mimetype, "video/x-indeo")) {
3189
3564
    gint indeoversion = 0;
3191
3566
    if (gst_structure_get_int (structure, "indeoversion", &indeoversion)) {
3192
3567
      switch (indeoversion) {
3193
3568
        case 5:
3194
 
          id = CODEC_ID_INDEO5;
 
3569
          id = AV_CODEC_ID_INDEO5;
3195
3570
          break;
3196
3571
        case 4:
3197
 
          id = CODEC_ID_INDEO4;
 
3572
          id = AV_CODEC_ID_INDEO4;
3198
3573
          break;
3199
3574
        case 3:
3200
 
          id = CODEC_ID_INDEO3;
 
3575
          id = AV_CODEC_ID_INDEO3;
3201
3576
          break;
3202
3577
        case 2:
3203
 
          id = CODEC_ID_INDEO2;
 
3578
          id = AV_CODEC_ID_INDEO2;
3204
3579
          break;
3205
3580
      }
3206
 
      if (id != CODEC_ID_NONE)
 
3581
      if (id != AV_CODEC_ID_NONE)
3207
3582
        video = TRUE;
3208
3583
    }
3209
3584
  } else if (!strcmp (mimetype, "video/x-divx")) {
3212
3587
    if (gst_structure_get_int (structure, "divxversion", &divxversion)) {
3213
3588
      switch (divxversion) {
3214
3589
        case 3:
3215
 
          id = CODEC_ID_MSMPEG4V3;
 
3590
          id = AV_CODEC_ID_MSMPEG4V3;
3216
3591
          break;
3217
3592
        case 4:
3218
3593
        case 5:
3219
 
          id = CODEC_ID_MPEG4;
 
3594
          id = AV_CODEC_ID_MPEG4;
3220
3595
          break;
3221
3596
      }
3222
3597
    }
3223
 
    if (id != CODEC_ID_NONE)
 
3598
    if (id != AV_CODEC_ID_NONE)
3224
3599
      video = TRUE;
3225
3600
  } else if (!strcmp (mimetype, "video/x-3ivx")) {
3226
 
    id = CODEC_ID_MPEG4;
 
3601
    id = AV_CODEC_ID_MPEG4;
3227
3602
    video = TRUE;
3228
3603
  } else if (!strcmp (mimetype, "video/x-xvid")) {
3229
 
    id = CODEC_ID_MPEG4;
 
3604
    id = AV_CODEC_ID_MPEG4;
3230
3605
    video = TRUE;
3231
3606
  } else if (!strcmp (mimetype, "video/x-ffv")) {
3232
3607
    gint ffvversion = 0;
3233
3608
 
3234
3609
    if (gst_structure_get_int (structure, "ffvversion", &ffvversion) &&
3235
3610
        ffvversion == 1) {
3236
 
      id = CODEC_ID_FFV1;
 
3611
      id = AV_CODEC_ID_FFV1;
3237
3612
      video = TRUE;
3238
3613
    }
3239
3614
  } else if (!strcmp (mimetype, "audio/x-adpcm")) {
3243
3618
    if (layout == NULL) {
3244
3619
      /* break */
3245
3620
    } else if (!strcmp (layout, "quicktime")) {
3246
 
      id = CODEC_ID_ADPCM_IMA_QT;
 
3621
      id = AV_CODEC_ID_ADPCM_IMA_QT;
3247
3622
    } else if (!strcmp (layout, "microsoft")) {
3248
 
      id = CODEC_ID_ADPCM_MS;
 
3623
      id = AV_CODEC_ID_ADPCM_MS;
3249
3624
    } else if (!strcmp (layout, "dvi")) {
3250
 
      id = CODEC_ID_ADPCM_IMA_WAV;
 
3625
      id = AV_CODEC_ID_ADPCM_IMA_WAV;
3251
3626
    } else if (!strcmp (layout, "4xm")) {
3252
 
      id = CODEC_ID_ADPCM_4XM;
 
3627
      id = AV_CODEC_ID_ADPCM_4XM;
3253
3628
    } else if (!strcmp (layout, "smjpeg")) {
3254
 
      id = CODEC_ID_ADPCM_IMA_SMJPEG;
 
3629
      id = AV_CODEC_ID_ADPCM_IMA_SMJPEG;
3255
3630
    } else if (!strcmp (layout, "dk3")) {
3256
 
      id = CODEC_ID_ADPCM_IMA_DK3;
 
3631
      id = AV_CODEC_ID_ADPCM_IMA_DK3;
3257
3632
    } else if (!strcmp (layout, "dk4")) {
3258
 
      id = CODEC_ID_ADPCM_IMA_DK4;
 
3633
      id = AV_CODEC_ID_ADPCM_IMA_DK4;
3259
3634
    } else if (!strcmp (layout, "westwood")) {
3260
 
      id = CODEC_ID_ADPCM_IMA_WS;
 
3635
      id = AV_CODEC_ID_ADPCM_IMA_WS;
3261
3636
    } else if (!strcmp (layout, "iss")) {
3262
 
      id = CODEC_ID_ADPCM_IMA_ISS;
 
3637
      id = AV_CODEC_ID_ADPCM_IMA_ISS;
3263
3638
    } else if (!strcmp (layout, "xa")) {
3264
 
      id = CODEC_ID_ADPCM_XA;
 
3639
      id = AV_CODEC_ID_ADPCM_XA;
3265
3640
    } else if (!strcmp (layout, "adx")) {
3266
 
      id = CODEC_ID_ADPCM_ADX;
 
3641
      id = AV_CODEC_ID_ADPCM_ADX;
3267
3642
    } else if (!strcmp (layout, "ea")) {
3268
 
      id = CODEC_ID_ADPCM_EA;
 
3643
      id = AV_CODEC_ID_ADPCM_EA;
3269
3644
    } else if (!strcmp (layout, "g726")) {
3270
 
      id = CODEC_ID_ADPCM_G726;
 
3645
      id = AV_CODEC_ID_ADPCM_G726;
3271
3646
    } else if (!strcmp (layout, "g721")) {
3272
 
      id = CODEC_ID_ADPCM_G726;
 
3647
      id = AV_CODEC_ID_ADPCM_G726;
3273
3648
    } else if (!strcmp (layout, "ct")) {
3274
 
      id = CODEC_ID_ADPCM_CT;
 
3649
      id = AV_CODEC_ID_ADPCM_CT;
3275
3650
    } else if (!strcmp (layout, "swf")) {
3276
 
      id = CODEC_ID_ADPCM_SWF;
 
3651
      id = AV_CODEC_ID_ADPCM_SWF;
3277
3652
    } else if (!strcmp (layout, "yamaha")) {
3278
 
      id = CODEC_ID_ADPCM_YAMAHA;
 
3653
      id = AV_CODEC_ID_ADPCM_YAMAHA;
3279
3654
    } else if (!strcmp (layout, "sbpro2")) {
3280
 
      id = CODEC_ID_ADPCM_SBPRO_2;
 
3655
      id = AV_CODEC_ID_ADPCM_SBPRO_2;
3281
3656
    } else if (!strcmp (layout, "sbpro3")) {
3282
 
      id = CODEC_ID_ADPCM_SBPRO_3;
 
3657
      id = AV_CODEC_ID_ADPCM_SBPRO_3;
3283
3658
    } else if (!strcmp (layout, "sbpro4")) {
3284
 
      id = CODEC_ID_ADPCM_SBPRO_4;
 
3659
      id = AV_CODEC_ID_ADPCM_SBPRO_4;
3285
3660
    }
3286
 
    if (id != CODEC_ID_NONE)
 
3661
    if (id != AV_CODEC_ID_NONE)
3287
3662
      audio = TRUE;
3288
3663
  } else if (!strcmp (mimetype, "video/x-4xm")) {
3289
 
    id = CODEC_ID_4XM;
 
3664
    id = AV_CODEC_ID_4XM;
3290
3665
    video = TRUE;
3291
3666
  } else if (!strcmp (mimetype, "audio/x-dpcm")) {
3292
3667
    const gchar *layout;
3295
3670
    if (!layout) {
3296
3671
      /* .. */
3297
3672
    } else if (!strcmp (layout, "roq")) {
3298
 
      id = CODEC_ID_ROQ_DPCM;
 
3673
      id = AV_CODEC_ID_ROQ_DPCM;
3299
3674
    } else if (!strcmp (layout, "interplay")) {
3300
 
      id = CODEC_ID_INTERPLAY_DPCM;
 
3675
      id = AV_CODEC_ID_INTERPLAY_DPCM;
3301
3676
    } else if (!strcmp (layout, "xan")) {
3302
 
      id = CODEC_ID_XAN_DPCM;
 
3677
      id = AV_CODEC_ID_XAN_DPCM;
3303
3678
    } else if (!strcmp (layout, "sol")) {
3304
 
      id = CODEC_ID_SOL_DPCM;
 
3679
      id = AV_CODEC_ID_SOL_DPCM;
3305
3680
    }
3306
 
    if (id != CODEC_ID_NONE)
 
3681
    if (id != AV_CODEC_ID_NONE)
3307
3682
      audio = TRUE;
3308
3683
  } else if (!strcmp (mimetype, "audio/x-flac")) {
3309
 
    id = CODEC_ID_FLAC;
 
3684
    id = AV_CODEC_ID_FLAC;
3310
3685
    audio = TRUE;
3311
3686
  } else if (!strcmp (mimetype, "audio/x-shorten")) {
3312
 
    id = CODEC_ID_SHORTEN;
 
3687
    id = AV_CODEC_ID_SHORTEN;
3313
3688
    audio = TRUE;
3314
3689
  } else if (!strcmp (mimetype, "audio/x-alac")) {
3315
 
    id = CODEC_ID_ALAC;
 
3690
    id = AV_CODEC_ID_ALAC;
3316
3691
    audio = TRUE;
3317
3692
  } else if (!strcmp (mimetype, "video/x-cinepak")) {
3318
 
    id = CODEC_ID_CINEPAK;
 
3693
    id = AV_CODEC_ID_CINEPAK;
3319
3694
    video = TRUE;
3320
3695
  } else if (!strcmp (mimetype, "video/x-pn-realvideo")) {
3321
3696
    gint rmversion;
3323
3698
    if (gst_structure_get_int (structure, "rmversion", &rmversion)) {
3324
3699
      switch (rmversion) {
3325
3700
        case 1:
3326
 
          id = CODEC_ID_RV10;
 
3701
          id = AV_CODEC_ID_RV10;
3327
3702
          break;
3328
3703
        case 2:
3329
 
          id = CODEC_ID_RV20;
 
3704
          id = AV_CODEC_ID_RV20;
3330
3705
          break;
3331
3706
        case 3:
3332
 
          id = CODEC_ID_RV30;
 
3707
          id = AV_CODEC_ID_RV30;
3333
3708
          break;
3334
3709
        case 4:
3335
 
          id = CODEC_ID_RV40;
 
3710
          id = AV_CODEC_ID_RV40;
3336
3711
          break;
3337
3712
      }
3338
3713
    }
3339
 
    if (id != CODEC_ID_NONE)
 
3714
    if (id != AV_CODEC_ID_NONE)
3340
3715
      video = TRUE;
3341
3716
  } else if (!strcmp (mimetype, "audio/x-sipro")) {
3342
 
    id = CODEC_ID_SIPR;
 
3717
    id = AV_CODEC_ID_SIPR;
3343
3718
    audio = TRUE;
3344
3719
  } else if (!strcmp (mimetype, "audio/x-pn-realaudio")) {
3345
3720
    gint raversion;
3347
3722
    if (gst_structure_get_int (structure, "raversion", &raversion)) {
3348
3723
      switch (raversion) {
3349
3724
        case 1:
3350
 
          id = CODEC_ID_RA_144;
 
3725
          id = AV_CODEC_ID_RA_144;
3351
3726
          break;
3352
3727
        case 2:
3353
 
          id = CODEC_ID_RA_288;
 
3728
          id = AV_CODEC_ID_RA_288;
3354
3729
          break;
3355
3730
        case 8:
3356
 
          id = CODEC_ID_COOK;
 
3731
          id = AV_CODEC_ID_COOK;
3357
3732
          break;
3358
3733
      }
3359
3734
    }
3360
 
    if (id != CODEC_ID_NONE)
 
3735
    if (id != AV_CODEC_ID_NONE)
3361
3736
      audio = TRUE;
3362
3737
  } else if (!strcmp (mimetype, "video/x-rle")) {
3363
3738
    const gchar *layout;
3364
3739
 
3365
3740
    if ((layout = gst_structure_get_string (structure, "layout"))) {
3366
3741
      if (!strcmp (layout, "microsoft")) {
3367
 
        id = CODEC_ID_MSRLE;
 
3742
        id = AV_CODEC_ID_MSRLE;
3368
3743
        video = TRUE;
3369
3744
      }
3370
3745
    }
3374
3749
    if ((gst_structure_get_int (structure, "wcversion", &wcversion))) {
3375
3750
      switch (wcversion) {
3376
3751
        case 3:
3377
 
          id = CODEC_ID_XAN_WC3;
 
3752
          id = AV_CODEC_ID_XAN_WC3;
3378
3753
          video = TRUE;
3379
3754
          break;
3380
3755
        case 4:
3381
 
          id = CODEC_ID_XAN_WC4;
 
3756
          id = AV_CODEC_ID_XAN_WC4;
3382
3757
          video = TRUE;
3383
3758
          break;
3384
3759
        default:
3387
3762
    }
3388
3763
  } else if (!strcmp (mimetype, "audio/AMR")) {
3389
3764
    audio = TRUE;
3390
 
    id = CODEC_ID_AMR_NB;
 
3765
    id = AV_CODEC_ID_AMR_NB;
3391
3766
  } else if (!strcmp (mimetype, "audio/AMR-WB")) {
3392
 
    id = CODEC_ID_AMR_WB;
 
3767
    id = AV_CODEC_ID_AMR_WB;
3393
3768
    audio = TRUE;
3394
3769
  } else if (!strcmp (mimetype, "audio/qcelp")) {
3395
 
    id = CODEC_ID_QCELP;
 
3770
    id = AV_CODEC_ID_QCELP;
3396
3771
    audio = TRUE;
3397
3772
  } else if (!strcmp (mimetype, "video/x-h264")) {
3398
 
    id = CODEC_ID_H264;
 
3773
    id = AV_CODEC_ID_H264;
3399
3774
    video = TRUE;
3400
3775
  } else if (!strcmp (mimetype, "video/x-flash-video")) {
3401
3776
    gint flvversion = 0;
3403
3778
    if ((gst_structure_get_int (structure, "flvversion", &flvversion))) {
3404
3779
      switch (flvversion) {
3405
3780
        case 1:
3406
 
          id = CODEC_ID_FLV1;
 
3781
          id = AV_CODEC_ID_FLV1;
3407
3782
          video = TRUE;
3408
3783
          break;
3409
3784
        default:
3412
3787
    }
3413
3788
 
3414
3789
  } else if (!strcmp (mimetype, "audio/x-nellymoser")) {
3415
 
    id = CODEC_ID_NELLYMOSER;
 
3790
    id = AV_CODEC_ID_NELLYMOSER;
3416
3791
    audio = TRUE;
3417
3792
  } else if (!strncmp (mimetype, "audio/x-gst-av-", 15)) {
3418
3793
    gchar ext[16];
3452
3827
    gst_ffmpeg_caps_with_codecid (id, context->codec_type, caps, context);
3453
3828
  }
3454
3829
 
3455
 
  if (id != CODEC_ID_NONE) {
 
3830
  if (id != AV_CODEC_ID_NONE) {
3456
3831
    GST_DEBUG ("The id=%d belongs to the caps %" GST_PTR_FORMAT, id, caps);
3457
3832
  } else {
3458
3833
    GST_WARNING ("Couldn't figure out the id for caps %" GST_PTR_FORMAT, caps);