X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=ext%2Flibav%2Fgstavcodecmap.c;h=f1587c5900175c23cfb036871cbd22697ef37669;hb=fb9fea0223c58230b98431dc31a0228c471ba4d8;hp=c9d3bfe6e18c410781042194d587659a8b0135e3;hpb=60ff639cd423b794dc6cf261c309fec49f7dc61d;p=platform%2Fupstream%2Fgst-libav.git diff --git a/ext/libav/gstavcodecmap.c b/ext/libav/gstavcodecmap.c index c9d3bfe..f1587c5 100644 --- a/ext/libav/gstavcodecmap.c +++ b/ext/libav/gstavcodecmap.c @@ -66,6 +66,28 @@ static const struct AV_CH_STEREO_RIGHT, GST_AUDIO_CHANNEL_POSITION_FRONT_RIGHT} }; +GType +gst_ffmpeg_compliance_get_type (void) +{ + static GType ffmpeg_compliance_type = 0; + static const GEnumValue compliance_types[] = { + {GST_FFMPEG_VERY_STRICT, "Strictly conform to older spec", + "verystrict"}, + {GST_FFMPEG_STRICT, "Strictly conform to current spec", "strict"}, + {GST_FFMPEG_NORMAL, "Normal behavior", "normal"}, + {GST_FFMPEG_UNOFFICIAL, "Allow unofficial extensions", "unofficial"}, + {GST_FFMPEG_EXPERIMENTAL, "Allow nonstandardized experimental things", + "experimental"}, + {0, NULL, NULL} + }; + + if (!ffmpeg_compliance_type) { + ffmpeg_compliance_type = + g_enum_register_static ("GstFFMpegCompliance", compliance_types); + } + return ffmpeg_compliance_type; +} + static guint64 gst_ffmpeg_channel_positions_to_layout (GstAudioChannelPosition * pos, gint channels) @@ -77,10 +99,13 @@ gst_ffmpeg_channel_positions_to_layout (GstAudioChannelPosition * pos, if (!pos) return 0; + if (channels == 1 && pos[0] == GST_AUDIO_CHANNEL_POSITION_MONO) + return AV_CH_LAYOUT_MONO; + for (i = 0; i < channels; i++) { for (j = 0; j < G_N_ELEMENTS (_ff_to_gst_layout); j++) { if (_ff_to_gst_layout[j].gst == pos[i]) { - ret |= _ff_to_gst_layout[i].ff; + ret |= _ff_to_gst_layout[j].ff; channels_found++; break; } @@ -105,6 +130,15 @@ gst_ffmpeg_channel_layout_to_gst (guint64 channel_layout, gint channels, } else { guint i, j; + /* Special path for mono, as AV_CH_LAYOUT_MONO is the same + * as FRONT_CENTER but we distinguish between the two in + * GStreamer + */ + if (channels == 1 && channel_layout == AV_CH_LAYOUT_MONO) { + pos[0] = GST_AUDIO_CHANNEL_POSITION_MONO; + return TRUE; + } + for (i = 0; i < 64; i++) { if ((channel_layout & (G_GUINT64_CONSTANT (1) << i)) != 0) { nchannels++; @@ -159,6 +193,70 @@ gst_ffmpeg_channel_layout_to_gst (guint64 channel_layout, gint channels, return TRUE; } +static gboolean +_gst_value_list_contains (const GValue * list, const GValue * value) +{ + guint i, n; + const GValue *tmp; + + n = gst_value_list_get_size (list); + for (i = 0; i < n; i++) { + tmp = gst_value_list_get_value (list, i); + if (gst_value_compare (value, tmp) == GST_VALUE_EQUAL) + return TRUE; + } + + return FALSE; +} + +static void +gst_ffmpeg_video_set_pix_fmts (GstCaps * caps, const enum AVPixelFormat *fmts) +{ + GValue va = { 0, }; + GValue v = { 0, }; + GstVideoFormat format; + + if (!fmts || fmts[0] == -1) { + gint i; + + g_value_init (&va, GST_TYPE_LIST); + g_value_init (&v, G_TYPE_STRING); + for (i = 0; i <= AV_PIX_FMT_NB; i++) { + format = gst_ffmpeg_pixfmt_to_videoformat (i); + if (format == GST_VIDEO_FORMAT_UNKNOWN) + continue; + g_value_set_string (&v, gst_video_format_to_string (format)); + gst_value_list_append_value (&va, &v); + } + gst_caps_set_value (caps, "format", &va); + g_value_unset (&v); + g_value_unset (&va); + return; + } + + /* Only a single format */ + g_value_init (&va, GST_TYPE_LIST); + g_value_init (&v, G_TYPE_STRING); + while (*fmts != -1) { + format = gst_ffmpeg_pixfmt_to_videoformat (*fmts); + if (format != GST_VIDEO_FORMAT_UNKNOWN) { + g_value_set_string (&v, gst_video_format_to_string (format)); + /* Only append values we don't have yet */ + if (!_gst_value_list_contains (&va, &v)) + gst_value_list_append_value (&va, &v); + } + fmts++; + } + if (gst_value_list_get_size (&va) == 1) { + /* The single value is still in v */ + gst_caps_set_value (caps, "format", &v); + } else if (gst_value_list_get_size (&va) > 1) { + gst_caps_set_value (caps, "format", &va); + } + g_value_unset (&v); + g_value_unset (&va); +} + /* this macro makes a caps width fixed or unfixed width/height * properties depending on whether we've got a context. * @@ -169,7 +267,7 @@ gst_ffmpeg_channel_layout_to_gst (guint64 channel_layout, gint channels, */ static GstCaps * gst_ff_vid_caps_new (AVCodecContext * context, AVCodec * codec, - enum CodecID codec_id, gboolean encode, const char *mimetype, + enum AVCodecID codec_id, gboolean encode, const char *mimetype, const char *fieldname, ...) { GstCaps *caps = NULL; @@ -204,7 +302,7 @@ gst_ff_vid_caps_new (AVCodecContext * context, AVCodec * codec, } else if (encode) { /* so we are after restricted caps in this case */ switch (codec_id) { - case CODEC_ID_H261: + case AV_CODEC_ID_H261: { caps = gst_caps_new_simple (mimetype, "width", G_TYPE_INT, 352, @@ -216,7 +314,7 @@ gst_ff_vid_caps_new (AVCodecContext * context, AVCodec * codec, "framerate", GST_TYPE_FRACTION_RANGE, 0, 1, G_MAXINT, 1, NULL)); break; } - case CODEC_ID_H263: + case AV_CODEC_ID_H263: { /* 128x96, 176x144, 352x288, 704x576, and 1408x1152. slightly reordered * because we want automatic negotiation to go as close to 320x240 as @@ -237,40 +335,66 @@ gst_ff_vid_caps_new (AVCodecContext * context, AVCodec * codec, } break; } - case CODEC_ID_DVVIDEO: + case AV_CODEC_ID_DVVIDEO: { static struct { - guint32 csp; + const gchar *csp; gint width, height; gint par_n, par_d; gint framerate_n, framerate_d; } profiles[] = { { - GST_MAKE_FOURCC ('Y', '4', '1', 'B'), 720, 480, 10, 11, 30000, 1001}, { - GST_MAKE_FOURCC ('Y', '4', '1', 'B'), 720, 480, 40, 33, 30000, 1001}, { - GST_MAKE_FOURCC ('I', '4', '2', '0'), 720, 576, 59, 54, 25, 1}, { - GST_MAKE_FOURCC ('I', '4', '2', '0'), 720, 576, 118, 81, 25, 1}, { - GST_MAKE_FOURCC ('Y', '4', '1', 'B'), 720, 576, 59, 54, 25, 1}, { - GST_MAKE_FOURCC ('Y', '4', '1', 'B'), 720, 576, 118, 81, 25, 1} - }; + "Y41B", 720, 480, 8, 9, 30000, 1001}, { + "Y41B", 720, 480, 32, 27, 30000, 1001}, { + "Y42B", 720, 480, 8, 9, 30000, 1001}, { + "Y42B", 720, 480, 32, 27, 30000, 1001}, { + "I420", 720, 576, 16, 15, 25, 1}, { + "I420", 720, 576, 64, 45, 25, 1}, { + "Y41B", 720, 576, 16, 15, 25, 1}, { + "Y41B", 720, 576, 64, 45, 25, 1}, { + "Y42B", 720, 576, 16, 15, 25, 1}, { + "Y42B", 720, 576, 64, 45, 25, 1}, { + "Y42B", 1280, 1080, 1, 1, 30000, 1001}, { + "Y42B", 1280, 1080, 3, 2, 30000, 1001}, { + "Y42B", 1440, 1080, 1, 1, 25, 1}, { + "Y42B", 1440, 1080, 4, 3, 25, 1}, { + "Y42B", 960, 720, 1, 1, 60000, 1001}, { + "Y42B", 960, 720, 4, 3, 60000, 1001}, { + "Y42B", 960, 720, 1, 1, 50, 1}, { + "Y42B", 960, 720, 4, 3, 50, 1},}; GstCaps *temp; gint n_sizes = G_N_ELEMENTS (profiles); - caps = gst_caps_new_empty (); - for (i = 0; i < n_sizes; i++) { - temp = gst_caps_new_simple (mimetype, - "width", G_TYPE_INT, profiles[i].width, - "height", G_TYPE_INT, profiles[i].height, - "framerate", GST_TYPE_FRACTION, profiles[i].framerate_n, - profiles[i].framerate_d, "pixel-aspect-ratio", GST_TYPE_FRACTION, - profiles[i].par_n, profiles[i].par_d, NULL); - - gst_caps_append (caps, temp); + if (strcmp (mimetype, "video/x-raw") == 0) { + caps = gst_caps_new_empty (); + for (i = 0; i < n_sizes; i++) { + temp = gst_caps_new_simple (mimetype, + "format", G_TYPE_STRING, profiles[i].csp, + "width", G_TYPE_INT, profiles[i].width, + "height", G_TYPE_INT, profiles[i].height, + "framerate", GST_TYPE_FRACTION, profiles[i].framerate_n, + profiles[i].framerate_d, "pixel-aspect-ratio", + GST_TYPE_FRACTION, profiles[i].par_n, profiles[i].par_d, NULL); + + gst_caps_append (caps, temp); + } + } else { + caps = gst_caps_new_empty (); + for (i = 0; i < n_sizes; i++) { + temp = gst_caps_new_simple (mimetype, + "width", G_TYPE_INT, profiles[i].width, + "height", G_TYPE_INT, profiles[i].height, + "framerate", GST_TYPE_FRACTION, profiles[i].framerate_n, + profiles[i].framerate_d, "pixel-aspect-ratio", + GST_TYPE_FRACTION, profiles[i].par_n, profiles[i].par_d, NULL); + + gst_caps_append (caps, temp); + } } break; } - case CODEC_ID_DNXHD: + case AV_CODEC_ID_DNXHD: { caps = gst_caps_new_simple (mimetype, "width", G_TYPE_INT, 1920, @@ -310,6 +434,9 @@ gst_ff_vid_caps_new (AVCodecContext * context, AVCodec * codec, g_value_unset (&va); g_value_unset (&v); } + + } else { + caps = gst_caps_new_empty_simple (mimetype); } break; @@ -321,7 +448,7 @@ gst_ff_vid_caps_new (AVCodecContext * context, AVCodec * codec, * default unfixed setting */ if (!caps) { GST_DEBUG ("Creating default caps"); - caps = gst_caps_new_simple (mimetype, NULL, NULL, NULL); + caps = gst_caps_new_empty_simple (mimetype); } va_start (var_args, fieldname); @@ -345,11 +472,59 @@ get_nbits_set (guint64 n) return x; } +static void +gst_ffmpeg_audio_set_sample_fmts (GstCaps * caps, + const enum AVSampleFormat *fmts) +{ + GValue va = { 0, }; + GValue v = { 0, }; + GstAudioFormat format; + + if (!fmts || fmts[0] == -1) { + gint i; + + g_value_init (&va, GST_TYPE_LIST); + g_value_init (&v, G_TYPE_STRING); + for (i = 0; i <= AV_SAMPLE_FMT_DBL; i++) { + format = gst_ffmpeg_smpfmt_to_audioformat (i); + if (format == GST_AUDIO_FORMAT_UNKNOWN) + continue; + g_value_set_string (&v, gst_audio_format_to_string (format)); + gst_value_list_append_value (&va, &v); + } + gst_caps_set_value (caps, "format", &va); + g_value_unset (&v); + g_value_unset (&va); + return; + } + + g_value_init (&va, GST_TYPE_LIST); + g_value_init (&v, G_TYPE_STRING); + while (*fmts != -1) { + format = gst_ffmpeg_smpfmt_to_audioformat (*fmts); + if (format != GST_AUDIO_FORMAT_UNKNOWN) { + g_value_set_string (&v, gst_audio_format_to_string (format)); + /* Only append values we don't have yet */ + if (!_gst_value_list_contains (&va, &v)) + gst_value_list_append_value (&va, &v); + } + fmts++; + } + if (gst_value_list_get_size (&va) == 1) { + /* The single value is still in v */ + gst_caps_set_value (caps, "format", &v); + } else if (gst_value_list_get_size (&va) > 1) { + gst_caps_set_value (caps, "format", &va); + } + g_value_unset (&v); + g_value_unset (&va); +} + /* same for audio - now with channels/sample rate */ static GstCaps * gst_ff_aud_caps_new (AVCodecContext * context, AVCodec * codec, - enum CodecID codec_id, gboolean encode, const char *mimetype, + enum AVCodecID codec_id, gboolean encode, const char *mimetype, const char *fieldname, ...) { GstCaps *caps = NULL; @@ -359,20 +534,18 @@ gst_ff_aud_caps_new (AVCodecContext * context, AVCodec * codec, /* fixed, non-probing context */ if (context != NULL && context->channels != -1) { GstAudioChannelPosition pos[64]; + guint64 mask; caps = gst_caps_new_simple (mimetype, "rate", G_TYPE_INT, context->sample_rate, "channels", G_TYPE_INT, context->channels, NULL); - if (gst_ffmpeg_channel_layout_to_gst (context->channel_layout, - context->channels, pos)) { - guint64 mask; - - if (gst_audio_channel_positions_to_mask (pos, context->channels, FALSE, - &mask)) { - gst_caps_set_simple (caps, "channel-mask", GST_TYPE_BITMASK, mask, - NULL); - } + if (context->channels > 1 && + gst_ffmpeg_channel_layout_to_gst (context->channel_layout, + context->channels, pos) && + gst_audio_channel_positions_to_mask (pos, context->channels, FALSE, + &mask)) { + gst_caps_set_simple (caps, "channel-mask", GST_TYPE_BITMASK, mask, NULL); } } else if (encode) { gint maxchannels = 2; @@ -381,12 +554,12 @@ gst_ff_aud_caps_new (AVCodecContext * context, AVCodec * codec, /* so we must be after restricted caps in this case */ switch (codec_id) { - case CODEC_ID_AAC: - case CODEC_ID_AAC_LATM: - case CODEC_ID_DTS: + case AV_CODEC_ID_AAC: + case AV_CODEC_ID_AAC_LATM: + case AV_CODEC_ID_DTS: maxchannels = 6; break; - case CODEC_ID_MP2: + case AV_CODEC_ID_MP2: { const static gint l_rates[] = { 48000, 44100, 32000, 24000, 22050, 16000 }; @@ -394,8 +567,8 @@ gst_ff_aud_caps_new (AVCodecContext * context, AVCodec * codec, rates = l_rates; break; } - case CODEC_ID_EAC3: - case CODEC_ID_AC3: + case AV_CODEC_ID_EAC3: + case AV_CODEC_ID_AC3: { const static gint l_rates[] = { 48000, 44100, 32000 }; maxchannels = 6; @@ -403,7 +576,7 @@ gst_ff_aud_caps_new (AVCodecContext * context, AVCodec * codec, rates = l_rates; break; } - case CODEC_ID_ADPCM_G722: + case AV_CODEC_ID_ADPCM_G722: { const static gint l_rates[] = { 16000 }; n_rates = G_N_ELEMENTS (l_rates); @@ -411,7 +584,7 @@ gst_ff_aud_caps_new (AVCodecContext * context, AVCodec * codec, maxchannels = 1; break; } - case CODEC_ID_ADPCM_G726: + case AV_CODEC_ID_ADPCM_G726: { const static gint l_rates[] = { 8000 }; n_rates = G_N_ELEMENTS (l_rates); @@ -419,21 +592,21 @@ gst_ff_aud_caps_new (AVCodecContext * context, AVCodec * codec, maxchannels = 1; break; } - case CODEC_ID_ADPCM_SWF: + case AV_CODEC_ID_ADPCM_SWF: { const static gint l_rates[] = { 11025, 22050, 44100 }; n_rates = G_N_ELEMENTS (l_rates); rates = l_rates; break; } - case CODEC_ID_ROQ_DPCM: + case AV_CODEC_ID_ROQ_DPCM: { const static gint l_rates[] = { 22050 }; n_rates = G_N_ELEMENTS (l_rates); rates = l_rates; break; } - case CODEC_ID_AMR_NB: + case AV_CODEC_ID_AMR_NB: { const static gint l_rates[] = { 8000 }; maxchannels = 1; @@ -441,7 +614,7 @@ gst_ff_aud_caps_new (AVCodecContext * context, AVCodec * codec, rates = l_rates; break; } - case CODEC_ID_AMR_WB: + case AV_CODEC_ID_AMR_WB: { const static gint l_rates[] = { 16000 }; maxchannels = 1; @@ -457,8 +630,8 @@ gst_ff_aud_caps_new (AVCodecContext * context, AVCodec * codec, /* Until decoders/encoders expose the maximum number of channels * they support, we whitelist them here. */ switch (codec_id) { - case CODEC_ID_WMAPRO: - case CODEC_ID_TRUEHD: + case AV_CODEC_ID_WMAPRO: + case AV_CODEC_ID_TRUEHD: maxchannels = 8; break; default: @@ -565,7 +738,7 @@ gst_ff_aud_caps_new (AVCodecContext * context, AVCodec * codec, */ GstCaps * -gst_ffmpeg_codecid_to_caps (enum CodecID codec_id, +gst_ffmpeg_codecid_to_caps (enum AVCodecID codec_id, AVCodecContext * context, gboolean encode) { GstCaps *caps = NULL; @@ -574,14 +747,14 @@ gst_ffmpeg_codecid_to_caps (enum CodecID codec_id, GST_LOG ("codec_id:%d, context:%p, encode:%d", codec_id, context, encode); switch (codec_id) { - case CODEC_ID_MPEG1VIDEO: + case AV_CODEC_ID_MPEG1VIDEO: /* FIXME: bitrate */ caps = gst_ff_vid_caps_new (context, NULL, codec_id, encode, "video/mpeg", "mpegversion", G_TYPE_INT, 1, "systemstream", G_TYPE_BOOLEAN, FALSE, NULL); break; - case CODEC_ID_MPEG2VIDEO: + case AV_CODEC_ID_MPEG2VIDEO: if (encode) { /* FIXME: bitrate */ caps = @@ -597,11 +770,7 @@ gst_ffmpeg_codecid_to_caps (enum CodecID codec_id, } break; - case CODEC_ID_MPEG2VIDEO_XVMC: - /* this is a special ID - don't need it in GStreamer, I think */ - break; - - case CODEC_ID_H263: + case AV_CODEC_ID_H263: if (encode) { caps = gst_ff_vid_caps_new (context, NULL, codec_id, encode, @@ -612,12 +781,12 @@ gst_ffmpeg_codecid_to_caps (enum CodecID codec_id, * decoder that don't have specific size requirements */ caps = - gst_ff_vid_caps_new (context, NULL, CODEC_ID_NONE, encode, + gst_ff_vid_caps_new (context, NULL, AV_CODEC_ID_NONE, encode, "video/x-h263", "variant", G_TYPE_STRING, "itu", NULL); } break; - case CODEC_ID_H263P: + case AV_CODEC_ID_H263P: caps = gst_ff_vid_caps_new (context, NULL, codec_id, encode, "video/x-h263", "variant", G_TYPE_STRING, "itu", "h263version", G_TYPE_STRING, @@ -633,33 +802,33 @@ gst_ffmpeg_codecid_to_caps (enum CodecID codec_id, } break; - case CODEC_ID_H263I: + case AV_CODEC_ID_H263I: caps = gst_ff_vid_caps_new (context, NULL, codec_id, encode, "video/x-intel-h263", "variant", G_TYPE_STRING, "intel", NULL); break; - case CODEC_ID_H261: + case AV_CODEC_ID_H261: caps = gst_ff_vid_caps_new (context, NULL, codec_id, encode, "video/x-h261", NULL); break; - case CODEC_ID_RV10: - case CODEC_ID_RV20: - case CODEC_ID_RV30: - case CODEC_ID_RV40: + case AV_CODEC_ID_RV10: + case AV_CODEC_ID_RV20: + case AV_CODEC_ID_RV30: + case AV_CODEC_ID_RV40: { gint version; switch (codec_id) { - case CODEC_ID_RV40: + case AV_CODEC_ID_RV40: version = 4; break; - case CODEC_ID_RV30: + case AV_CODEC_ID_RV30: version = 3; break; - case CODEC_ID_RV20: + case AV_CODEC_ID_RV20: version = 2; break; default: @@ -667,13 +836,10 @@ gst_ffmpeg_codecid_to_caps (enum CodecID codec_id, break; } - /* FIXME: context->sub_id must be filled in during decoding */ caps = gst_ff_vid_caps_new (context, NULL, codec_id, encode, - "video/x-pn-realvideo", "systemstream", G_TYPE_BOOLEAN, FALSE, - "rmversion", G_TYPE_INT, version, NULL); + "video/x-pn-realvideo", "rmversion", G_TYPE_INT, version, NULL); if (context) { - gst_caps_set_simple (caps, "format", G_TYPE_INT, context->sub_id, NULL); if (context->extradata_size >= 8) { gst_caps_set_simple (caps, "subformat", G_TYPE_INT, GST_READ_UINT32_BE (context->extradata), @@ -683,19 +849,19 @@ gst_ffmpeg_codecid_to_caps (enum CodecID codec_id, } break; - case CODEC_ID_MP1: + case AV_CODEC_ID_MP1: /* FIXME: bitrate */ caps = gst_ff_aud_caps_new (context, NULL, codec_id, encode, "audio/mpeg", "mpegversion", G_TYPE_INT, 1, "layer", G_TYPE_INT, 1, NULL); break; - case CODEC_ID_MP2: + case AV_CODEC_ID_MP2: /* FIXME: bitrate */ caps = gst_ff_aud_caps_new (context, NULL, codec_id, encode, "audio/mpeg", "mpegversion", G_TYPE_INT, 1, "layer", G_TYPE_INT, 2, NULL); break; - case CODEC_ID_MP3: + case AV_CODEC_ID_MP3: if (encode) { /* FIXME: bitrate */ caps = @@ -710,59 +876,59 @@ gst_ffmpeg_codecid_to_caps (enum CodecID codec_id, } break; - case CODEC_ID_MUSEPACK7: + case AV_CODEC_ID_MUSEPACK7: caps = gst_ff_aud_caps_new (context, NULL, codec_id, encode, "audio/x-ffmpeg-parsed-musepack", "streamversion", G_TYPE_INT, 7, NULL); break; - case CODEC_ID_MUSEPACK8: + case AV_CODEC_ID_MUSEPACK8: caps = gst_ff_aud_caps_new (context, NULL, codec_id, encode, "audio/x-ffmpeg-parsed-musepack", "streamversion", G_TYPE_INT, 8, NULL); break; - case CODEC_ID_AC3: + case AV_CODEC_ID_AC3: /* FIXME: bitrate */ caps = gst_ff_aud_caps_new (context, NULL, codec_id, encode, "audio/x-ac3", NULL); break; - case CODEC_ID_EAC3: + case AV_CODEC_ID_EAC3: /* FIXME: bitrate */ caps = gst_ff_aud_caps_new (context, NULL, codec_id, encode, "audio/x-eac3", NULL); break; - case CODEC_ID_TRUEHD: + case AV_CODEC_ID_TRUEHD: caps = gst_ff_aud_caps_new (context, NULL, codec_id, encode, "audio/x-true-hd", NULL); break; - case CODEC_ID_ATRAC1: + case AV_CODEC_ID_ATRAC1: caps = gst_ff_aud_caps_new (context, NULL, codec_id, encode, "audio/x-vnd.sony.atrac1", NULL); break; - case CODEC_ID_ATRAC3: + case AV_CODEC_ID_ATRAC3: caps = gst_ff_aud_caps_new (context, NULL, codec_id, encode, "audio/x-vnd.sony.atrac3", NULL); break; - case CODEC_ID_DTS: + case AV_CODEC_ID_DTS: caps = gst_ff_aud_caps_new (context, NULL, codec_id, encode, "audio/x-dts", NULL); break; - case CODEC_ID_APE: + case AV_CODEC_ID_APE: caps = gst_ff_aud_caps_new (context, NULL, codec_id, encode, "audio/x-ffmpeg-parsed-ape", NULL); @@ -772,13 +938,13 @@ gst_ffmpeg_codecid_to_caps (enum CodecID codec_id, } break; - case CODEC_ID_MLP: + case AV_CODEC_ID_MLP: caps = gst_ff_aud_caps_new (context, NULL, codec_id, encode, "audio/x-mlp", NULL); break; - case CODEC_ID_IMC: + case AV_CODEC_ID_IMC: caps = gst_ff_aud_caps_new (context, NULL, codec_id, encode, "audio/x-imc", NULL); @@ -789,26 +955,38 @@ gst_ffmpeg_codecid_to_caps (enum CodecID codec_id, * sp5x is, but it's apparently something JPEG... We don't separate * between those in GStreamer. Should we (at least between MJPEG, * MJPEG-B and sp5x decoding...)? */ - case CODEC_ID_MJPEG: - case CODEC_ID_LJPEG: + case AV_CODEC_ID_MJPEG: + case AV_CODEC_ID_LJPEG: caps = gst_ff_vid_caps_new (context, NULL, codec_id, encode, "image/jpeg", + "parsed", G_TYPE_BOOLEAN, TRUE, NULL); + break; + + case AV_CODEC_ID_JPEG2000: + caps = + gst_ff_vid_caps_new (context, NULL, codec_id, encode, "image/x-j2c", NULL); + if (!encode) { + gst_caps_append (caps, gst_ff_vid_caps_new (context, NULL, codec_id, + encode, "image/x-jpc", NULL)); + gst_caps_append (caps, gst_ff_vid_caps_new (context, NULL, codec_id, + encode, "image/jp2", NULL)); + } break; - case CODEC_ID_SP5X: + case AV_CODEC_ID_SP5X: caps = gst_ff_vid_caps_new (context, NULL, codec_id, encode, "video/sp5x", NULL); break; - case CODEC_ID_MJPEGB: + case AV_CODEC_ID_MJPEGB: caps = gst_ff_vid_caps_new (context, NULL, codec_id, encode, "video/x-mjpeg-b", NULL); break; - case CODEC_ID_MPEG4: + case AV_CODEC_ID_MPEG4: if (encode && context != NULL) { /* I'm not exactly sure what ffmpeg outputs... ffmpeg itself uses * the AVI fourcc 'DIVX', but 'mp4v' for Quicktime... */ @@ -820,7 +998,7 @@ gst_ffmpeg_codecid_to_caps (enum CodecID codec_id, break; case GST_MAKE_FOURCC ('m', 'p', '4', 'v'): default: - /* FIXME: bitrate */ + /* FIXME: bitrate. libav doesn't expose the used profile and level */ caps = gst_ff_vid_caps_new (context, NULL, codec_id, encode, "video/mpeg", "systemstream", G_TYPE_BOOLEAN, FALSE, @@ -833,47 +1011,58 @@ gst_ffmpeg_codecid_to_caps (enum CodecID codec_id, gst_ff_vid_caps_new (context, NULL, codec_id, encode, "video/mpeg", "mpegversion", G_TYPE_INT, 4, "systemstream", G_TYPE_BOOLEAN, FALSE, NULL); + if (encode) { + GValue arr = { 0, }; + GValue item = { 0, }; + + g_value_init (&arr, GST_TYPE_LIST); + g_value_init (&item, G_TYPE_STRING); + g_value_set_string (&item, "simple"); + gst_value_list_append_value (&arr, &item); + g_value_set_string (&item, "advanced-simple"); + gst_value_list_append_value (&arr, &item); + g_value_unset (&item); + + gst_caps_set_value (caps, "profile", &arr); + g_value_unset (&arr); + gst_caps_append (caps, gst_ff_vid_caps_new (context, NULL, codec_id, encode, "video/x-divx", "divxversion", G_TYPE_INT, 5, NULL)); } else { gst_caps_append (caps, gst_ff_vid_caps_new (context, NULL, codec_id, encode, "video/x-divx", "divxversion", GST_TYPE_INT_RANGE, 4, 5, NULL)); - gst_caps_append (caps, gst_ff_vid_caps_new (context, NULL, codec_id, - encode, "video/x-xvid", NULL)); - gst_caps_append (caps, gst_ff_vid_caps_new (context, NULL, codec_id, - encode, "video/x-3ivx", NULL)); } } break; - case CODEC_ID_RAWVIDEO: + case AV_CODEC_ID_RAWVIDEO: caps = gst_ffmpeg_codectype_to_video_caps (context, codec_id, encode, NULL); break; - case CODEC_ID_MSMPEG4V1: - case CODEC_ID_MSMPEG4V2: - case CODEC_ID_MSMPEG4V3: + case AV_CODEC_ID_MSMPEG4V1: + case AV_CODEC_ID_MSMPEG4V2: + case AV_CODEC_ID_MSMPEG4V3: { - gint version = 41 + codec_id - CODEC_ID_MSMPEG4V1; + gint version = 41 + codec_id - AV_CODEC_ID_MSMPEG4V1; /* encode-FIXME: bitrate */ caps = gst_ff_vid_caps_new (context, NULL, codec_id, encode, "video/x-msmpeg", "msmpegversion", G_TYPE_INT, version, NULL); - if (!encode && codec_id == CODEC_ID_MSMPEG4V3) { + if (!encode && codec_id == AV_CODEC_ID_MSMPEG4V3) { gst_caps_append (caps, gst_ff_vid_caps_new (context, NULL, codec_id, encode, "video/x-divx", "divxversion", G_TYPE_INT, 3, NULL)); } } break; - case CODEC_ID_WMV1: - case CODEC_ID_WMV2: + case AV_CODEC_ID_WMV1: + case AV_CODEC_ID_WMV2: { - gint version = (codec_id == CODEC_ID_WMV1) ? 1 : 2; + gint version = (codec_id == AV_CODEC_ID_WMV1) ? 1 : 2; caps = gst_ff_vid_caps_new (context, NULL, codec_id, encode, "video/x-wmv", @@ -881,52 +1070,52 @@ gst_ffmpeg_codecid_to_caps (enum CodecID codec_id, } break; - case CODEC_ID_FLV1: + case AV_CODEC_ID_FLV1: caps = gst_ff_vid_caps_new (context, NULL, codec_id, encode, "video/x-flash-video", "flvversion", G_TYPE_INT, 1, NULL); break; - case CODEC_ID_SVQ1: + case AV_CODEC_ID_SVQ1: caps = gst_ff_vid_caps_new (context, NULL, codec_id, encode, "video/x-svq", "svqversion", G_TYPE_INT, 1, NULL); break; - case CODEC_ID_SVQ3: + case AV_CODEC_ID_SVQ3: caps = gst_ff_vid_caps_new (context, NULL, codec_id, encode, "video/x-svq", "svqversion", G_TYPE_INT, 3, NULL); break; - case CODEC_ID_DVAUDIO: + case AV_CODEC_ID_DVAUDIO: caps = gst_ff_aud_caps_new (context, NULL, codec_id, encode, "audio/x-dv", NULL); break; - case CODEC_ID_DVVIDEO: + case AV_CODEC_ID_DVVIDEO: { if (encode && context) { const gchar *format; switch (context->pix_fmt) { - case PIX_FMT_YUYV422: + case AV_PIX_FMT_YUYV422: format = "YUY2"; break; - case PIX_FMT_YUV420P: + case AV_PIX_FMT_YUV420P: format = "I420"; break; - case PIX_FMT_YUVA420P: + case AV_PIX_FMT_YUVA420P: format = "A420"; break; - case PIX_FMT_YUV411P: + case AV_PIX_FMT_YUV411P: format = "Y41B"; break; - case PIX_FMT_YUV422P: + case AV_PIX_FMT_YUV422P: format = "Y42B"; break; - case PIX_FMT_YUV410P: + case AV_PIX_FMT_YUV410P: format = "YUV9"; break; default: @@ -948,17 +1137,17 @@ gst_ffmpeg_codecid_to_caps (enum CodecID codec_id, } break; - case CODEC_ID_WMAV1: - case CODEC_ID_WMAV2: + case AV_CODEC_ID_WMAV1: + case AV_CODEC_ID_WMAV2: { - gint version = (codec_id == CODEC_ID_WMAV1) ? 1 : 2; + gint version = (codec_id == AV_CODEC_ID_WMAV1) ? 1 : 2; if (context) { caps = gst_ff_aud_caps_new (context, NULL, codec_id, encode, "audio/x-wma", "wmaversion", G_TYPE_INT, version, "block_align", G_TYPE_INT, - context->block_align, "bitrate", G_TYPE_INT, context->bit_rate, - NULL); + context->block_align, "bitrate", G_TYPE_INT, + (guint) context->bit_rate, NULL); } else { caps = gst_ff_aud_caps_new (context, NULL, codec_id, encode, "audio/x-wma", @@ -968,15 +1157,22 @@ gst_ffmpeg_codecid_to_caps (enum CodecID codec_id, } } break; - case CODEC_ID_WMAPRO: + case AV_CODEC_ID_WMAPRO: { caps = gst_ff_aud_caps_new (context, NULL, codec_id, encode, "audio/x-wma", "wmaversion", G_TYPE_INT, 3, NULL); break; } - - case CODEC_ID_WMAVOICE: + case AV_CODEC_ID_WMALOSSLESS: + { + /* libav only supports a depth of 16 at the moment */ + caps = + gst_ff_aud_caps_new (context, NULL, codec_id, encode, "audio/x-wma", + "wmaversion", G_TYPE_INT, 4, "depth", G_TYPE_INT, 16, NULL); + break; + } + case AV_CODEC_ID_WMAVOICE: { caps = gst_ff_aud_caps_new (context, NULL, codec_id, encode, "audio/x-wms", @@ -984,10 +1180,10 @@ gst_ffmpeg_codecid_to_caps (enum CodecID codec_id, break; } - case CODEC_ID_MACE3: - case CODEC_ID_MACE6: + case AV_CODEC_ID_MACE3: + case AV_CODEC_ID_MACE6: { - gint version = (codec_id == CODEC_ID_MACE3) ? 3 : 6; + gint version = (codec_id == AV_CODEC_ID_MACE3) ? 3 : 6; caps = gst_ff_aud_caps_new (context, NULL, codec_id, encode, "audio/x-mace", @@ -995,7 +1191,7 @@ gst_ffmpeg_codecid_to_caps (enum CodecID codec_id, } break; - case CODEC_ID_HUFFYUV: + case AV_CODEC_ID_HUFFYUV: caps = gst_ff_vid_caps_new (context, NULL, codec_id, encode, "video/x-huffyuv", NULL); @@ -1005,91 +1201,131 @@ gst_ffmpeg_codecid_to_caps (enum CodecID codec_id, } break; - case CODEC_ID_CYUV: + case AV_CODEC_ID_CYUV: caps = gst_ff_vid_caps_new (context, NULL, codec_id, encode, "video/x-compressed-yuv", NULL); break; - case CODEC_ID_H264: + case AV_CODEC_ID_H264: caps = gst_ff_vid_caps_new (context, NULL, codec_id, encode, "video/x-h264", "alignment", G_TYPE_STRING, "au", NULL); + if (!encode) { + GValue arr = { 0, }; + GValue item = { 0, }; + g_value_init (&arr, GST_TYPE_LIST); + g_value_init (&item, G_TYPE_STRING); + g_value_set_string (&item, "avc"); + gst_value_list_append_value (&arr, &item); + g_value_set_string (&item, "byte-stream"); + gst_value_list_append_value (&arr, &item); + g_value_unset (&item); + gst_caps_set_value (caps, "stream-format", &arr); + g_value_unset (&arr); + } + break; + + case AV_CODEC_ID_HEVC: + caps = + gst_ff_vid_caps_new (context, NULL, codec_id, encode, "video/x-h265", + "alignment", G_TYPE_STRING, "au", NULL); + if (!encode) { + GValue arr = { 0, }; + GValue item = { 0, }; + g_value_init (&arr, GST_TYPE_LIST); + g_value_init (&item, G_TYPE_STRING); + g_value_set_string (&item, "hvc1"); + gst_value_list_append_value (&arr, &item); + g_value_set_string (&item, "hev1"); + gst_value_list_append_value (&arr, &item); + g_value_set_string (&item, "byte-stream"); + gst_value_list_append_value (&arr, &item); + g_value_unset (&item); + gst_caps_set_value (caps, "stream-format", &arr); + g_value_unset (&arr); + } break; - case CODEC_ID_INDEO5: + case AV_CODEC_ID_INDEO5: caps = gst_ff_vid_caps_new (context, NULL, codec_id, encode, "video/x-indeo", "indeoversion", G_TYPE_INT, 5, NULL); break; - case CODEC_ID_INDEO4: + case AV_CODEC_ID_INDEO4: caps = gst_ff_vid_caps_new (context, NULL, codec_id, encode, "video/x-indeo", "indeoversion", G_TYPE_INT, 4, NULL); break; - case CODEC_ID_INDEO3: + case AV_CODEC_ID_INDEO3: caps = gst_ff_vid_caps_new (context, NULL, codec_id, encode, "video/x-indeo", "indeoversion", G_TYPE_INT, 3, NULL); break; - case CODEC_ID_INDEO2: + case AV_CODEC_ID_INDEO2: caps = gst_ff_vid_caps_new (context, NULL, codec_id, encode, "video/x-indeo", "indeoversion", G_TYPE_INT, 2, NULL); break; - case CODEC_ID_FLASHSV: + case AV_CODEC_ID_FLASHSV: caps = gst_ff_vid_caps_new (context, NULL, codec_id, encode, "video/x-flash-screen", NULL); break; - case CODEC_ID_VP3: + case AV_CODEC_ID_VP3: caps = gst_ff_vid_caps_new (context, NULL, codec_id, encode, "video/x-vp3", NULL); break; - case CODEC_ID_VP5: + case AV_CODEC_ID_VP5: caps = gst_ff_vid_caps_new (context, NULL, codec_id, encode, "video/x-vp5", NULL); break; - case CODEC_ID_VP6: + case AV_CODEC_ID_VP6: caps = gst_ff_vid_caps_new (context, NULL, codec_id, encode, "video/x-vp6", NULL); break; - case CODEC_ID_VP6F: + case AV_CODEC_ID_VP6F: caps = gst_ff_vid_caps_new (context, NULL, codec_id, encode, "video/x-vp6-flash", NULL); break; - case CODEC_ID_VP6A: + case AV_CODEC_ID_VP6A: caps = gst_ff_vid_caps_new (context, NULL, codec_id, encode, "video/x-vp6-alpha", NULL); break; - case CODEC_ID_VP8: + case AV_CODEC_ID_VP8: caps = gst_ff_vid_caps_new (context, NULL, codec_id, encode, "video/x-vp8", NULL); break; - case CODEC_ID_THEORA: + case AV_CODEC_ID_VP9: + caps = + gst_ff_vid_caps_new (context, NULL, codec_id, encode, "video/x-vp9", + NULL); + break; + + case AV_CODEC_ID_THEORA: caps = gst_ff_vid_caps_new (context, NULL, codec_id, encode, "video/x-theora", NULL); break; - case CODEC_ID_AAC: + case AV_CODEC_ID_AAC: { caps = gst_ff_aud_caps_new (context, NULL, codec_id, encode, "audio/mpeg", @@ -1134,73 +1370,73 @@ gst_ffmpeg_codecid_to_caps (enum CodecID codec_id, break; } - case CODEC_ID_AAC_LATM: /* LATM/LOAS AAC syntax */ + case AV_CODEC_ID_AAC_LATM: /* LATM/LOAS AAC syntax */ caps = gst_ff_aud_caps_new (context, NULL, codec_id, encode, "audio/mpeg", "mpegversion", G_TYPE_INT, 4, "stream-format", G_TYPE_STRING, "loas", NULL); break; - case CODEC_ID_ASV1: + case AV_CODEC_ID_ASV1: caps = gst_ff_vid_caps_new (context, NULL, codec_id, encode, "video/x-asus", "asusversion", G_TYPE_INT, 1, NULL); break; - case CODEC_ID_ASV2: + case AV_CODEC_ID_ASV2: caps = gst_ff_vid_caps_new (context, NULL, codec_id, encode, "video/x-asus", "asusversion", G_TYPE_INT, 2, NULL); break; - case CODEC_ID_FFV1: + case AV_CODEC_ID_FFV1: caps = gst_ff_vid_caps_new (context, NULL, codec_id, encode, "video/x-ffv", "ffvversion", G_TYPE_INT, 1, NULL); break; - case CODEC_ID_4XM: + case AV_CODEC_ID_4XM: caps = gst_ff_vid_caps_new (context, NULL, codec_id, encode, "video/x-4xm", NULL); break; - case CODEC_ID_XAN_WC3: - case CODEC_ID_XAN_WC4: + case AV_CODEC_ID_XAN_WC3: + case AV_CODEC_ID_XAN_WC4: caps = gst_ff_vid_caps_new (context, NULL, codec_id, encode, "video/x-xan", - "wcversion", G_TYPE_INT, 3 - CODEC_ID_XAN_WC3 + codec_id, NULL); + "wcversion", G_TYPE_INT, 3 - AV_CODEC_ID_XAN_WC3 + codec_id, NULL); break; - case CODEC_ID_CLJR: + case AV_CODEC_ID_CLJR: caps = gst_ff_vid_caps_new (context, NULL, codec_id, encode, "video/x-cirrus-logic-accupak", NULL); break; - case CODEC_ID_FRAPS: + case AV_CODEC_ID_FRAPS: caps = gst_ff_vid_caps_new (context, NULL, codec_id, encode, "video/x-fraps", NULL); break; - case CODEC_ID_MDEC: - case CODEC_ID_ROQ: - case CODEC_ID_INTERPLAY_VIDEO: + case AV_CODEC_ID_MDEC: + case AV_CODEC_ID_ROQ: + case AV_CODEC_ID_INTERPLAY_VIDEO: buildcaps = TRUE; break; - case CODEC_ID_VCR1: + case AV_CODEC_ID_VCR1: caps = gst_ff_vid_caps_new (context, NULL, codec_id, encode, "video/x-ati-vcr", "vcrversion", G_TYPE_INT, 1, NULL); break; - case CODEC_ID_RPZA: + case AV_CODEC_ID_RPZA: caps = gst_ff_vid_caps_new (context, NULL, codec_id, encode, "video/x-apple-video", NULL); break; - case CODEC_ID_CINEPAK: + case AV_CODEC_ID_CINEPAK: caps = gst_ff_vid_caps_new (context, NULL, codec_id, encode, "video/x-cinepak", NULL); @@ -1208,7 +1444,7 @@ gst_ffmpeg_codecid_to_caps (enum CodecID codec_id, /* WS_VQA belogns here (order) */ - case CODEC_ID_MSRLE: + case AV_CODEC_ID_MSRLE: caps = gst_ff_vid_caps_new (context, NULL, codec_id, encode, "video/x-rle", "layout", G_TYPE_STRING, "microsoft", NULL); @@ -1220,7 +1456,7 @@ gst_ffmpeg_codecid_to_caps (enum CodecID codec_id, } break; - case CODEC_ID_QTRLE: + case AV_CODEC_ID_QTRLE: caps = gst_ff_vid_caps_new (context, NULL, codec_id, encode, "video/x-rle", "layout", G_TYPE_STRING, "quicktime", NULL); @@ -1232,58 +1468,85 @@ gst_ffmpeg_codecid_to_caps (enum CodecID codec_id, } break; - case CODEC_ID_MSVIDEO1: + case AV_CODEC_ID_MSVIDEO1: caps = gst_ff_vid_caps_new (context, NULL, codec_id, encode, "video/x-msvideocodec", "msvideoversion", G_TYPE_INT, 1, NULL); break; - case CODEC_ID_WMV3: + case AV_CODEC_ID_MSS1: caps = gst_ff_vid_caps_new (context, NULL, codec_id, encode, "video/x-wmv", - "wmvversion", G_TYPE_INT, 3, NULL); + "wmvversion", G_TYPE_INT, 1, "format", G_TYPE_STRING, "MSS1", NULL); + break; + + case AV_CODEC_ID_MSS2: + caps = + gst_ff_vid_caps_new (context, NULL, codec_id, encode, "video/x-wmv", + "wmvversion", G_TYPE_INT, 3, "format", G_TYPE_STRING, "MSS2", NULL); + break; + + case AV_CODEC_ID_WMV3: + caps = + gst_ff_vid_caps_new (context, NULL, codec_id, encode, "video/x-wmv", + "wmvversion", G_TYPE_INT, 3, "format", G_TYPE_STRING, "WMV3", NULL); break; - case CODEC_ID_VC1: + case AV_CODEC_ID_VC1: caps = gst_ff_vid_caps_new (context, NULL, codec_id, encode, "video/x-wmv", - "wmvversion", G_TYPE_INT, 3, "format", G_TYPE_STRING, "WVC1", NULL); + "wmvversion", G_TYPE_INT, 3, NULL); + if (!context && !encode) { + GValue arr = { 0, }; + GValue item = { 0, }; + + g_value_init (&arr, GST_TYPE_LIST); + g_value_init (&item, G_TYPE_STRING); + g_value_set_string (&item, "WVC1"); + gst_value_list_append_value (&arr, &item); + g_value_set_string (&item, "WMVA"); + gst_value_list_append_and_take_value (&arr, &item); + gst_caps_set_value (caps, "format", &arr); + g_value_unset (&arr); + } else { + gst_caps_set_simple (caps, "format", G_TYPE_STRING, "WVC1", NULL); + } break; - case CODEC_ID_QDM2: + case AV_CODEC_ID_QDM2: caps = gst_ff_aud_caps_new (context, NULL, codec_id, encode, "audio/x-qdm2", NULL); break; - case CODEC_ID_MSZH: + case AV_CODEC_ID_MSZH: caps = gst_ff_vid_caps_new (context, NULL, codec_id, encode, "video/x-mszh", NULL); break; - case CODEC_ID_ZLIB: + case AV_CODEC_ID_ZLIB: caps = gst_ff_vid_caps_new (context, NULL, codec_id, encode, "video/x-zlib", NULL); break; - case CODEC_ID_TRUEMOTION1: + case AV_CODEC_ID_TRUEMOTION1: caps = gst_ff_vid_caps_new (context, NULL, codec_id, encode, "video/x-truemotion", "trueversion", G_TYPE_INT, 1, NULL); break; - case CODEC_ID_TRUEMOTION2: + case AV_CODEC_ID_TRUEMOTION2: caps = gst_ff_vid_caps_new (context, NULL, codec_id, encode, "video/x-truemotion", "trueversion", G_TYPE_INT, 2, NULL); break; - case CODEC_ID_ULTI: + case AV_CODEC_ID_ULTI: caps = gst_ff_vid_caps_new (context, NULL, codec_id, encode, "video/x-ultimotion", NULL); break; - case CODEC_ID_TSCC: + case AV_CODEC_ID_TSCC: caps = gst_ff_vid_caps_new (context, NULL, codec_id, encode, "video/x-camtasia", NULL); @@ -1295,163 +1558,169 @@ gst_ffmpeg_codecid_to_caps (enum CodecID codec_id, } break; - case CODEC_ID_KMVC: + case AV_CODEC_ID_TSCC2: + caps = + gst_ff_vid_caps_new (context, NULL, codec_id, encode, + "video/x-tscc", "tsccversion", G_TYPE_INT, 2, NULL); + break; + + case AV_CODEC_ID_KMVC: caps = gst_ff_vid_caps_new (context, NULL, codec_id, encode, "video/x-kmvc", NULL); break; - case CODEC_ID_NUV: + case AV_CODEC_ID_NUV: caps = gst_ff_vid_caps_new (context, NULL, codec_id, encode, "video/x-nuv", NULL); break; - case CODEC_ID_GIF: + case AV_CODEC_ID_GIF: caps = gst_ff_vid_caps_new (context, NULL, codec_id, encode, "image/gif", NULL); break; - case CODEC_ID_PNG: + case AV_CODEC_ID_PNG: caps = gst_ff_vid_caps_new (context, NULL, codec_id, encode, "image/png", NULL); break; - case CODEC_ID_PPM: + case AV_CODEC_ID_PPM: caps = gst_ff_vid_caps_new (context, NULL, codec_id, encode, "image/ppm", NULL); break; - case CODEC_ID_PBM: + case AV_CODEC_ID_PBM: caps = gst_ff_vid_caps_new (context, NULL, codec_id, encode, "image/pbm", NULL); break; - case CODEC_ID_PAM: + case AV_CODEC_ID_PAM: caps = gst_ff_vid_caps_new (context, NULL, codec_id, encode, "image/x-portable-anymap", NULL); break; - case CODEC_ID_PGM: + case AV_CODEC_ID_PGM: caps = gst_ff_vid_caps_new (context, NULL, codec_id, encode, "image/x-portable-graymap", NULL); break; - case CODEC_ID_PCX: + case AV_CODEC_ID_PCX: caps = gst_ff_vid_caps_new (context, NULL, codec_id, encode, "image/x-pcx", NULL); break; - case CODEC_ID_SGI: + case AV_CODEC_ID_SGI: caps = gst_ff_vid_caps_new (context, NULL, codec_id, encode, "image/x-sgi", NULL); break; - case CODEC_ID_TARGA: + case AV_CODEC_ID_TARGA: caps = gst_ff_vid_caps_new (context, NULL, codec_id, encode, "image/x-tga", NULL); break; - case CODEC_ID_TIFF: + case AV_CODEC_ID_TIFF: caps = gst_ff_vid_caps_new (context, NULL, codec_id, encode, "image/tiff", NULL); break; - case CODEC_ID_SUNRAST: + case AV_CODEC_ID_SUNRAST: caps = gst_ff_vid_caps_new (context, NULL, codec_id, encode, "image/x-sun-raster", NULL); break; - case CODEC_ID_SMC: + case AV_CODEC_ID_SMC: caps = gst_ff_vid_caps_new (context, NULL, codec_id, encode, "video/x-smc", NULL); break; - case CODEC_ID_QDRAW: + case AV_CODEC_ID_QDRAW: caps = gst_ff_vid_caps_new (context, NULL, codec_id, encode, "video/x-qdrw", NULL); break; - case CODEC_ID_DNXHD: + case AV_CODEC_ID_DNXHD: caps = gst_ff_vid_caps_new (context, NULL, codec_id, encode, "video/x-dnxhd", NULL); break; - case CODEC_ID_PRORES: + case AV_CODEC_ID_PRORES: caps = gst_ff_vid_caps_new (context, NULL, codec_id, encode, "video/x-prores", NULL); break; - case CODEC_ID_MIMIC: + case AV_CODEC_ID_MIMIC: caps = gst_ff_vid_caps_new (context, NULL, codec_id, encode, "video/x-mimic", NULL); break; - case CODEC_ID_VMNC: + case AV_CODEC_ID_VMNC: caps = gst_ff_vid_caps_new (context, NULL, codec_id, encode, "video/x-vmnc", NULL); break; - case CODEC_ID_TRUESPEECH: + case AV_CODEC_ID_TRUESPEECH: caps = gst_ff_aud_caps_new (context, NULL, codec_id, encode, "audio/x-truespeech", NULL); break; - case CODEC_ID_QCELP: + case AV_CODEC_ID_QCELP: caps = gst_ff_aud_caps_new (context, NULL, codec_id, encode, "audio/qcelp", NULL); break; - case CODEC_ID_AMV: + case AV_CODEC_ID_AMV: caps = gst_ff_vid_caps_new (context, NULL, codec_id, encode, "video/x-amv", NULL); break; - case CODEC_ID_AASC: + case AV_CODEC_ID_AASC: caps = gst_ff_vid_caps_new (context, NULL, codec_id, encode, "video/x-aasc", NULL); break; - case CODEC_ID_LOCO: + case AV_CODEC_ID_LOCO: caps = gst_ff_vid_caps_new (context, NULL, codec_id, encode, "video/x-loco", NULL); break; - case CODEC_ID_ZMBV: + case AV_CODEC_ID_ZMBV: caps = gst_ff_vid_caps_new (context, NULL, codec_id, encode, "video/x-zmbv", NULL); break; - case CODEC_ID_LAGARITH: + case AV_CODEC_ID_LAGARITH: caps = gst_ff_vid_caps_new (context, NULL, codec_id, encode, "video/x-lagarith", NULL); break; - case CODEC_ID_CSCD: + case AV_CODEC_ID_CSCD: caps = gst_ff_vid_caps_new (context, NULL, codec_id, encode, "video/x-camstudio", NULL); @@ -1463,57 +1732,68 @@ gst_ffmpeg_codecid_to_caps (enum CodecID codec_id, } break; - case CODEC_ID_WS_VQA: - case CODEC_ID_IDCIN: - case CODEC_ID_8BPS: - case CODEC_ID_FLIC: - case CODEC_ID_VMDVIDEO: - case CODEC_ID_VMDAUDIO: - case CODEC_ID_SNOW: - case CODEC_ID_VIXL: - case CODEC_ID_QPEG: - case CODEC_ID_PGMYUV: - case CODEC_ID_FFVHUFF: - case CODEC_ID_WNV1: - case CODEC_ID_MP3ADU: - case CODEC_ID_MP3ON4: - case CODEC_ID_WESTWOOD_SND1: - case CODEC_ID_MMVIDEO: - case CODEC_ID_AVS: - case CODEC_ID_CAVS: + case AV_CODEC_ID_AIC: + caps = + gst_ff_vid_caps_new (context, NULL, codec_id, encode, + "video/x-apple-intermediate-codec", NULL); + break; + + case AV_CODEC_ID_CAVS: + caps = + gst_ff_vid_caps_new (context, NULL, codec_id, encode, + "video/x-cavs", NULL); + break; + + case AV_CODEC_ID_WS_VQA: + case AV_CODEC_ID_IDCIN: + case AV_CODEC_ID_8BPS: + case AV_CODEC_ID_FLIC: + case AV_CODEC_ID_VMDVIDEO: + case AV_CODEC_ID_VMDAUDIO: + case AV_CODEC_ID_VIXL: + case AV_CODEC_ID_QPEG: + case AV_CODEC_ID_PGMYUV: + case AV_CODEC_ID_FFVHUFF: + case AV_CODEC_ID_WNV1: + case AV_CODEC_ID_MP3ADU: + case AV_CODEC_ID_MP3ON4: + case AV_CODEC_ID_WESTWOOD_SND1: + case AV_CODEC_ID_MMVIDEO: + case AV_CODEC_ID_AVS: buildcaps = TRUE; break; /* weird quasi-codecs for the demuxers only */ - case CODEC_ID_PCM_S16LE: - case CODEC_ID_PCM_S16BE: - case CODEC_ID_PCM_U16LE: - case CODEC_ID_PCM_U16BE: - case CODEC_ID_PCM_S8: - case CODEC_ID_PCM_U8: + case AV_CODEC_ID_PCM_S16LE: + case AV_CODEC_ID_PCM_S16BE: + case AV_CODEC_ID_PCM_U16LE: + case AV_CODEC_ID_PCM_U16BE: + case AV_CODEC_ID_PCM_S8: + case AV_CODEC_ID_PCM_U8: { GstAudioFormat format; switch (codec_id) { - case CODEC_ID_PCM_S16LE: + case AV_CODEC_ID_PCM_S16LE: format = GST_AUDIO_FORMAT_S16LE; break; - case CODEC_ID_PCM_S16BE: + case AV_CODEC_ID_PCM_S16BE: format = GST_AUDIO_FORMAT_S16BE; break; - case CODEC_ID_PCM_U16LE: + case AV_CODEC_ID_PCM_U16LE: format = GST_AUDIO_FORMAT_U16LE; break; - case CODEC_ID_PCM_U16BE: + case AV_CODEC_ID_PCM_U16BE: format = GST_AUDIO_FORMAT_U16BE; break; - case CODEC_ID_PCM_S8: + case AV_CODEC_ID_PCM_S8: format = GST_AUDIO_FORMAT_S8; break; - case CODEC_ID_PCM_U8: + case AV_CODEC_ID_PCM_U8: format = GST_AUDIO_FORMAT_U8; break; default: + format = 0; g_assert (0); /* don't worry, we never get here */ break; } @@ -1525,29 +1805,29 @@ gst_ffmpeg_codecid_to_caps (enum CodecID codec_id, } break; - case CODEC_ID_PCM_MULAW: + case AV_CODEC_ID_PCM_MULAW: caps = gst_ff_aud_caps_new (context, NULL, codec_id, encode, "audio/x-mulaw", NULL); break; - case CODEC_ID_PCM_ALAW: + case AV_CODEC_ID_PCM_ALAW: caps = gst_ff_aud_caps_new (context, NULL, codec_id, encode, "audio/x-alaw", NULL); break; - case CODEC_ID_ADPCM_G722: + case AV_CODEC_ID_ADPCM_G722: caps = gst_ff_aud_caps_new (context, NULL, codec_id, encode, "audio/G722", NULL); if (context) gst_caps_set_simple (caps, "block_align", G_TYPE_INT, context->block_align, - "bitrate", G_TYPE_INT, context->bit_rate, NULL); + "bitrate", G_TYPE_INT, (guint) context->bit_rate, NULL); break; - case CODEC_ID_ADPCM_G726: + case AV_CODEC_ID_ADPCM_G726: { /* the G726 decoder can also handle G721 */ caps = @@ -1556,7 +1836,7 @@ gst_ffmpeg_codecid_to_caps (enum CodecID codec_id, if (context) gst_caps_set_simple (caps, "block_align", G_TYPE_INT, context->block_align, - "bitrate", G_TYPE_INT, context->bit_rate, NULL); + "bitrate", G_TYPE_INT, (guint) context->bit_rate, NULL); if (!encode) { gst_caps_append (caps, gst_caps_new_simple ("audio/x-adpcm", @@ -1565,116 +1845,116 @@ gst_ffmpeg_codecid_to_caps (enum CodecID codec_id, } break; } - case CODEC_ID_ADPCM_IMA_QT: - case CODEC_ID_ADPCM_IMA_WAV: - case CODEC_ID_ADPCM_IMA_DK3: - case CODEC_ID_ADPCM_IMA_DK4: - case CODEC_ID_ADPCM_IMA_WS: - case CODEC_ID_ADPCM_IMA_SMJPEG: - case CODEC_ID_ADPCM_IMA_AMV: - case CODEC_ID_ADPCM_IMA_ISS: - case CODEC_ID_ADPCM_IMA_EA_EACS: - case CODEC_ID_ADPCM_IMA_EA_SEAD: - case CODEC_ID_ADPCM_MS: - case CODEC_ID_ADPCM_4XM: - case CODEC_ID_ADPCM_XA: - case CODEC_ID_ADPCM_ADX: - case CODEC_ID_ADPCM_EA: - case CODEC_ID_ADPCM_CT: - case CODEC_ID_ADPCM_SWF: - case CODEC_ID_ADPCM_YAMAHA: - case CODEC_ID_ADPCM_SBPRO_2: - case CODEC_ID_ADPCM_SBPRO_3: - case CODEC_ID_ADPCM_SBPRO_4: - case CODEC_ID_ADPCM_EA_R1: - case CODEC_ID_ADPCM_EA_R2: - case CODEC_ID_ADPCM_EA_R3: - case CODEC_ID_ADPCM_EA_MAXIS_XA: - case CODEC_ID_ADPCM_EA_XAS: - case CODEC_ID_ADPCM_THP: + case AV_CODEC_ID_ADPCM_IMA_QT: + case AV_CODEC_ID_ADPCM_IMA_WAV: + case AV_CODEC_ID_ADPCM_IMA_DK3: + case AV_CODEC_ID_ADPCM_IMA_DK4: + case AV_CODEC_ID_ADPCM_IMA_WS: + case AV_CODEC_ID_ADPCM_IMA_SMJPEG: + case AV_CODEC_ID_ADPCM_IMA_AMV: + case AV_CODEC_ID_ADPCM_IMA_ISS: + case AV_CODEC_ID_ADPCM_IMA_EA_EACS: + case AV_CODEC_ID_ADPCM_IMA_EA_SEAD: + case AV_CODEC_ID_ADPCM_MS: + case AV_CODEC_ID_ADPCM_4XM: + case AV_CODEC_ID_ADPCM_XA: + case AV_CODEC_ID_ADPCM_ADX: + case AV_CODEC_ID_ADPCM_EA: + case AV_CODEC_ID_ADPCM_CT: + case AV_CODEC_ID_ADPCM_SWF: + case AV_CODEC_ID_ADPCM_YAMAHA: + case AV_CODEC_ID_ADPCM_SBPRO_2: + case AV_CODEC_ID_ADPCM_SBPRO_3: + case AV_CODEC_ID_ADPCM_SBPRO_4: + case AV_CODEC_ID_ADPCM_EA_R1: + case AV_CODEC_ID_ADPCM_EA_R2: + case AV_CODEC_ID_ADPCM_EA_R3: + case AV_CODEC_ID_ADPCM_EA_MAXIS_XA: + case AV_CODEC_ID_ADPCM_EA_XAS: + case AV_CODEC_ID_ADPCM_THP: { const gchar *layout = NULL; switch (codec_id) { - case CODEC_ID_ADPCM_IMA_QT: + case AV_CODEC_ID_ADPCM_IMA_QT: layout = "quicktime"; break; - case CODEC_ID_ADPCM_IMA_WAV: + case AV_CODEC_ID_ADPCM_IMA_WAV: layout = "dvi"; break; - case CODEC_ID_ADPCM_IMA_DK3: + case AV_CODEC_ID_ADPCM_IMA_DK3: layout = "dk3"; break; - case CODEC_ID_ADPCM_IMA_DK4: + case AV_CODEC_ID_ADPCM_IMA_DK4: layout = "dk4"; break; - case CODEC_ID_ADPCM_IMA_WS: + case AV_CODEC_ID_ADPCM_IMA_WS: layout = "westwood"; break; - case CODEC_ID_ADPCM_IMA_SMJPEG: + case AV_CODEC_ID_ADPCM_IMA_SMJPEG: layout = "smjpeg"; break; - case CODEC_ID_ADPCM_IMA_AMV: + case AV_CODEC_ID_ADPCM_IMA_AMV: layout = "amv"; break; - case CODEC_ID_ADPCM_IMA_ISS: + case AV_CODEC_ID_ADPCM_IMA_ISS: layout = "iss"; break; - case CODEC_ID_ADPCM_IMA_EA_EACS: + case AV_CODEC_ID_ADPCM_IMA_EA_EACS: layout = "ea-eacs"; break; - case CODEC_ID_ADPCM_IMA_EA_SEAD: + case AV_CODEC_ID_ADPCM_IMA_EA_SEAD: layout = "ea-sead"; break; - case CODEC_ID_ADPCM_MS: + case AV_CODEC_ID_ADPCM_MS: layout = "microsoft"; break; - case CODEC_ID_ADPCM_4XM: + case AV_CODEC_ID_ADPCM_4XM: layout = "4xm"; break; - case CODEC_ID_ADPCM_XA: + case AV_CODEC_ID_ADPCM_XA: layout = "xa"; break; - case CODEC_ID_ADPCM_ADX: + case AV_CODEC_ID_ADPCM_ADX: layout = "adx"; break; - case CODEC_ID_ADPCM_EA: + case AV_CODEC_ID_ADPCM_EA: layout = "ea"; break; - case CODEC_ID_ADPCM_CT: + case AV_CODEC_ID_ADPCM_CT: layout = "ct"; break; - case CODEC_ID_ADPCM_SWF: + case AV_CODEC_ID_ADPCM_SWF: layout = "swf"; break; - case CODEC_ID_ADPCM_YAMAHA: + case AV_CODEC_ID_ADPCM_YAMAHA: layout = "yamaha"; break; - case CODEC_ID_ADPCM_SBPRO_2: + case AV_CODEC_ID_ADPCM_SBPRO_2: layout = "sbpro2"; break; - case CODEC_ID_ADPCM_SBPRO_3: + case AV_CODEC_ID_ADPCM_SBPRO_3: layout = "sbpro3"; break; - case CODEC_ID_ADPCM_SBPRO_4: + case AV_CODEC_ID_ADPCM_SBPRO_4: layout = "sbpro4"; break; - case CODEC_ID_ADPCM_EA_R1: + case AV_CODEC_ID_ADPCM_EA_R1: layout = "ea-r1"; break; - case CODEC_ID_ADPCM_EA_R2: + case AV_CODEC_ID_ADPCM_EA_R2: layout = "ea-r3"; break; - case CODEC_ID_ADPCM_EA_R3: + case AV_CODEC_ID_ADPCM_EA_R3: layout = "ea-r3"; break; - case CODEC_ID_ADPCM_EA_MAXIS_XA: + case AV_CODEC_ID_ADPCM_EA_MAXIS_XA: layout = "ea-maxis-xa"; break; - case CODEC_ID_ADPCM_EA_XAS: + case AV_CODEC_ID_ADPCM_EA_XAS: layout = "ea-xas"; break; - case CODEC_ID_ADPCM_THP: + case AV_CODEC_ID_ADPCM_THP: layout = "thp"; break; default: @@ -1690,41 +1970,41 @@ gst_ffmpeg_codecid_to_caps (enum CodecID codec_id, if (context) gst_caps_set_simple (caps, "block_align", G_TYPE_INT, context->block_align, - "bitrate", G_TYPE_INT, context->bit_rate, NULL); + "bitrate", G_TYPE_INT, (guint) context->bit_rate, NULL); } break; - case CODEC_ID_AMR_NB: + case AV_CODEC_ID_AMR_NB: caps = gst_ff_aud_caps_new (context, NULL, codec_id, encode, "audio/AMR", NULL); break; - case CODEC_ID_AMR_WB: + case AV_CODEC_ID_AMR_WB: caps = gst_ff_aud_caps_new (context, NULL, codec_id, encode, "audio/AMR-WB", NULL); break; - case CODEC_ID_GSM: + case AV_CODEC_ID_GSM: caps = gst_ff_aud_caps_new (context, NULL, codec_id, encode, "audio/x-gsm", NULL); break; - case CODEC_ID_GSM_MS: + case AV_CODEC_ID_GSM_MS: caps = gst_ff_aud_caps_new (context, NULL, codec_id, encode, "audio/ms-gsm", NULL); break; - case CODEC_ID_NELLYMOSER: + case AV_CODEC_ID_NELLYMOSER: caps = gst_ff_aud_caps_new (context, NULL, codec_id, encode, "audio/x-nellymoser", NULL); break; - case CODEC_ID_SIPR: + case AV_CODEC_ID_SIPR: { caps = gst_ff_aud_caps_new (context, NULL, codec_id, encode, "audio/x-sipro", @@ -1732,25 +2012,25 @@ gst_ffmpeg_codecid_to_caps (enum CodecID codec_id, if (context) { gst_caps_set_simple (caps, "leaf_size", G_TYPE_INT, context->block_align, - "bitrate", G_TYPE_INT, context->bit_rate, NULL); + "bitrate", G_TYPE_INT, (guint) context->bit_rate, NULL); } } break; - case CODEC_ID_RA_144: - case CODEC_ID_RA_288: - case CODEC_ID_COOK: + case AV_CODEC_ID_RA_144: + case AV_CODEC_ID_RA_288: + case AV_CODEC_ID_COOK: { gint version = 0; switch (codec_id) { - case CODEC_ID_RA_144: + case AV_CODEC_ID_RA_144: version = 1; break; - case CODEC_ID_RA_288: + case AV_CODEC_ID_RA_288: version = 2; break; - case CODEC_ID_COOK: + case AV_CODEC_ID_COOK: version = 8; break; default: @@ -1764,29 +2044,29 @@ gst_ffmpeg_codecid_to_caps (enum CodecID codec_id, if (context) { gst_caps_set_simple (caps, "leaf_size", G_TYPE_INT, context->block_align, - "bitrate", G_TYPE_INT, context->bit_rate, NULL); + "bitrate", G_TYPE_INT, (guint) context->bit_rate, NULL); } } break; - case CODEC_ID_ROQ_DPCM: - case CODEC_ID_INTERPLAY_DPCM: - case CODEC_ID_XAN_DPCM: - case CODEC_ID_SOL_DPCM: + case AV_CODEC_ID_ROQ_DPCM: + case AV_CODEC_ID_INTERPLAY_DPCM: + case AV_CODEC_ID_XAN_DPCM: + case AV_CODEC_ID_SOL_DPCM: { const gchar *layout = NULL; switch (codec_id) { - case CODEC_ID_ROQ_DPCM: + case AV_CODEC_ID_ROQ_DPCM: layout = "roq"; break; - case CODEC_ID_INTERPLAY_DPCM: + case AV_CODEC_ID_INTERPLAY_DPCM: layout = "interplay"; break; - case CODEC_ID_XAN_DPCM: + case AV_CODEC_ID_XAN_DPCM: layout = "xan"; break; - case CODEC_ID_SOL_DPCM: + case AV_CODEC_ID_SOL_DPCM: layout = "sol"; break; default: @@ -1802,15 +2082,15 @@ gst_ffmpeg_codecid_to_caps (enum CodecID codec_id, if (context) gst_caps_set_simple (caps, "block_align", G_TYPE_INT, context->block_align, - "bitrate", G_TYPE_INT, context->bit_rate, NULL); + "bitrate", G_TYPE_INT, (guint) context->bit_rate, NULL); } break; - case CODEC_ID_SHORTEN: + case AV_CODEC_ID_SHORTEN: caps = gst_caps_new_empty_simple ("audio/x-shorten"); break; - case CODEC_ID_ALAC: + case AV_CODEC_ID_ALAC: caps = gst_ff_aud_caps_new (context, NULL, codec_id, encode, "audio/x-alac", NULL); @@ -1820,7 +2100,7 @@ gst_ffmpeg_codecid_to_caps (enum CodecID codec_id, } break; - case CODEC_ID_FLAC: + case AV_CODEC_ID_FLAC: /* Note that ffmpeg has no encoder yet, but just for safety. In the * encoder case, we want to add things like samplerate, channels... */ if (!encode) { @@ -1828,14 +2108,28 @@ gst_ffmpeg_codecid_to_caps (enum CodecID codec_id, } break; - case CODEC_ID_DVD_SUBTITLE: - case CODEC_ID_DVB_SUBTITLE: + case AV_CODEC_ID_OPUS: + /* Note that ffmpeg has no encoder yet, but just for safety. In the + * encoder case, we want to add things like samplerate, channels... */ + if (!encode) { + /* FIXME: can ffmpeg handle multichannel Opus? */ + caps = gst_caps_new_simple ("audio/x-opus", + "channel-mapping-family", G_TYPE_INT, 0, NULL); + } + break; + + case AV_CODEC_ID_S302M: + caps = gst_caps_new_empty_simple ("audio/x-smpte-302m"); + break; + + case AV_CODEC_ID_DVD_SUBTITLE: + case AV_CODEC_ID_DVB_SUBTITLE: caps = NULL; break; - case CODEC_ID_BMP: + case AV_CODEC_ID_BMP: caps = gst_caps_new_empty_simple ("image/bmp"); break; - case CODEC_ID_TTA: + case AV_CODEC_ID_TTA: caps = gst_ff_aud_caps_new (context, NULL, codec_id, encode, "audio/x-tta", NULL); @@ -1844,11 +2138,16 @@ gst_ffmpeg_codecid_to_caps (enum CodecID codec_id, "samplesize", G_TYPE_INT, context->bits_per_coded_sample, NULL); } break; - case CODEC_ID_TWINVQ: + case AV_CODEC_ID_TWINVQ: caps = gst_ff_aud_caps_new (context, NULL, codec_id, encode, "audio/x-twin-vq", NULL); break; + case AV_CODEC_ID_G729: + caps = + gst_ff_aud_caps_new (context, NULL, codec_id, encode, "audio/G729", + NULL); + break; default: GST_DEBUG ("Unknown codec ID %d, please add mapping here", codec_id); break; @@ -1877,7 +2176,7 @@ gst_ffmpeg_codecid_to_caps (enum CodecID codec_id, if (context) gst_caps_set_simple (caps, "block_align", G_TYPE_INT, context->block_align, - "bitrate", G_TYPE_INT, context->bit_rate, NULL); + "bitrate", G_TYPE_INT, (guint) context->bit_rate, NULL); g_free (mime); break; default: @@ -1914,8 +2213,8 @@ gst_ffmpeg_codecid_to_caps (enum CodecID codec_id, */ static GstCaps * -gst_ffmpeg_pixfmt_to_caps (enum PixelFormat pix_fmt, AVCodecContext * context, - enum CodecID codec_id) +gst_ffmpeg_pixfmt_to_caps (enum AVPixelFormat pix_fmt, AVCodecContext * context, + enum AVCodecID codec_id) { GstCaps *caps = NULL; GstVideoFormat format; @@ -1976,7 +2275,7 @@ gst_ffmpeg_smpfmt_to_audioformat (enum AVSampleFormat sample_fmt) static GstCaps * gst_ffmpeg_smpfmt_to_caps (enum AVSampleFormat sample_fmt, - AVCodecContext * context, AVCodec * codec, enum CodecID codec_id) + AVCodecContext * context, AVCodec * codec, enum AVCodecID codec_id) { GstCaps *caps = NULL; GstAudioFormat format; @@ -1995,55 +2294,25 @@ gst_ffmpeg_smpfmt_to_caps (enum AVSampleFormat sample_fmt, return caps; } -static void -gst_ffmpeg_audio_set_sample_fmts (GstCaps * caps, - const enum AVSampleFormat *fmts) +static gboolean +caps_has_field (GstCaps * caps, const gchar * field) { - GValue va = { 0, }; - GValue v = { 0, }; - GstAudioFormat format; + guint i, n; - if (!fmts || fmts[0] == -1) { - gint i; + n = gst_caps_get_size (caps); + for (i = 0; i < n; i++) { + GstStructure *s = gst_caps_get_structure (caps, i); - g_value_init (&va, GST_TYPE_LIST); - g_value_init (&v, G_TYPE_STRING); - for (i = 0; i <= AV_SAMPLE_FMT_DBL; i++) { - format = gst_ffmpeg_smpfmt_to_audioformat (i); - if (format == GST_AUDIO_FORMAT_UNKNOWN) - continue; - g_value_set_string (&v, gst_audio_format_to_string (format)); - gst_value_list_append_value (&va, &v); - } - gst_caps_set_value (caps, "format", &va); - g_value_unset (&v); - g_value_unset (&va); - return; + if (gst_structure_has_field (s, field)) + return TRUE; } - g_value_init (&va, GST_TYPE_LIST); - g_value_init (&v, G_TYPE_STRING); - while (*fmts != -1) { - format = gst_ffmpeg_smpfmt_to_audioformat (*fmts); - if (format != GST_AUDIO_FORMAT_UNKNOWN) { - g_value_set_string (&v, gst_audio_format_to_string (format)); - gst_value_list_append_value (&va, &v); - } - fmts++; - } - if (gst_value_list_get_size (&va) == 1) { - /* The single value is still in v */ - gst_caps_set_value (caps, "format", &v); - } else if (gst_value_list_get_size (&va) > 1) { - gst_caps_set_value (caps, "format", &va); - } - g_value_unset (&v); - g_value_unset (&va); + return FALSE; } GstCaps * gst_ffmpeg_codectype_to_audio_caps (AVCodecContext * context, - enum CodecID codec_id, gboolean encode, AVCodec * codec) + enum AVCodecID codec_id, gboolean encode, AVCodec * codec) { GstCaps *caps = NULL; @@ -2061,61 +2330,17 @@ gst_ffmpeg_codectype_to_audio_caps (AVCodecContext * context, } else { caps = gst_ff_aud_caps_new (context, codec, codec_id, encode, "audio/x-raw", "layout", G_TYPE_STRING, "interleaved", NULL); - gst_ffmpeg_audio_set_sample_fmts (caps, codec ? codec->sample_fmts : NULL); + if (!caps_has_field (caps, "format")) + gst_ffmpeg_audio_set_sample_fmts (caps, + codec ? codec->sample_fmts : NULL); } return caps; } -static void -gst_ffmpeg_video_set_pix_fmts (GstCaps * caps, const enum AVPixelFormat *fmts) -{ - GValue va = { 0, }; - GValue v = { 0, }; - GstVideoFormat format; - - if (!fmts || fmts[0] == -1) { - gint i; - - g_value_init (&va, GST_TYPE_LIST); - g_value_init (&v, G_TYPE_STRING); - for (i = 0; i <= PIX_FMT_NB; i++) { - format = gst_ffmpeg_pixfmt_to_videoformat (i); - if (format == GST_VIDEO_FORMAT_UNKNOWN) - continue; - g_value_set_string (&v, gst_video_format_to_string (format)); - gst_value_list_append_value (&va, &v); - } - gst_caps_set_value (caps, "format", &va); - g_value_unset (&v); - g_value_unset (&va); - return; - } - - /* Only a single format */ - g_value_init (&va, GST_TYPE_LIST); - g_value_init (&v, G_TYPE_STRING); - while (*fmts != -1) { - format = gst_ffmpeg_pixfmt_to_videoformat (*fmts); - if (format != GST_VIDEO_FORMAT_UNKNOWN) { - g_value_set_string (&v, gst_video_format_to_string (format)); - gst_value_list_append_value (&va, &v); - } - fmts++; - } - if (gst_value_list_get_size (&va) == 1) { - /* The single value is still in v */ - gst_caps_set_value (caps, "format", &v); - } else if (gst_value_list_get_size (&va) > 1) { - gst_caps_set_value (caps, "format", &va); - } - g_value_unset (&v); - g_value_unset (&va); -} - GstCaps * gst_ffmpeg_codectype_to_video_caps (AVCodecContext * context, - enum CodecID codec_id, gboolean encode, AVCodec * codec) + enum AVCodecID codec_id, gboolean encode, AVCodec * codec) { GstCaps *caps; @@ -2128,7 +2353,8 @@ gst_ffmpeg_codectype_to_video_caps (AVCodecContext * context, caps = gst_ff_vid_caps_new (context, codec, codec_id, encode, "video/x-raw", NULL); - gst_ffmpeg_video_set_pix_fmts (caps, codec ? codec->pix_fmts : NULL); + if (!caps_has_field (caps, "format")) + gst_ffmpeg_video_set_pix_fmts (caps, codec ? codec->pix_fmts : NULL); } return caps; } @@ -2146,6 +2372,7 @@ gst_ffmpeg_caps_to_smpfmt (const GstCaps * caps, GstStructure *structure; const gchar *fmt; GstAudioFormat format = GST_AUDIO_FORMAT_UNKNOWN; + gint bitrate; g_return_if_fail (gst_caps_get_size (caps) == 1); @@ -2154,7 +2381,8 @@ gst_ffmpeg_caps_to_smpfmt (const GstCaps * caps, gst_structure_get_int (structure, "channels", &context->channels); gst_structure_get_int (structure, "rate", &context->sample_rate); gst_structure_get_int (structure, "block_align", &context->block_align); - gst_structure_get_int (structure, "bitrate", &context->bit_rate); + if (gst_structure_get_int (structure, "bitrate", &bitrate)) + context->bit_rate = bitrate; if (!raw) return; @@ -2210,26 +2438,43 @@ gst_ffmpeg_caps_to_pixfmt (const GstCaps * caps, fps = gst_structure_get_value (structure, "framerate"); if (fps != NULL && GST_VALUE_HOLDS_FRACTION (fps)) { - /* somehow these seem mixed up.. */ - context->time_base.den = gst_value_get_fraction_numerator (fps); - context->time_base.num = gst_value_get_fraction_denominator (fps); - context->ticks_per_frame = 1; + int num = gst_value_get_fraction_numerator (fps); + int den = gst_value_get_fraction_denominator (fps); + + if (num > 0 && den > 0) { + /* somehow these seem mixed up.. */ + /* they're fine, this is because it does period=1/frequency */ + context->time_base.den = gst_value_get_fraction_numerator (fps); + context->time_base.num = gst_value_get_fraction_denominator (fps); + context->ticks_per_frame = 1; - GST_DEBUG ("setting framerate %d/%d = %lf", - context->time_base.den, context->time_base.num, - 1. * context->time_base.den / context->time_base.num); + GST_DEBUG ("setting framerate %d/%d = %lf", + context->time_base.den, context->time_base.num, + 1. * context->time_base.den / context->time_base.num); + } else { + GST_INFO ("ignoring framerate %d/%d (probably variable framerate)", + context->time_base.num, context->time_base.den); + } } par = gst_structure_get_value (structure, "pixel-aspect-ratio"); if (par && GST_VALUE_HOLDS_FRACTION (par)) { - context->sample_aspect_ratio.num = gst_value_get_fraction_numerator (par); - context->sample_aspect_ratio.den = gst_value_get_fraction_denominator (par); + int num = gst_value_get_fraction_numerator (par); + int den = gst_value_get_fraction_denominator (par); + + if (num > 0 && den > 0) { + context->sample_aspect_ratio.num = num; + context->sample_aspect_ratio.den = den; - GST_DEBUG ("setting pixel-aspect-ratio %d/%d = %lf", - context->sample_aspect_ratio.den, context->sample_aspect_ratio.num, - 1. * context->sample_aspect_ratio.den / - context->sample_aspect_ratio.num); + GST_DEBUG ("setting pixel-aspect-ratio %d/%d = %lf", + context->sample_aspect_ratio.num, context->sample_aspect_ratio.den, + 1. * context->sample_aspect_ratio.num / + context->sample_aspect_ratio.den); + } else { + GST_WARNING ("ignoring insane pixel-aspect-ratio %d/%d", + context->sample_aspect_ratio.num, context->sample_aspect_ratio.den); + } } if (!raw) @@ -2245,53 +2490,53 @@ gst_ffmpeg_caps_to_pixfmt (const GstCaps * caps, switch (format) { case GST_VIDEO_FORMAT_YUY2: - context->pix_fmt = PIX_FMT_YUYV422; + context->pix_fmt = AV_PIX_FMT_YUYV422; break; case GST_VIDEO_FORMAT_I420: - context->pix_fmt = PIX_FMT_YUV420P; + context->pix_fmt = AV_PIX_FMT_YUV420P; break; case GST_VIDEO_FORMAT_A420: - context->pix_fmt = PIX_FMT_YUVA420P; + context->pix_fmt = AV_PIX_FMT_YUVA420P; break; case GST_VIDEO_FORMAT_Y41B: - context->pix_fmt = PIX_FMT_YUV411P; + context->pix_fmt = AV_PIX_FMT_YUV411P; break; case GST_VIDEO_FORMAT_Y42B: - context->pix_fmt = PIX_FMT_YUV422P; + context->pix_fmt = AV_PIX_FMT_YUV422P; break; case GST_VIDEO_FORMAT_YUV9: - context->pix_fmt = PIX_FMT_YUV410P; + context->pix_fmt = AV_PIX_FMT_YUV410P; break; case GST_VIDEO_FORMAT_Y444: - context->pix_fmt = PIX_FMT_YUV444P; + context->pix_fmt = AV_PIX_FMT_YUV444P; break; case GST_VIDEO_FORMAT_GRAY8: - context->pix_fmt = PIX_FMT_GRAY8; + context->pix_fmt = AV_PIX_FMT_GRAY8; break; case GST_VIDEO_FORMAT_xRGB: #if (G_BYTE_ORDER == G_BIG_ENDIAN) - context->pix_fmt = PIX_FMT_RGB32; + context->pix_fmt = AV_PIX_FMT_RGB32; #endif break; case GST_VIDEO_FORMAT_BGRx: #if (G_BYTE_ORDER == G_LITTLE_ENDIAN) - context->pix_fmt = PIX_FMT_RGB32; + context->pix_fmt = AV_PIX_FMT_RGB32; #endif break; case GST_VIDEO_FORMAT_RGB: - context->pix_fmt = PIX_FMT_RGB24; + context->pix_fmt = AV_PIX_FMT_RGB24; break; case GST_VIDEO_FORMAT_BGR: - context->pix_fmt = PIX_FMT_BGR24; + context->pix_fmt = AV_PIX_FMT_BGR24; break; case GST_VIDEO_FORMAT_RGB16: - context->pix_fmt = PIX_FMT_RGB565; + context->pix_fmt = AV_PIX_FMT_RGB565; break; case GST_VIDEO_FORMAT_RGB15: - context->pix_fmt = PIX_FMT_RGB555; + context->pix_fmt = AV_PIX_FMT_RGB555; break; case GST_VIDEO_FORMAT_RGB8P: - context->pix_fmt = PIX_FMT_PAL8; + context->pix_fmt = AV_PIX_FMT_PAL8; break; default: break; @@ -2301,93 +2546,99 @@ gst_ffmpeg_caps_to_pixfmt (const GstCaps * caps, typedef struct { GstVideoFormat format; - enum PixelFormat pixfmt; + enum AVPixelFormat pixfmt; } PixToFmt; /* FIXME : FILLME */ static const PixToFmt pixtofmttable[] = { /* GST_VIDEO_FORMAT_I420, */ - {GST_VIDEO_FORMAT_I420, PIX_FMT_YUV420P}, + {GST_VIDEO_FORMAT_I420, AV_PIX_FMT_YUV420P}, /* Note : this should use a different chroma placement */ - {GST_VIDEO_FORMAT_I420, PIX_FMT_YUVJ420P}, + {GST_VIDEO_FORMAT_I420, AV_PIX_FMT_YUVJ420P}, /* GST_VIDEO_FORMAT_YV12, */ /* GST_VIDEO_FORMAT_YUY2, */ - {GST_VIDEO_FORMAT_YUY2, PIX_FMT_YUYV422}, + {GST_VIDEO_FORMAT_YUY2, AV_PIX_FMT_YUYV422}, /* GST_VIDEO_FORMAT_UYVY, */ - {GST_VIDEO_FORMAT_UYVY, PIX_FMT_UYVY422}, + {GST_VIDEO_FORMAT_UYVY, AV_PIX_FMT_UYVY422}, /* GST_VIDEO_FORMAT_AYUV, */ /* GST_VIDEO_FORMAT_RGBx, */ /* GST_VIDEO_FORMAT_BGRx, */ /* GST_VIDEO_FORMAT_xRGB, */ /* GST_VIDEO_FORMAT_xBGR, */ /* GST_VIDEO_FORMAT_RGBA, */ - {GST_VIDEO_FORMAT_RGBA, PIX_FMT_RGBA}, + {GST_VIDEO_FORMAT_RGBA, AV_PIX_FMT_RGBA}, /* GST_VIDEO_FORMAT_BGRA, */ - {GST_VIDEO_FORMAT_BGRA, PIX_FMT_BGRA}, + {GST_VIDEO_FORMAT_BGRA, AV_PIX_FMT_BGRA}, /* GST_VIDEO_FORMAT_ARGB, */ - {GST_VIDEO_FORMAT_ARGB, PIX_FMT_ARGB}, + {GST_VIDEO_FORMAT_ARGB, AV_PIX_FMT_ARGB}, /* GST_VIDEO_FORMAT_ABGR, */ - {GST_VIDEO_FORMAT_ABGR, PIX_FMT_ABGR}, + {GST_VIDEO_FORMAT_ABGR, AV_PIX_FMT_ABGR}, /* GST_VIDEO_FORMAT_RGB, */ - {GST_VIDEO_FORMAT_RGB, PIX_FMT_RGB24}, + {GST_VIDEO_FORMAT_RGB, AV_PIX_FMT_RGB24}, /* GST_VIDEO_FORMAT_BGR, */ - {GST_VIDEO_FORMAT_BGR, PIX_FMT_BGR24}, + {GST_VIDEO_FORMAT_BGR, AV_PIX_FMT_BGR24}, /* GST_VIDEO_FORMAT_Y41B, */ - {GST_VIDEO_FORMAT_Y41B, PIX_FMT_YUV411P}, + {GST_VIDEO_FORMAT_Y41B, AV_PIX_FMT_YUV411P}, /* GST_VIDEO_FORMAT_Y42B, */ - {GST_VIDEO_FORMAT_Y42B, PIX_FMT_YUV422P}, - {GST_VIDEO_FORMAT_Y42B, PIX_FMT_YUVJ422P}, + {GST_VIDEO_FORMAT_Y42B, AV_PIX_FMT_YUV422P}, + {GST_VIDEO_FORMAT_Y42B, AV_PIX_FMT_YUVJ422P}, /* GST_VIDEO_FORMAT_YVYU, */ /* GST_VIDEO_FORMAT_Y444, */ - {GST_VIDEO_FORMAT_Y444, PIX_FMT_YUV444P}, - {GST_VIDEO_FORMAT_Y444, PIX_FMT_YUVJ444P}, + {GST_VIDEO_FORMAT_Y444, AV_PIX_FMT_YUV444P}, + {GST_VIDEO_FORMAT_Y444, AV_PIX_FMT_YUVJ444P}, /* GST_VIDEO_FORMAT_v210, */ /* GST_VIDEO_FORMAT_v216, */ /* GST_VIDEO_FORMAT_NV12, */ - {GST_VIDEO_FORMAT_NV12, PIX_FMT_NV12}, + {GST_VIDEO_FORMAT_NV12, AV_PIX_FMT_NV12}, /* GST_VIDEO_FORMAT_NV21, */ - {GST_VIDEO_FORMAT_NV21, PIX_FMT_NV21}, + {GST_VIDEO_FORMAT_NV21, AV_PIX_FMT_NV21}, /* GST_VIDEO_FORMAT_GRAY8, */ - {GST_VIDEO_FORMAT_GRAY8, PIX_FMT_GRAY8}, + {GST_VIDEO_FORMAT_GRAY8, AV_PIX_FMT_GRAY8}, /* GST_VIDEO_FORMAT_GRAY16_BE, */ - {GST_VIDEO_FORMAT_GRAY16_BE, PIX_FMT_GRAY16BE}, + {GST_VIDEO_FORMAT_GRAY16_BE, AV_PIX_FMT_GRAY16BE}, /* GST_VIDEO_FORMAT_GRAY16_LE, */ - {GST_VIDEO_FORMAT_GRAY16_LE, PIX_FMT_GRAY16LE}, + {GST_VIDEO_FORMAT_GRAY16_LE, AV_PIX_FMT_GRAY16LE}, /* GST_VIDEO_FORMAT_v308, */ /* GST_VIDEO_FORMAT_Y800, */ /* GST_VIDEO_FORMAT_Y16, */ /* GST_VIDEO_FORMAT_RGB16, */ - {GST_VIDEO_FORMAT_RGB16, PIX_FMT_RGB565}, + {GST_VIDEO_FORMAT_RGB16, AV_PIX_FMT_RGB565}, /* GST_VIDEO_FORMAT_BGR16, */ /* GST_VIDEO_FORMAT_RGB15, */ - {GST_VIDEO_FORMAT_RGB15, PIX_FMT_RGB555}, + {GST_VIDEO_FORMAT_RGB15, AV_PIX_FMT_RGB555}, /* GST_VIDEO_FORMAT_BGR15, */ /* GST_VIDEO_FORMAT_UYVP, */ /* GST_VIDEO_FORMAT_A420, */ - {GST_VIDEO_FORMAT_A420, PIX_FMT_YUVA420P}, + {GST_VIDEO_FORMAT_A420, AV_PIX_FMT_YUVA420P}, /* GST_VIDEO_FORMAT_RGB8_PALETTED, */ - {GST_VIDEO_FORMAT_RGB8P, PIX_FMT_PAL8}, + {GST_VIDEO_FORMAT_RGB8P, AV_PIX_FMT_PAL8}, /* GST_VIDEO_FORMAT_YUV9, */ - {GST_VIDEO_FORMAT_YUV9, PIX_FMT_YUV410P}, + {GST_VIDEO_FORMAT_YUV9, AV_PIX_FMT_YUV410P}, /* GST_VIDEO_FORMAT_YVU9, */ /* GST_VIDEO_FORMAT_IYU1, */ /* GST_VIDEO_FORMAT_ARGB64, */ /* GST_VIDEO_FORMAT_AYUV64, */ /* GST_VIDEO_FORMAT_r210, */ - {GST_VIDEO_FORMAT_I420_10LE, PIX_FMT_YUV420P10LE}, - {GST_VIDEO_FORMAT_I420_10BE, PIX_FMT_YUV420P10BE}, - {GST_VIDEO_FORMAT_I422_10LE, PIX_FMT_YUV422P10LE}, - {GST_VIDEO_FORMAT_I422_10BE, PIX_FMT_YUV422P10BE}, - {GST_VIDEO_FORMAT_Y444_10LE, PIX_FMT_YUV444P10LE}, - {GST_VIDEO_FORMAT_Y444_10BE, PIX_FMT_YUV444P10BE}, - {GST_VIDEO_FORMAT_GBR, PIX_FMT_GBRP}, - {GST_VIDEO_FORMAT_GBR_10LE, PIX_FMT_GBRP10LE}, - {GST_VIDEO_FORMAT_GBR_10BE, PIX_FMT_GBRP10BE}, + {GST_VIDEO_FORMAT_I420_10LE, AV_PIX_FMT_YUV420P10LE}, + {GST_VIDEO_FORMAT_I420_10BE, AV_PIX_FMT_YUV420P10BE}, + {GST_VIDEO_FORMAT_I422_10LE, AV_PIX_FMT_YUV422P10LE}, + {GST_VIDEO_FORMAT_I422_10BE, AV_PIX_FMT_YUV422P10BE}, + {GST_VIDEO_FORMAT_Y444_10LE, AV_PIX_FMT_YUV444P10LE}, + {GST_VIDEO_FORMAT_Y444_10BE, AV_PIX_FMT_YUV444P10BE}, + {GST_VIDEO_FORMAT_GBR, AV_PIX_FMT_GBRP}, + {GST_VIDEO_FORMAT_GBR_10LE, AV_PIX_FMT_GBRP10LE}, + {GST_VIDEO_FORMAT_GBR_10BE, AV_PIX_FMT_GBRP10BE}, + {GST_VIDEO_FORMAT_A420_10LE, AV_PIX_FMT_YUVA420P10LE}, + {GST_VIDEO_FORMAT_A420_10BE, AV_PIX_FMT_YUVA420P10BE}, + {GST_VIDEO_FORMAT_A422_10LE, AV_PIX_FMT_YUVA422P10LE}, + {GST_VIDEO_FORMAT_A422_10BE, AV_PIX_FMT_YUVA422P10BE}, + {GST_VIDEO_FORMAT_A444_10LE, AV_PIX_FMT_YUVA444P10LE}, + {GST_VIDEO_FORMAT_A444_10BE, AV_PIX_FMT_YUVA444P10BE}, }; GstVideoFormat -gst_ffmpeg_pixfmt_to_videoformat (enum PixelFormat pixfmt) +gst_ffmpeg_pixfmt_to_videoformat (enum AVPixelFormat pixfmt) { guint i; @@ -2395,19 +2646,38 @@ gst_ffmpeg_pixfmt_to_videoformat (enum PixelFormat pixfmt) if (pixtofmttable[i].pixfmt == pixfmt) return pixtofmttable[i].format; - GST_WARNING ("Unknown pixel format %d", pixfmt); + GST_DEBUG ("Unknown pixel format %d", pixfmt); return GST_VIDEO_FORMAT_UNKNOWN; } -enum PixelFormat -gst_ffmpeg_videoformat_to_pixfmt (GstVideoFormat format) +static enum AVPixelFormat +gst_ffmpeg_videoformat_to_pixfmt_for_codec (GstVideoFormat format, + const AVCodec * codec) { guint i; - for (i = 0; i < G_N_ELEMENTS (pixtofmttable); i++) - if (pixtofmttable[i].format == format) - return pixtofmttable[i].pixfmt; - return PIX_FMT_NONE; + for (i = 0; i < G_N_ELEMENTS (pixtofmttable); i++) { + if (pixtofmttable[i].format == format) { + gint j; + + if (codec && codec->pix_fmts) { + for (j = 0; codec->pix_fmts[j] != -1; j++) { + if (pixtofmttable[i].pixfmt == codec->pix_fmts[j]) + return pixtofmttable[i].pixfmt; + } + } else { + return pixtofmttable[i].pixfmt; + } + } + } + + return AV_PIX_FMT_NONE; +} + +enum AVPixelFormat +gst_ffmpeg_videoformat_to_pixfmt (GstVideoFormat format) +{ + return gst_ffmpeg_videoformat_to_pixfmt_for_codec (format, NULL); } void @@ -2422,14 +2692,122 @@ gst_ffmpeg_videoinfo_to_context (GstVideoInfo * info, AVCodecContext * context) context->bits_per_coded_sample = bpp; context->ticks_per_frame = 1; - context->time_base.den = GST_VIDEO_INFO_FPS_N (info); - context->time_base.num = GST_VIDEO_INFO_FPS_D (info); + if (GST_VIDEO_INFO_FPS_N (info) == 0) { + GST_DEBUG ("Using 25/1 framerate"); + context->time_base.den = 25; + context->time_base.num = 1; + } else { + context->time_base.den = GST_VIDEO_INFO_FPS_N (info); + context->time_base.num = GST_VIDEO_INFO_FPS_D (info); + } context->sample_aspect_ratio.num = GST_VIDEO_INFO_PAR_N (info); context->sample_aspect_ratio.den = GST_VIDEO_INFO_PAR_D (info); context->pix_fmt = - gst_ffmpeg_videoformat_to_pixfmt (GST_VIDEO_INFO_FORMAT (info)); + gst_ffmpeg_videoformat_to_pixfmt_for_codec (GST_VIDEO_INFO_FORMAT (info), + context->codec); + + switch (info->chroma_site) { + case GST_VIDEO_CHROMA_SITE_MPEG2: + context->chroma_sample_location = AVCHROMA_LOC_LEFT; + break; + case GST_VIDEO_CHROMA_SITE_JPEG: + context->chroma_sample_location = AVCHROMA_LOC_CENTER; + break; + case GST_VIDEO_CHROMA_SITE_DV: + context->chroma_sample_location = AVCHROMA_LOC_TOPLEFT; + break; + case GST_VIDEO_CHROMA_SITE_V_COSITED: + context->chroma_sample_location = AVCHROMA_LOC_TOP; + break; + default: + break; + } + + switch (info->colorimetry.primaries) { + case GST_VIDEO_COLOR_PRIMARIES_BT709: + context->color_primaries = AVCOL_PRI_BT709; + break; + case GST_VIDEO_COLOR_PRIMARIES_BT470M: + context->color_primaries = AVCOL_PRI_BT470M; + break; + case GST_VIDEO_COLOR_PRIMARIES_BT470BG: + context->color_primaries = AVCOL_PRI_BT470BG; + break; + case GST_VIDEO_COLOR_PRIMARIES_SMPTE170M: + context->color_primaries = AVCOL_PRI_SMPTE170M; + break; + case GST_VIDEO_COLOR_PRIMARIES_SMPTE240M: + context->color_primaries = AVCOL_PRI_SMPTE240M; + break; + case GST_VIDEO_COLOR_PRIMARIES_FILM: + context->color_primaries = AVCOL_PRI_FILM; + break; + case GST_VIDEO_COLOR_PRIMARIES_BT2020: + context->color_primaries = AVCOL_PRI_BT2020; + break; + default: + break; + } + + switch (info->colorimetry.transfer) { + case GST_VIDEO_TRANSFER_BT709: + context->color_trc = AVCOL_TRC_BT709; + break; + case GST_VIDEO_TRANSFER_GAMMA22: + context->color_trc = AVCOL_TRC_GAMMA22; + break; + case GST_VIDEO_TRANSFER_GAMMA28: + context->color_trc = AVCOL_TRC_GAMMA28; + break; + case GST_VIDEO_TRANSFER_SMPTE240M: + context->color_trc = AVCOL_TRC_SMPTE240M; + break; + case GST_VIDEO_TRANSFER_GAMMA10: + context->color_trc = AVCOL_TRC_LINEAR; + break; + case GST_VIDEO_TRANSFER_LOG100: + context->color_trc = AVCOL_TRC_LOG; + break; + case GST_VIDEO_TRANSFER_LOG316: + context->color_trc = AVCOL_TRC_LOG_SQRT; + break; + case GST_VIDEO_TRANSFER_BT2020_12: + context->color_trc = AVCOL_TRC_BT2020_12; + break; + default: + break; + } + + switch (info->colorimetry.matrix) { + case GST_VIDEO_COLOR_MATRIX_RGB: + context->colorspace = AVCOL_SPC_RGB; + break; + case GST_VIDEO_COLOR_MATRIX_BT709: + context->colorspace = AVCOL_SPC_BT709; + break; + case GST_VIDEO_COLOR_MATRIX_FCC: + context->colorspace = AVCOL_SPC_FCC; + break; + case GST_VIDEO_COLOR_MATRIX_BT601: + context->colorspace = AVCOL_SPC_BT470BG; + break; + case GST_VIDEO_COLOR_MATRIX_SMPTE240M: + context->colorspace = AVCOL_SPC_SMPTE240M; + break; + case GST_VIDEO_COLOR_MATRIX_BT2020: + context->colorspace = AVCOL_SPC_BT2020_NCL; + break; + default: + break; + } + + if (info->colorimetry.range == GST_VIDEO_COLOR_RANGE_0_255) { + context->color_range = AVCOL_RANGE_JPEG; + } else { + context->color_range = AVCOL_RANGE_MPEG; + } } void @@ -2663,7 +3041,7 @@ full_copy: */ void -gst_ffmpeg_caps_with_codecid (enum CodecID codec_id, +gst_ffmpeg_caps_with_codecid (enum AVCodecID codec_id, enum AVMediaType codec_type, const GstCaps * caps, AVCodecContext * context) { GstStructure *str; @@ -2690,7 +3068,7 @@ gst_ffmpeg_caps_with_codecid (enum CodecID codec_id, av_free (context->extradata); #if 0 - if (codec_id == CODEC_ID_H264) { + if (codec_id == AV_CODEC_ID_H264) { guint extrasize; GST_DEBUG ("copy, escaping codec_data %d", size); @@ -2720,40 +3098,43 @@ gst_ffmpeg_caps_with_codecid (enum CodecID codec_id, } /* Hack for VC1. Sometimes the first (length) byte is 0 for some files */ - if (codec_id == CODEC_ID_VC1 && map.size > 0 && map.data[0] == 0) { + if (codec_id == AV_CODEC_ID_VC1 && map.size > 0 && map.data[0] == 0) { context->extradata[0] = (guint8) map.size; } GST_DEBUG ("have codec data of size %" G_GSIZE_FORMAT, map.size); gst_buffer_unmap (buf, &map); - } else if (context->extradata == NULL && codec_id != CODEC_ID_AAC_LATM && - codec_id != CODEC_ID_FLAC) { - /* no extradata, alloc dummy with 0 sized, some codecs insist on reading - * extradata anyway which makes then segfault. */ - context->extradata = - av_mallocz (GST_ROUND_UP_16 (FF_INPUT_BUFFER_PADDING_SIZE)); + } else { + context->extradata = NULL; context->extradata_size = 0; GST_DEBUG ("no codec data"); } switch (codec_id) { - case CODEC_ID_MPEG4: + case AV_CODEC_ID_MPEG4: { const gchar *mime = gst_structure_get_name (str); + context->flags |= CODEC_FLAG_4MV; + if (!strcmp (mime, "video/x-divx")) context->codec_tag = GST_MAKE_FOURCC ('D', 'I', 'V', 'X'); - else if (!strcmp (mime, "video/x-xvid")) - context->codec_tag = GST_MAKE_FOURCC ('X', 'V', 'I', 'D'); - else if (!strcmp (mime, "video/x-3ivx")) - context->codec_tag = GST_MAKE_FOURCC ('3', 'I', 'V', '1'); - else if (!strcmp (mime, "video/mpeg")) + else if (!strcmp (mime, "video/mpeg")) { + const gchar *profile; + context->codec_tag = GST_MAKE_FOURCC ('m', 'p', '4', 'v'); - } + + profile = gst_structure_get_string (str, "profile"); + if (profile) { + if (g_strcmp0 (profile, "advanced-simple") == 0) + context->flags |= CODEC_FLAG_GMC | CODEC_FLAG_QPEL; + } + } break; + } - case CODEC_ID_SVQ3: + case AV_CODEC_ID_SVQ3: /* FIXME: this is a workaround for older gst-plugins releases * (<= 0.8.9). This should be removed at some point, because * it causes wrong decoded frame order. */ @@ -2761,9 +3142,9 @@ gst_ffmpeg_caps_with_codecid (enum CodecID codec_id, gint halfpel_flag, thirdpel_flag, low_delay, unknown_svq3_flag; guint16 flags; - if (gst_structure_get_int (str, "halfpel_flag", &halfpel_flag) || - gst_structure_get_int (str, "thirdpel_flag", &thirdpel_flag) || - gst_structure_get_int (str, "low_delay", &low_delay) || + if (gst_structure_get_int (str, "halfpel_flag", &halfpel_flag) && + gst_structure_get_int (str, "thirdpel_flag", &thirdpel_flag) && + gst_structure_get_int (str, "low_delay", &low_delay) && gst_structure_get_int (str, "unknown_svq3_flag", &unknown_svq3_flag)) { context->extradata = (guint8 *) av_mallocz (0x64); @@ -2786,11 +3167,11 @@ gst_ffmpeg_caps_with_codecid (enum CodecID codec_id, } break; - case CODEC_ID_MSRLE: - case CODEC_ID_QTRLE: - case CODEC_ID_TSCC: - case CODEC_ID_CSCD: - case CODEC_ID_APE: + case AV_CODEC_ID_MSRLE: + case AV_CODEC_ID_QTRLE: + case AV_CODEC_ID_TSCC: + case AV_CODEC_ID_CSCD: + case AV_CODEC_ID_APE: { gint depth; @@ -2803,22 +3184,10 @@ gst_ffmpeg_caps_with_codecid (enum CodecID codec_id, } break; - case CODEC_ID_RV10: - case CODEC_ID_RV20: - case CODEC_ID_RV30: - case CODEC_ID_RV40: - { - gint format; - - if (gst_structure_get_int (str, "format", &format)) - context->sub_id = format; - - break; - } - case CODEC_ID_COOK: - case CODEC_ID_RA_288: - case CODEC_ID_RA_144: - case CODEC_ID_SIPR: + case AV_CODEC_ID_COOK: + case AV_CODEC_ID_RA_288: + case AV_CODEC_ID_RA_144: + case AV_CODEC_ID_SIPR: { gint leaf_size; gint bitrate; @@ -2828,29 +3197,30 @@ gst_ffmpeg_caps_with_codecid (enum CodecID codec_id, if (gst_structure_get_int (str, "bitrate", &bitrate)) context->bit_rate = bitrate; } - case CODEC_ID_ALAC: + break; + case AV_CODEC_ID_ALAC: gst_structure_get_int (str, "samplesize", &context->bits_per_coded_sample); break; - case CODEC_ID_DVVIDEO: + case AV_CODEC_ID_DVVIDEO: { const gchar *format; if ((format = gst_structure_get_string (str, "format"))) { if (g_str_equal (format, "YUY2")) - context->pix_fmt = PIX_FMT_YUYV422; + context->pix_fmt = AV_PIX_FMT_YUYV422; else if (g_str_equal (format, "I420")) - context->pix_fmt = PIX_FMT_YUV420P; + context->pix_fmt = AV_PIX_FMT_YUV420P; else if (g_str_equal (format, "A420")) - context->pix_fmt = PIX_FMT_YUVA420P; + context->pix_fmt = AV_PIX_FMT_YUVA420P; else if (g_str_equal (format, "Y41B")) - context->pix_fmt = PIX_FMT_YUV411P; + context->pix_fmt = AV_PIX_FMT_YUV411P; else if (g_str_equal (format, "Y42B")) - context->pix_fmt = PIX_FMT_YUV422P; + context->pix_fmt = AV_PIX_FMT_YUV422P; else if (g_str_equal (format, "YUV9")) - context->pix_fmt = PIX_FMT_YUV410P; + context->pix_fmt = AV_PIX_FMT_YUV410P; else { GST_WARNING ("couldn't convert format %s" " to a pixel format", format); @@ -2859,7 +3229,7 @@ gst_ffmpeg_caps_with_codecid (enum CodecID codec_id, GST_WARNING ("No specified format"); break; } - case CODEC_ID_H263P: + case AV_CODEC_ID_H263P: { gboolean val; @@ -2878,7 +3248,7 @@ gst_ffmpeg_caps_with_codecid (enum CodecID codec_id, context->flags &= ~CODEC_FLAG_LOOP_FILTER; break; } - case CODEC_ID_ADPCM_G726: + case AV_CODEC_ID_ADPCM_G726: { const gchar *layout; @@ -2901,7 +3271,8 @@ gst_ffmpeg_caps_with_codecid (enum CodecID codec_id, /* common properties (width, height, fps) */ switch (codec_type) { case AVMEDIA_TYPE_VIDEO: - gst_ffmpeg_caps_to_pixfmt (caps, context, codec_id == CODEC_ID_RAWVIDEO); + gst_ffmpeg_caps_to_pixfmt (caps, context, + codec_id == AV_CODEC_ID_RAWVIDEO); break; case AVMEDIA_TYPE_AUDIO: gst_ffmpeg_caps_to_smpfmt (caps, context, FALSE); @@ -2912,11 +3283,11 @@ gst_ffmpeg_caps_with_codecid (enum CodecID codec_id, /* fixup of default settings */ switch (codec_id) { - case CODEC_ID_QCELP: + case AV_CODEC_ID_QCELP: /* QCELP is always mono, no matter what the caps say */ context->channels = 1; break; - case CODEC_ID_ADPCM_G726: + case AV_CODEC_ID_ADPCM_G726: if (context->sample_rate && context->bit_rate) context->bits_per_coded_sample = context->bit_rate / context->sample_rate; @@ -3011,6 +3382,8 @@ gst_ffmpeg_formatid_to_caps (const gchar * format_name) "y4mversion", G_TYPE_INT, 2, NULL); } else if (!strcmp (format_name, "mpc")) { caps = gst_caps_from_string ("audio/x-musepack, streamversion = (int) 7"); + } else if (!strcmp (format_name, "mpc8")) { + caps = gst_caps_from_string ("audio/x-musepack, streamversion = (int) 8"); } else if (!strcmp (format_name, "vqf")) { caps = gst_caps_from_string ("audio/x-vqf"); } else if (!strcmp (format_name, "nsv")) { @@ -3021,6 +3394,8 @@ gst_ffmpeg_formatid_to_caps (const gchar * format_name) caps = gst_caps_from_string ("video/webm"); } else if (!strcmp (format_name, "voc")) { caps = gst_caps_from_string ("audio/x-voc"); + } else if (!strcmp (format_name, "pva")) { + caps = gst_caps_from_string ("video/x-pva"); } else { gchar *name; @@ -3035,162 +3410,182 @@ gst_ffmpeg_formatid_to_caps (const gchar * format_name) gboolean gst_ffmpeg_formatid_get_codecids (const gchar * format_name, - enum CodecID ** video_codec_list, enum CodecID ** audio_codec_list, + enum AVCodecID ** video_codec_list, enum AVCodecID ** audio_codec_list, AVOutputFormat * plugin) { - static enum CodecID tmp_vlist[] = { - CODEC_ID_NONE, - CODEC_ID_NONE + static enum AVCodecID tmp_vlist[] = { + AV_CODEC_ID_NONE, + AV_CODEC_ID_NONE }; - static enum CodecID tmp_alist[] = { - CODEC_ID_NONE, - CODEC_ID_NONE + static enum AVCodecID tmp_alist[] = { + AV_CODEC_ID_NONE, + AV_CODEC_ID_NONE }; GST_LOG ("format_name : %s", format_name); if (!strcmp (format_name, "mp4")) { - static enum CodecID mp4_video_list[] = { - CODEC_ID_MPEG4, CODEC_ID_H264, - CODEC_ID_MJPEG, - CODEC_ID_NONE + static enum AVCodecID mp4_video_list[] = { + AV_CODEC_ID_MPEG4, AV_CODEC_ID_H264, + AV_CODEC_ID_MJPEG, + AV_CODEC_ID_NONE }; - static enum CodecID mp4_audio_list[] = { - CODEC_ID_AAC, CODEC_ID_MP3, - CODEC_ID_NONE + static enum AVCodecID mp4_audio_list[] = { + AV_CODEC_ID_AAC, AV_CODEC_ID_MP3, + AV_CODEC_ID_NONE }; *video_codec_list = mp4_video_list; *audio_codec_list = mp4_audio_list; } else if (!strcmp (format_name, "mpeg")) { - static enum CodecID mpeg_video_list[] = { CODEC_ID_MPEG1VIDEO, - CODEC_ID_MPEG2VIDEO, - CODEC_ID_H264, - CODEC_ID_NONE + static enum AVCodecID mpeg_video_list[] = { AV_CODEC_ID_MPEG1VIDEO, + AV_CODEC_ID_MPEG2VIDEO, + AV_CODEC_ID_H264, + AV_CODEC_ID_NONE }; - static enum CodecID mpeg_audio_list[] = { CODEC_ID_MP1, - CODEC_ID_MP2, - CODEC_ID_MP3, - CODEC_ID_NONE + static enum AVCodecID mpeg_audio_list[] = { AV_CODEC_ID_MP1, + AV_CODEC_ID_MP2, + AV_CODEC_ID_MP3, + AV_CODEC_ID_NONE }; *video_codec_list = mpeg_video_list; *audio_codec_list = mpeg_audio_list; } else if (!strcmp (format_name, "dvd")) { - static enum CodecID mpeg_video_list[] = { CODEC_ID_MPEG2VIDEO, - CODEC_ID_NONE + static enum AVCodecID mpeg_video_list[] = { AV_CODEC_ID_MPEG2VIDEO, + AV_CODEC_ID_NONE }; - static enum CodecID mpeg_audio_list[] = { CODEC_ID_MP2, - CODEC_ID_AC3, - CODEC_ID_DTS, - CODEC_ID_PCM_S16BE, - CODEC_ID_NONE + static enum AVCodecID mpeg_audio_list[] = { AV_CODEC_ID_MP2, + AV_CODEC_ID_AC3, + AV_CODEC_ID_DTS, + AV_CODEC_ID_PCM_S16BE, + AV_CODEC_ID_NONE }; *video_codec_list = mpeg_video_list; *audio_codec_list = mpeg_audio_list; } else if (!strcmp (format_name, "mpegts")) { - static enum CodecID mpegts_video_list[] = { CODEC_ID_MPEG1VIDEO, - CODEC_ID_MPEG2VIDEO, - CODEC_ID_H264, - CODEC_ID_NONE + static enum AVCodecID mpegts_video_list[] = { AV_CODEC_ID_MPEG1VIDEO, + AV_CODEC_ID_MPEG2VIDEO, + AV_CODEC_ID_H264, + AV_CODEC_ID_NONE }; - static enum CodecID mpegts_audio_list[] = { CODEC_ID_MP2, - CODEC_ID_MP3, - CODEC_ID_AC3, - CODEC_ID_DTS, - CODEC_ID_AAC, - CODEC_ID_NONE + static enum AVCodecID mpegts_audio_list[] = { AV_CODEC_ID_MP2, + AV_CODEC_ID_MP3, + AV_CODEC_ID_AC3, + AV_CODEC_ID_DTS, + AV_CODEC_ID_AAC, + AV_CODEC_ID_NONE }; *video_codec_list = mpegts_video_list; *audio_codec_list = mpegts_audio_list; } else if (!strcmp (format_name, "vob")) { - static enum CodecID vob_video_list[] = - { CODEC_ID_MPEG2VIDEO, CODEC_ID_NONE }; - static enum CodecID vob_audio_list[] = { CODEC_ID_MP2, CODEC_ID_AC3, - CODEC_ID_DTS, CODEC_ID_NONE + static enum AVCodecID vob_video_list[] = + { AV_CODEC_ID_MPEG2VIDEO, AV_CODEC_ID_NONE }; + static enum AVCodecID vob_audio_list[] = { AV_CODEC_ID_MP2, AV_CODEC_ID_AC3, + AV_CODEC_ID_DTS, AV_CODEC_ID_NONE }; *video_codec_list = vob_video_list; *audio_codec_list = vob_audio_list; } else if (!strcmp (format_name, "flv")) { - static enum CodecID flv_video_list[] = { CODEC_ID_FLV1, CODEC_ID_NONE }; - static enum CodecID flv_audio_list[] = { CODEC_ID_MP3, CODEC_ID_NONE }; + static enum AVCodecID flv_video_list[] = + { AV_CODEC_ID_FLV1, AV_CODEC_ID_NONE }; + static enum AVCodecID flv_audio_list[] = + { AV_CODEC_ID_MP3, AV_CODEC_ID_NONE }; *video_codec_list = flv_video_list; *audio_codec_list = flv_audio_list; } else if (!strcmp (format_name, "asf")) { - static enum CodecID asf_video_list[] = - { CODEC_ID_WMV1, CODEC_ID_WMV2, CODEC_ID_MSMPEG4V3, CODEC_ID_NONE }; - static enum CodecID asf_audio_list[] = - { CODEC_ID_WMAV1, CODEC_ID_WMAV2, CODEC_ID_MP3, CODEC_ID_NONE }; + static enum AVCodecID asf_video_list[] = + { AV_CODEC_ID_WMV1, AV_CODEC_ID_WMV2, AV_CODEC_ID_MSMPEG4V3, + AV_CODEC_ID_NONE + }; + static enum AVCodecID asf_audio_list[] = + { AV_CODEC_ID_WMAV1, AV_CODEC_ID_WMAV2, AV_CODEC_ID_MP3, + AV_CODEC_ID_NONE + }; *video_codec_list = asf_video_list; *audio_codec_list = asf_audio_list; } else if (!strcmp (format_name, "dv")) { - static enum CodecID dv_video_list[] = { CODEC_ID_DVVIDEO, CODEC_ID_NONE }; - static enum CodecID dv_audio_list[] = { CODEC_ID_PCM_S16LE, CODEC_ID_NONE }; + static enum AVCodecID dv_video_list[] = + { AV_CODEC_ID_DVVIDEO, AV_CODEC_ID_NONE }; + static enum AVCodecID dv_audio_list[] = + { AV_CODEC_ID_PCM_S16LE, AV_CODEC_ID_NONE }; *video_codec_list = dv_video_list; *audio_codec_list = dv_audio_list; } else if (!strcmp (format_name, "mov")) { - static enum CodecID mov_video_list[] = { - CODEC_ID_SVQ1, CODEC_ID_SVQ3, CODEC_ID_MPEG4, - CODEC_ID_H263, CODEC_ID_H263P, - CODEC_ID_H264, CODEC_ID_DVVIDEO, - CODEC_ID_MJPEG, - CODEC_ID_NONE + static enum AVCodecID mov_video_list[] = { + AV_CODEC_ID_SVQ1, AV_CODEC_ID_SVQ3, AV_CODEC_ID_MPEG4, + AV_CODEC_ID_H263, AV_CODEC_ID_H263P, + AV_CODEC_ID_H264, AV_CODEC_ID_DVVIDEO, + AV_CODEC_ID_MJPEG, + AV_CODEC_ID_NONE }; - static enum CodecID mov_audio_list[] = { - CODEC_ID_PCM_MULAW, CODEC_ID_PCM_ALAW, CODEC_ID_ADPCM_IMA_QT, - CODEC_ID_MACE3, CODEC_ID_MACE6, CODEC_ID_AAC, - CODEC_ID_AMR_NB, CODEC_ID_AMR_WB, - CODEC_ID_PCM_S16BE, CODEC_ID_PCM_S16LE, - CODEC_ID_MP3, CODEC_ID_NONE + static enum AVCodecID mov_audio_list[] = { + AV_CODEC_ID_PCM_MULAW, AV_CODEC_ID_PCM_ALAW, AV_CODEC_ID_ADPCM_IMA_QT, + AV_CODEC_ID_MACE3, AV_CODEC_ID_MACE6, AV_CODEC_ID_AAC, + AV_CODEC_ID_AMR_NB, AV_CODEC_ID_AMR_WB, + AV_CODEC_ID_PCM_S16BE, AV_CODEC_ID_PCM_S16LE, + AV_CODEC_ID_MP3, AV_CODEC_ID_NONE }; *video_codec_list = mov_video_list; *audio_codec_list = mov_audio_list; } else if ((!strcmp (format_name, "3gp") || !strcmp (format_name, "3g2"))) { - static enum CodecID tgp_video_list[] = { - CODEC_ID_MPEG4, CODEC_ID_H263, CODEC_ID_H263P, CODEC_ID_H264, - CODEC_ID_NONE + static enum AVCodecID tgp_video_list[] = { + AV_CODEC_ID_MPEG4, AV_CODEC_ID_H263, AV_CODEC_ID_H263P, AV_CODEC_ID_H264, + AV_CODEC_ID_NONE }; - static enum CodecID tgp_audio_list[] = { - CODEC_ID_AMR_NB, CODEC_ID_AMR_WB, - CODEC_ID_AAC, - CODEC_ID_NONE + static enum AVCodecID tgp_audio_list[] = { + AV_CODEC_ID_AMR_NB, AV_CODEC_ID_AMR_WB, + AV_CODEC_ID_AAC, + AV_CODEC_ID_NONE }; *video_codec_list = tgp_video_list; *audio_codec_list = tgp_audio_list; } else if (!strcmp (format_name, "mmf")) { - static enum CodecID mmf_audio_list[] = { - CODEC_ID_ADPCM_YAMAHA, CODEC_ID_NONE + static enum AVCodecID mmf_audio_list[] = { + AV_CODEC_ID_ADPCM_YAMAHA, AV_CODEC_ID_NONE }; *video_codec_list = NULL; *audio_codec_list = mmf_audio_list; } else if (!strcmp (format_name, "amr")) { - static enum CodecID amr_audio_list[] = { - CODEC_ID_AMR_NB, CODEC_ID_AMR_WB, - CODEC_ID_NONE + static enum AVCodecID amr_audio_list[] = { + AV_CODEC_ID_AMR_NB, AV_CODEC_ID_AMR_WB, + AV_CODEC_ID_NONE }; *video_codec_list = NULL; *audio_codec_list = amr_audio_list; } else if (!strcmp (format_name, "gif")) { - static enum CodecID gif_image_list[] = { - CODEC_ID_RAWVIDEO, CODEC_ID_NONE + static enum AVCodecID gif_image_list[] = { + AV_CODEC_ID_RAWVIDEO, AV_CODEC_ID_NONE }; *video_codec_list = gif_image_list; *audio_codec_list = NULL; - } else if ((plugin->audio_codec != CODEC_ID_NONE) || - (plugin->video_codec != CODEC_ID_NONE)) { + } else if ((plugin->audio_codec != AV_CODEC_ID_NONE) || + (plugin->video_codec != AV_CODEC_ID_NONE)) { tmp_vlist[0] = plugin->video_codec; tmp_alist[0] = plugin->audio_codec; *video_codec_list = tmp_vlist; *audio_codec_list = tmp_alist; + } else if ((!strcmp (format_name, "pva"))) { + static enum AVCodecID tgp_video_list[] = { + AV_CODEC_ID_MPEG2VIDEO, + AV_CODEC_ID_NONE + }; + static enum AVCodecID tgp_audio_list[] = { + AV_CODEC_ID_MP2, + AV_CODEC_ID_NONE + }; + + *video_codec_list = tgp_video_list; + *audio_codec_list = tgp_audio_list; } else { GST_LOG ("Format %s not found", format_name); return FALSE; @@ -3206,22 +3601,22 @@ gst_ffmpeg_formatid_get_codecids (const gchar * format_name, * optional extra info */ -enum CodecID +enum AVCodecID gst_ffmpeg_caps_to_codecid (const GstCaps * caps, AVCodecContext * context) { - enum CodecID id = CODEC_ID_NONE; + enum AVCodecID id = AV_CODEC_ID_NONE; const gchar *mimetype; const GstStructure *structure; gboolean video = FALSE, audio = FALSE; /* we want to be sure! */ - g_return_val_if_fail (caps != NULL, CODEC_ID_NONE); - g_return_val_if_fail (gst_caps_get_size (caps) == 1, CODEC_ID_NONE); + g_return_val_if_fail (caps != NULL, AV_CODEC_ID_NONE); + g_return_val_if_fail (gst_caps_get_size (caps) == 1, AV_CODEC_ID_NONE); structure = gst_caps_get_structure (caps, 0); mimetype = gst_structure_get_name (structure); if (!strcmp (mimetype, "video/x-raw")) { - id = CODEC_ID_RAWVIDEO; + id = AV_CODEC_ID_RAWVIDEO; video = TRUE; } else if (!strcmp (mimetype, "audio/x-raw")) { GstAudioInfo info; @@ -3229,59 +3624,59 @@ gst_ffmpeg_caps_to_codecid (const GstCaps * caps, AVCodecContext * context) if (gst_audio_info_from_caps (&info, caps)) { switch (GST_AUDIO_INFO_FORMAT (&info)) { case GST_AUDIO_FORMAT_S8: - id = CODEC_ID_PCM_S8; + id = AV_CODEC_ID_PCM_S8; break; case GST_AUDIO_FORMAT_U8: - id = CODEC_ID_PCM_U8; + id = AV_CODEC_ID_PCM_U8; break; case GST_AUDIO_FORMAT_S16LE: - id = CODEC_ID_PCM_S16LE; + id = AV_CODEC_ID_PCM_S16LE; break; case GST_AUDIO_FORMAT_S16BE: - id = CODEC_ID_PCM_S16BE; + id = AV_CODEC_ID_PCM_S16BE; break; case GST_AUDIO_FORMAT_U16LE: - id = CODEC_ID_PCM_U16LE; + id = AV_CODEC_ID_PCM_U16LE; break; case GST_AUDIO_FORMAT_U16BE: - id = CODEC_ID_PCM_U16BE; + id = AV_CODEC_ID_PCM_U16BE; break; default: break; } - if (id != CODEC_ID_NONE) + if (id != AV_CODEC_ID_NONE) audio = TRUE; } } else if (!strcmp (mimetype, "audio/x-mulaw")) { - id = CODEC_ID_PCM_MULAW; + id = AV_CODEC_ID_PCM_MULAW; audio = TRUE; } else if (!strcmp (mimetype, "audio/x-alaw")) { - id = CODEC_ID_PCM_ALAW; + id = AV_CODEC_ID_PCM_ALAW; audio = TRUE; } else if (!strcmp (mimetype, "video/x-dv")) { gboolean sys_strm; if (gst_structure_get_boolean (structure, "systemstream", &sys_strm) && !sys_strm) { - id = CODEC_ID_DVVIDEO; + id = AV_CODEC_ID_DVVIDEO; video = TRUE; } } else if (!strcmp (mimetype, "audio/x-dv")) { /* ??? */ - id = CODEC_ID_DVAUDIO; + id = AV_CODEC_ID_DVAUDIO; audio = TRUE; } else if (!strcmp (mimetype, "video/x-h263")) { const gchar *h263version = gst_structure_get_string (structure, "h263version"); if (h263version && !strcmp (h263version, "h263p")) - id = CODEC_ID_H263P; + id = AV_CODEC_ID_H263P; else - id = CODEC_ID_H263; + id = AV_CODEC_ID_H263; video = TRUE; } else if (!strcmp (mimetype, "video/x-intel-h263")) { - id = CODEC_ID_H263I; + id = AV_CODEC_ID_H263I; video = TRUE; } else if (!strcmp (mimetype, "video/x-h261")) { - id = CODEC_ID_H261; + id = AV_CODEC_ID_H261; video = TRUE; } else if (!strcmp (mimetype, "video/mpeg")) { gboolean sys_strm; @@ -3292,23 +3687,23 @@ gst_ffmpeg_caps_to_codecid (const GstCaps * caps, AVCodecContext * context) !sys_strm) { switch (mpegversion) { case 1: - id = CODEC_ID_MPEG1VIDEO; + id = AV_CODEC_ID_MPEG1VIDEO; break; case 2: - id = CODEC_ID_MPEG2VIDEO; + id = AV_CODEC_ID_MPEG2VIDEO; break; case 4: - id = CODEC_ID_MPEG4; + id = AV_CODEC_ID_MPEG4; break; } } - if (id != CODEC_ID_NONE) + if (id != AV_CODEC_ID_NONE) video = TRUE; } else if (!strcmp (mimetype, "image/jpeg")) { - id = CODEC_ID_MJPEG; /* A... B... */ + id = AV_CODEC_ID_MJPEG; /* A... B... */ video = TRUE; } else if (!strcmp (mimetype, "video/x-jpeg-b")) { - id = CODEC_ID_MJPEGB; + id = AV_CODEC_ID_MJPEGB; video = TRUE; } else if (!strcmp (mimetype, "video/x-wmv")) { gint wmvversion = 0; @@ -3316,33 +3711,33 @@ gst_ffmpeg_caps_to_codecid (const GstCaps * caps, AVCodecContext * context) if (gst_structure_get_int (structure, "wmvversion", &wmvversion)) { switch (wmvversion) { case 1: - id = CODEC_ID_WMV1; + id = AV_CODEC_ID_WMV1; break; case 2: - id = CODEC_ID_WMV2; + id = AV_CODEC_ID_WMV2; break; case 3: { const gchar *format; /* WMV3 unless the fourcc exists and says otherwise */ - id = CODEC_ID_WMV3; + id = AV_CODEC_ID_WMV3; if ((format = gst_structure_get_string (structure, "format")) && (g_str_equal (format, "WVC1") || g_str_equal (format, "WMVA"))) - id = CODEC_ID_VC1; + id = AV_CODEC_ID_VC1; break; } } } - if (id != CODEC_ID_NONE) + if (id != AV_CODEC_ID_NONE) video = TRUE; } else if (!strcmp (mimetype, "audio/x-vorbis")) { - id = CODEC_ID_VORBIS; + id = AV_CODEC_ID_VORBIS; audio = TRUE; } else if (!strcmp (mimetype, "audio/x-qdm2")) { - id = CODEC_ID_QDM2; + id = AV_CODEC_ID_QDM2; audio = TRUE; } else if (!strcmp (mimetype, "audio/mpeg")) { gint layer = 0; @@ -3352,34 +3747,34 @@ gst_ffmpeg_caps_to_codecid (const GstCaps * caps, AVCodecContext * context) switch (mpegversion) { case 2: /* ffmpeg uses faad for both... */ case 4: - id = CODEC_ID_AAC; + id = AV_CODEC_ID_AAC; break; case 1: if (gst_structure_get_int (structure, "layer", &layer)) { switch (layer) { case 1: - id = CODEC_ID_MP1; + id = AV_CODEC_ID_MP1; break; case 2: - id = CODEC_ID_MP2; + id = AV_CODEC_ID_MP2; break; case 3: - id = CODEC_ID_MP3; + id = AV_CODEC_ID_MP3; break; } } } } - if (id != CODEC_ID_NONE) + if (id != AV_CODEC_ID_NONE) audio = TRUE; } else if (!strcmp (mimetype, "audio/x-musepack")) { gint streamversion = -1; if (gst_structure_get_int (structure, "streamversion", &streamversion)) { if (streamversion == 7) - id = CODEC_ID_MUSEPACK7; + id = AV_CODEC_ID_MUSEPACK7; } else { - id = CODEC_ID_MUSEPACK7; + id = AV_CODEC_ID_MUSEPACK7; } } else if (!strcmp (mimetype, "audio/x-wma")) { gint wmaversion = 0; @@ -3387,36 +3782,36 @@ gst_ffmpeg_caps_to_codecid (const GstCaps * caps, AVCodecContext * context) if (gst_structure_get_int (structure, "wmaversion", &wmaversion)) { switch (wmaversion) { case 1: - id = CODEC_ID_WMAV1; + id = AV_CODEC_ID_WMAV1; break; case 2: - id = CODEC_ID_WMAV2; + id = AV_CODEC_ID_WMAV2; break; case 3: - id = CODEC_ID_WMAPRO; + id = AV_CODEC_ID_WMAPRO; break; } } - if (id != CODEC_ID_NONE) + if (id != AV_CODEC_ID_NONE) audio = TRUE; } else if (!strcmp (mimetype, "audio/x-wms")) { - id = CODEC_ID_WMAVOICE; + id = AV_CODEC_ID_WMAVOICE; audio = TRUE; } else if (!strcmp (mimetype, "audio/x-ac3")) { - id = CODEC_ID_AC3; + id = AV_CODEC_ID_AC3; audio = TRUE; } else if (!strcmp (mimetype, "audio/x-eac3")) { - id = CODEC_ID_EAC3; + id = AV_CODEC_ID_EAC3; audio = TRUE; } else if (!strcmp (mimetype, "audio/x-vnd.sony.atrac3") || !strcmp (mimetype, "audio/atrac3")) { - id = CODEC_ID_ATRAC3; + id = AV_CODEC_ID_ATRAC3; audio = TRUE; } else if (!strcmp (mimetype, "audio/x-dts")) { - id = CODEC_ID_DTS; + id = AV_CODEC_ID_DTS; audio = TRUE; } else if (!strcmp (mimetype, "application/x-ape")) { - id = CODEC_ID_APE; + id = AV_CODEC_ID_APE; audio = TRUE; } else if (!strcmp (mimetype, "video/x-msmpeg")) { gint msmpegversion = 0; @@ -3424,17 +3819,17 @@ gst_ffmpeg_caps_to_codecid (const GstCaps * caps, AVCodecContext * context) if (gst_structure_get_int (structure, "msmpegversion", &msmpegversion)) { switch (msmpegversion) { case 41: - id = CODEC_ID_MSMPEG4V1; + id = AV_CODEC_ID_MSMPEG4V1; break; case 42: - id = CODEC_ID_MSMPEG4V2; + id = AV_CODEC_ID_MSMPEG4V2; break; case 43: - id = CODEC_ID_MSMPEG4V3; + id = AV_CODEC_ID_MSMPEG4V3; break; } } - if (id != CODEC_ID_NONE) + if (id != AV_CODEC_ID_NONE) video = TRUE; } else if (!strcmp (mimetype, "video/x-svq")) { gint svqversion = 0; @@ -3442,17 +3837,17 @@ gst_ffmpeg_caps_to_codecid (const GstCaps * caps, AVCodecContext * context) if (gst_structure_get_int (structure, "svqversion", &svqversion)) { switch (svqversion) { case 1: - id = CODEC_ID_SVQ1; + id = AV_CODEC_ID_SVQ1; break; case 3: - id = CODEC_ID_SVQ3; + id = AV_CODEC_ID_SVQ3; break; } } - if (id != CODEC_ID_NONE) + if (id != AV_CODEC_ID_NONE) video = TRUE; } else if (!strcmp (mimetype, "video/x-huffyuv")) { - id = CODEC_ID_HUFFYUV; + id = AV_CODEC_ID_HUFFYUV; video = TRUE; } else if (!strcmp (mimetype, "audio/x-mace")) { gint maceversion = 0; @@ -3460,38 +3855,41 @@ gst_ffmpeg_caps_to_codecid (const GstCaps * caps, AVCodecContext * context) if (gst_structure_get_int (structure, "maceversion", &maceversion)) { switch (maceversion) { case 3: - id = CODEC_ID_MACE3; + id = AV_CODEC_ID_MACE3; break; case 6: - id = CODEC_ID_MACE6; + id = AV_CODEC_ID_MACE6; break; } } - if (id != CODEC_ID_NONE) + if (id != AV_CODEC_ID_NONE) audio = TRUE; } else if (!strcmp (mimetype, "video/x-theora")) { - id = CODEC_ID_THEORA; + id = AV_CODEC_ID_THEORA; video = TRUE; } else if (!strcmp (mimetype, "video/x-vp3")) { - id = CODEC_ID_VP3; + id = AV_CODEC_ID_VP3; video = TRUE; } else if (!strcmp (mimetype, "video/x-vp5")) { - id = CODEC_ID_VP5; + id = AV_CODEC_ID_VP5; video = TRUE; } else if (!strcmp (mimetype, "video/x-vp6")) { - id = CODEC_ID_VP6; + id = AV_CODEC_ID_VP6; video = TRUE; } else if (!strcmp (mimetype, "video/x-vp6-flash")) { - id = CODEC_ID_VP6F; + id = AV_CODEC_ID_VP6F; video = TRUE; } else if (!strcmp (mimetype, "video/x-vp6-alpha")) { - id = CODEC_ID_VP6A; + id = AV_CODEC_ID_VP6A; video = TRUE; } else if (!strcmp (mimetype, "video/x-vp8")) { - id = CODEC_ID_VP8; + id = AV_CODEC_ID_VP8; + video = TRUE; + } else if (!strcmp (mimetype, "video/x-vp9")) { + id = AV_CODEC_ID_VP9; video = TRUE; } else if (!strcmp (mimetype, "video/x-flash-screen")) { - id = CODEC_ID_FLASHSV; + id = AV_CODEC_ID_FLASHSV; video = TRUE; } else if (!strcmp (mimetype, "video/x-indeo")) { gint indeoversion = 0; @@ -3499,19 +3897,19 @@ gst_ffmpeg_caps_to_codecid (const GstCaps * caps, AVCodecContext * context) if (gst_structure_get_int (structure, "indeoversion", &indeoversion)) { switch (indeoversion) { case 5: - id = CODEC_ID_INDEO5; + id = AV_CODEC_ID_INDEO5; break; case 4: - id = CODEC_ID_INDEO4; + id = AV_CODEC_ID_INDEO4; break; case 3: - id = CODEC_ID_INDEO3; + id = AV_CODEC_ID_INDEO3; break; case 2: - id = CODEC_ID_INDEO2; + id = AV_CODEC_ID_INDEO2; break; } - if (id != CODEC_ID_NONE) + if (id != AV_CODEC_ID_NONE) video = TRUE; } } else if (!strcmp (mimetype, "video/x-divx")) { @@ -3520,30 +3918,27 @@ gst_ffmpeg_caps_to_codecid (const GstCaps * caps, AVCodecContext * context) if (gst_structure_get_int (structure, "divxversion", &divxversion)) { switch (divxversion) { case 3: - id = CODEC_ID_MSMPEG4V3; + id = AV_CODEC_ID_MSMPEG4V3; break; case 4: case 5: - id = CODEC_ID_MPEG4; + id = AV_CODEC_ID_MPEG4; break; } } - if (id != CODEC_ID_NONE) + if (id != AV_CODEC_ID_NONE) video = TRUE; - } else if (!strcmp (mimetype, "video/x-3ivx")) { - id = CODEC_ID_MPEG4; - video = TRUE; - } else if (!strcmp (mimetype, "video/x-xvid")) { - id = CODEC_ID_MPEG4; - video = TRUE; } else if (!strcmp (mimetype, "video/x-ffv")) { gint ffvversion = 0; if (gst_structure_get_int (structure, "ffvversion", &ffvversion) && ffvversion == 1) { - id = CODEC_ID_FFV1; + id = AV_CODEC_ID_FFV1; video = TRUE; } + } else if (!strcmp (mimetype, "video/x-apple-intermediate-codec")) { + id = AV_CODEC_ID_AIC; + video = TRUE; } else if (!strcmp (mimetype, "audio/x-adpcm")) { const gchar *layout; @@ -3551,50 +3946,50 @@ gst_ffmpeg_caps_to_codecid (const GstCaps * caps, AVCodecContext * context) if (layout == NULL) { /* break */ } else if (!strcmp (layout, "quicktime")) { - id = CODEC_ID_ADPCM_IMA_QT; + id = AV_CODEC_ID_ADPCM_IMA_QT; } else if (!strcmp (layout, "microsoft")) { - id = CODEC_ID_ADPCM_MS; + id = AV_CODEC_ID_ADPCM_MS; } else if (!strcmp (layout, "dvi")) { - id = CODEC_ID_ADPCM_IMA_WAV; + id = AV_CODEC_ID_ADPCM_IMA_WAV; } else if (!strcmp (layout, "4xm")) { - id = CODEC_ID_ADPCM_4XM; + id = AV_CODEC_ID_ADPCM_4XM; } else if (!strcmp (layout, "smjpeg")) { - id = CODEC_ID_ADPCM_IMA_SMJPEG; + id = AV_CODEC_ID_ADPCM_IMA_SMJPEG; } else if (!strcmp (layout, "dk3")) { - id = CODEC_ID_ADPCM_IMA_DK3; + id = AV_CODEC_ID_ADPCM_IMA_DK3; } else if (!strcmp (layout, "dk4")) { - id = CODEC_ID_ADPCM_IMA_DK4; + id = AV_CODEC_ID_ADPCM_IMA_DK4; } else if (!strcmp (layout, "westwood")) { - id = CODEC_ID_ADPCM_IMA_WS; + id = AV_CODEC_ID_ADPCM_IMA_WS; } else if (!strcmp (layout, "iss")) { - id = CODEC_ID_ADPCM_IMA_ISS; + id = AV_CODEC_ID_ADPCM_IMA_ISS; } else if (!strcmp (layout, "xa")) { - id = CODEC_ID_ADPCM_XA; + id = AV_CODEC_ID_ADPCM_XA; } else if (!strcmp (layout, "adx")) { - id = CODEC_ID_ADPCM_ADX; + id = AV_CODEC_ID_ADPCM_ADX; } else if (!strcmp (layout, "ea")) { - id = CODEC_ID_ADPCM_EA; + id = AV_CODEC_ID_ADPCM_EA; } else if (!strcmp (layout, "g726")) { - id = CODEC_ID_ADPCM_G726; + id = AV_CODEC_ID_ADPCM_G726; } else if (!strcmp (layout, "g721")) { - id = CODEC_ID_ADPCM_G726; + id = AV_CODEC_ID_ADPCM_G726; } else if (!strcmp (layout, "ct")) { - id = CODEC_ID_ADPCM_CT; + id = AV_CODEC_ID_ADPCM_CT; } else if (!strcmp (layout, "swf")) { - id = CODEC_ID_ADPCM_SWF; + id = AV_CODEC_ID_ADPCM_SWF; } else if (!strcmp (layout, "yamaha")) { - id = CODEC_ID_ADPCM_YAMAHA; + id = AV_CODEC_ID_ADPCM_YAMAHA; } else if (!strcmp (layout, "sbpro2")) { - id = CODEC_ID_ADPCM_SBPRO_2; + id = AV_CODEC_ID_ADPCM_SBPRO_2; } else if (!strcmp (layout, "sbpro3")) { - id = CODEC_ID_ADPCM_SBPRO_3; + id = AV_CODEC_ID_ADPCM_SBPRO_3; } else if (!strcmp (layout, "sbpro4")) { - id = CODEC_ID_ADPCM_SBPRO_4; + id = AV_CODEC_ID_ADPCM_SBPRO_4; } - if (id != CODEC_ID_NONE) + if (id != AV_CODEC_ID_NONE) audio = TRUE; } else if (!strcmp (mimetype, "video/x-4xm")) { - id = CODEC_ID_4XM; + id = AV_CODEC_ID_4XM; video = TRUE; } else if (!strcmp (mimetype, "audio/x-dpcm")) { const gchar *layout; @@ -3603,27 +3998,27 @@ gst_ffmpeg_caps_to_codecid (const GstCaps * caps, AVCodecContext * context) if (!layout) { /* .. */ } else if (!strcmp (layout, "roq")) { - id = CODEC_ID_ROQ_DPCM; + id = AV_CODEC_ID_ROQ_DPCM; } else if (!strcmp (layout, "interplay")) { - id = CODEC_ID_INTERPLAY_DPCM; + id = AV_CODEC_ID_INTERPLAY_DPCM; } else if (!strcmp (layout, "xan")) { - id = CODEC_ID_XAN_DPCM; + id = AV_CODEC_ID_XAN_DPCM; } else if (!strcmp (layout, "sol")) { - id = CODEC_ID_SOL_DPCM; + id = AV_CODEC_ID_SOL_DPCM; } - if (id != CODEC_ID_NONE) + if (id != AV_CODEC_ID_NONE) audio = TRUE; } else if (!strcmp (mimetype, "audio/x-flac")) { - id = CODEC_ID_FLAC; + id = AV_CODEC_ID_FLAC; audio = TRUE; } else if (!strcmp (mimetype, "audio/x-shorten")) { - id = CODEC_ID_SHORTEN; + id = AV_CODEC_ID_SHORTEN; audio = TRUE; } else if (!strcmp (mimetype, "audio/x-alac")) { - id = CODEC_ID_ALAC; + id = AV_CODEC_ID_ALAC; audio = TRUE; } else if (!strcmp (mimetype, "video/x-cinepak")) { - id = CODEC_ID_CINEPAK; + id = AV_CODEC_ID_CINEPAK; video = TRUE; } else if (!strcmp (mimetype, "video/x-pn-realvideo")) { gint rmversion; @@ -3631,23 +4026,23 @@ gst_ffmpeg_caps_to_codecid (const GstCaps * caps, AVCodecContext * context) if (gst_structure_get_int (structure, "rmversion", &rmversion)) { switch (rmversion) { case 1: - id = CODEC_ID_RV10; + id = AV_CODEC_ID_RV10; break; case 2: - id = CODEC_ID_RV20; + id = AV_CODEC_ID_RV20; break; case 3: - id = CODEC_ID_RV30; + id = AV_CODEC_ID_RV30; break; case 4: - id = CODEC_ID_RV40; + id = AV_CODEC_ID_RV40; break; } } - if (id != CODEC_ID_NONE) + if (id != AV_CODEC_ID_NONE) video = TRUE; } else if (!strcmp (mimetype, "audio/x-sipro")) { - id = CODEC_ID_SIPR; + id = AV_CODEC_ID_SIPR; audio = TRUE; } else if (!strcmp (mimetype, "audio/x-pn-realaudio")) { gint raversion; @@ -3655,24 +4050,24 @@ gst_ffmpeg_caps_to_codecid (const GstCaps * caps, AVCodecContext * context) if (gst_structure_get_int (structure, "raversion", &raversion)) { switch (raversion) { case 1: - id = CODEC_ID_RA_144; + id = AV_CODEC_ID_RA_144; break; case 2: - id = CODEC_ID_RA_288; + id = AV_CODEC_ID_RA_288; break; case 8: - id = CODEC_ID_COOK; + id = AV_CODEC_ID_COOK; break; } } - if (id != CODEC_ID_NONE) + if (id != AV_CODEC_ID_NONE) audio = TRUE; } else if (!strcmp (mimetype, "video/x-rle")) { const gchar *layout; if ((layout = gst_structure_get_string (structure, "layout"))) { if (!strcmp (layout, "microsoft")) { - id = CODEC_ID_MSRLE; + id = AV_CODEC_ID_MSRLE; video = TRUE; } } @@ -3682,11 +4077,11 @@ gst_ffmpeg_caps_to_codecid (const GstCaps * caps, AVCodecContext * context) if ((gst_structure_get_int (structure, "wcversion", &wcversion))) { switch (wcversion) { case 3: - id = CODEC_ID_XAN_WC3; + id = AV_CODEC_ID_XAN_WC3; video = TRUE; break; case 4: - id = CODEC_ID_XAN_WC4; + id = AV_CODEC_ID_XAN_WC4; video = TRUE; break; default: @@ -3695,15 +4090,18 @@ gst_ffmpeg_caps_to_codecid (const GstCaps * caps, AVCodecContext * context) } } else if (!strcmp (mimetype, "audio/AMR")) { audio = TRUE; - id = CODEC_ID_AMR_NB; + id = AV_CODEC_ID_AMR_NB; } else if (!strcmp (mimetype, "audio/AMR-WB")) { - id = CODEC_ID_AMR_WB; + id = AV_CODEC_ID_AMR_WB; audio = TRUE; } else if (!strcmp (mimetype, "audio/qcelp")) { - id = CODEC_ID_QCELP; + id = AV_CODEC_ID_QCELP; audio = TRUE; } else if (!strcmp (mimetype, "video/x-h264")) { - id = CODEC_ID_H264; + id = AV_CODEC_ID_H264; + video = TRUE; + } else if (!strcmp (mimetype, "video/x-h265")) { + id = AV_CODEC_ID_HEVC; video = TRUE; } else if (!strcmp (mimetype, "video/x-flash-video")) { gint flvversion = 0; @@ -3711,7 +4109,7 @@ gst_ffmpeg_caps_to_codecid (const GstCaps * caps, AVCodecContext * context) if ((gst_structure_get_int (structure, "flvversion", &flvversion))) { switch (flvversion) { case 1: - id = CODEC_ID_FLV1; + id = AV_CODEC_ID_FLV1; video = TRUE; break; default: @@ -3720,7 +4118,7 @@ gst_ffmpeg_caps_to_codecid (const GstCaps * caps, AVCodecContext * context) } } else if (!strcmp (mimetype, "audio/x-nellymoser")) { - id = CODEC_ID_NELLYMOSER; + id = AV_CODEC_ID_NELLYMOSER; audio = TRUE; } else if (!strncmp (mimetype, "audio/x-gst-av-", 15)) { gchar ext[16]; @@ -3760,7 +4158,7 @@ gst_ffmpeg_caps_to_codecid (const GstCaps * caps, AVCodecContext * context) gst_ffmpeg_caps_with_codecid (id, context->codec_type, caps, context); } - if (id != CODEC_ID_NONE) { + if (id != AV_CODEC_ID_NONE) { GST_DEBUG ("The id=%d belongs to the caps %" GST_PTR_FORMAT, id, caps); } else { GST_WARNING ("Couldn't figure out the id for caps %" GST_PTR_FORMAT, caps);