1 /* GStreamer
2 * Copyright (C) <1999> Erik Walthinsen <omega@cse.ogi.edu>
3 * This file:
4 * Copyright (c) 2002-2004 Ronald Bultje <rbultje@ronald.bitfreak.net>
5 *
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Library General Public
8 * License as published by the Free Software Foundation; either
9 * version 2 of the License, or (at your option) any later version.
10 *
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Library General Public License for more details.
15 *
16 * You should have received a copy of the GNU Library General Public
17 * License along with this library; if not, write to the
18 * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
19 * Boston, MA 02110-1301, USA.
20 */
21
22 #ifdef HAVE_CONFIG_H
23 #include "config.h"
24 #endif
25
26 #include <string.h>
27
28 #include <gst/gst.h>
29 #include <libavcodec/avcodec.h>
30 #include <libavutil/channel_layout.h>
31
32 #include "gstav.h"
33 #include "gstavcodecmap.h"
34
35 #include <gst/video/video.h>
36 #include <gst/audio/audio.h>
37 #include <gst/pbutils/codec-utils.h>
38
39 /* IMPORTANT: Keep this sorted by the ffmpeg channel masks */
40 static const struct
41 {
42 guint64 ff;
43 GstAudioChannelPosition gst;
44 } _ff_to_gst_layout[] = {
45 {
46 AV_CH_FRONT_LEFT, GST_AUDIO_CHANNEL_POSITION_FRONT_LEFT}, {
47 AV_CH_FRONT_RIGHT, GST_AUDIO_CHANNEL_POSITION_FRONT_RIGHT}, {
48 AV_CH_FRONT_CENTER, GST_AUDIO_CHANNEL_POSITION_FRONT_CENTER}, {
49 AV_CH_LOW_FREQUENCY, GST_AUDIO_CHANNEL_POSITION_LFE1}, {
50 AV_CH_BACK_LEFT, GST_AUDIO_CHANNEL_POSITION_REAR_LEFT}, {
51 AV_CH_BACK_RIGHT, GST_AUDIO_CHANNEL_POSITION_REAR_RIGHT}, {
52 AV_CH_FRONT_LEFT_OF_CENTER, GST_AUDIO_CHANNEL_POSITION_FRONT_LEFT_OF_CENTER}, {
53 AV_CH_FRONT_RIGHT_OF_CENTER,
54 GST_AUDIO_CHANNEL_POSITION_FRONT_RIGHT_OF_CENTER}, {
55 AV_CH_BACK_CENTER, GST_AUDIO_CHANNEL_POSITION_REAR_CENTER}, {
56 AV_CH_SIDE_LEFT, GST_AUDIO_CHANNEL_POSITION_SIDE_LEFT}, {
57 AV_CH_SIDE_RIGHT, GST_AUDIO_CHANNEL_POSITION_SIDE_RIGHT}, {
58 AV_CH_TOP_CENTER, GST_AUDIO_CHANNEL_POSITION_TOP_CENTER}, {
59 AV_CH_TOP_FRONT_LEFT, GST_AUDIO_CHANNEL_POSITION_TOP_FRONT_LEFT}, {
60 AV_CH_TOP_FRONT_CENTER, GST_AUDIO_CHANNEL_POSITION_TOP_FRONT_CENTER}, {
61 AV_CH_TOP_FRONT_RIGHT, GST_AUDIO_CHANNEL_POSITION_TOP_FRONT_RIGHT}, {
62 AV_CH_TOP_BACK_LEFT, GST_AUDIO_CHANNEL_POSITION_TOP_REAR_LEFT}, {
63 AV_CH_TOP_BACK_CENTER, GST_AUDIO_CHANNEL_POSITION_TOP_REAR_CENTER}, {
64 AV_CH_TOP_BACK_RIGHT, GST_AUDIO_CHANNEL_POSITION_TOP_REAR_RIGHT}, {
65 AV_CH_STEREO_LEFT, GST_AUDIO_CHANNEL_POSITION_FRONT_LEFT}, {
66 AV_CH_STEREO_RIGHT, GST_AUDIO_CHANNEL_POSITION_FRONT_RIGHT}
67 };
68
69 GType
gst_ffmpeg_compliance_get_type(void)70 gst_ffmpeg_compliance_get_type (void)
71 {
72 static GType ffmpeg_compliance_type = 0;
73 static const GEnumValue compliance_types[] = {
74 {GST_FFMPEG_VERY_STRICT, "Strictly conform to older spec",
75 "verystrict"},
76 {GST_FFMPEG_STRICT, "Strictly conform to current spec", "strict"},
77 {GST_FFMPEG_NORMAL, "Normal behavior", "normal"},
78 {GST_FFMPEG_UNOFFICIAL, "Allow unofficial extensions", "unofficial"},
79 {GST_FFMPEG_EXPERIMENTAL, "Allow nonstandardized experimental things",
80 "experimental"},
81 {0, NULL, NULL}
82 };
83
84 if (!ffmpeg_compliance_type) {
85 ffmpeg_compliance_type =
86 g_enum_register_static ("GstFFMpegCompliance", compliance_types);
87 }
88 return ffmpeg_compliance_type;
89 }
90
91 static guint64
gst_ffmpeg_channel_positions_to_layout(GstAudioChannelPosition * pos,gint channels)92 gst_ffmpeg_channel_positions_to_layout (GstAudioChannelPosition * pos,
93 gint channels)
94 {
95 gint i, j;
96 guint64 ret = 0;
97 gint channels_found = 0;
98
99 if (!pos)
100 return 0;
101
102 if (channels == 1 && pos[0] == GST_AUDIO_CHANNEL_POSITION_MONO)
103 return AV_CH_LAYOUT_MONO;
104
105 for (i = 0; i < channels; i++) {
106 for (j = 0; j < G_N_ELEMENTS (_ff_to_gst_layout); j++) {
107 if (_ff_to_gst_layout[j].gst == pos[i]) {
108 ret |= _ff_to_gst_layout[j].ff;
109 channels_found++;
110 break;
111 }
112 }
113 }
114
115 if (channels_found != channels)
116 return 0;
117 return ret;
118 }
119
120 gboolean
gst_ffmpeg_channel_layout_to_gst(guint64 channel_layout,gint channels,GstAudioChannelPosition * pos)121 gst_ffmpeg_channel_layout_to_gst (guint64 channel_layout, gint channels,
122 GstAudioChannelPosition * pos)
123 {
124 guint nchannels = 0;
125 gboolean none_layout = FALSE;
126
127 if (channel_layout == 0) {
128 nchannels = channels;
129 none_layout = TRUE;
130 } else {
131 guint i, j;
132
133 /* Special path for mono, as AV_CH_LAYOUT_MONO is the same
134 * as FRONT_CENTER but we distinguish between the two in
135 * GStreamer
136 */
137 if (channels == 1 && channel_layout == AV_CH_LAYOUT_MONO) {
138 pos[0] = GST_AUDIO_CHANNEL_POSITION_MONO;
139 return TRUE;
140 }
141
142 for (i = 0; i < 64; i++) {
143 if ((channel_layout & (G_GUINT64_CONSTANT (1) << i)) != 0) {
144 nchannels++;
145 }
146 }
147
148 if (nchannels != channels) {
149 GST_ERROR ("Number of channels is different (%u != %u)", channels,
150 nchannels);
151 nchannels = channels;
152 none_layout = TRUE;
153 } else {
154
155 for (i = 0, j = 0; i < G_N_ELEMENTS (_ff_to_gst_layout); i++) {
156 if ((channel_layout & _ff_to_gst_layout[i].ff) != 0) {
157 pos[j++] = _ff_to_gst_layout[i].gst;
158
159 if (_ff_to_gst_layout[i].gst == GST_AUDIO_CHANNEL_POSITION_NONE)
160 none_layout = TRUE;
161 }
162 }
163
164 if (j != nchannels) {
165 GST_WARNING
166 ("Unknown channels in channel layout - assuming NONE layout");
167 none_layout = TRUE;
168 }
169 }
170 }
171
172 if (!none_layout
173 && !gst_audio_check_valid_channel_positions (pos, nchannels, FALSE)) {
174 GST_ERROR ("Invalid channel layout %" G_GUINT64_FORMAT
175 " - assuming NONE layout", channel_layout);
176 none_layout = TRUE;
177 }
178
179 if (none_layout) {
180 if (nchannels == 1) {
181 pos[0] = GST_AUDIO_CHANNEL_POSITION_MONO;
182 } else if (nchannels == 2) {
183 pos[0] = GST_AUDIO_CHANNEL_POSITION_FRONT_LEFT;
184 pos[1] = GST_AUDIO_CHANNEL_POSITION_FRONT_RIGHT;
185 } else {
186 guint i;
187
188 for (i = 0; i < nchannels; i++)
189 pos[i] = GST_AUDIO_CHANNEL_POSITION_NONE;
190 }
191 }
192
193 return TRUE;
194 }
195
196 static gboolean
_gst_value_list_contains(const GValue * list,const GValue * value)197 _gst_value_list_contains (const GValue * list, const GValue * value)
198 {
199 guint i, n;
200 const GValue *tmp;
201
202 n = gst_value_list_get_size (list);
203 for (i = 0; i < n; i++) {
204 tmp = gst_value_list_get_value (list, i);
205 if (gst_value_compare (value, tmp) == GST_VALUE_EQUAL)
206 return TRUE;
207 }
208
209 return FALSE;
210 }
211
212 static void
gst_ffmpeg_video_set_pix_fmts(GstCaps * caps,const enum AVPixelFormat * fmts)213 gst_ffmpeg_video_set_pix_fmts (GstCaps * caps, const enum AVPixelFormat *fmts)
214 {
215 GValue va = { 0, };
216 GValue v = { 0, };
217 GstVideoFormat format;
218
219 if (!fmts || fmts[0] == -1) {
220 gint i;
221
222 g_value_init (&va, GST_TYPE_LIST);
223 g_value_init (&v, G_TYPE_STRING);
224 for (i = 0; i <= AV_PIX_FMT_NB; i++) {
225 format = gst_ffmpeg_pixfmt_to_videoformat (i);
226 if (format == GST_VIDEO_FORMAT_UNKNOWN)
227 continue;
228 g_value_set_string (&v, gst_video_format_to_string (format));
229 gst_value_list_append_value (&va, &v);
230 }
231 gst_caps_set_value (caps, "format", &va);
232 g_value_unset (&v);
233 g_value_unset (&va);
234 return;
235 }
236
237 /* Only a single format */
238 g_value_init (&va, GST_TYPE_LIST);
239 g_value_init (&v, G_TYPE_STRING);
240 while (*fmts != -1) {
241 format = gst_ffmpeg_pixfmt_to_videoformat (*fmts);
242 if (format != GST_VIDEO_FORMAT_UNKNOWN) {
243 g_value_set_string (&v, gst_video_format_to_string (format));
244 /* Only append values we don't have yet */
245 if (!_gst_value_list_contains (&va, &v))
246 gst_value_list_append_value (&va, &v);
247 }
248 fmts++;
249 }
250 if (gst_value_list_get_size (&va) == 1) {
251 /* The single value is still in v */
252 gst_caps_set_value (caps, "format", &v);
253 } else if (gst_value_list_get_size (&va) > 1) {
254 gst_caps_set_value (caps, "format", &va);
255 }
256 g_value_unset (&v);
257 g_value_unset (&va);
258 }
259
260 /* this macro makes a caps width fixed or unfixed width/height
261 * properties depending on whether we've got a context.
262 *
263 * See below for why we use this.
264 *
265 * We should actually do this stuff at the end, like in riff-media.c,
266 * but I'm too lazy today. Maybe later.
267 */
268 static GstCaps *
gst_ff_vid_caps_new(AVCodecContext * context,AVCodec * codec,enum AVCodecID codec_id,gboolean encode,const char * mimetype,const char * fieldname,...)269 gst_ff_vid_caps_new (AVCodecContext * context, AVCodec * codec,
270 enum AVCodecID codec_id, gboolean encode, const char *mimetype,
271 const char *fieldname, ...)
272 {
273 GstCaps *caps = NULL;
274 va_list var_args;
275 gint i;
276
277 GST_LOG ("context:%p, codec_id:%d, mimetype:%s", context, codec_id, mimetype);
278
279 /* fixed, non probing context */
280 if (context != NULL && context->width != -1) {
281 gint num, denom;
282
283 caps = gst_caps_new_simple (mimetype,
284 "width", G_TYPE_INT, context->width,
285 "height", G_TYPE_INT, context->height, NULL);
286
287 num = context->time_base.den / context->ticks_per_frame;
288 denom = context->time_base.num;
289
290 if (!denom) {
291 GST_LOG ("invalid framerate: %d/0, -> %d/1", num, num);
292 denom = 1;
293 }
294 if (gst_util_fraction_compare (num, denom, 1000, 1) > 0) {
295 GST_LOG ("excessive framerate: %d/%d, -> 0/1", num, denom);
296 num = 0;
297 denom = 1;
298 }
299 GST_LOG ("setting framerate: %d/%d", num, denom);
300 gst_caps_set_simple (caps,
301 "framerate", GST_TYPE_FRACTION, num, denom, NULL);
302 } else if (encode) {
303 /* so we are after restricted caps in this case */
304 switch (codec_id) {
305 case AV_CODEC_ID_H261:
306 {
307 caps = gst_caps_new_simple (mimetype,
308 "width", G_TYPE_INT, 352,
309 "height", G_TYPE_INT, 288,
310 "framerate", GST_TYPE_FRACTION_RANGE, 0, 1, G_MAXINT, 1, NULL);
311 gst_caps_append (caps, gst_caps_new_simple (mimetype,
312 "width", G_TYPE_INT, 176,
313 "height", G_TYPE_INT, 144,
314 "framerate", GST_TYPE_FRACTION_RANGE, 0, 1, G_MAXINT, 1, NULL));
315 break;
316 }
317 case AV_CODEC_ID_H263:
318 {
319 /* 128x96, 176x144, 352x288, 704x576, and 1408x1152. slightly reordered
320 * because we want automatic negotiation to go as close to 320x240 as
321 * possible. */
322 const static gint widths[] = { 352, 704, 176, 1408, 128 };
323 const static gint heights[] = { 288, 576, 144, 1152, 96 };
324 GstCaps *temp;
325 gint n_sizes = G_N_ELEMENTS (widths);
326
327 caps = gst_caps_new_empty ();
328 for (i = 0; i < n_sizes; i++) {
329 temp = gst_caps_new_simple (mimetype,
330 "width", G_TYPE_INT, widths[i],
331 "height", G_TYPE_INT, heights[i],
332 "framerate", GST_TYPE_FRACTION_RANGE, 0, 1, G_MAXINT, 1, NULL);
333
334 gst_caps_append (caps, temp);
335 }
336 break;
337 }
338 case AV_CODEC_ID_DVVIDEO:
339 {
340 static struct
341 {
342 const gchar *csp;
343 gint width, height;
344 gint par_n, par_d;
345 gint framerate_n, framerate_d;
346 } profiles[] = {
347 {
348 "Y41B", 720, 480, 8, 9, 30000, 1001}, {
349 "Y41B", 720, 480, 32, 27, 30000, 1001}, {
350 "Y42B", 720, 480, 8, 9, 30000, 1001}, {
351 "Y42B", 720, 480, 32, 27, 30000, 1001}, {
352 "I420", 720, 576, 16, 15, 25, 1}, {
353 "I420", 720, 576, 64, 45, 25, 1}, {
354 "Y41B", 720, 576, 16, 15, 25, 1}, {
355 "Y41B", 720, 576, 64, 45, 25, 1}, {
356 "Y42B", 720, 576, 16, 15, 25, 1}, {
357 "Y42B", 720, 576, 64, 45, 25, 1}, {
358 "Y42B", 1280, 1080, 1, 1, 30000, 1001}, {
359 "Y42B", 1280, 1080, 3, 2, 30000, 1001}, {
360 "Y42B", 1440, 1080, 1, 1, 25, 1}, {
361 "Y42B", 1440, 1080, 4, 3, 25, 1}, {
362 "Y42B", 960, 720, 1, 1, 60000, 1001}, {
363 "Y42B", 960, 720, 4, 3, 60000, 1001}, {
364 "Y42B", 960, 720, 1, 1, 50, 1}, {
365 "Y42B", 960, 720, 4, 3, 50, 1},};
366 GstCaps *temp;
367 gint n_sizes = G_N_ELEMENTS (profiles);
368
369 if (strcmp (mimetype, "video/x-raw") == 0) {
370 caps = gst_caps_new_empty ();
371 for (i = 0; i < n_sizes; i++) {
372 temp = gst_caps_new_simple (mimetype,
373 "format", G_TYPE_STRING, profiles[i].csp,
374 "width", G_TYPE_INT, profiles[i].width,
375 "height", G_TYPE_INT, profiles[i].height,
376 "framerate", GST_TYPE_FRACTION, profiles[i].framerate_n,
377 profiles[i].framerate_d, "pixel-aspect-ratio",
378 GST_TYPE_FRACTION, profiles[i].par_n, profiles[i].par_d, NULL);
379
380 gst_caps_append (caps, temp);
381 }
382 } else {
383 caps = gst_caps_new_empty ();
384 for (i = 0; i < n_sizes; i++) {
385 temp = gst_caps_new_simple (mimetype,
386 "width", G_TYPE_INT, profiles[i].width,
387 "height", G_TYPE_INT, profiles[i].height,
388 "framerate", GST_TYPE_FRACTION, profiles[i].framerate_n,
389 profiles[i].framerate_d, "pixel-aspect-ratio",
390 GST_TYPE_FRACTION, profiles[i].par_n, profiles[i].par_d, NULL);
391
392 gst_caps_append (caps, temp);
393 }
394 }
395 break;
396 }
397 case AV_CODEC_ID_DNXHD:
398 {
399 caps = gst_caps_new_simple (mimetype,
400 "width", G_TYPE_INT, 1920,
401 "height", G_TYPE_INT, 1080,
402 "framerate", GST_TYPE_FRACTION_RANGE, 0, 1, G_MAXINT, 1, NULL);
403 gst_caps_append (caps, gst_caps_new_simple (mimetype,
404 "width", G_TYPE_INT, 1280,
405 "height", G_TYPE_INT, 720,
406 "framerate", GST_TYPE_FRACTION_RANGE, 0, 1, G_MAXINT, 1, NULL));
407 break;
408 }
409 default:
410 {
411 if (codec && codec->supported_framerates
412 && codec->supported_framerates[0].num != 0
413 && codec->supported_framerates[0].den != 0) {
414 GValue va = { 0, };
415 GValue v = { 0, };
416 const AVRational *rates = codec->supported_framerates;
417
418 if (rates[1].num == 0 && rates[1].den == 0) {
419 caps =
420 gst_caps_new_simple (mimetype, "framerate", GST_TYPE_FRACTION,
421 rates[0].num, rates[0].den, NULL);
422 } else {
423 g_value_init (&va, GST_TYPE_LIST);
424 g_value_init (&v, GST_TYPE_FRACTION);
425
426 while (rates->num != 0 && rates->den != 0) {
427 gst_value_set_fraction (&v, rates->num, rates->den);
428 gst_value_list_append_value (&va, &v);
429 rates++;
430 }
431
432 caps = gst_caps_new_simple (mimetype, NULL, NULL, NULL);
433 gst_caps_set_value (caps, "framerate", &va);
434 g_value_unset (&va);
435 g_value_unset (&v);
436 }
437
438 } else {
439 caps = gst_caps_new_empty_simple (mimetype);
440 }
441
442 break;
443 }
444 }
445 }
446
447 /* no fixed caps or special restrictions applied;
448 * default unfixed setting */
449 if (!caps) {
450 GST_DEBUG ("Creating default caps");
451 caps = gst_caps_new_empty_simple (mimetype);
452 }
453
454 va_start (var_args, fieldname);
455 gst_caps_set_simple_valist (caps, fieldname, var_args);
456 va_end (var_args);
457
458 return caps;
459 }
460
461 static gint
get_nbits_set(guint64 n)462 get_nbits_set (guint64 n)
463 {
464 gint i, x;
465
466 x = 0;
467 for (i = 0; i < 64; i++) {
468 if ((n & (G_GUINT64_CONSTANT (1) << i)))
469 x++;
470 }
471
472 return x;
473 }
474
475 static void
gst_ffmpeg_audio_set_sample_fmts(GstCaps * caps,const enum AVSampleFormat * fmts,gboolean always_interleaved)476 gst_ffmpeg_audio_set_sample_fmts (GstCaps * caps,
477 const enum AVSampleFormat *fmts, gboolean always_interleaved)
478 {
479 GValue va = { 0, };
480 GValue vap = { 0, };
481 GValue v = { 0, };
482 GstAudioFormat format;
483 GstAudioLayout layout;
484 GstCaps *caps_copy = NULL;
485
486 if (!fmts || fmts[0] == -1) {
487 gint i;
488
489 g_value_init (&va, GST_TYPE_LIST);
490 g_value_init (&v, G_TYPE_STRING);
491 for (i = 0; i <= AV_SAMPLE_FMT_DBL; i++) {
492 format = gst_ffmpeg_smpfmt_to_audioformat (i, NULL);
493 if (format == GST_AUDIO_FORMAT_UNKNOWN)
494 continue;
495 g_value_set_string (&v, gst_audio_format_to_string (format));
496 gst_value_list_append_value (&va, &v);
497 }
498 gst_caps_set_value (caps, "format", &va);
499 if (!always_interleaved) {
500 g_value_init (&vap, GST_TYPE_LIST);
501 g_value_set_string (&v, "interleaved");
502 gst_value_list_append_value (&vap, &v);
503 g_value_set_string (&v, "non-interleaved");
504 gst_value_list_append_value (&vap, &v);
505 gst_caps_set_value (caps, "layout", &vap);
506 g_value_unset (&vap);
507 } else {
508 gst_caps_set_simple (caps, "layout", G_TYPE_STRING, "interleaved", NULL);
509 }
510 g_value_unset (&v);
511 g_value_unset (&va);
512 return;
513 }
514
515 g_value_init (&va, GST_TYPE_LIST);
516 g_value_init (&vap, GST_TYPE_LIST);
517 g_value_init (&v, G_TYPE_STRING);
518 while (*fmts != -1) {
519 format = gst_ffmpeg_smpfmt_to_audioformat (*fmts, &layout);
520 if (format != GST_AUDIO_FORMAT_UNKNOWN) {
521 g_value_set_string (&v, gst_audio_format_to_string (format));
522 /* Only append values we don't have yet */
523 if (layout == GST_AUDIO_LAYOUT_INTERLEAVED || always_interleaved) {
524 if (!_gst_value_list_contains (&va, &v))
525 gst_value_list_append_value (&va, &v);
526 } else {
527 if (!_gst_value_list_contains (&vap, &v))
528 gst_value_list_append_value (&vap, &v);
529 }
530 }
531 fmts++;
532 }
533 if (gst_value_list_get_size (&va) >= 1 && gst_value_list_get_size (&vap) >= 1) {
534 caps_copy = gst_caps_copy (caps);
535 }
536 if (gst_value_list_get_size (&va) == 1) {
537 gst_caps_set_value (caps, "format", gst_value_list_get_value (&va, 0));
538 gst_caps_set_simple (caps, "layout", G_TYPE_STRING, "interleaved", NULL);
539 } else if (gst_value_list_get_size (&va) > 1) {
540 gst_caps_set_value (caps, "format", &va);
541 gst_caps_set_simple (caps, "layout", G_TYPE_STRING, "interleaved", NULL);
542 }
543 if (gst_value_list_get_size (&vap) == 1) {
544 gst_caps_set_value (caps_copy ? caps_copy : caps, "format",
545 gst_value_list_get_value (&vap, 0));
546 gst_caps_set_simple (caps_copy ? caps_copy : caps, "layout", G_TYPE_STRING,
547 "non-interleaved", NULL);
548 } else if (gst_value_list_get_size (&vap) > 1) {
549 gst_caps_set_value (caps_copy ? caps_copy : caps, "format", &vap);
550 gst_caps_set_simple (caps_copy ? caps_copy : caps, "layout", G_TYPE_STRING,
551 "non-interleaved", NULL);
552 }
553 if (caps_copy) {
554 gst_caps_append (caps, caps_copy);
555 }
556 g_value_unset (&v);
557 g_value_unset (&va);
558 g_value_unset (&vap);
559 }
560
561 /* same for audio - now with channels/sample rate
562 */
563 static GstCaps *
gst_ff_aud_caps_new(AVCodecContext * context,AVCodec * codec,enum AVCodecID codec_id,gboolean encode,const char * mimetype,const char * fieldname,...)564 gst_ff_aud_caps_new (AVCodecContext * context, AVCodec * codec,
565 enum AVCodecID codec_id, gboolean encode, const char *mimetype,
566 const char *fieldname, ...)
567 {
568 GstCaps *caps = NULL;
569 gint i;
570 va_list var_args;
571
572 /* fixed, non-probing context */
573 if (context != NULL && context->channels != -1) {
574 GstAudioChannelPosition pos[64];
575 guint64 mask;
576
577 caps = gst_caps_new_simple (mimetype,
578 "rate", G_TYPE_INT, context->sample_rate,
579 "channels", G_TYPE_INT, context->channels, NULL);
580
581 if (context->channels > 1 &&
582 gst_ffmpeg_channel_layout_to_gst (context->channel_layout,
583 context->channels, pos) &&
584 gst_audio_channel_positions_to_mask (pos, context->channels, FALSE,
585 &mask)) {
586 gst_caps_set_simple (caps, "channel-mask", GST_TYPE_BITMASK, mask, NULL);
587 }
588 } else if (encode) {
589 gint maxchannels = 2;
590 const gint *rates = NULL;
591 gint n_rates = 0;
592
593 /* so we must be after restricted caps in this case */
594 switch (codec_id) {
595 case AV_CODEC_ID_AAC:
596 case AV_CODEC_ID_AAC_LATM:
597 case AV_CODEC_ID_DTS:
598 maxchannels = 6;
599 break;
600 case AV_CODEC_ID_MP2:
601 {
602 const static gint l_rates[] =
603 { 48000, 44100, 32000, 24000, 22050, 16000 };
604 n_rates = G_N_ELEMENTS (l_rates);
605 rates = l_rates;
606 break;
607 }
608 case AV_CODEC_ID_EAC3:
609 case AV_CODEC_ID_AC3:
610 {
611 const static gint l_rates[] = { 48000, 44100, 32000 };
612 maxchannels = 6;
613 n_rates = G_N_ELEMENTS (l_rates);
614 rates = l_rates;
615 break;
616 }
617 case AV_CODEC_ID_ADPCM_G722:
618 {
619 const static gint l_rates[] = { 16000 };
620 n_rates = G_N_ELEMENTS (l_rates);
621 rates = l_rates;
622 maxchannels = 1;
623 break;
624 }
625 case AV_CODEC_ID_ADPCM_G726:
626 {
627 const static gint l_rates[] = { 8000 };
628 n_rates = G_N_ELEMENTS (l_rates);
629 rates = l_rates;
630 maxchannels = 1;
631 break;
632 }
633 case AV_CODEC_ID_ADPCM_SWF:
634 {
635 const static gint l_rates[] = { 11025, 22050, 44100 };
636 n_rates = G_N_ELEMENTS (l_rates);
637 rates = l_rates;
638 break;
639 }
640 case AV_CODEC_ID_ROQ_DPCM:
641 {
642 const static gint l_rates[] = { 22050 };
643 n_rates = G_N_ELEMENTS (l_rates);
644 rates = l_rates;
645 break;
646 }
647 case AV_CODEC_ID_AMR_NB:
648 {
649 const static gint l_rates[] = { 8000 };
650 maxchannels = 1;
651 n_rates = G_N_ELEMENTS (l_rates);
652 rates = l_rates;
653 break;
654 }
655 case AV_CODEC_ID_AMR_WB:
656 {
657 const static gint l_rates[] = { 16000 };
658 maxchannels = 1;
659 n_rates = G_N_ELEMENTS (l_rates);
660 rates = l_rates;
661 break;
662 }
663 default:
664 break;
665 }
666
667 /* regardless of encode/decode, open up channels if applicable */
668 /* Until decoders/encoders expose the maximum number of channels
669 * they support, we whitelist them here. */
670 switch (codec_id) {
671 case AV_CODEC_ID_WMAPRO:
672 case AV_CODEC_ID_TRUEHD:
673 maxchannels = 8;
674 break;
675 default:
676 break;
677 }
678
679 if (codec && codec->channel_layouts) {
680 const uint64_t *layouts = codec->channel_layouts;
681 GstAudioChannelPosition pos[64];
682
683 caps = gst_caps_new_empty ();
684 while (*layouts) {
685 gint nbits_set = get_nbits_set (*layouts);
686
687 if (gst_ffmpeg_channel_layout_to_gst (*layouts, nbits_set, pos)) {
688 guint64 mask;
689
690 if (gst_audio_channel_positions_to_mask (pos, nbits_set, FALSE,
691 &mask)) {
692 GstStructure *s =
693 gst_structure_new (mimetype, "channels", G_TYPE_INT, nbits_set,
694 NULL);
695
696 /* No need to require a channel mask for mono or stereo */
697 if (!(nbits_set == 1 && pos[0] == GST_AUDIO_CHANNEL_POSITION_MONO)
698 && !(nbits_set == 2
699 && pos[0] == GST_AUDIO_CHANNEL_POSITION_FRONT_LEFT
700 && pos[1] == GST_AUDIO_CHANNEL_POSITION_FRONT_RIGHT))
701 gst_structure_set (s, "channel-mask", GST_TYPE_BITMASK, mask,
702 NULL);
703
704 gst_caps_append_structure (caps, s);
705 }
706 }
707 layouts++;
708 }
709 } else {
710 if (maxchannels == 1)
711 caps = gst_caps_new_simple (mimetype,
712 "channels", G_TYPE_INT, maxchannels, NULL);
713 else
714 caps = gst_caps_new_simple (mimetype,
715 "channels", GST_TYPE_INT_RANGE, 1, maxchannels, NULL);
716 }
717
718 if (n_rates) {
719 GValue list = { 0, };
720
721 g_value_init (&list, GST_TYPE_LIST);
722 for (i = 0; i < n_rates; i++) {
723 GValue v = { 0, };
724
725 g_value_init (&v, G_TYPE_INT);
726 g_value_set_int (&v, rates[i]);
727 gst_value_list_append_value (&list, &v);
728 g_value_unset (&v);
729 }
730 gst_caps_set_value (caps, "rate", &list);
731 g_value_unset (&list);
732 } else if (codec && codec->supported_samplerates
733 && codec->supported_samplerates[0]) {
734 GValue va = { 0, };
735 GValue v = { 0, };
736
737 if (!codec->supported_samplerates[1]) {
738 gst_caps_set_simple (caps, "rate", G_TYPE_INT,
739 codec->supported_samplerates[0], NULL);
740 } else {
741 const int *rates = codec->supported_samplerates;
742
743 g_value_init (&va, GST_TYPE_LIST);
744 g_value_init (&v, G_TYPE_INT);
745
746 while (*rates) {
747 g_value_set_int (&v, *rates);
748 gst_value_list_append_value (&va, &v);
749 rates++;
750 }
751 gst_caps_set_value (caps, "rate", &va);
752 g_value_unset (&va);
753 g_value_unset (&v);
754 }
755 } else {
756 gst_caps_set_simple (caps, "rate", GST_TYPE_INT_RANGE, 4000, 96000, NULL);
757 }
758 } else {
759 caps = gst_caps_new_empty_simple (mimetype);
760 }
761
762 va_start (var_args, fieldname);
763 gst_caps_set_simple_valist (caps, fieldname, var_args);
764 va_end (var_args);
765
766 return caps;
767 }
768
769 /* Check if the given codec ID is an image format -- for now this is just
770 * anything whose caps is image/... */
771 gboolean
gst_ffmpeg_codecid_is_image(enum AVCodecID codec_id)772 gst_ffmpeg_codecid_is_image (enum AVCodecID codec_id)
773 {
774 switch (codec_id) {
775 case AV_CODEC_ID_MJPEG:
776 case AV_CODEC_ID_LJPEG:
777 case AV_CODEC_ID_GIF:
778 case AV_CODEC_ID_PPM:
779 case AV_CODEC_ID_PBM:
780 case AV_CODEC_ID_PCX:
781 case AV_CODEC_ID_SGI:
782 case AV_CODEC_ID_TARGA:
783 case AV_CODEC_ID_TIFF:
784 case AV_CODEC_ID_SUNRAST:
785 case AV_CODEC_ID_BMP:
786 return TRUE;
787
788 default:
789 return FALSE;
790 }
791 }
792
793 /* Convert a FFMPEG codec ID and optional AVCodecContext
794 * to a GstCaps. If the context is ommitted, no fixed values
795 * for video/audio size will be included in the GstCaps
796 *
797 * CodecID is primarily meant for compressed data GstCaps!
798 *
799 * encode is a special parameter. gstffmpegdec will say
800 * FALSE, gstffmpegenc will say TRUE. The output caps
801 * depends on this, in such a way that it will be very
802 * specific, defined, fixed and correct caps for encoders,
803 * yet very wide, "forgiving" caps for decoders. Example
804 * for mp3: decode: audio/mpeg,mpegversion=1,layer=[1-3]
805 * but encode: audio/mpeg,mpegversion=1,layer=3,bitrate=x,
806 * rate=x,channels=x.
807 */
808
809 GstCaps *
gst_ffmpeg_codecid_to_caps(enum AVCodecID codec_id,AVCodecContext * context,gboolean encode)810 gst_ffmpeg_codecid_to_caps (enum AVCodecID codec_id,
811 AVCodecContext * context, gboolean encode)
812 {
813 GstCaps *caps = NULL;
814 gboolean buildcaps = FALSE;
815
816 GST_LOG ("codec_id:%d, context:%p, encode:%d", codec_id, context, encode);
817
818 switch (codec_id) {
819 case AV_CODEC_ID_MPEG1VIDEO:
820 /* FIXME: bitrate */
821 caps = gst_ff_vid_caps_new (context, NULL, codec_id, encode, "video/mpeg",
822 "mpegversion", G_TYPE_INT, 1,
823 "systemstream", G_TYPE_BOOLEAN, FALSE, NULL);
824 break;
825
826 case AV_CODEC_ID_MPEG2VIDEO:
827 if (encode) {
828 /* FIXME: bitrate */
829 caps =
830 gst_ff_vid_caps_new (context, NULL, codec_id, encode, "video/mpeg",
831 "mpegversion", G_TYPE_INT, 2, "systemstream", G_TYPE_BOOLEAN, FALSE,
832 NULL);
833 } else {
834 /* decode both MPEG-1 and MPEG-2; width/height/fps are all in
835 * the MPEG video stream headers, so may be omitted from caps. */
836 caps = gst_caps_new_simple ("video/mpeg",
837 "mpegversion", GST_TYPE_INT_RANGE, 1, 2,
838 "systemstream", G_TYPE_BOOLEAN, FALSE, NULL);
839 }
840 break;
841
842 case AV_CODEC_ID_H263:
843 if (encode) {
844 caps =
845 gst_ff_vid_caps_new (context, NULL, codec_id, encode,
846 "video/x-h263", "variant", G_TYPE_STRING, "itu", "h263version",
847 G_TYPE_STRING, "h263", NULL);
848 } else {
849 /* don't pass codec_id, we can decode other variants with the H263
850 * decoder that don't have specific size requirements
851 */
852 caps =
853 gst_ff_vid_caps_new (context, NULL, AV_CODEC_ID_NONE, encode,
854 "video/x-h263", "variant", G_TYPE_STRING, "itu", NULL);
855 }
856 break;
857 case AV_CODEC_ID_H263P:
858 caps =
859 gst_ff_vid_caps_new (context, NULL, codec_id, encode, "video/x-h263",
860 "variant", G_TYPE_STRING, "itu", "h263version", G_TYPE_STRING,
861 "h263p", NULL);
862 if (encode && context) {
863
864 gst_caps_set_simple (caps,
865 "annex-f", G_TYPE_BOOLEAN, context->flags & AV_CODEC_FLAG_4MV,
866 "annex-j", G_TYPE_BOOLEAN,
867 context->flags & AV_CODEC_FLAG_LOOP_FILTER,
868 "annex-i", G_TYPE_BOOLEAN, context->flags & AV_CODEC_FLAG_AC_PRED,
869 "annex-t", G_TYPE_BOOLEAN, context->flags & AV_CODEC_FLAG_AC_PRED,
870 NULL);
871 }
872 break;
873
874 case AV_CODEC_ID_H263I:
875 caps =
876 gst_ff_vid_caps_new (context, NULL, codec_id, encode,
877 "video/x-intel-h263", "variant", G_TYPE_STRING, "intel", NULL);
878 break;
879
880 case AV_CODEC_ID_H261:
881 caps =
882 gst_ff_vid_caps_new (context, NULL, codec_id, encode, "video/x-h261",
883 NULL);
884 break;
885
886 case AV_CODEC_ID_RV10:
887 case AV_CODEC_ID_RV20:
888 case AV_CODEC_ID_RV30:
889 case AV_CODEC_ID_RV40:
890 {
891 gint version;
892
893 switch (codec_id) {
894 case AV_CODEC_ID_RV40:
895 version = 4;
896 break;
897 case AV_CODEC_ID_RV30:
898 version = 3;
899 break;
900 case AV_CODEC_ID_RV20:
901 version = 2;
902 break;
903 default:
904 version = 1;
905 break;
906 }
907
908 caps =
909 gst_ff_vid_caps_new (context, NULL, codec_id, encode,
910 "video/x-pn-realvideo", "rmversion", G_TYPE_INT, version, NULL);
911 if (context) {
912 if (context->extradata_size >= 8) {
913 gst_caps_set_simple (caps,
914 "subformat", G_TYPE_INT, GST_READ_UINT32_BE (context->extradata),
915 NULL);
916 }
917 }
918 }
919 break;
920
921 #ifdef OHOS_OPT_COMPAT
922 /* ohos.opt.compat.0001 enable to use avdec_vorbis */
923 case AV_CODEC_ID_VORBIS:
924 caps = gst_ff_aud_caps_new (context, NULL, codec_id, encode, "audio/x-vorbis", NULL);
925 break;
926 #endif
927 case AV_CODEC_ID_MP1:
928 /* FIXME: bitrate */
929 caps = gst_ff_aud_caps_new (context, NULL, codec_id, encode, "audio/mpeg",
930 "mpegversion", G_TYPE_INT, 1, "layer", G_TYPE_INT, 1, NULL);
931 break;
932
933 case AV_CODEC_ID_MP2:
934 /* FIXME: bitrate */
935 caps = gst_ff_aud_caps_new (context, NULL, codec_id, encode, "audio/mpeg",
936 "mpegversion", G_TYPE_INT, 1, "layer", G_TYPE_INT, 2, NULL);
937 break;
938
939 case AV_CODEC_ID_MP3:
940 if (encode) {
941 /* FIXME: bitrate */
942 caps =
943 gst_ff_aud_caps_new (context, NULL, codec_id, encode, "audio/mpeg",
944 "mpegversion", G_TYPE_INT, 1, "layer", G_TYPE_INT, 3, NULL);
945 } else {
946 /* Decodes MPEG-1 layer 1/2/3. Samplerate, channels et al are
947 * in the MPEG audio header, so may be omitted from caps. */
948 caps = gst_caps_new_simple ("audio/mpeg",
949 "mpegversion", G_TYPE_INT, 1,
950 "layer", GST_TYPE_INT_RANGE, 1, 3, NULL);
951 }
952 break;
953
954 case AV_CODEC_ID_MUSEPACK7:
955 caps =
956 gst_ff_aud_caps_new (context, NULL, codec_id, encode,
957 "audio/x-ffmpeg-parsed-musepack", "streamversion", G_TYPE_INT, 7,
958 NULL);
959 break;
960
961 case AV_CODEC_ID_MUSEPACK8:
962 caps =
963 gst_ff_aud_caps_new (context, NULL, codec_id, encode,
964 "audio/x-ffmpeg-parsed-musepack", "streamversion", G_TYPE_INT, 8,
965 NULL);
966 break;
967
968 case AV_CODEC_ID_AC3:
969 /* FIXME: bitrate */
970 caps =
971 gst_ff_aud_caps_new (context, NULL, codec_id, encode, "audio/x-ac3",
972 NULL);
973 break;
974
975 case AV_CODEC_ID_EAC3:
976 /* FIXME: bitrate */
977 caps =
978 gst_ff_aud_caps_new (context, NULL, codec_id, encode, "audio/x-eac3",
979 NULL);
980 break;
981
982 case AV_CODEC_ID_TRUEHD:
983 caps =
984 gst_ff_aud_caps_new (context, NULL, codec_id, encode,
985 "audio/x-true-hd", NULL);
986 break;
987
988 case AV_CODEC_ID_ATRAC1:
989 caps =
990 gst_ff_aud_caps_new (context, NULL, codec_id, encode,
991 "audio/x-vnd.sony.atrac1", NULL);
992 break;
993
994 case AV_CODEC_ID_ATRAC3:
995 caps =
996 gst_ff_aud_caps_new (context, NULL, codec_id, encode,
997 "audio/x-vnd.sony.atrac3", NULL);
998 break;
999
1000 case AV_CODEC_ID_DTS:
1001 caps =
1002 gst_ff_aud_caps_new (context, NULL, codec_id, encode, "audio/x-dts",
1003 NULL);
1004 break;
1005
1006 case AV_CODEC_ID_APE:
1007 caps =
1008 gst_ff_aud_caps_new (context, NULL, codec_id, encode,
1009 "audio/x-ffmpeg-parsed-ape", NULL);
1010 if (context) {
1011 gst_caps_set_simple (caps,
1012 "depth", G_TYPE_INT, context->bits_per_coded_sample, NULL);
1013 }
1014 break;
1015
1016 case AV_CODEC_ID_MLP:
1017 caps =
1018 gst_ff_aud_caps_new (context, NULL, codec_id, encode, "audio/x-mlp",
1019 NULL);
1020 break;
1021
1022 case AV_CODEC_ID_METASOUND:
1023 caps =
1024 gst_ff_aud_caps_new (context, NULL, codec_id, encode,
1025 "audio/x-voxware", NULL);
1026 break;
1027
1028 case AV_CODEC_ID_IMC:
1029 caps =
1030 gst_ff_aud_caps_new (context, NULL, codec_id, encode, "audio/x-imc",
1031 NULL);
1032 break;
1033
1034 /* MJPEG is normal JPEG, Motion-JPEG and Quicktime MJPEG-A. MJPEGB
1035 * is Quicktime's MJPEG-B. LJPEG is lossless JPEG. I don't know what
1036 * sp5x is, but it's apparently something JPEG... We don't separate
1037 * between those in GStreamer. Should we (at least between MJPEG,
1038 * MJPEG-B and sp5x decoding...)? */
1039 case AV_CODEC_ID_MJPEG:
1040 case AV_CODEC_ID_LJPEG:
1041 caps =
1042 gst_ff_vid_caps_new (context, NULL, codec_id, encode, "image/jpeg",
1043 "parsed", G_TYPE_BOOLEAN, TRUE, NULL);
1044 break;
1045
1046 case AV_CODEC_ID_JPEG2000:
1047 caps =
1048 gst_ff_vid_caps_new (context, NULL, codec_id, encode, "image/x-j2c",
1049 NULL);
1050 if (!encode) {
1051 gst_caps_append (caps, gst_ff_vid_caps_new (context, NULL, codec_id,
1052 encode, "image/x-jpc", NULL));
1053 gst_caps_append (caps, gst_ff_vid_caps_new (context, NULL, codec_id,
1054 encode, "image/jp2", NULL));
1055 }
1056 break;
1057
1058 case AV_CODEC_ID_SP5X:
1059 caps =
1060 gst_ff_vid_caps_new (context, NULL, codec_id, encode, "video/sp5x",
1061 NULL);
1062 break;
1063
1064 case AV_CODEC_ID_MJPEGB:
1065 caps =
1066 gst_ff_vid_caps_new (context, NULL, codec_id, encode,
1067 "video/x-mjpeg-b", NULL);
1068 break;
1069
1070 case AV_CODEC_ID_MPEG4:
1071 if (encode && context != NULL) {
1072 /* I'm not exactly sure what ffmpeg outputs... ffmpeg itself uses
1073 * the AVI fourcc 'DIVX', but 'mp4v' for Quicktime... */
1074 switch (context->codec_tag) {
1075 case GST_MAKE_FOURCC ('D', 'I', 'V', 'X'):
1076 caps =
1077 gst_ff_vid_caps_new (context, NULL, codec_id, encode,
1078 "video/x-divx", "divxversion", G_TYPE_INT, 5, NULL);
1079 break;
1080 case GST_MAKE_FOURCC ('m', 'p', '4', 'v'):
1081 default:
1082 /* FIXME: bitrate. libav doesn't expose the used profile and level */
1083 caps =
1084 gst_ff_vid_caps_new (context, NULL, codec_id, encode,
1085 "video/mpeg", "systemstream", G_TYPE_BOOLEAN, FALSE,
1086 "mpegversion", G_TYPE_INT, 4, NULL);
1087 break;
1088 }
1089 } else {
1090 /* The trick here is to separate xvid, divx, mpeg4, 3ivx et al */
1091 caps =
1092 gst_ff_vid_caps_new (context, NULL, codec_id, encode, "video/mpeg",
1093 "mpegversion", G_TYPE_INT, 4, "systemstream", G_TYPE_BOOLEAN, FALSE,
1094 NULL);
1095
1096 if (encode) {
1097 GValue arr = { 0, };
1098 GValue item = { 0, };
1099
1100 g_value_init (&arr, GST_TYPE_LIST);
1101 g_value_init (&item, G_TYPE_STRING);
1102 g_value_set_string (&item, "simple");
1103 gst_value_list_append_value (&arr, &item);
1104 g_value_set_string (&item, "advanced-simple");
1105 gst_value_list_append_value (&arr, &item);
1106 g_value_unset (&item);
1107
1108 gst_caps_set_value (caps, "profile", &arr);
1109 g_value_unset (&arr);
1110
1111 gst_caps_append (caps, gst_ff_vid_caps_new (context, NULL, codec_id,
1112 encode, "video/x-divx", "divxversion", G_TYPE_INT, 5, NULL));
1113 } else {
1114 gst_caps_append (caps, gst_ff_vid_caps_new (context, NULL, codec_id,
1115 encode, "video/x-divx", "divxversion", GST_TYPE_INT_RANGE, 4,
1116 5, NULL));
1117 }
1118 }
1119 break;
1120
1121 case AV_CODEC_ID_RAWVIDEO:
1122 caps =
1123 gst_ffmpeg_codectype_to_video_caps (context, codec_id, encode, NULL);
1124 break;
1125
1126 case AV_CODEC_ID_MSMPEG4V1:
1127 case AV_CODEC_ID_MSMPEG4V2:
1128 case AV_CODEC_ID_MSMPEG4V3:
1129 {
1130 gint version = 41 + codec_id - AV_CODEC_ID_MSMPEG4V1;
1131
1132 /* encode-FIXME: bitrate */
1133 caps =
1134 gst_ff_vid_caps_new (context, NULL, codec_id, encode,
1135 "video/x-msmpeg", "msmpegversion", G_TYPE_INT, version, NULL);
1136 if (!encode && codec_id == AV_CODEC_ID_MSMPEG4V3) {
1137 gst_caps_append (caps, gst_ff_vid_caps_new (context, NULL, codec_id,
1138 encode, "video/x-divx", "divxversion", G_TYPE_INT, 3, NULL));
1139 }
1140 }
1141 break;
1142
1143 case AV_CODEC_ID_WMV1:
1144 case AV_CODEC_ID_WMV2:
1145 {
1146 gint version = (codec_id == AV_CODEC_ID_WMV1) ? 1 : 2;
1147
1148 caps =
1149 gst_ff_vid_caps_new (context, NULL, codec_id, encode, "video/x-wmv",
1150 "wmvversion", G_TYPE_INT, version, NULL);
1151 }
1152 break;
1153
1154 case AV_CODEC_ID_FLV1:
1155 caps =
1156 gst_ff_vid_caps_new (context, NULL, codec_id, encode,
1157 "video/x-flash-video", "flvversion", G_TYPE_INT, 1, NULL);
1158 break;
1159
1160 case AV_CODEC_ID_SVQ1:
1161 caps =
1162 gst_ff_vid_caps_new (context, NULL, codec_id, encode, "video/x-svq",
1163 "svqversion", G_TYPE_INT, 1, NULL);
1164 break;
1165
1166 case AV_CODEC_ID_SVQ3:
1167 caps =
1168 gst_ff_vid_caps_new (context, NULL, codec_id, encode, "video/x-svq",
1169 "svqversion", G_TYPE_INT, 3, NULL);
1170 break;
1171
1172 case AV_CODEC_ID_DVAUDIO:
1173 caps =
1174 gst_ff_aud_caps_new (context, NULL, codec_id, encode, "audio/x-dv",
1175 NULL);
1176 break;
1177
1178 case AV_CODEC_ID_DVVIDEO:
1179 {
1180 if (encode && context) {
1181 const gchar *format;
1182
1183 switch (context->pix_fmt) {
1184 case AV_PIX_FMT_YUYV422:
1185 format = "YUY2";
1186 break;
1187 case AV_PIX_FMT_YUV420P:
1188 format = "I420";
1189 break;
1190 case AV_PIX_FMT_YUVA420P:
1191 format = "A420";
1192 break;
1193 case AV_PIX_FMT_YUV411P:
1194 format = "Y41B";
1195 break;
1196 case AV_PIX_FMT_YUV422P:
1197 format = "Y42B";
1198 break;
1199 case AV_PIX_FMT_YUV410P:
1200 format = "YUV9";
1201 break;
1202 default:
1203 GST_WARNING
1204 ("Couldnt' find format for pixfmt %d, defaulting to I420",
1205 context->pix_fmt);
1206 format = "I420";
1207 break;
1208 }
1209 caps =
1210 gst_ff_vid_caps_new (context, NULL, codec_id, encode, "video/x-dv",
1211 "systemstream", G_TYPE_BOOLEAN, FALSE, "format", G_TYPE_STRING,
1212 format, NULL);
1213 } else {
1214 caps =
1215 gst_ff_vid_caps_new (context, NULL, codec_id, encode, "video/x-dv",
1216 "systemstream", G_TYPE_BOOLEAN, FALSE, NULL);
1217 }
1218 }
1219 break;
1220
1221 case AV_CODEC_ID_WMAV1:
1222 case AV_CODEC_ID_WMAV2:
1223 {
1224 gint version = (codec_id == AV_CODEC_ID_WMAV1) ? 1 : 2;
1225
1226 if (context) {
1227 caps =
1228 gst_ff_aud_caps_new (context, NULL, codec_id, encode, "audio/x-wma",
1229 "wmaversion", G_TYPE_INT, version, "block_align", G_TYPE_INT,
1230 context->block_align, "bitrate", G_TYPE_INT,
1231 (guint) context->bit_rate, NULL);
1232 } else {
1233 caps =
1234 gst_ff_aud_caps_new (context, NULL, codec_id, encode, "audio/x-wma",
1235 "wmaversion", G_TYPE_INT, version, "block_align",
1236 GST_TYPE_INT_RANGE, 0, G_MAXINT, "bitrate", GST_TYPE_INT_RANGE, 0,
1237 G_MAXINT, NULL);
1238 }
1239 }
1240 break;
1241 case AV_CODEC_ID_WMAPRO:
1242 {
1243 caps =
1244 gst_ff_aud_caps_new (context, NULL, codec_id, encode, "audio/x-wma",
1245 "wmaversion", G_TYPE_INT, 3, NULL);
1246 break;
1247 }
1248 case AV_CODEC_ID_WMALOSSLESS:
1249 {
1250 /* libav only supports a depth of 16 at the moment */
1251 caps =
1252 gst_ff_aud_caps_new (context, NULL, codec_id, encode, "audio/x-wma",
1253 "wmaversion", G_TYPE_INT, 4, "depth", G_TYPE_INT, 16, NULL);
1254 break;
1255 }
1256 case AV_CODEC_ID_WMAVOICE:
1257 {
1258 caps =
1259 gst_ff_aud_caps_new (context, NULL, codec_id, encode, "audio/x-wms",
1260 NULL);
1261 break;
1262 }
1263
1264 case AV_CODEC_ID_MACE3:
1265 case AV_CODEC_ID_MACE6:
1266 {
1267 gint version = (codec_id == AV_CODEC_ID_MACE3) ? 3 : 6;
1268
1269 caps =
1270 gst_ff_aud_caps_new (context, NULL, codec_id, encode, "audio/x-mace",
1271 "maceversion", G_TYPE_INT, version, NULL);
1272 }
1273 break;
1274
1275 case AV_CODEC_ID_HUFFYUV:
1276 caps =
1277 gst_ff_vid_caps_new (context, NULL, codec_id, encode,
1278 "video/x-huffyuv", NULL);
1279 if (context) {
1280 gst_caps_set_simple (caps,
1281 "bpp", G_TYPE_INT, context->bits_per_coded_sample, NULL);
1282 }
1283 break;
1284
1285 case AV_CODEC_ID_CYUV:
1286 caps =
1287 gst_ff_vid_caps_new (context, NULL, codec_id, encode,
1288 "video/x-compressed-yuv", NULL);
1289 break;
1290
1291 case AV_CODEC_ID_H264:
1292 #ifdef OHOS_EXT_FUNC
1293 // ohos.ext.func.0013
1294 caps =
1295 gst_ff_vid_caps_new (context, NULL, codec_id, encode, "video/x-h264", NULL);
1296 if (!encode) {
1297 GValue arr = { 0, };
1298 GValue item = { 0, };
1299 GValue arralign = { 0, };
1300 GValue align = { 0, };
1301 g_value_init (&arr, GST_TYPE_LIST);
1302 g_value_init (&item, G_TYPE_STRING);
1303
1304 g_value_init (&arralign, GST_TYPE_LIST);
1305 g_value_init (&align, G_TYPE_STRING);
1306
1307 g_value_set_string (&align, "au");
1308 gst_value_list_append_value (&arralign, &align);
1309 g_value_set_string (&align, "nal");
1310 gst_value_list_append_value (&arralign, &align);
1311 g_value_unset (&align);
1312 gst_caps_set_value (caps, "alignment", &arralign);
1313 g_value_unset (&arralign);
1314
1315
1316 g_value_set_string (&item, "avc");
1317 gst_value_list_append_value (&arr, &item);
1318 g_value_set_string (&item, "byte-stream");
1319 gst_value_list_append_value (&arr, &item);
1320 g_value_unset (&item);
1321 gst_caps_set_value (caps, "stream-format", &arr);
1322 g_value_unset (&arr);
1323 }
1324 break;
1325 #else
1326 caps =
1327 gst_ff_vid_caps_new (context, NULL, codec_id, encode, "video/x-h264",
1328 "alignment", G_TYPE_STRING, "au", NULL);
1329 if (!encode) {
1330 GValue arr = { 0, };
1331 GValue item = { 0, };
1332 g_value_init (&arr, GST_TYPE_LIST);
1333 g_value_init (&item, G_TYPE_STRING);
1334 g_value_set_string (&item, "avc");
1335 gst_value_list_append_value (&arr, &item);
1336 g_value_set_string (&item, "byte-stream");
1337 gst_value_list_append_value (&arr, &item);
1338 g_value_unset (&item);
1339 gst_caps_set_value (caps, "stream-format", &arr);
1340 g_value_unset (&arr);
1341 }
1342 break;
1343 #endif
1344 case AV_CODEC_ID_HEVC:
1345 caps =
1346 gst_ff_vid_caps_new (context, NULL, codec_id, encode, "video/x-h265",
1347 "alignment", G_TYPE_STRING, "au", NULL);
1348 if (!encode) {
1349 GValue arr = { 0, };
1350 GValue item = { 0, };
1351 g_value_init (&arr, GST_TYPE_LIST);
1352 g_value_init (&item, G_TYPE_STRING);
1353 g_value_set_string (&item, "hvc1");
1354 gst_value_list_append_value (&arr, &item);
1355 g_value_set_string (&item, "hev1");
1356 gst_value_list_append_value (&arr, &item);
1357 g_value_set_string (&item, "byte-stream");
1358 gst_value_list_append_value (&arr, &item);
1359 g_value_unset (&item);
1360 gst_caps_set_value (caps, "stream-format", &arr);
1361 g_value_unset (&arr);
1362 }
1363 break;
1364
1365 case AV_CODEC_ID_INDEO5:
1366 caps =
1367 gst_ff_vid_caps_new (context, NULL, codec_id, encode, "video/x-indeo",
1368 "indeoversion", G_TYPE_INT, 5, NULL);
1369 break;
1370
1371 case AV_CODEC_ID_INDEO4:
1372 caps =
1373 gst_ff_vid_caps_new (context, NULL, codec_id, encode, "video/x-indeo",
1374 "indeoversion", G_TYPE_INT, 4, NULL);
1375 break;
1376
1377 case AV_CODEC_ID_INDEO3:
1378 caps =
1379 gst_ff_vid_caps_new (context, NULL, codec_id, encode, "video/x-indeo",
1380 "indeoversion", G_TYPE_INT, 3, NULL);
1381 break;
1382
1383 case AV_CODEC_ID_INDEO2:
1384 caps =
1385 gst_ff_vid_caps_new (context, NULL, codec_id, encode, "video/x-indeo",
1386 "indeoversion", G_TYPE_INT, 2, NULL);
1387 break;
1388
1389 case AV_CODEC_ID_FLASHSV:
1390 caps =
1391 gst_ff_vid_caps_new (context, NULL, codec_id, encode,
1392 "video/x-flash-screen", NULL);
1393 break;
1394
1395 case AV_CODEC_ID_FLASHSV2:
1396 caps =
1397 gst_ff_vid_caps_new (context, NULL, codec_id, encode,
1398 "video/x-flash-screen2", NULL);
1399 break;
1400
1401 case AV_CODEC_ID_VP3:
1402 caps =
1403 gst_ff_vid_caps_new (context, NULL, codec_id, encode, "video/x-vp3",
1404 NULL);
1405 break;
1406
1407 case AV_CODEC_ID_VP5:
1408 caps =
1409 gst_ff_vid_caps_new (context, NULL, codec_id, encode, "video/x-vp5",
1410 NULL);
1411 break;
1412
1413 case AV_CODEC_ID_VP6:
1414 caps =
1415 gst_ff_vid_caps_new (context, NULL, codec_id, encode, "video/x-vp6",
1416 NULL);
1417 break;
1418
1419 case AV_CODEC_ID_VP6F:
1420 caps =
1421 gst_ff_vid_caps_new (context, NULL, codec_id, encode,
1422 "video/x-vp6-flash", NULL);
1423 break;
1424
1425 case AV_CODEC_ID_VP6A:
1426 caps =
1427 gst_ff_vid_caps_new (context, NULL, codec_id, encode,
1428 "video/x-vp6-alpha", NULL);
1429 break;
1430
1431 case AV_CODEC_ID_VP8:
1432 caps =
1433 gst_ff_vid_caps_new (context, NULL, codec_id, encode, "video/x-vp8",
1434 NULL);
1435 break;
1436
1437 case AV_CODEC_ID_VP9:
1438 caps =
1439 gst_ff_vid_caps_new (context, NULL, codec_id, encode, "video/x-vp9",
1440 NULL);
1441 break;
1442
1443 case AV_CODEC_ID_THEORA:
1444 caps =
1445 gst_ff_vid_caps_new (context, NULL, codec_id, encode,
1446 "video/x-theora", NULL);
1447 break;
1448
1449 case AV_CODEC_ID_CFHD:
1450 caps =
1451 gst_ff_vid_caps_new (context, NULL, codec_id, encode,
1452 "video/x-cineform", NULL);
1453 break;
1454
1455 case AV_CODEC_ID_AAC:
1456 {
1457 caps =
1458 gst_ff_aud_caps_new (context, NULL, codec_id, encode, "audio/mpeg",
1459 NULL);
1460
1461 if (!encode) {
1462 GValue arr = { 0, };
1463 GValue item = { 0, };
1464
1465 g_value_init (&arr, GST_TYPE_LIST);
1466 g_value_init (&item, G_TYPE_INT);
1467 g_value_set_int (&item, 2);
1468 gst_value_list_append_value (&arr, &item);
1469 g_value_set_int (&item, 4);
1470 gst_value_list_append_value (&arr, &item);
1471 g_value_unset (&item);
1472
1473 gst_caps_set_value (caps, "mpegversion", &arr);
1474 g_value_unset (&arr);
1475
1476 g_value_init (&arr, GST_TYPE_LIST);
1477 g_value_init (&item, G_TYPE_STRING);
1478 g_value_set_string (&item, "raw");
1479 gst_value_list_append_value (&arr, &item);
1480 g_value_set_string (&item, "adts");
1481 gst_value_list_append_value (&arr, &item);
1482 g_value_set_string (&item, "adif");
1483 gst_value_list_append_value (&arr, &item);
1484 g_value_unset (&item);
1485
1486 gst_caps_set_value (caps, "stream-format", &arr);
1487 g_value_unset (&arr);
1488 } else {
1489 gst_caps_set_simple (caps, "mpegversion", G_TYPE_INT, 4,
1490 "stream-format", G_TYPE_STRING, "raw",
1491 "base-profile", G_TYPE_STRING, "lc", NULL);
1492
1493 if (context && context->extradata_size > 0)
1494 gst_codec_utils_aac_caps_set_level_and_profile (caps,
1495 context->extradata, context->extradata_size);
1496 }
1497
1498 break;
1499 }
1500 case AV_CODEC_ID_AAC_LATM: /* LATM/LOAS AAC syntax */
1501 caps = gst_ff_aud_caps_new (context, NULL, codec_id, encode, "audio/mpeg",
1502 "mpegversion", G_TYPE_INT, 4, "stream-format", G_TYPE_STRING, "loas",
1503 NULL);
1504 break;
1505
1506 case AV_CODEC_ID_ASV1:
1507 caps =
1508 gst_ff_vid_caps_new (context, NULL, codec_id, encode, "video/x-asus",
1509 "asusversion", G_TYPE_INT, 1, NULL);
1510 break;
1511 case AV_CODEC_ID_ASV2:
1512 caps =
1513 gst_ff_vid_caps_new (context, NULL, codec_id, encode, "video/x-asus",
1514 "asusversion", G_TYPE_INT, 2, NULL);
1515 break;
1516
1517 case AV_CODEC_ID_FFV1:
1518 caps =
1519 gst_ff_vid_caps_new (context, NULL, codec_id, encode, "video/x-ffv",
1520 "ffvversion", G_TYPE_INT, 1, NULL);
1521 break;
1522
1523 case AV_CODEC_ID_4XM:
1524 caps =
1525 gst_ff_vid_caps_new (context, NULL, codec_id, encode, "video/x-4xm",
1526 NULL);
1527 break;
1528
1529 case AV_CODEC_ID_XAN_WC3:
1530 case AV_CODEC_ID_XAN_WC4:
1531 caps =
1532 gst_ff_vid_caps_new (context, NULL, codec_id, encode, "video/x-xan",
1533 "wcversion", G_TYPE_INT, 3 - AV_CODEC_ID_XAN_WC3 + codec_id, NULL);
1534 break;
1535
1536 case AV_CODEC_ID_CLJR:
1537 caps =
1538 gst_ff_vid_caps_new (context, NULL, codec_id, encode,
1539 "video/x-cirrus-logic-accupak", NULL);
1540 break;
1541
1542 case AV_CODEC_ID_FRAPS:
1543 caps =
1544 gst_ff_vid_caps_new (context, NULL, codec_id, encode, "video/x-fraps",
1545 NULL);
1546 break;
1547
1548 case AV_CODEC_ID_MDEC:
1549 case AV_CODEC_ID_ROQ:
1550 case AV_CODEC_ID_INTERPLAY_VIDEO:
1551 buildcaps = TRUE;
1552 break;
1553
1554 case AV_CODEC_ID_VCR1:
1555 caps =
1556 gst_ff_vid_caps_new (context, NULL, codec_id, encode,
1557 "video/x-ati-vcr", "vcrversion", G_TYPE_INT, 1, NULL);
1558 break;
1559
1560 case AV_CODEC_ID_RPZA:
1561 caps =
1562 gst_ff_vid_caps_new (context, NULL, codec_id, encode,
1563 "video/x-apple-video", NULL);
1564 break;
1565
1566 case AV_CODEC_ID_CINEPAK:
1567 caps =
1568 gst_ff_vid_caps_new (context, NULL, codec_id, encode,
1569 "video/x-cinepak", NULL);
1570 break;
1571
1572 /* WS_VQA belogns here (order) */
1573
1574 case AV_CODEC_ID_MSRLE:
1575 caps =
1576 gst_ff_vid_caps_new (context, NULL, codec_id, encode, "video/x-rle",
1577 "layout", G_TYPE_STRING, "microsoft", NULL);
1578 if (context) {
1579 gst_caps_set_simple (caps,
1580 "depth", G_TYPE_INT, (gint) context->bits_per_coded_sample, NULL);
1581 } else {
1582 gst_caps_set_simple (caps, "depth", GST_TYPE_INT_RANGE, 1, 64, NULL);
1583 }
1584 break;
1585
1586 case AV_CODEC_ID_QTRLE:
1587 caps =
1588 gst_ff_vid_caps_new (context, NULL, codec_id, encode, "video/x-rle",
1589 "layout", G_TYPE_STRING, "quicktime", NULL);
1590 if (context) {
1591 gst_caps_set_simple (caps,
1592 "depth", G_TYPE_INT, (gint) context->bits_per_coded_sample, NULL);
1593 } else {
1594 gst_caps_set_simple (caps, "depth", GST_TYPE_INT_RANGE, 1, 64, NULL);
1595 }
1596 break;
1597
1598 case AV_CODEC_ID_MSVIDEO1:
1599 caps =
1600 gst_ff_vid_caps_new (context, NULL, codec_id, encode,
1601 "video/x-msvideocodec", "msvideoversion", G_TYPE_INT, 1, NULL);
1602 break;
1603
1604 case AV_CODEC_ID_MSS1:
1605 caps =
1606 gst_ff_vid_caps_new (context, NULL, codec_id, encode, "video/x-wmv",
1607 "wmvversion", G_TYPE_INT, 1, "format", G_TYPE_STRING, "MSS1", NULL);
1608 break;
1609
1610 case AV_CODEC_ID_MSS2:
1611 caps =
1612 gst_ff_vid_caps_new (context, NULL, codec_id, encode, "video/x-wmv",
1613 "wmvversion", G_TYPE_INT, 3, "format", G_TYPE_STRING, "MSS2", NULL);
1614 break;
1615
1616 case AV_CODEC_ID_WMV3:
1617 caps =
1618 gst_ff_vid_caps_new (context, NULL, codec_id, encode, "video/x-wmv",
1619 "wmvversion", G_TYPE_INT, 3, "format", G_TYPE_STRING, "WMV3", NULL);
1620 break;
1621 case AV_CODEC_ID_VC1:
1622 caps =
1623 gst_ff_vid_caps_new (context, NULL, codec_id, encode, "video/x-wmv",
1624 "wmvversion", G_TYPE_INT, 3, NULL);
1625 if (!context && !encode) {
1626 GValue arr = { 0, };
1627 GValue item = { 0, };
1628
1629 g_value_init (&arr, GST_TYPE_LIST);
1630 g_value_init (&item, G_TYPE_STRING);
1631 g_value_set_string (&item, "WVC1");
1632 gst_value_list_append_value (&arr, &item);
1633 g_value_set_string (&item, "WMVA");
1634 gst_value_list_append_and_take_value (&arr, &item);
1635 gst_caps_set_value (caps, "format", &arr);
1636 g_value_unset (&arr);
1637 } else {
1638 gst_caps_set_simple (caps, "format", G_TYPE_STRING, "WVC1", NULL);
1639 }
1640 break;
1641 case AV_CODEC_ID_QDM2:
1642 caps =
1643 gst_ff_aud_caps_new (context, NULL, codec_id, encode, "audio/x-qdm2",
1644 NULL);
1645 break;
1646
1647 case AV_CODEC_ID_MSZH:
1648 caps =
1649 gst_ff_vid_caps_new (context, NULL, codec_id, encode, "video/x-mszh",
1650 NULL);
1651 break;
1652
1653 case AV_CODEC_ID_ZLIB:
1654 caps =
1655 gst_ff_vid_caps_new (context, NULL, codec_id, encode, "video/x-zlib",
1656 NULL);
1657 break;
1658
1659 case AV_CODEC_ID_TRUEMOTION1:
1660 caps =
1661 gst_ff_vid_caps_new (context, NULL, codec_id, encode,
1662 "video/x-truemotion", "trueversion", G_TYPE_INT, 1, NULL);
1663 break;
1664 case AV_CODEC_ID_TRUEMOTION2:
1665 caps =
1666 gst_ff_vid_caps_new (context, NULL, codec_id, encode,
1667 "video/x-truemotion", "trueversion", G_TYPE_INT, 2, NULL);
1668 break;
1669
1670 case AV_CODEC_ID_ULTI:
1671 caps =
1672 gst_ff_vid_caps_new (context, NULL, codec_id, encode,
1673 "video/x-ultimotion", NULL);
1674 break;
1675
1676 case AV_CODEC_ID_TSCC:
1677 caps =
1678 gst_ff_vid_caps_new (context, NULL, codec_id, encode,
1679 "video/x-camtasia", NULL);
1680 if (context) {
1681 gst_caps_set_simple (caps,
1682 "depth", G_TYPE_INT, (gint) context->bits_per_coded_sample, NULL);
1683 } else {
1684 gst_caps_set_simple (caps, "depth", GST_TYPE_INT_RANGE, 8, 32, NULL);
1685 }
1686 break;
1687
1688 case AV_CODEC_ID_TSCC2:
1689 caps =
1690 gst_ff_vid_caps_new (context, NULL, codec_id, encode,
1691 "video/x-tscc", "tsccversion", G_TYPE_INT, 2, NULL);
1692 break;
1693
1694 case AV_CODEC_ID_KMVC:
1695 caps =
1696 gst_ff_vid_caps_new (context, NULL, codec_id, encode, "video/x-kmvc",
1697 NULL);
1698 break;
1699
1700 case AV_CODEC_ID_NUV:
1701 caps =
1702 gst_ff_vid_caps_new (context, NULL, codec_id, encode, "video/x-nuv",
1703 NULL);
1704 break;
1705
1706 case AV_CODEC_ID_GIF:
1707 caps =
1708 gst_ff_vid_caps_new (context, NULL, codec_id, encode,
1709 "image/gst-libav-gif", "parsed", G_TYPE_BOOLEAN, TRUE, NULL);
1710 break;
1711
1712 case AV_CODEC_ID_PNG:
1713 caps =
1714 gst_ff_vid_caps_new (context, NULL, codec_id, encode, "image/png",
1715 NULL);
1716 break;
1717
1718 case AV_CODEC_ID_PPM:
1719 caps =
1720 gst_ff_vid_caps_new (context, NULL, codec_id, encode, "image/ppm",
1721 NULL);
1722 break;
1723
1724 case AV_CODEC_ID_PBM:
1725 caps =
1726 gst_ff_vid_caps_new (context, NULL, codec_id, encode, "image/pbm",
1727 NULL);
1728 break;
1729
1730 case AV_CODEC_ID_PAM:
1731 caps =
1732 gst_ff_vid_caps_new (context, NULL, codec_id, encode,
1733 "image/x-portable-anymap", NULL);
1734 break;
1735
1736 case AV_CODEC_ID_PGM:
1737 caps =
1738 gst_ff_vid_caps_new (context, NULL, codec_id, encode,
1739 "image/x-portable-graymap", NULL);
1740 break;
1741
1742 case AV_CODEC_ID_PCX:
1743 caps =
1744 gst_ff_vid_caps_new (context, NULL, codec_id, encode, "image/x-pcx",
1745 NULL);
1746 break;
1747
1748 case AV_CODEC_ID_SGI:
1749 caps =
1750 gst_ff_vid_caps_new (context, NULL, codec_id, encode, "image/x-sgi",
1751 NULL);
1752 break;
1753
1754 case AV_CODEC_ID_TARGA:
1755 caps =
1756 gst_ff_vid_caps_new (context, NULL, codec_id, encode, "image/x-tga",
1757 NULL);
1758 break;
1759
1760 case AV_CODEC_ID_TIFF:
1761 caps =
1762 gst_ff_vid_caps_new (context, NULL, codec_id, encode, "image/tiff",
1763 NULL);
1764 break;
1765
1766 case AV_CODEC_ID_SUNRAST:
1767 caps =
1768 gst_ff_vid_caps_new (context, NULL, codec_id, encode,
1769 "image/x-sun-raster", NULL);
1770 break;
1771
1772 case AV_CODEC_ID_SMC:
1773 caps =
1774 gst_ff_vid_caps_new (context, NULL, codec_id, encode, "video/x-smc",
1775 NULL);
1776 break;
1777
1778 case AV_CODEC_ID_QDRAW:
1779 caps =
1780 gst_ff_vid_caps_new (context, NULL, codec_id, encode, "video/x-qdrw",
1781 NULL);
1782 break;
1783
1784 case AV_CODEC_ID_DNXHD:
1785 caps =
1786 gst_ff_vid_caps_new (context, NULL, codec_id, encode, "video/x-dnxhd",
1787 NULL);
1788 break;
1789
1790 case AV_CODEC_ID_PRORES:
1791 caps =
1792 gst_ff_vid_caps_new (context, NULL, codec_id, encode,
1793 "video/x-prores", NULL);
1794 if (context) {
1795 switch (context->codec_tag) {
1796 case GST_MAKE_FOURCC ('a', 'p', 'c', 'o'):
1797 gst_caps_set_simple (caps, "variant", G_TYPE_STRING, "proxy", NULL);
1798 break;
1799 case GST_MAKE_FOURCC ('a', 'p', 'c', 's'):
1800 gst_caps_set_simple (caps, "variant", G_TYPE_STRING, "lt", NULL);
1801 break;
1802 default:
1803 case GST_MAKE_FOURCC ('a', 'p', 'c', 'n'):
1804 gst_caps_set_simple (caps, "variant", G_TYPE_STRING, "standard",
1805 NULL);
1806 break;
1807 case GST_MAKE_FOURCC ('a', 'p', 'c', 'h'):
1808 gst_caps_set_simple (caps, "variant", G_TYPE_STRING, "hq", NULL);
1809 break;
1810 case GST_MAKE_FOURCC ('a', 'p', '4', 'h'):
1811 gst_caps_set_simple (caps, "variant", G_TYPE_STRING, "4444", NULL);
1812 break;
1813 case GST_MAKE_FOURCC ('a', 'p', '4', 'x'):
1814 gst_caps_set_simple (caps, "variant", G_TYPE_STRING, "4444xq",
1815 NULL);
1816 break;
1817 }
1818 }
1819 break;
1820
1821 case AV_CODEC_ID_MIMIC:
1822 caps =
1823 gst_ff_vid_caps_new (context, NULL, codec_id, encode, "video/x-mimic",
1824 NULL);
1825 break;
1826
1827 case AV_CODEC_ID_VMNC:
1828 caps =
1829 gst_ff_vid_caps_new (context, NULL, codec_id, encode, "video/x-vmnc",
1830 NULL);
1831 break;
1832
1833 case AV_CODEC_ID_TRUESPEECH:
1834 caps =
1835 gst_ff_aud_caps_new (context, NULL, codec_id, encode,
1836 "audio/x-truespeech", NULL);
1837 break;
1838
1839 case AV_CODEC_ID_QCELP:
1840 caps =
1841 gst_ff_aud_caps_new (context, NULL, codec_id, encode, "audio/qcelp",
1842 NULL);
1843 break;
1844
1845 case AV_CODEC_ID_AMV:
1846 caps =
1847 gst_ff_vid_caps_new (context, NULL, codec_id, encode, "video/x-amv",
1848 NULL);
1849 break;
1850
1851 case AV_CODEC_ID_AASC:
1852 caps =
1853 gst_ff_vid_caps_new (context, NULL, codec_id, encode, "video/x-aasc",
1854 NULL);
1855 break;
1856
1857 case AV_CODEC_ID_LOCO:
1858 caps =
1859 gst_ff_vid_caps_new (context, NULL, codec_id, encode, "video/x-loco",
1860 NULL);
1861 break;
1862
1863 case AV_CODEC_ID_ZMBV:
1864 caps =
1865 gst_ff_vid_caps_new (context, NULL, codec_id, encode, "video/x-zmbv",
1866 NULL);
1867 break;
1868
1869 case AV_CODEC_ID_LAGARITH:
1870 caps =
1871 gst_ff_vid_caps_new (context, NULL, codec_id, encode,
1872 "video/x-lagarith", NULL);
1873 break;
1874
1875 case AV_CODEC_ID_CSCD:
1876 caps =
1877 gst_ff_vid_caps_new (context, NULL, codec_id, encode,
1878 "video/x-camstudio", NULL);
1879 if (context) {
1880 gst_caps_set_simple (caps,
1881 "depth", G_TYPE_INT, (gint) context->bits_per_coded_sample, NULL);
1882 } else {
1883 gst_caps_set_simple (caps, "depth", GST_TYPE_INT_RANGE, 8, 32, NULL);
1884 }
1885 break;
1886
1887 case AV_CODEC_ID_AIC:
1888 caps =
1889 gst_ff_vid_caps_new (context, NULL, codec_id, encode,
1890 "video/x-apple-intermediate-codec", NULL);
1891 break;
1892
1893 case AV_CODEC_ID_CAVS:
1894 caps =
1895 gst_ff_vid_caps_new (context, NULL, codec_id, encode,
1896 "video/x-cavs", NULL);
1897 break;
1898
1899 case AV_CODEC_ID_WS_VQA:
1900 case AV_CODEC_ID_IDCIN:
1901 case AV_CODEC_ID_8BPS:
1902 case AV_CODEC_ID_FLIC:
1903 case AV_CODEC_ID_VMDVIDEO:
1904 case AV_CODEC_ID_VMDAUDIO:
1905 case AV_CODEC_ID_VIXL:
1906 case AV_CODEC_ID_QPEG:
1907 case AV_CODEC_ID_PGMYUV:
1908 case AV_CODEC_ID_FFVHUFF:
1909 case AV_CODEC_ID_WNV1:
1910 case AV_CODEC_ID_MP3ADU:
1911 case AV_CODEC_ID_MP3ON4:
1912 case AV_CODEC_ID_WESTWOOD_SND1:
1913 case AV_CODEC_ID_MMVIDEO:
1914 case AV_CODEC_ID_AVS:
1915 buildcaps = TRUE;
1916 break;
1917
1918 /* weird quasi-codecs for the demuxers only */
1919 case AV_CODEC_ID_PCM_S16LE:
1920 case AV_CODEC_ID_PCM_S16BE:
1921 case AV_CODEC_ID_PCM_U16LE:
1922 case AV_CODEC_ID_PCM_U16BE:
1923 case AV_CODEC_ID_PCM_S8:
1924 case AV_CODEC_ID_PCM_U8:
1925 {
1926 GstAudioFormat format;
1927
1928 switch (codec_id) {
1929 case AV_CODEC_ID_PCM_S16LE:
1930 format = GST_AUDIO_FORMAT_S16LE;
1931 break;
1932 case AV_CODEC_ID_PCM_S16BE:
1933 format = GST_AUDIO_FORMAT_S16BE;
1934 break;
1935 case AV_CODEC_ID_PCM_U16LE:
1936 format = GST_AUDIO_FORMAT_U16LE;
1937 break;
1938 case AV_CODEC_ID_PCM_U16BE:
1939 format = GST_AUDIO_FORMAT_U16BE;
1940 break;
1941 case AV_CODEC_ID_PCM_S8:
1942 format = GST_AUDIO_FORMAT_S8;
1943 break;
1944 case AV_CODEC_ID_PCM_U8:
1945 format = GST_AUDIO_FORMAT_U8;
1946 break;
1947 default:
1948 format = 0;
1949 g_assert (0); /* don't worry, we never get here */
1950 break;
1951 }
1952
1953 caps =
1954 gst_ff_aud_caps_new (context, NULL, codec_id, encode, "audio/x-raw",
1955 "format", G_TYPE_STRING, gst_audio_format_to_string (format),
1956 "layout", G_TYPE_STRING, "interleaved", NULL);
1957 }
1958 break;
1959
1960 case AV_CODEC_ID_PCM_MULAW:
1961 caps =
1962 gst_ff_aud_caps_new (context, NULL, codec_id, encode, "audio/x-mulaw",
1963 NULL);
1964 break;
1965
1966 case AV_CODEC_ID_PCM_ALAW:
1967 caps =
1968 gst_ff_aud_caps_new (context, NULL, codec_id, encode, "audio/x-alaw",
1969 NULL);
1970 break;
1971
1972 case AV_CODEC_ID_ADPCM_G722:
1973 caps =
1974 gst_ff_aud_caps_new (context, NULL, codec_id, encode, "audio/G722",
1975 NULL);
1976 if (context)
1977 gst_caps_set_simple (caps,
1978 "block_align", G_TYPE_INT, context->block_align,
1979 "bitrate", G_TYPE_INT, (guint) context->bit_rate, NULL);
1980 break;
1981
1982 case AV_CODEC_ID_ADPCM_G726:
1983 {
1984 /* the G726 decoder can also handle G721 */
1985 caps =
1986 gst_ff_aud_caps_new (context, NULL, codec_id, encode, "audio/x-adpcm",
1987 "layout", G_TYPE_STRING, "g726", NULL);
1988 if (context)
1989 gst_caps_set_simple (caps,
1990 "block_align", G_TYPE_INT, context->block_align,
1991 "bitrate", G_TYPE_INT, (guint) context->bit_rate, NULL);
1992
1993 if (!encode) {
1994 gst_caps_append (caps, gst_caps_new_simple ("audio/x-adpcm",
1995 "layout", G_TYPE_STRING, "g721",
1996 "channels", G_TYPE_INT, 1, "rate", G_TYPE_INT, 8000, NULL));
1997 }
1998 break;
1999 }
2000 case AV_CODEC_ID_ADPCM_IMA_QT:
2001 case AV_CODEC_ID_ADPCM_IMA_WAV:
2002 case AV_CODEC_ID_ADPCM_IMA_DK3:
2003 case AV_CODEC_ID_ADPCM_IMA_DK4:
2004 case AV_CODEC_ID_ADPCM_IMA_WS:
2005 case AV_CODEC_ID_ADPCM_IMA_SMJPEG:
2006 case AV_CODEC_ID_ADPCM_IMA_AMV:
2007 case AV_CODEC_ID_ADPCM_IMA_ISS:
2008 case AV_CODEC_ID_ADPCM_IMA_EA_EACS:
2009 case AV_CODEC_ID_ADPCM_IMA_EA_SEAD:
2010 case AV_CODEC_ID_ADPCM_MS:
2011 case AV_CODEC_ID_ADPCM_4XM:
2012 case AV_CODEC_ID_ADPCM_XA:
2013 case AV_CODEC_ID_ADPCM_ADX:
2014 case AV_CODEC_ID_ADPCM_EA:
2015 case AV_CODEC_ID_ADPCM_CT:
2016 case AV_CODEC_ID_ADPCM_SWF:
2017 case AV_CODEC_ID_ADPCM_YAMAHA:
2018 case AV_CODEC_ID_ADPCM_SBPRO_2:
2019 case AV_CODEC_ID_ADPCM_SBPRO_3:
2020 case AV_CODEC_ID_ADPCM_SBPRO_4:
2021 case AV_CODEC_ID_ADPCM_EA_R1:
2022 case AV_CODEC_ID_ADPCM_EA_R2:
2023 case AV_CODEC_ID_ADPCM_EA_R3:
2024 case AV_CODEC_ID_ADPCM_EA_MAXIS_XA:
2025 case AV_CODEC_ID_ADPCM_EA_XAS:
2026 case AV_CODEC_ID_ADPCM_THP:
2027 {
2028 const gchar *layout = NULL;
2029
2030 switch (codec_id) {
2031 case AV_CODEC_ID_ADPCM_IMA_QT:
2032 layout = "quicktime";
2033 break;
2034 case AV_CODEC_ID_ADPCM_IMA_WAV:
2035 layout = "dvi";
2036 break;
2037 case AV_CODEC_ID_ADPCM_IMA_DK3:
2038 layout = "dk3";
2039 break;
2040 case AV_CODEC_ID_ADPCM_IMA_DK4:
2041 layout = "dk4";
2042 break;
2043 case AV_CODEC_ID_ADPCM_IMA_WS:
2044 layout = "westwood";
2045 break;
2046 case AV_CODEC_ID_ADPCM_IMA_SMJPEG:
2047 layout = "smjpeg";
2048 break;
2049 case AV_CODEC_ID_ADPCM_IMA_AMV:
2050 layout = "amv";
2051 break;
2052 case AV_CODEC_ID_ADPCM_IMA_ISS:
2053 layout = "iss";
2054 break;
2055 case AV_CODEC_ID_ADPCM_IMA_EA_EACS:
2056 layout = "ea-eacs";
2057 break;
2058 case AV_CODEC_ID_ADPCM_IMA_EA_SEAD:
2059 layout = "ea-sead";
2060 break;
2061 case AV_CODEC_ID_ADPCM_MS:
2062 layout = "microsoft";
2063 break;
2064 case AV_CODEC_ID_ADPCM_4XM:
2065 layout = "4xm";
2066 break;
2067 case AV_CODEC_ID_ADPCM_XA:
2068 layout = "xa";
2069 break;
2070 case AV_CODEC_ID_ADPCM_ADX:
2071 layout = "adx";
2072 break;
2073 case AV_CODEC_ID_ADPCM_EA:
2074 layout = "ea";
2075 break;
2076 case AV_CODEC_ID_ADPCM_CT:
2077 layout = "ct";
2078 break;
2079 case AV_CODEC_ID_ADPCM_SWF:
2080 layout = "swf";
2081 break;
2082 case AV_CODEC_ID_ADPCM_YAMAHA:
2083 layout = "yamaha";
2084 break;
2085 case AV_CODEC_ID_ADPCM_SBPRO_2:
2086 layout = "sbpro2";
2087 break;
2088 case AV_CODEC_ID_ADPCM_SBPRO_3:
2089 layout = "sbpro3";
2090 break;
2091 case AV_CODEC_ID_ADPCM_SBPRO_4:
2092 layout = "sbpro4";
2093 break;
2094 case AV_CODEC_ID_ADPCM_EA_R1:
2095 layout = "ea-r1";
2096 break;
2097 case AV_CODEC_ID_ADPCM_EA_R2:
2098 layout = "ea-r3";
2099 break;
2100 case AV_CODEC_ID_ADPCM_EA_R3:
2101 layout = "ea-r3";
2102 break;
2103 case AV_CODEC_ID_ADPCM_EA_MAXIS_XA:
2104 layout = "ea-maxis-xa";
2105 break;
2106 case AV_CODEC_ID_ADPCM_EA_XAS:
2107 layout = "ea-xas";
2108 break;
2109 case AV_CODEC_ID_ADPCM_THP:
2110 layout = "thp";
2111 break;
2112 default:
2113 g_assert (0); /* don't worry, we never get here */
2114 break;
2115 }
2116
2117 /* FIXME: someone please check whether we need additional properties
2118 * in this caps definition. */
2119 caps =
2120 gst_ff_aud_caps_new (context, NULL, codec_id, encode, "audio/x-adpcm",
2121 "layout", G_TYPE_STRING, layout, NULL);
2122 if (context)
2123 gst_caps_set_simple (caps,
2124 "block_align", G_TYPE_INT, context->block_align,
2125 "bitrate", G_TYPE_INT, (guint) context->bit_rate, NULL);
2126 }
2127 break;
2128
2129 case AV_CODEC_ID_AMR_NB:
2130 caps =
2131 gst_ff_aud_caps_new (context, NULL, codec_id, encode, "audio/AMR",
2132 NULL);
2133 break;
2134
2135 case AV_CODEC_ID_AMR_WB:
2136 caps =
2137 gst_ff_aud_caps_new (context, NULL, codec_id, encode, "audio/AMR-WB",
2138 NULL);
2139 break;
2140
2141 case AV_CODEC_ID_GSM:
2142 caps =
2143 gst_ff_aud_caps_new (context, NULL, codec_id, encode, "audio/x-gsm",
2144 NULL);
2145 break;
2146
2147 case AV_CODEC_ID_GSM_MS:
2148 caps =
2149 gst_ff_aud_caps_new (context, NULL, codec_id, encode, "audio/ms-gsm",
2150 NULL);
2151 break;
2152
2153 case AV_CODEC_ID_NELLYMOSER:
2154 caps =
2155 gst_ff_aud_caps_new (context, NULL, codec_id, encode,
2156 "audio/x-nellymoser", NULL);
2157 break;
2158
2159 case AV_CODEC_ID_SIPR:
2160 {
2161 caps =
2162 gst_ff_aud_caps_new (context, NULL, codec_id, encode, "audio/x-sipro",
2163 NULL);
2164 if (context) {
2165 gst_caps_set_simple (caps,
2166 "leaf_size", G_TYPE_INT, context->block_align,
2167 "bitrate", G_TYPE_INT, (guint) context->bit_rate, NULL);
2168 }
2169 }
2170 break;
2171
2172 case AV_CODEC_ID_RA_144:
2173 case AV_CODEC_ID_RA_288:
2174 case AV_CODEC_ID_COOK:
2175 {
2176 gint version = 0;
2177
2178 switch (codec_id) {
2179 case AV_CODEC_ID_RA_144:
2180 version = 1;
2181 break;
2182 case AV_CODEC_ID_RA_288:
2183 version = 2;
2184 break;
2185 case AV_CODEC_ID_COOK:
2186 version = 8;
2187 break;
2188 default:
2189 break;
2190 }
2191
2192 /* FIXME: properties? */
2193 caps =
2194 gst_ff_aud_caps_new (context, NULL, codec_id, encode,
2195 "audio/x-pn-realaudio", "raversion", G_TYPE_INT, version, NULL);
2196 if (context) {
2197 gst_caps_set_simple (caps,
2198 "leaf_size", G_TYPE_INT, context->block_align,
2199 "bitrate", G_TYPE_INT, (guint) context->bit_rate, NULL);
2200 }
2201 }
2202 break;
2203
2204 case AV_CODEC_ID_ROQ_DPCM:
2205 case AV_CODEC_ID_INTERPLAY_DPCM:
2206 case AV_CODEC_ID_XAN_DPCM:
2207 case AV_CODEC_ID_SOL_DPCM:
2208 {
2209 const gchar *layout = NULL;
2210
2211 switch (codec_id) {
2212 case AV_CODEC_ID_ROQ_DPCM:
2213 layout = "roq";
2214 break;
2215 case AV_CODEC_ID_INTERPLAY_DPCM:
2216 layout = "interplay";
2217 break;
2218 case AV_CODEC_ID_XAN_DPCM:
2219 layout = "xan";
2220 break;
2221 case AV_CODEC_ID_SOL_DPCM:
2222 layout = "sol";
2223 break;
2224 default:
2225 g_assert (0); /* don't worry, we never get here */
2226 break;
2227 }
2228
2229 /* FIXME: someone please check whether we need additional properties
2230 * in this caps definition. */
2231 caps =
2232 gst_ff_aud_caps_new (context, NULL, codec_id, encode, "audio/x-dpcm",
2233 "layout", G_TYPE_STRING, layout, NULL);
2234 if (context)
2235 gst_caps_set_simple (caps,
2236 "block_align", G_TYPE_INT, context->block_align,
2237 "bitrate", G_TYPE_INT, (guint) context->bit_rate, NULL);
2238 }
2239 break;
2240
2241 case AV_CODEC_ID_SHORTEN:
2242 caps = gst_caps_new_empty_simple ("audio/x-shorten");
2243 break;
2244
2245 case AV_CODEC_ID_ALAC:
2246 caps =
2247 gst_ff_aud_caps_new (context, NULL, codec_id, encode, "audio/x-alac",
2248 NULL);
2249 if (context) {
2250 gst_caps_set_simple (caps,
2251 "samplesize", G_TYPE_INT, context->bits_per_coded_sample, NULL);
2252 }
2253 break;
2254
2255 case AV_CODEC_ID_FLAC:
2256 /* Note that ffmpeg has no encoder yet, but just for safety. In the
2257 * encoder case, we want to add things like samplerate, channels... */
2258 if (!encode) {
2259 caps = gst_caps_new_empty_simple ("audio/x-flac");
2260 }
2261 break;
2262
2263 case AV_CODEC_ID_OPUS:
2264 #ifdef OHOS_EXT_FUNC
2265 // ohos.ext.func.0023
2266 caps = gst_caps_new_empty_simple ("audio/x-opus");
2267 break;
2268 #else
2269 /* Note that ffmpeg has no encoder yet, but just for safety. In the
2270 * encoder case, we want to add things like samplerate, channels... */
2271 if (!encode) {
2272 /* FIXME: can ffmpeg handle multichannel Opus? */
2273 caps = gst_caps_new_simple ("audio/x-opus",
2274 "channel-mapping-family", G_TYPE_INT, 0, NULL);
2275 }
2276 break;
2277 #endif
2278
2279 case AV_CODEC_ID_S302M:
2280 caps = gst_caps_new_empty_simple ("audio/x-smpte-302m");
2281 break;
2282
2283 case AV_CODEC_ID_DVD_SUBTITLE:
2284 case AV_CODEC_ID_DVB_SUBTITLE:
2285 caps = NULL;
2286 break;
2287 case AV_CODEC_ID_BMP:
2288 caps = gst_caps_new_empty_simple ("image/bmp");
2289 break;
2290 case AV_CODEC_ID_TTA:
2291 caps =
2292 gst_ff_aud_caps_new (context, NULL, codec_id, encode, "audio/x-tta",
2293 NULL);
2294 if (context) {
2295 gst_caps_set_simple (caps,
2296 "samplesize", G_TYPE_INT, context->bits_per_coded_sample, NULL);
2297 }
2298 break;
2299 case AV_CODEC_ID_TWINVQ:
2300 caps =
2301 gst_ff_aud_caps_new (context, NULL, codec_id, encode,
2302 "audio/x-twin-vq", NULL);
2303 break;
2304 case AV_CODEC_ID_G729:
2305 caps =
2306 gst_ff_aud_caps_new (context, NULL, codec_id, encode, "audio/G729",
2307 NULL);
2308 break;
2309 case AV_CODEC_ID_DSD_LSBF:
2310 caps =
2311 gst_ff_aud_caps_new (context, NULL, codec_id, encode, "audio/x-dsd",
2312 NULL);
2313 gst_caps_set_simple (caps, "lsbf", G_TYPE_BOOLEAN,
2314 TRUE, "planar", G_TYPE_BOOLEAN, FALSE, NULL);
2315 break;
2316 case AV_CODEC_ID_DSD_MSBF:
2317 caps =
2318 gst_ff_aud_caps_new (context, NULL, codec_id, encode, "audio/x-dsd",
2319 NULL);
2320 gst_caps_set_simple (caps, "lsbf", G_TYPE_BOOLEAN,
2321 FALSE, "planar", G_TYPE_BOOLEAN, FALSE, NULL);
2322 break;
2323 case AV_CODEC_ID_DSD_LSBF_PLANAR:
2324 caps =
2325 gst_ff_aud_caps_new (context, NULL, codec_id, encode, "audio/x-dsd",
2326 NULL);
2327 gst_caps_set_simple (caps, "lsbf", G_TYPE_BOOLEAN,
2328 TRUE, "planar", G_TYPE_BOOLEAN, TRUE, NULL);
2329 break;
2330 case AV_CODEC_ID_DSD_MSBF_PLANAR:
2331 caps =
2332 gst_ff_aud_caps_new (context, NULL, codec_id, encode, "audio/x-dsd",
2333 NULL);
2334 gst_caps_set_simple (caps, "lsbf", G_TYPE_BOOLEAN,
2335 FALSE, "planar", G_TYPE_BOOLEAN, TRUE, NULL);
2336 break;
2337 default:
2338 GST_DEBUG ("Unknown codec ID %d, please add mapping here", codec_id);
2339 break;
2340 }
2341
2342 if (buildcaps) {
2343 AVCodec *codec;
2344
2345 if ((codec = avcodec_find_decoder (codec_id)) ||
2346 (codec = avcodec_find_encoder (codec_id))) {
2347 gchar *mime = NULL;
2348
2349 GST_LOG ("Could not create stream format caps for %s", codec->name);
2350
2351 switch (codec->type) {
2352 case AVMEDIA_TYPE_VIDEO:
2353 mime = g_strdup_printf ("video/x-gst-av-%s", codec->name);
2354 caps =
2355 gst_ff_vid_caps_new (context, NULL, codec_id, encode, mime, NULL);
2356 g_free (mime);
2357 break;
2358 case AVMEDIA_TYPE_AUDIO:
2359 mime = g_strdup_printf ("audio/x-gst-av-%s", codec->name);
2360 caps =
2361 gst_ff_aud_caps_new (context, NULL, codec_id, encode, mime, NULL);
2362 if (context)
2363 gst_caps_set_simple (caps,
2364 "block_align", G_TYPE_INT, context->block_align,
2365 "bitrate", G_TYPE_INT, (guint) context->bit_rate, NULL);
2366 g_free (mime);
2367 break;
2368 default:
2369 break;
2370 }
2371 }
2372 }
2373
2374 if (caps != NULL) {
2375
2376 /* set private data */
2377 if (context && context->extradata_size > 0) {
2378 GstBuffer *data = gst_buffer_new_and_alloc (context->extradata_size);
2379
2380 gst_buffer_fill (data, 0, context->extradata, context->extradata_size);
2381 gst_caps_set_simple (caps, "codec_data", GST_TYPE_BUFFER, data, NULL);
2382 gst_buffer_unref (data);
2383 }
2384
2385 GST_LOG ("caps for codec_id=%d: %" GST_PTR_FORMAT, codec_id, caps);
2386
2387 } else {
2388 GST_LOG ("No caps found for codec_id=%d", codec_id);
2389 }
2390
2391 return caps;
2392 }
2393
2394 /* Convert a FFMPEG Pixel Format and optional AVCodecContext
2395 * to a GstCaps. If the context is ommitted, no fixed values
2396 * for video/audio size will be included in the GstCaps
2397 *
2398 * See below for usefullness
2399 */
2400
2401 static GstCaps *
gst_ffmpeg_pixfmt_to_caps(enum AVPixelFormat pix_fmt,AVCodecContext * context,enum AVCodecID codec_id)2402 gst_ffmpeg_pixfmt_to_caps (enum AVPixelFormat pix_fmt, AVCodecContext * context,
2403 enum AVCodecID codec_id)
2404 {
2405 GstCaps *caps = NULL;
2406 GstVideoFormat format;
2407
2408 format = gst_ffmpeg_pixfmt_to_videoformat (pix_fmt);
2409
2410 if (format != GST_VIDEO_FORMAT_UNKNOWN) {
2411 caps = gst_ff_vid_caps_new (context, NULL, codec_id, TRUE, "video/x-raw",
2412 "format", G_TYPE_STRING, gst_video_format_to_string (format), NULL);
2413 }
2414
2415 if (caps != NULL) {
2416 GST_DEBUG ("caps for pix_fmt=%d: %" GST_PTR_FORMAT, pix_fmt, caps);
2417 } else {
2418 GST_LOG ("No caps found for pix_fmt=%d", pix_fmt);
2419 }
2420
2421 return caps;
2422 }
2423
2424 GstAudioFormat
gst_ffmpeg_smpfmt_to_audioformat(enum AVSampleFormat sample_fmt,GstAudioLayout * layout)2425 gst_ffmpeg_smpfmt_to_audioformat (enum AVSampleFormat sample_fmt,
2426 GstAudioLayout * layout)
2427 {
2428 if (layout)
2429 *layout = GST_AUDIO_LAYOUT_NON_INTERLEAVED;
2430
2431 switch (sample_fmt) {
2432 case AV_SAMPLE_FMT_U8:
2433 if (layout)
2434 *layout = GST_AUDIO_LAYOUT_INTERLEAVED;
2435 case AV_SAMPLE_FMT_U8P:
2436 return GST_AUDIO_FORMAT_U8;
2437 break;
2438
2439 case AV_SAMPLE_FMT_S16:
2440 if (layout)
2441 *layout = GST_AUDIO_LAYOUT_INTERLEAVED;
2442 case AV_SAMPLE_FMT_S16P:
2443 return GST_AUDIO_FORMAT_S16;
2444 break;
2445
2446 case AV_SAMPLE_FMT_S32:
2447 if (layout)
2448 *layout = GST_AUDIO_LAYOUT_INTERLEAVED;
2449 case AV_SAMPLE_FMT_S32P:
2450 return GST_AUDIO_FORMAT_S32;
2451 break;
2452 case AV_SAMPLE_FMT_FLT:
2453 if (layout)
2454 *layout = GST_AUDIO_LAYOUT_INTERLEAVED;
2455 case AV_SAMPLE_FMT_FLTP:
2456 return GST_AUDIO_FORMAT_F32;
2457 break;
2458
2459 case AV_SAMPLE_FMT_DBL:
2460 if (layout)
2461 *layout = GST_AUDIO_LAYOUT_INTERLEAVED;
2462 case AV_SAMPLE_FMT_DBLP:
2463 return GST_AUDIO_FORMAT_F64;
2464 break;
2465
2466 default:
2467 /* .. */
2468 return GST_AUDIO_FORMAT_UNKNOWN;
2469 break;
2470 }
2471 }
2472
2473 /* Convert a FFMPEG Sample Format and optional AVCodecContext
2474 * to a GstCaps. If the context is ommitted, no fixed values
2475 * for video/audio size will be included in the GstCaps
2476 *
2477 * See below for usefullness
2478 */
2479
2480 static GstCaps *
gst_ffmpeg_smpfmt_to_caps(enum AVSampleFormat sample_fmt,AVCodecContext * context,AVCodec * codec,enum AVCodecID codec_id)2481 gst_ffmpeg_smpfmt_to_caps (enum AVSampleFormat sample_fmt,
2482 AVCodecContext * context, AVCodec * codec, enum AVCodecID codec_id)
2483 {
2484 GstCaps *caps = NULL;
2485 GstAudioFormat format;
2486 GstAudioLayout layout;
2487
2488 format = gst_ffmpeg_smpfmt_to_audioformat (sample_fmt, &layout);
2489
2490 if (format != GST_AUDIO_FORMAT_UNKNOWN) {
2491 caps = gst_ff_aud_caps_new (context, codec, codec_id, TRUE, "audio/x-raw",
2492 "format", G_TYPE_STRING, gst_audio_format_to_string (format),
2493 "layout", G_TYPE_STRING,
2494 (layout == GST_AUDIO_LAYOUT_INTERLEAVED) ?
2495 "interleaved" : "non-interleaved", NULL);
2496 GST_LOG ("caps for sample_fmt=%d: %" GST_PTR_FORMAT, sample_fmt, caps);
2497 } else {
2498 GST_LOG ("No caps found for sample_fmt=%d", sample_fmt);
2499 }
2500
2501 return caps;
2502 }
2503
2504 static gboolean
caps_has_field(GstCaps * caps,const gchar * field)2505 caps_has_field (GstCaps * caps, const gchar * field)
2506 {
2507 guint i, n;
2508
2509 n = gst_caps_get_size (caps);
2510 for (i = 0; i < n; i++) {
2511 GstStructure *s = gst_caps_get_structure (caps, i);
2512
2513 if (gst_structure_has_field (s, field))
2514 return TRUE;
2515 }
2516
2517 return FALSE;
2518 }
2519
2520 GstCaps *
gst_ffmpeg_codectype_to_audio_caps(AVCodecContext * context,enum AVCodecID codec_id,gboolean encode,AVCodec * codec)2521 gst_ffmpeg_codectype_to_audio_caps (AVCodecContext * context,
2522 enum AVCodecID codec_id, gboolean encode, AVCodec * codec)
2523 {
2524 GstCaps *caps = NULL;
2525
2526 GST_DEBUG ("context:%p, codec_id:%d, encode:%d, codec:%p",
2527 context, codec_id, encode, codec);
2528 if (codec)
2529 GST_DEBUG ("sample_fmts:%p, samplerates:%p",
2530 codec->sample_fmts, codec->supported_samplerates);
2531
2532 if (context) {
2533 /* Specific codec context */
2534 caps =
2535 gst_ffmpeg_smpfmt_to_caps (context->sample_fmt, context, codec,
2536 codec_id);
2537 } else {
2538 caps = gst_ff_aud_caps_new (context, codec, codec_id, encode, "audio/x-raw",
2539 NULL);
2540 if (!caps_has_field (caps, "format"))
2541 gst_ffmpeg_audio_set_sample_fmts (caps,
2542 codec ? codec->sample_fmts : NULL, encode);
2543 }
2544
2545 return caps;
2546 }
2547
2548 GstCaps *
gst_ffmpeg_codectype_to_video_caps(AVCodecContext * context,enum AVCodecID codec_id,gboolean encode,AVCodec * codec)2549 gst_ffmpeg_codectype_to_video_caps (AVCodecContext * context,
2550 enum AVCodecID codec_id, gboolean encode, AVCodec * codec)
2551 {
2552 GstCaps *caps;
2553
2554 GST_LOG ("context:%p, codec_id:%d, encode:%d, codec:%p",
2555 context, codec_id, encode, codec);
2556
2557 if (context) {
2558 caps = gst_ffmpeg_pixfmt_to_caps (context->pix_fmt, context, codec_id);
2559 } else {
2560 caps =
2561 gst_ff_vid_caps_new (context, codec, codec_id, encode, "video/x-raw",
2562 NULL);
2563 if (!caps_has_field (caps, "format"))
2564 gst_ffmpeg_video_set_pix_fmts (caps, codec ? codec->pix_fmts : NULL);
2565 }
2566 return caps;
2567 }
2568
2569 /* Convert a GstCaps (audio/raw) to a FFMPEG SampleFmt
2570 * and other audio properties in a AVCodecContext.
2571 *
2572 * For usefullness, see below
2573 */
2574
2575 static void
gst_ffmpeg_caps_to_smpfmt(const GstCaps * caps,AVCodecContext * context,gboolean raw)2576 gst_ffmpeg_caps_to_smpfmt (const GstCaps * caps,
2577 AVCodecContext * context, gboolean raw)
2578 {
2579 GstStructure *structure;
2580 const gchar *fmt;
2581 GstAudioFormat format = GST_AUDIO_FORMAT_UNKNOWN;
2582 gint bitrate;
2583 const gchar *layout;
2584 gboolean interleaved;
2585
2586 g_return_if_fail (gst_caps_get_size (caps) == 1);
2587
2588 structure = gst_caps_get_structure (caps, 0);
2589
2590 gst_structure_get_int (structure, "channels", &context->channels);
2591 gst_structure_get_int (structure, "rate", &context->sample_rate);
2592 gst_structure_get_int (structure, "block_align", &context->block_align);
2593 if (gst_structure_get_int (structure, "bitrate", &bitrate))
2594 context->bit_rate = bitrate;
2595
2596 if (!raw)
2597 return;
2598
2599 if (gst_structure_has_name (structure, "audio/x-raw")) {
2600 if ((fmt = gst_structure_get_string (structure, "format"))) {
2601 format = gst_audio_format_from_string (fmt);
2602 }
2603 }
2604
2605 layout = gst_structure_get_string (structure, "layout");
2606 interleaved = ! !g_strcmp0 (layout, "non-interleaved");
2607
2608 switch (format) {
2609 case GST_AUDIO_FORMAT_F32:
2610 context->sample_fmt =
2611 interleaved ? AV_SAMPLE_FMT_FLT : AV_SAMPLE_FMT_FLTP;
2612 break;
2613 case GST_AUDIO_FORMAT_F64:
2614 context->sample_fmt =
2615 interleaved ? AV_SAMPLE_FMT_DBL : AV_SAMPLE_FMT_DBLP;
2616 break;
2617 case GST_AUDIO_FORMAT_S32:
2618 context->sample_fmt =
2619 interleaved ? AV_SAMPLE_FMT_S32 : AV_SAMPLE_FMT_S32P;
2620 break;
2621 case GST_AUDIO_FORMAT_S16:
2622 context->sample_fmt =
2623 interleaved ? AV_SAMPLE_FMT_S16 : AV_SAMPLE_FMT_S16P;
2624 break;
2625 default:
2626 break;
2627 }
2628 }
2629
2630 /* Convert a GstCaps (video/raw) to a FFMPEG PixFmt
2631 * and other video properties in a AVCodecContext.
2632 *
2633 * For usefullness, see below
2634 */
2635
2636 static void
gst_ffmpeg_caps_to_pixfmt(const GstCaps * caps,AVCodecContext * context,gboolean raw)2637 gst_ffmpeg_caps_to_pixfmt (const GstCaps * caps,
2638 AVCodecContext * context, gboolean raw)
2639 {
2640 GstStructure *structure;
2641 const GValue *fps;
2642 const GValue *par = NULL;
2643 const gchar *fmt;
2644 GstVideoFormat format = GST_VIDEO_FORMAT_UNKNOWN;
2645 const gchar *s;
2646
2647 GST_DEBUG ("converting caps %" GST_PTR_FORMAT, caps);
2648 g_return_if_fail (gst_caps_get_size (caps) == 1);
2649 structure = gst_caps_get_structure (caps, 0);
2650
2651 gst_structure_get_int (structure, "width", &context->width);
2652 gst_structure_get_int (structure, "height", &context->height);
2653 gst_structure_get_int (structure, "bpp", &context->bits_per_coded_sample);
2654
2655 fps = gst_structure_get_value (structure, "framerate");
2656 if (fps != NULL && GST_VALUE_HOLDS_FRACTION (fps)) {
2657
2658 int num = gst_value_get_fraction_numerator (fps);
2659 int den = gst_value_get_fraction_denominator (fps);
2660
2661 if (num > 0 && den > 0) {
2662 /* somehow these seem mixed up.. */
2663 /* they're fine, this is because it does period=1/frequency */
2664 context->time_base.den = gst_value_get_fraction_numerator (fps);
2665 context->time_base.num = gst_value_get_fraction_denominator (fps);
2666 context->ticks_per_frame = 1;
2667
2668 GST_DEBUG ("setting framerate %d/%d = %lf",
2669 context->time_base.den, context->time_base.num,
2670 1. * context->time_base.den / context->time_base.num);
2671 } else {
2672 GST_INFO ("ignoring framerate %d/%d (probably variable framerate)",
2673 context->time_base.num, context->time_base.den);
2674 }
2675 }
2676
2677 par = gst_structure_get_value (structure, "pixel-aspect-ratio");
2678 if (par && GST_VALUE_HOLDS_FRACTION (par)) {
2679
2680 int num = gst_value_get_fraction_numerator (par);
2681 int den = gst_value_get_fraction_denominator (par);
2682
2683 if (num > 0 && den > 0) {
2684 context->sample_aspect_ratio.num = num;
2685 context->sample_aspect_ratio.den = den;
2686
2687 GST_DEBUG ("setting pixel-aspect-ratio %d/%d = %lf",
2688 context->sample_aspect_ratio.num, context->sample_aspect_ratio.den,
2689 1. * context->sample_aspect_ratio.num /
2690 context->sample_aspect_ratio.den);
2691 } else {
2692 GST_WARNING ("ignoring insane pixel-aspect-ratio %d/%d",
2693 context->sample_aspect_ratio.num, context->sample_aspect_ratio.den);
2694 }
2695 }
2696
2697 if (!raw)
2698 return;
2699
2700 g_return_if_fail (fps != NULL && GST_VALUE_HOLDS_FRACTION (fps));
2701
2702 if (gst_structure_has_name (structure, "video/x-raw")) {
2703 if ((fmt = gst_structure_get_string (structure, "format"))) {
2704 format = gst_video_format_from_string (fmt);
2705 }
2706 }
2707
2708 switch (format) {
2709 case GST_VIDEO_FORMAT_YUY2:
2710 context->pix_fmt = AV_PIX_FMT_YUYV422;
2711 break;
2712 case GST_VIDEO_FORMAT_I420:
2713 context->pix_fmt = AV_PIX_FMT_YUV420P;
2714 break;
2715 case GST_VIDEO_FORMAT_A420:
2716 context->pix_fmt = AV_PIX_FMT_YUVA420P;
2717 break;
2718 case GST_VIDEO_FORMAT_Y41B:
2719 context->pix_fmt = AV_PIX_FMT_YUV411P;
2720 break;
2721 case GST_VIDEO_FORMAT_Y42B:
2722 context->pix_fmt = AV_PIX_FMT_YUV422P;
2723 break;
2724 case GST_VIDEO_FORMAT_YUV9:
2725 context->pix_fmt = AV_PIX_FMT_YUV410P;
2726 break;
2727 case GST_VIDEO_FORMAT_Y444:
2728 context->pix_fmt = AV_PIX_FMT_YUV444P;
2729 break;
2730 case GST_VIDEO_FORMAT_GRAY8:
2731 context->pix_fmt = AV_PIX_FMT_GRAY8;
2732 break;
2733 case GST_VIDEO_FORMAT_xRGB:
2734 #if (G_BYTE_ORDER == G_BIG_ENDIAN)
2735 context->pix_fmt = AV_PIX_FMT_RGB32;
2736 #endif
2737 break;
2738 case GST_VIDEO_FORMAT_BGRx:
2739 #if (G_BYTE_ORDER == G_LITTLE_ENDIAN)
2740 context->pix_fmt = AV_PIX_FMT_RGB32;
2741 #endif
2742 break;
2743 case GST_VIDEO_FORMAT_RGB:
2744 context->pix_fmt = AV_PIX_FMT_RGB24;
2745 break;
2746 case GST_VIDEO_FORMAT_BGR:
2747 context->pix_fmt = AV_PIX_FMT_BGR24;
2748 break;
2749 case GST_VIDEO_FORMAT_RGB16:
2750 context->pix_fmt = AV_PIX_FMT_RGB565;
2751 break;
2752 case GST_VIDEO_FORMAT_RGB15:
2753 context->pix_fmt = AV_PIX_FMT_RGB555;
2754 break;
2755 case GST_VIDEO_FORMAT_RGB8P:
2756 context->pix_fmt = AV_PIX_FMT_PAL8;
2757 break;
2758 default:
2759 break;
2760 }
2761
2762 s = gst_structure_get_string (structure, "interlace-mode");
2763 if (s) {
2764 if (strcmp (s, "progressive") == 0) {
2765 context->field_order = AV_FIELD_PROGRESSIVE;
2766 } else if (strcmp (s, "interleaved") == 0) {
2767 s = gst_structure_get_string (structure, "field-order");
2768 if (s) {
2769 if (strcmp (s, "top-field-first") == 0) {
2770 context->field_order = AV_FIELD_TT;
2771 } else if (strcmp (s, "bottom-field-first") == 0) {
2772 context->field_order = AV_FIELD_TB;
2773 }
2774 }
2775 }
2776 }
2777 }
2778
2779 typedef struct
2780 {
2781 GstVideoFormat format;
2782 enum AVPixelFormat pixfmt;
2783 } PixToFmt;
2784
2785 /* FIXME : FILLME */
2786 static const PixToFmt pixtofmttable[] = {
2787 /* GST_VIDEO_FORMAT_I420, */
2788 {GST_VIDEO_FORMAT_I420, AV_PIX_FMT_YUV420P},
2789 /* Note : this should use a different chroma placement */
2790 {GST_VIDEO_FORMAT_I420, AV_PIX_FMT_YUVJ420P},
2791
2792 /* GST_VIDEO_FORMAT_YV12, */
2793 /* GST_VIDEO_FORMAT_YUY2, */
2794 {GST_VIDEO_FORMAT_YUY2, AV_PIX_FMT_YUYV422},
2795 /* GST_VIDEO_FORMAT_UYVY, */
2796 {GST_VIDEO_FORMAT_UYVY, AV_PIX_FMT_UYVY422},
2797 /* GST_VIDEO_FORMAT_AYUV, */
2798 /* GST_VIDEO_FORMAT_RGBx, */
2799 {GST_VIDEO_FORMAT_RGBx, AV_PIX_FMT_RGB0},
2800 /* GST_VIDEO_FORMAT_BGRx, */
2801 {GST_VIDEO_FORMAT_BGRx, AV_PIX_FMT_BGR0},
2802 /* GST_VIDEO_FORMAT_xRGB, */
2803 {GST_VIDEO_FORMAT_xRGB, AV_PIX_FMT_0RGB},
2804 /* GST_VIDEO_FORMAT_xBGR, */
2805 {GST_VIDEO_FORMAT_xBGR, AV_PIX_FMT_0BGR},
2806 /* GST_VIDEO_FORMAT_RGBA, */
2807 {GST_VIDEO_FORMAT_RGBA, AV_PIX_FMT_RGBA},
2808 /* GST_VIDEO_FORMAT_BGRA, */
2809 {GST_VIDEO_FORMAT_BGRA, AV_PIX_FMT_BGRA},
2810 /* GST_VIDEO_FORMAT_ARGB, */
2811 {GST_VIDEO_FORMAT_ARGB, AV_PIX_FMT_ARGB},
2812 /* GST_VIDEO_FORMAT_ABGR, */
2813 {GST_VIDEO_FORMAT_ABGR, AV_PIX_FMT_ABGR},
2814 /* GST_VIDEO_FORMAT_RGB, */
2815 {GST_VIDEO_FORMAT_RGB, AV_PIX_FMT_RGB24},
2816 /* GST_VIDEO_FORMAT_BGR, */
2817 {GST_VIDEO_FORMAT_BGR, AV_PIX_FMT_BGR24},
2818 /* GST_VIDEO_FORMAT_Y41B, */
2819 {GST_VIDEO_FORMAT_Y41B, AV_PIX_FMT_YUV411P},
2820 /* GST_VIDEO_FORMAT_Y42B, */
2821 {GST_VIDEO_FORMAT_Y42B, AV_PIX_FMT_YUV422P},
2822 {GST_VIDEO_FORMAT_Y42B, AV_PIX_FMT_YUVJ422P},
2823 /* GST_VIDEO_FORMAT_YVYU, */
2824 /* GST_VIDEO_FORMAT_Y444, */
2825 {GST_VIDEO_FORMAT_Y444, AV_PIX_FMT_YUV444P},
2826 {GST_VIDEO_FORMAT_Y444, AV_PIX_FMT_YUVJ444P},
2827 /* GST_VIDEO_FORMAT_v210, */
2828 /* GST_VIDEO_FORMAT_v216, */
2829 /* GST_VIDEO_FORMAT_NV12, */
2830 {GST_VIDEO_FORMAT_NV12, AV_PIX_FMT_NV12},
2831 /* GST_VIDEO_FORMAT_NV21, */
2832 {GST_VIDEO_FORMAT_NV21, AV_PIX_FMT_NV21},
2833 /* GST_VIDEO_FORMAT_GRAY8, */
2834 {GST_VIDEO_FORMAT_GRAY8, AV_PIX_FMT_GRAY8},
2835 /* GST_VIDEO_FORMAT_GRAY16_BE, */
2836 {GST_VIDEO_FORMAT_GRAY16_BE, AV_PIX_FMT_GRAY16BE},
2837 /* GST_VIDEO_FORMAT_GRAY16_LE, */
2838 {GST_VIDEO_FORMAT_GRAY16_LE, AV_PIX_FMT_GRAY16LE},
2839 /* GST_VIDEO_FORMAT_v308, */
2840 /* GST_VIDEO_FORMAT_Y800, */
2841 /* GST_VIDEO_FORMAT_Y16, */
2842 /* GST_VIDEO_FORMAT_RGB16, */
2843 {GST_VIDEO_FORMAT_RGB16, AV_PIX_FMT_RGB565},
2844 /* GST_VIDEO_FORMAT_BGR16, */
2845 /* GST_VIDEO_FORMAT_RGB15, */
2846 {GST_VIDEO_FORMAT_RGB15, AV_PIX_FMT_RGB555},
2847 /* GST_VIDEO_FORMAT_BGR15, */
2848 /* GST_VIDEO_FORMAT_UYVP, */
2849 /* GST_VIDEO_FORMAT_A420, */
2850 {GST_VIDEO_FORMAT_A420, AV_PIX_FMT_YUVA420P},
2851 /* GST_VIDEO_FORMAT_RGB8_PALETTED, */
2852 {GST_VIDEO_FORMAT_RGB8P, AV_PIX_FMT_PAL8},
2853 /* GST_VIDEO_FORMAT_YUV9, */
2854 {GST_VIDEO_FORMAT_YUV9, AV_PIX_FMT_YUV410P},
2855 /* GST_VIDEO_FORMAT_YVU9, */
2856 /* GST_VIDEO_FORMAT_IYU1, */
2857 /* GST_VIDEO_FORMAT_ARGB64, */
2858 /* GST_VIDEO_FORMAT_AYUV64, */
2859 /* GST_VIDEO_FORMAT_r210, */
2860 {GST_VIDEO_FORMAT_I420_10LE, AV_PIX_FMT_YUV420P10LE},
2861 {GST_VIDEO_FORMAT_I420_10BE, AV_PIX_FMT_YUV420P10BE},
2862 {GST_VIDEO_FORMAT_I422_10LE, AV_PIX_FMT_YUV422P10LE},
2863 {GST_VIDEO_FORMAT_I422_10BE, AV_PIX_FMT_YUV422P10BE},
2864 {GST_VIDEO_FORMAT_Y444_10LE, AV_PIX_FMT_YUV444P10LE},
2865 {GST_VIDEO_FORMAT_Y444_10BE, AV_PIX_FMT_YUV444P10BE},
2866 {GST_VIDEO_FORMAT_GBR, AV_PIX_FMT_GBRP},
2867 {GST_VIDEO_FORMAT_GBRA, AV_PIX_FMT_GBRAP},
2868 {GST_VIDEO_FORMAT_GBR_10LE, AV_PIX_FMT_GBRP10LE},
2869 {GST_VIDEO_FORMAT_GBR_10BE, AV_PIX_FMT_GBRP10BE},
2870 {GST_VIDEO_FORMAT_GBR_12LE, AV_PIX_FMT_GBRP12LE},
2871 {GST_VIDEO_FORMAT_GBR_12BE, AV_PIX_FMT_GBRP12BE},
2872 {GST_VIDEO_FORMAT_GBRA_12LE, AV_PIX_FMT_GBRAP12LE},
2873 {GST_VIDEO_FORMAT_GBRA_12BE, AV_PIX_FMT_GBRAP12BE},
2874 {GST_VIDEO_FORMAT_A420_10LE, AV_PIX_FMT_YUVA420P10LE},
2875 {GST_VIDEO_FORMAT_A420_10BE, AV_PIX_FMT_YUVA420P10BE},
2876 {GST_VIDEO_FORMAT_A422_10LE, AV_PIX_FMT_YUVA422P10LE},
2877 {GST_VIDEO_FORMAT_A422_10BE, AV_PIX_FMT_YUVA422P10BE},
2878 {GST_VIDEO_FORMAT_A444_10LE, AV_PIX_FMT_YUVA444P10LE},
2879 {GST_VIDEO_FORMAT_A444_10BE, AV_PIX_FMT_YUVA444P10BE},
2880 {GST_VIDEO_FORMAT_I420_12LE, AV_PIX_FMT_YUV420P12LE},
2881 {GST_VIDEO_FORMAT_I420_12BE, AV_PIX_FMT_YUV420P12BE},
2882 {GST_VIDEO_FORMAT_I422_12LE, AV_PIX_FMT_YUV422P12LE},
2883 {GST_VIDEO_FORMAT_I422_12BE, AV_PIX_FMT_YUV422P12BE},
2884 {GST_VIDEO_FORMAT_Y444_12LE, AV_PIX_FMT_YUV444P12LE},
2885 {GST_VIDEO_FORMAT_Y444_12BE, AV_PIX_FMT_YUV444P12BE},
2886 };
2887
2888 GstVideoFormat
gst_ffmpeg_pixfmt_to_videoformat(enum AVPixelFormat pixfmt)2889 gst_ffmpeg_pixfmt_to_videoformat (enum AVPixelFormat pixfmt)
2890 {
2891 guint i;
2892
2893 for (i = 0; i < G_N_ELEMENTS (pixtofmttable); i++)
2894 if (pixtofmttable[i].pixfmt == pixfmt)
2895 return pixtofmttable[i].format;
2896
2897 GST_DEBUG ("Unknown pixel format %d", pixfmt);
2898 return GST_VIDEO_FORMAT_UNKNOWN;
2899 }
2900
2901 static enum AVPixelFormat
gst_ffmpeg_videoformat_to_pixfmt_for_codec(GstVideoFormat format,const AVCodec * codec)2902 gst_ffmpeg_videoformat_to_pixfmt_for_codec (GstVideoFormat format,
2903 const AVCodec * codec)
2904 {
2905 guint i;
2906
2907 for (i = 0; i < G_N_ELEMENTS (pixtofmttable); i++) {
2908 if (pixtofmttable[i].format == format) {
2909 gint j;
2910
2911 if (codec && codec->pix_fmts) {
2912 for (j = 0; codec->pix_fmts[j] != -1; j++) {
2913 if (pixtofmttable[i].pixfmt == codec->pix_fmts[j])
2914 return pixtofmttable[i].pixfmt;
2915 }
2916 } else {
2917 return pixtofmttable[i].pixfmt;
2918 }
2919 }
2920 }
2921
2922 return AV_PIX_FMT_NONE;
2923 }
2924
2925 enum AVPixelFormat
gst_ffmpeg_videoformat_to_pixfmt(GstVideoFormat format)2926 gst_ffmpeg_videoformat_to_pixfmt (GstVideoFormat format)
2927 {
2928 return gst_ffmpeg_videoformat_to_pixfmt_for_codec (format, NULL);
2929 }
2930
2931 void
gst_ffmpeg_videoinfo_to_context(GstVideoInfo * info,AVCodecContext * context)2932 gst_ffmpeg_videoinfo_to_context (GstVideoInfo * info, AVCodecContext * context)
2933 {
2934 gint i, bpp = 0;
2935
2936 context->width = GST_VIDEO_INFO_WIDTH (info);
2937 context->height = GST_VIDEO_INFO_HEIGHT (info);
2938 for (i = 0; i < GST_VIDEO_INFO_N_COMPONENTS (info); i++)
2939 bpp += GST_VIDEO_INFO_COMP_DEPTH (info, i);
2940 context->bits_per_coded_sample = bpp;
2941
2942 context->ticks_per_frame = 1;
2943 if (GST_VIDEO_INFO_FPS_N (info) == 0) {
2944 GST_DEBUG ("Using 25/1 framerate");
2945 context->time_base.den = 25;
2946 context->time_base.num = 1;
2947 } else {
2948 context->time_base.den = GST_VIDEO_INFO_FPS_N (info);
2949 context->time_base.num = GST_VIDEO_INFO_FPS_D (info);
2950 }
2951
2952 context->sample_aspect_ratio.num = GST_VIDEO_INFO_PAR_N (info);
2953 context->sample_aspect_ratio.den = GST_VIDEO_INFO_PAR_D (info);
2954
2955 context->pix_fmt =
2956 gst_ffmpeg_videoformat_to_pixfmt_for_codec (GST_VIDEO_INFO_FORMAT (info),
2957 context->codec);
2958
2959 switch (info->chroma_site) {
2960 case GST_VIDEO_CHROMA_SITE_MPEG2:
2961 context->chroma_sample_location = AVCHROMA_LOC_LEFT;
2962 break;
2963 case GST_VIDEO_CHROMA_SITE_JPEG:
2964 context->chroma_sample_location = AVCHROMA_LOC_CENTER;
2965 break;
2966 case GST_VIDEO_CHROMA_SITE_DV:
2967 context->chroma_sample_location = AVCHROMA_LOC_TOPLEFT;
2968 break;
2969 case GST_VIDEO_CHROMA_SITE_V_COSITED:
2970 context->chroma_sample_location = AVCHROMA_LOC_TOP;
2971 break;
2972 default:
2973 break;
2974 }
2975
2976 switch (info->colorimetry.primaries) {
2977 case GST_VIDEO_COLOR_PRIMARIES_BT709:
2978 context->color_primaries = AVCOL_PRI_BT709;
2979 break;
2980 case GST_VIDEO_COLOR_PRIMARIES_BT470M:
2981 context->color_primaries = AVCOL_PRI_BT470M;
2982 break;
2983 case GST_VIDEO_COLOR_PRIMARIES_BT470BG:
2984 context->color_primaries = AVCOL_PRI_BT470BG;
2985 break;
2986 case GST_VIDEO_COLOR_PRIMARIES_SMPTE170M:
2987 context->color_primaries = AVCOL_PRI_SMPTE170M;
2988 break;
2989 case GST_VIDEO_COLOR_PRIMARIES_SMPTE240M:
2990 context->color_primaries = AVCOL_PRI_SMPTE240M;
2991 break;
2992 case GST_VIDEO_COLOR_PRIMARIES_FILM:
2993 context->color_primaries = AVCOL_PRI_FILM;
2994 break;
2995 case GST_VIDEO_COLOR_PRIMARIES_BT2020:
2996 context->color_primaries = AVCOL_PRI_BT2020;
2997 break;
2998 default:
2999 break;
3000 }
3001
3002 switch (info->colorimetry.transfer) {
3003 case GST_VIDEO_TRANSFER_BT709:
3004 context->color_trc = AVCOL_TRC_BT709;
3005 break;
3006 case GST_VIDEO_TRANSFER_GAMMA22:
3007 context->color_trc = AVCOL_TRC_GAMMA22;
3008 break;
3009 case GST_VIDEO_TRANSFER_GAMMA28:
3010 context->color_trc = AVCOL_TRC_GAMMA28;
3011 break;
3012 case GST_VIDEO_TRANSFER_SMPTE240M:
3013 context->color_trc = AVCOL_TRC_SMPTE240M;
3014 break;
3015 case GST_VIDEO_TRANSFER_GAMMA10:
3016 context->color_trc = AVCOL_TRC_LINEAR;
3017 break;
3018 case GST_VIDEO_TRANSFER_LOG100:
3019 context->color_trc = AVCOL_TRC_LOG;
3020 break;
3021 case GST_VIDEO_TRANSFER_LOG316:
3022 context->color_trc = AVCOL_TRC_LOG_SQRT;
3023 break;
3024 case GST_VIDEO_TRANSFER_BT2020_12:
3025 context->color_trc = AVCOL_TRC_BT2020_12;
3026 break;
3027 default:
3028 break;
3029 }
3030
3031 switch (info->colorimetry.matrix) {
3032 case GST_VIDEO_COLOR_MATRIX_RGB:
3033 context->colorspace = AVCOL_SPC_RGB;
3034 break;
3035 case GST_VIDEO_COLOR_MATRIX_BT709:
3036 context->colorspace = AVCOL_SPC_BT709;
3037 break;
3038 case GST_VIDEO_COLOR_MATRIX_FCC:
3039 context->colorspace = AVCOL_SPC_FCC;
3040 break;
3041 case GST_VIDEO_COLOR_MATRIX_BT601:
3042 context->colorspace = AVCOL_SPC_BT470BG;
3043 break;
3044 case GST_VIDEO_COLOR_MATRIX_SMPTE240M:
3045 context->colorspace = AVCOL_SPC_SMPTE240M;
3046 break;
3047 case GST_VIDEO_COLOR_MATRIX_BT2020:
3048 context->colorspace = AVCOL_SPC_BT2020_NCL;
3049 break;
3050 default:
3051 break;
3052 }
3053
3054 if (info->colorimetry.range == GST_VIDEO_COLOR_RANGE_0_255) {
3055 context->color_range = AVCOL_RANGE_JPEG;
3056 } else {
3057 context->color_range = AVCOL_RANGE_MPEG;
3058 }
3059 }
3060
3061 void
gst_ffmpeg_audioinfo_to_context(GstAudioInfo * info,AVCodecContext * context)3062 gst_ffmpeg_audioinfo_to_context (GstAudioInfo * info, AVCodecContext * context)
3063 {
3064 const AVCodec *codec;
3065 const enum AVSampleFormat *smpl_fmts;
3066 enum AVSampleFormat smpl_fmt = -1;
3067
3068 context->channels = info->channels;
3069 context->sample_rate = info->rate;
3070 context->channel_layout =
3071 gst_ffmpeg_channel_positions_to_layout (info->position, info->channels);
3072
3073 codec = context->codec;
3074
3075 smpl_fmts = codec->sample_fmts;
3076
3077 switch (info->finfo->format) {
3078 case GST_AUDIO_FORMAT_F32:
3079 if (smpl_fmts) {
3080 while (*smpl_fmts != -1) {
3081 if (*smpl_fmts == AV_SAMPLE_FMT_FLT) {
3082 smpl_fmt = *smpl_fmts;
3083 break;
3084 } else if (*smpl_fmts == AV_SAMPLE_FMT_FLTP) {
3085 smpl_fmt = *smpl_fmts;
3086 }
3087
3088 smpl_fmts++;
3089 }
3090 } else {
3091 smpl_fmt = AV_SAMPLE_FMT_FLT;
3092 }
3093 break;
3094 case GST_AUDIO_FORMAT_F64:
3095 if (smpl_fmts) {
3096 while (*smpl_fmts != -1) {
3097 if (*smpl_fmts == AV_SAMPLE_FMT_DBL) {
3098 smpl_fmt = *smpl_fmts;
3099 break;
3100 } else if (*smpl_fmts == AV_SAMPLE_FMT_DBLP) {
3101 smpl_fmt = *smpl_fmts;
3102 }
3103
3104 smpl_fmts++;
3105 }
3106 } else {
3107 smpl_fmt = AV_SAMPLE_FMT_DBL;
3108 }
3109 break;
3110 case GST_AUDIO_FORMAT_S32:
3111 if (smpl_fmts) {
3112 while (*smpl_fmts != -1) {
3113 if (*smpl_fmts == AV_SAMPLE_FMT_S32) {
3114 smpl_fmt = *smpl_fmts;
3115 break;
3116 } else if (*smpl_fmts == AV_SAMPLE_FMT_S32P) {
3117 smpl_fmt = *smpl_fmts;
3118 }
3119
3120 smpl_fmts++;
3121 }
3122 } else {
3123 smpl_fmt = AV_SAMPLE_FMT_S32;
3124 }
3125 break;
3126 case GST_AUDIO_FORMAT_S16:
3127 if (smpl_fmts) {
3128 while (*smpl_fmts != -1) {
3129 if (*smpl_fmts == AV_SAMPLE_FMT_S16) {
3130 smpl_fmt = *smpl_fmts;
3131 break;
3132 } else if (*smpl_fmts == AV_SAMPLE_FMT_S16P) {
3133 smpl_fmt = *smpl_fmts;
3134 }
3135
3136 smpl_fmts++;
3137 }
3138 } else {
3139 smpl_fmt = AV_SAMPLE_FMT_S16;
3140 }
3141 break;
3142 case GST_AUDIO_FORMAT_U8:
3143 if (smpl_fmts) {
3144 while (*smpl_fmts != -1) {
3145 if (*smpl_fmts == AV_SAMPLE_FMT_U8) {
3146 smpl_fmt = *smpl_fmts;
3147 break;
3148 } else if (*smpl_fmts == AV_SAMPLE_FMT_U8P) {
3149 smpl_fmt = *smpl_fmts;
3150 }
3151
3152 smpl_fmts++;
3153 }
3154 } else {
3155 smpl_fmt = AV_SAMPLE_FMT_U8;
3156 }
3157 break;
3158 default:
3159 break;
3160 }
3161
3162 g_assert (smpl_fmt != -1);
3163
3164 context->sample_fmt = smpl_fmt;
3165 }
3166
3167 /* Convert a GstCaps and a FFMPEG codec Type to a
3168 * AVCodecContext. If the context is ommitted, no fixed values
3169 * for video/audio size will be included in the context
3170 *
3171 * AVMediaType is primarily meant for uncompressed data GstCaps!
3172 */
3173
3174 void
gst_ffmpeg_caps_with_codectype(enum AVMediaType type,const GstCaps * caps,AVCodecContext * context)3175 gst_ffmpeg_caps_with_codectype (enum AVMediaType type,
3176 const GstCaps * caps, AVCodecContext * context)
3177 {
3178 if (context == NULL)
3179 return;
3180
3181 switch (type) {
3182 case AVMEDIA_TYPE_VIDEO:
3183 gst_ffmpeg_caps_to_pixfmt (caps, context, TRUE);
3184 break;
3185
3186 case AVMEDIA_TYPE_AUDIO:
3187 gst_ffmpeg_caps_to_smpfmt (caps, context, TRUE);
3188 break;
3189
3190 default:
3191 /* unknown */
3192 break;
3193 }
3194 }
3195
3196 #if 0
3197 static void
3198 nal_escape (guint8 * dst, guint8 * src, guint size, guint * destsize)
3199 {
3200 guint8 *dstp = dst;
3201 guint8 *srcp = src;
3202 guint8 *end = src + size;
3203 gint count = 0;
3204
3205 while (srcp < end) {
3206 if (count == 2 && *srcp <= 0x03) {
3207 GST_DEBUG ("added escape code");
3208 *dstp++ = 0x03;
3209 count = 0;
3210 }
3211 if (*srcp == 0)
3212 count++;
3213 else
3214 count = 0;
3215
3216 GST_DEBUG ("copy %02x, count %d", *srcp, count);
3217 *dstp++ = *srcp++;
3218 }
3219 *destsize = dstp - dst;
3220 }
3221
3222 /* copy the config, escaping NAL units as we iterate them, if something fails we
3223 * copy everything and hope for the best. */
3224 static void
3225 copy_config (guint8 * dst, guint8 * src, guint size, guint * destsize)
3226 {
3227 guint8 *dstp = dst;
3228 guint8 *srcp = src;
3229 gint cnt, i;
3230 guint nalsize, esize;
3231
3232 /* check size */
3233 if (size < 7)
3234 goto full_copy;
3235
3236 /* check version */
3237 if (*srcp != 1)
3238 goto full_copy;
3239
3240 cnt = *(srcp + 5) & 0x1f; /* Number of sps */
3241
3242 GST_DEBUG ("num SPS %d", cnt);
3243
3244 memcpy (dstp, srcp, 6);
3245 srcp += 6;
3246 dstp += 6;
3247
3248 for (i = 0; i < cnt; i++) {
3249 GST_DEBUG ("copy SPS %d", i);
3250 nalsize = (srcp[0] << 8) | srcp[1];
3251 nal_escape (dstp + 2, srcp + 2, nalsize, &esize);
3252 dstp[0] = esize >> 8;
3253 dstp[1] = esize & 0xff;
3254 dstp += esize + 2;
3255 srcp += nalsize + 2;
3256 }
3257
3258 cnt = *(dstp++) = *(srcp++); /* Number of pps */
3259
3260 GST_DEBUG ("num PPS %d", cnt);
3261
3262 for (i = 0; i < cnt; i++) {
3263 GST_DEBUG ("copy PPS %d", i);
3264 nalsize = (srcp[0] << 8) | srcp[1];
3265 nal_escape (dstp + 2, srcp + 2, nalsize, &esize);
3266 dstp[0] = esize >> 8;
3267 dstp[1] = esize & 0xff;
3268 dstp += esize + 2;
3269 srcp += nalsize + 2;
3270 }
3271 *destsize = dstp - dst;
3272
3273 return;
3274
3275 full_copy:
3276 {
3277 GST_DEBUG ("something unexpected, doing full copy");
3278 memcpy (dst, src, size);
3279 *destsize = size;
3280 return;
3281 }
3282 }
3283 #endif
3284
3285 /*
3286 * caps_with_codecid () transforms a GstCaps for a known codec
3287 * ID into a filled-in context.
3288 * codec_data from caps will override possible extradata already in the context
3289 */
3290
3291 void
gst_ffmpeg_caps_with_codecid(enum AVCodecID codec_id,enum AVMediaType codec_type,const GstCaps * caps,AVCodecContext * context)3292 gst_ffmpeg_caps_with_codecid (enum AVCodecID codec_id,
3293 enum AVMediaType codec_type, const GstCaps * caps, AVCodecContext * context)
3294 {
3295 GstStructure *str;
3296 const GValue *value;
3297 GstBuffer *buf;
3298
3299 GST_LOG ("codec_id:%d, codec_type:%d, caps:%" GST_PTR_FORMAT " context:%p",
3300 codec_id, codec_type, caps, context);
3301
3302 if (!context || !gst_caps_get_size (caps))
3303 return;
3304
3305 str = gst_caps_get_structure (caps, 0);
3306
3307 /* extradata parsing (esds [mpeg4], wma/wmv, msmpeg4v1/2/3, etc.) */
3308 if ((value = gst_structure_get_value (str, "codec_data"))) {
3309 GstMapInfo map;
3310
3311 buf = gst_value_get_buffer (value);
3312 gst_buffer_map (buf, &map, GST_MAP_READ);
3313
3314 /* free the old one if it is there */
3315 if (context->extradata)
3316 av_free (context->extradata);
3317
3318 #if 0
3319 if (codec_id == AV_CODEC_ID_H264) {
3320 guint extrasize;
3321
3322 GST_DEBUG ("copy, escaping codec_data %d", size);
3323 /* ffmpeg h264 expects the codec_data to be escaped, there is no real
3324 * reason for this but let's just escape it for now. Start by allocating
3325 * enough space, x2 is more than enough.
3326 *
3327 * FIXME, we disabled escaping because some file already contain escaped
3328 * codec_data and then we escape twice and fail. It's better to leave it
3329 * as is, as that is what most players do. */
3330 context->extradata =
3331 av_mallocz (GST_ROUND_UP_16 (size * 2 +
3332 AV_INPUT_BUFFER_PADDING_SIZE));
3333 copy_config (context->extradata, data, size, &extrasize);
3334 GST_DEBUG ("escaped size: %d", extrasize);
3335 context->extradata_size = extrasize;
3336 } else
3337 #endif
3338 {
3339 /* allocate with enough padding */
3340 GST_DEBUG ("copy codec_data");
3341 context->extradata =
3342 av_mallocz (GST_ROUND_UP_16 (map.size +
3343 AV_INPUT_BUFFER_PADDING_SIZE));
3344 memcpy (context->extradata, map.data, map.size);
3345 context->extradata_size = map.size;
3346 }
3347
3348 /* Hack for VC1. Sometimes the first (length) byte is 0 for some files */
3349 if (codec_id == AV_CODEC_ID_VC1 && map.size > 0 && map.data[0] == 0) {
3350 context->extradata[0] = (guint8) map.size;
3351 }
3352
3353 GST_DEBUG ("have codec data of size %" G_GSIZE_FORMAT, map.size);
3354
3355 gst_buffer_unmap (buf, &map);
3356 } else {
3357 context->extradata = NULL;
3358 context->extradata_size = 0;
3359 GST_DEBUG ("no codec data");
3360 }
3361
3362 switch (codec_id) {
3363 case AV_CODEC_ID_MPEG4:
3364 {
3365 const gchar *mime = gst_structure_get_name (str);
3366
3367 context->flags |= AV_CODEC_FLAG_4MV;
3368
3369 if (!strcmp (mime, "video/x-divx"))
3370 context->codec_tag = GST_MAKE_FOURCC ('D', 'I', 'V', 'X');
3371 else if (!strcmp (mime, "video/mpeg")) {
3372 const gchar *profile;
3373
3374 context->codec_tag = GST_MAKE_FOURCC ('m', 'p', '4', 'v');
3375
3376 profile = gst_structure_get_string (str, "profile");
3377 if (profile) {
3378 if (g_strcmp0 (profile, "advanced-simple") == 0)
3379 context->flags |= AV_CODEC_FLAG_QPEL;
3380 }
3381 }
3382 break;
3383 }
3384
3385 case AV_CODEC_ID_SVQ3:
3386 /* FIXME: this is a workaround for older gst-plugins releases
3387 * (<= 0.8.9). This should be removed at some point, because
3388 * it causes wrong decoded frame order. */
3389 if (!context->extradata) {
3390 gint halfpel_flag, thirdpel_flag, low_delay, unknown_svq3_flag;
3391 guint16 flags;
3392
3393 if (gst_structure_get_int (str, "halfpel_flag", &halfpel_flag) &&
3394 gst_structure_get_int (str, "thirdpel_flag", &thirdpel_flag) &&
3395 gst_structure_get_int (str, "low_delay", &low_delay) &&
3396 gst_structure_get_int (str, "unknown_svq3_flag",
3397 &unknown_svq3_flag)) {
3398 context->extradata = (guint8 *) av_mallocz (0x64);
3399 g_stpcpy ((gchar *) context->extradata, "SVQ3");
3400 flags = 1 << 3;
3401 flags |= low_delay;
3402 flags = flags << 2;
3403 flags |= unknown_svq3_flag;
3404 flags = flags << 6;
3405 flags |= halfpel_flag;
3406 flags = flags << 1;
3407 flags |= thirdpel_flag;
3408 flags = flags << 3;
3409
3410 flags = GUINT16_FROM_LE (flags);
3411
3412 memcpy ((gchar *) context->extradata + 0x62, &flags, 2);
3413 context->extradata_size = 0x64;
3414 }
3415 }
3416 break;
3417
3418 case AV_CODEC_ID_MSRLE:
3419 case AV_CODEC_ID_QTRLE:
3420 case AV_CODEC_ID_TSCC:
3421 case AV_CODEC_ID_CSCD:
3422 case AV_CODEC_ID_APE:
3423 {
3424 gint depth;
3425
3426 if (gst_structure_get_int (str, "depth", &depth)) {
3427 context->bits_per_coded_sample = depth;
3428 } else {
3429 GST_WARNING ("No depth field in caps %" GST_PTR_FORMAT, caps);
3430 }
3431
3432 }
3433 break;
3434
3435 case AV_CODEC_ID_COOK:
3436 case AV_CODEC_ID_RA_288:
3437 case AV_CODEC_ID_RA_144:
3438 case AV_CODEC_ID_SIPR:
3439 {
3440 gint leaf_size;
3441 gint bitrate;
3442
3443 if (gst_structure_get_int (str, "leaf_size", &leaf_size))
3444 context->block_align = leaf_size;
3445 if (gst_structure_get_int (str, "bitrate", &bitrate))
3446 context->bit_rate = bitrate;
3447 }
3448 break;
3449 case AV_CODEC_ID_ALAC:
3450 gst_structure_get_int (str, "samplesize",
3451 &context->bits_per_coded_sample);
3452 break;
3453
3454 case AV_CODEC_ID_DVVIDEO:
3455 {
3456 const gchar *format;
3457
3458 if ((format = gst_structure_get_string (str, "format"))) {
3459
3460 if (g_str_equal (format, "YUY2"))
3461 context->pix_fmt = AV_PIX_FMT_YUYV422;
3462 else if (g_str_equal (format, "I420"))
3463 context->pix_fmt = AV_PIX_FMT_YUV420P;
3464 else if (g_str_equal (format, "A420"))
3465 context->pix_fmt = AV_PIX_FMT_YUVA420P;
3466 else if (g_str_equal (format, "Y41B"))
3467 context->pix_fmt = AV_PIX_FMT_YUV411P;
3468 else if (g_str_equal (format, "Y42B"))
3469 context->pix_fmt = AV_PIX_FMT_YUV422P;
3470 else if (g_str_equal (format, "YUV9"))
3471 context->pix_fmt = AV_PIX_FMT_YUV410P;
3472 else {
3473 GST_WARNING ("couldn't convert format %s" " to a pixel format",
3474 format);
3475 }
3476 } else
3477 GST_WARNING ("No specified format");
3478 break;
3479 }
3480 case AV_CODEC_ID_H263P:
3481 {
3482 gboolean val;
3483
3484 if (!gst_structure_get_boolean (str, "annex-f", &val) || val)
3485 context->flags |= AV_CODEC_FLAG_4MV;
3486 else
3487 context->flags &= ~AV_CODEC_FLAG_4MV;
3488 if ((!gst_structure_get_boolean (str, "annex-i", &val) || val) &&
3489 (!gst_structure_get_boolean (str, "annex-t", &val) || val))
3490 context->flags |= AV_CODEC_FLAG_AC_PRED;
3491 else
3492 context->flags &= ~AV_CODEC_FLAG_AC_PRED;
3493 if (!gst_structure_get_boolean (str, "annex-j", &val) || val)
3494 context->flags |= AV_CODEC_FLAG_LOOP_FILTER;
3495 else
3496 context->flags &= ~AV_CODEC_FLAG_LOOP_FILTER;
3497 break;
3498 }
3499 case AV_CODEC_ID_ADPCM_G726:
3500 {
3501 const gchar *layout;
3502
3503 if ((layout = gst_structure_get_string (str, "layout"))) {
3504 if (!strcmp (layout, "g721")) {
3505 context->sample_rate = 8000;
3506 context->channels = 1;
3507 context->bit_rate = 32000;
3508 }
3509 }
3510 break;
3511 }
3512 default:
3513 break;
3514 }
3515
3516 if (!gst_caps_is_fixed (caps))
3517 return;
3518
3519 /* common properties (width, height, fps) */
3520 switch (codec_type) {
3521 case AVMEDIA_TYPE_VIDEO:
3522 gst_ffmpeg_caps_to_pixfmt (caps, context,
3523 codec_id == AV_CODEC_ID_RAWVIDEO);
3524 break;
3525 case AVMEDIA_TYPE_AUDIO:
3526 gst_ffmpeg_caps_to_smpfmt (caps, context, FALSE);
3527 break;
3528 default:
3529 break;
3530 }
3531
3532 /* fixup of default settings */
3533 switch (codec_id) {
3534 case AV_CODEC_ID_QCELP:
3535 /* QCELP is always mono, no matter what the caps say */
3536 context->channels = 1;
3537 break;
3538 case AV_CODEC_ID_ADPCM_G726:
3539 if (context->sample_rate && context->bit_rate)
3540 context->bits_per_coded_sample =
3541 context->bit_rate / context->sample_rate;
3542 break;
3543 default:
3544 break;
3545 }
3546 }
3547
3548 /* _formatid_to_caps () is meant for muxers/demuxers, it
3549 * transforms a name (ffmpeg way of ID'ing these, why don't
3550 * they have unique numerical IDs?) to the corresponding
3551 * caps belonging to that mux-format
3552 *
3553 * Note: we don't need any additional info because the caps
3554 * isn't supposed to contain any useful info besides the
3555 * media type anyway
3556 */
3557
3558 GstCaps *
gst_ffmpeg_formatid_to_caps(const gchar * format_name)3559 gst_ffmpeg_formatid_to_caps (const gchar * format_name)
3560 {
3561 GstCaps *caps = NULL;
3562
3563 if (!strcmp (format_name, "mpeg")) {
3564 caps = gst_caps_new_simple ("video/mpeg",
3565 "systemstream", G_TYPE_BOOLEAN, TRUE, NULL);
3566 } else if (!strcmp (format_name, "mpegts")) {
3567 caps = gst_caps_new_simple ("video/mpegts",
3568 "systemstream", G_TYPE_BOOLEAN, TRUE, NULL);
3569 } else if (!strcmp (format_name, "rm")) {
3570 caps = gst_caps_new_simple ("application/x-pn-realmedia",
3571 "systemstream", G_TYPE_BOOLEAN, TRUE, NULL);
3572 } else if (!strcmp (format_name, "asf")) {
3573 caps = gst_caps_new_empty_simple ("video/x-ms-asf");
3574 } else if (!strcmp (format_name, "avi")) {
3575 caps = gst_caps_new_empty_simple ("video/x-msvideo");
3576 } else if (!strcmp (format_name, "wav")) {
3577 caps = gst_caps_new_empty_simple ("audio/x-wav");
3578 } else if (!strcmp (format_name, "ape")) {
3579 caps = gst_caps_new_empty_simple ("application/x-ape");
3580 } else if (!strcmp (format_name, "swf")) {
3581 caps = gst_caps_new_empty_simple ("application/x-shockwave-flash");
3582 } else if (!strcmp (format_name, "au")) {
3583 caps = gst_caps_new_empty_simple ("audio/x-au");
3584 } else if (!strcmp (format_name, "dv")) {
3585 caps = gst_caps_new_simple ("video/x-dv",
3586 "systemstream", G_TYPE_BOOLEAN, TRUE, NULL);
3587 } else if (!strcmp (format_name, "4xm")) {
3588 caps = gst_caps_new_empty_simple ("video/x-4xm");
3589 } else if (!strcmp (format_name, "matroska")) {
3590 caps = gst_caps_new_empty_simple ("video/x-matroska");
3591 } else if (!strcmp (format_name, "ivf")) {
3592 caps = gst_caps_new_empty_simple ("video/x-ivf");
3593 } else if (!strcmp (format_name, "mp3")) {
3594 caps = gst_caps_new_empty_simple ("application/x-id3");
3595 } else if (!strcmp (format_name, "flic")) {
3596 caps = gst_caps_new_empty_simple ("video/x-fli");
3597 } else if (!strcmp (format_name, "flv")) {
3598 caps = gst_caps_new_empty_simple ("video/x-flv");
3599 } else if (!strcmp (format_name, "tta")) {
3600 caps = gst_caps_new_empty_simple ("audio/x-ttafile");
3601 } else if (!strcmp (format_name, "aiff")) {
3602 caps = gst_caps_new_empty_simple ("audio/x-aiff");
3603 } else if (!strcmp (format_name, "mov_mp4_m4a_3gp_3g2")) {
3604 caps =
3605 gst_caps_from_string
3606 ("application/x-3gp; video/quicktime; audio/x-m4a");
3607 } else if (!strcmp (format_name, "mov")) {
3608 caps = gst_caps_from_string ("video/quicktime,variant=(string)apple");
3609 } else if (!strcmp (format_name, "mp4")) {
3610 caps = gst_caps_from_string ("video/quicktime,variant=(string)iso");
3611 } else if (!strcmp (format_name, "3gp")) {
3612 caps = gst_caps_from_string ("video/quicktime,variant=(string)3gpp");
3613 } else if (!strcmp (format_name, "3g2")) {
3614 caps = gst_caps_from_string ("video/quicktime,variant=(string)3g2");
3615 } else if (!strcmp (format_name, "psp")) {
3616 caps = gst_caps_from_string ("video/quicktime,variant=(string)psp");
3617 } else if (!strcmp (format_name, "ipod")) {
3618 caps = gst_caps_from_string ("video/quicktime,variant=(string)ipod");
3619 } else if (!strcmp (format_name, "aac")) {
3620 caps = gst_caps_new_simple ("audio/mpeg",
3621 "mpegversion", G_TYPE_INT, 4, NULL);
3622 } else if (!strcmp (format_name, "gif")) {
3623 caps = gst_caps_from_string ("image/gif");
3624 #ifdef OHOS_OPT_COMPAT
3625 } else if (!strcmp (format_name, "ogg")) {
3626 /* fix caps, enable to use avdemux_ogg for pure audio scene */
3627 caps = gst_caps_from_string ("application/ogg; audio/ogg");
3628 #endif
3629 } else if (!strcmp (format_name, "mxf") || !strcmp (format_name, "mxf_d10")) {
3630 caps = gst_caps_from_string ("application/mxf");
3631 } else if (!strcmp (format_name, "gxf")) {
3632 caps = gst_caps_from_string ("application/gxf");
3633 } else if (!strcmp (format_name, "yuv4mpegpipe")) {
3634 caps = gst_caps_new_simple ("application/x-yuv4mpeg",
3635 "y4mversion", G_TYPE_INT, 2, NULL);
3636 } else if (!strcmp (format_name, "mpc")) {
3637 caps = gst_caps_from_string ("audio/x-musepack, streamversion = (int) 7");
3638 } else if (!strcmp (format_name, "mpc8")) {
3639 caps = gst_caps_from_string ("audio/x-musepack, streamversion = (int) 8");
3640 } else if (!strcmp (format_name, "vqf")) {
3641 caps = gst_caps_from_string ("audio/x-vqf");
3642 } else if (!strcmp (format_name, "nsv")) {
3643 caps = gst_caps_from_string ("video/x-nsv");
3644 } else if (!strcmp (format_name, "amr")) {
3645 caps = gst_caps_from_string ("audio/x-amr-nb-sh");
3646 } else if (!strcmp (format_name, "webm")) {
3647 caps = gst_caps_from_string ("video/webm");
3648 } else if (!strcmp (format_name, "voc")) {
3649 caps = gst_caps_from_string ("audio/x-voc");
3650 } else if (!strcmp (format_name, "pva")) {
3651 caps = gst_caps_from_string ("video/x-pva");
3652 } else if (!strcmp (format_name, "brstm")) {
3653 caps = gst_caps_from_string ("audio/x-brstm");
3654 } else if (!strcmp (format_name, "bfstm")) {
3655 caps = gst_caps_from_string ("audio/x-bfstm");
3656 } else {
3657 gchar *name;
3658
3659 GST_LOG ("Could not create stream format caps for %s", format_name);
3660 name = g_strdup_printf ("application/x-gst-av-%s", format_name);
3661 caps = gst_caps_new_empty_simple (name);
3662 g_free (name);
3663 }
3664
3665 return caps;
3666 }
3667
3668 gboolean
gst_ffmpeg_formatid_get_codecids(const gchar * format_name,enum AVCodecID ** video_codec_list,enum AVCodecID ** audio_codec_list,AVOutputFormat * plugin)3669 gst_ffmpeg_formatid_get_codecids (const gchar * format_name,
3670 enum AVCodecID ** video_codec_list, enum AVCodecID ** audio_codec_list,
3671 AVOutputFormat * plugin)
3672 {
3673 static enum AVCodecID tmp_vlist[] = {
3674 AV_CODEC_ID_NONE,
3675 AV_CODEC_ID_NONE
3676 };
3677 static enum AVCodecID tmp_alist[] = {
3678 AV_CODEC_ID_NONE,
3679 AV_CODEC_ID_NONE
3680 };
3681
3682 GST_LOG ("format_name : %s", format_name);
3683
3684 if (!strcmp (format_name, "mp4")) {
3685 static enum AVCodecID mp4_video_list[] = {
3686 AV_CODEC_ID_MPEG4, AV_CODEC_ID_H264,
3687 AV_CODEC_ID_MJPEG,
3688 AV_CODEC_ID_NONE
3689 };
3690 static enum AVCodecID mp4_audio_list[] = {
3691 AV_CODEC_ID_AAC, AV_CODEC_ID_MP3,
3692 AV_CODEC_ID_NONE
3693 };
3694
3695 *video_codec_list = mp4_video_list;
3696 *audio_codec_list = mp4_audio_list;
3697 } else if (!strcmp (format_name, "mpeg")) {
3698 static enum AVCodecID mpeg_video_list[] = { AV_CODEC_ID_MPEG1VIDEO,
3699 AV_CODEC_ID_MPEG2VIDEO,
3700 AV_CODEC_ID_H264,
3701 AV_CODEC_ID_NONE
3702 };
3703 static enum AVCodecID mpeg_audio_list[] = { AV_CODEC_ID_MP1,
3704 AV_CODEC_ID_MP2,
3705 AV_CODEC_ID_MP3,
3706 AV_CODEC_ID_NONE
3707 };
3708
3709 *video_codec_list = mpeg_video_list;
3710 *audio_codec_list = mpeg_audio_list;
3711 } else if (!strcmp (format_name, "dvd")) {
3712 static enum AVCodecID mpeg_video_list[] = { AV_CODEC_ID_MPEG2VIDEO,
3713 AV_CODEC_ID_NONE
3714 };
3715 static enum AVCodecID mpeg_audio_list[] = { AV_CODEC_ID_MP2,
3716 AV_CODEC_ID_AC3,
3717 AV_CODEC_ID_DTS,
3718 AV_CODEC_ID_PCM_S16BE,
3719 AV_CODEC_ID_NONE
3720 };
3721
3722 *video_codec_list = mpeg_video_list;
3723 *audio_codec_list = mpeg_audio_list;
3724 } else if (!strcmp (format_name, "mpegts")) {
3725 static enum AVCodecID mpegts_video_list[] = { AV_CODEC_ID_MPEG1VIDEO,
3726 AV_CODEC_ID_MPEG2VIDEO,
3727 AV_CODEC_ID_H264,
3728 AV_CODEC_ID_NONE
3729 };
3730 static enum AVCodecID mpegts_audio_list[] = { AV_CODEC_ID_MP2,
3731 AV_CODEC_ID_MP3,
3732 AV_CODEC_ID_AC3,
3733 AV_CODEC_ID_DTS,
3734 AV_CODEC_ID_AAC,
3735 AV_CODEC_ID_NONE
3736 };
3737
3738 *video_codec_list = mpegts_video_list;
3739 *audio_codec_list = mpegts_audio_list;
3740 } else if (!strcmp (format_name, "vob")) {
3741 static enum AVCodecID vob_video_list[] =
3742 { AV_CODEC_ID_MPEG2VIDEO, AV_CODEC_ID_NONE };
3743 static enum AVCodecID vob_audio_list[] = { AV_CODEC_ID_MP2, AV_CODEC_ID_AC3,
3744 AV_CODEC_ID_DTS, AV_CODEC_ID_NONE
3745 };
3746
3747 *video_codec_list = vob_video_list;
3748 *audio_codec_list = vob_audio_list;
3749 } else if (!strcmp (format_name, "flv")) {
3750 static enum AVCodecID flv_video_list[] =
3751 { AV_CODEC_ID_FLV1, AV_CODEC_ID_NONE };
3752 static enum AVCodecID flv_audio_list[] =
3753 { AV_CODEC_ID_MP3, AV_CODEC_ID_NONE };
3754
3755 *video_codec_list = flv_video_list;
3756 *audio_codec_list = flv_audio_list;
3757 } else if (!strcmp (format_name, "asf")) {
3758 static enum AVCodecID asf_video_list[] =
3759 { AV_CODEC_ID_WMV1, AV_CODEC_ID_WMV2, AV_CODEC_ID_MSMPEG4V3,
3760 AV_CODEC_ID_NONE
3761 };
3762 static enum AVCodecID asf_audio_list[] =
3763 { AV_CODEC_ID_WMAV1, AV_CODEC_ID_WMAV2, AV_CODEC_ID_MP3,
3764 AV_CODEC_ID_NONE
3765 };
3766
3767 *video_codec_list = asf_video_list;
3768 *audio_codec_list = asf_audio_list;
3769 } else if (!strcmp (format_name, "dv")) {
3770 static enum AVCodecID dv_video_list[] =
3771 { AV_CODEC_ID_DVVIDEO, AV_CODEC_ID_NONE };
3772 static enum AVCodecID dv_audio_list[] =
3773 { AV_CODEC_ID_PCM_S16LE, AV_CODEC_ID_NONE };
3774
3775 *video_codec_list = dv_video_list;
3776 *audio_codec_list = dv_audio_list;
3777 } else if (!strcmp (format_name, "mov")) {
3778 static enum AVCodecID mov_video_list[] = {
3779 AV_CODEC_ID_SVQ1, AV_CODEC_ID_SVQ3, AV_CODEC_ID_MPEG4,
3780 AV_CODEC_ID_H263, AV_CODEC_ID_H263P,
3781 AV_CODEC_ID_H264, AV_CODEC_ID_DVVIDEO,
3782 AV_CODEC_ID_MJPEG,
3783 AV_CODEC_ID_NONE
3784 };
3785 static enum AVCodecID mov_audio_list[] = {
3786 AV_CODEC_ID_PCM_MULAW, AV_CODEC_ID_PCM_ALAW, AV_CODEC_ID_ADPCM_IMA_QT,
3787 AV_CODEC_ID_MACE3, AV_CODEC_ID_MACE6, AV_CODEC_ID_AAC,
3788 AV_CODEC_ID_AMR_NB, AV_CODEC_ID_AMR_WB,
3789 AV_CODEC_ID_PCM_S16BE, AV_CODEC_ID_PCM_S16LE,
3790 AV_CODEC_ID_MP3, AV_CODEC_ID_NONE
3791 };
3792
3793 *video_codec_list = mov_video_list;
3794 *audio_codec_list = mov_audio_list;
3795 } else if ((!strcmp (format_name, "3gp") || !strcmp (format_name, "3g2"))) {
3796 static enum AVCodecID tgp_video_list[] = {
3797 AV_CODEC_ID_MPEG4, AV_CODEC_ID_H263, AV_CODEC_ID_H263P, AV_CODEC_ID_H264,
3798 AV_CODEC_ID_NONE
3799 };
3800 static enum AVCodecID tgp_audio_list[] = {
3801 AV_CODEC_ID_AMR_NB, AV_CODEC_ID_AMR_WB,
3802 AV_CODEC_ID_AAC,
3803 AV_CODEC_ID_NONE
3804 };
3805
3806 *video_codec_list = tgp_video_list;
3807 *audio_codec_list = tgp_audio_list;
3808 } else if (!strcmp (format_name, "mmf")) {
3809 static enum AVCodecID mmf_audio_list[] = {
3810 AV_CODEC_ID_ADPCM_YAMAHA, AV_CODEC_ID_NONE
3811 };
3812 *video_codec_list = NULL;
3813 *audio_codec_list = mmf_audio_list;
3814 } else if (!strcmp (format_name, "amr")) {
3815 static enum AVCodecID amr_audio_list[] = {
3816 AV_CODEC_ID_AMR_NB, AV_CODEC_ID_AMR_WB,
3817 AV_CODEC_ID_NONE
3818 };
3819 *video_codec_list = NULL;
3820 *audio_codec_list = amr_audio_list;
3821 } else if (!strcmp (format_name, "gif")) {
3822 static enum AVCodecID gif_image_list[] = {
3823 AV_CODEC_ID_RAWVIDEO, AV_CODEC_ID_NONE
3824 };
3825 *video_codec_list = gif_image_list;
3826 *audio_codec_list = NULL;
3827 } else if ((!strcmp (format_name, "pva"))) {
3828 static enum AVCodecID pga_video_list[] = {
3829 AV_CODEC_ID_MPEG2VIDEO,
3830 AV_CODEC_ID_NONE
3831 };
3832 static enum AVCodecID pga_audio_list[] = {
3833 AV_CODEC_ID_MP2,
3834 AV_CODEC_ID_NONE
3835 };
3836
3837 *video_codec_list = pga_video_list;
3838 *audio_codec_list = pga_audio_list;
3839 } else if ((plugin->audio_codec != AV_CODEC_ID_NONE) ||
3840 (plugin->video_codec != AV_CODEC_ID_NONE)) {
3841 tmp_vlist[0] = plugin->video_codec;
3842 tmp_alist[0] = plugin->audio_codec;
3843
3844 *video_codec_list = tmp_vlist;
3845 *audio_codec_list = tmp_alist;
3846 } else {
3847 GST_LOG ("Format %s not found", format_name);
3848 return FALSE;
3849 }
3850
3851 return TRUE;
3852 }
3853
3854 /* Convert a GstCaps to a FFMPEG codec ID. Size et all
3855 * are omitted, that can be queried by the user itself,
3856 * we're not eating the GstCaps or anything
3857 * A pointer to an allocated context is also needed for
3858 * optional extra info
3859 */
3860
3861 enum AVCodecID
gst_ffmpeg_caps_to_codecid(const GstCaps * caps,AVCodecContext * context)3862 gst_ffmpeg_caps_to_codecid (const GstCaps * caps, AVCodecContext * context)
3863 {
3864 enum AVCodecID id = AV_CODEC_ID_NONE;
3865 const gchar *mimetype;
3866 const GstStructure *structure;
3867 gboolean video = FALSE, audio = FALSE; /* we want to be sure! */
3868
3869 g_return_val_if_fail (caps != NULL, AV_CODEC_ID_NONE);
3870 g_return_val_if_fail (gst_caps_get_size (caps) == 1, AV_CODEC_ID_NONE);
3871 structure = gst_caps_get_structure (caps, 0);
3872
3873 mimetype = gst_structure_get_name (structure);
3874
3875 if (!strcmp (mimetype, "video/x-raw")) {
3876 id = AV_CODEC_ID_RAWVIDEO;
3877 video = TRUE;
3878 } else if (!strcmp (mimetype, "audio/x-raw")) {
3879 GstAudioInfo info;
3880
3881 if (gst_audio_info_from_caps (&info, caps)) {
3882 switch (GST_AUDIO_INFO_FORMAT (&info)) {
3883 case GST_AUDIO_FORMAT_S8:
3884 id = AV_CODEC_ID_PCM_S8;
3885 break;
3886 case GST_AUDIO_FORMAT_U8:
3887 id = AV_CODEC_ID_PCM_U8;
3888 break;
3889 case GST_AUDIO_FORMAT_S16LE:
3890 id = AV_CODEC_ID_PCM_S16LE;
3891 break;
3892 case GST_AUDIO_FORMAT_S16BE:
3893 id = AV_CODEC_ID_PCM_S16BE;
3894 break;
3895 case GST_AUDIO_FORMAT_U16LE:
3896 id = AV_CODEC_ID_PCM_U16LE;
3897 break;
3898 case GST_AUDIO_FORMAT_U16BE:
3899 id = AV_CODEC_ID_PCM_U16BE;
3900 break;
3901 default:
3902 break;
3903 }
3904 if (id != AV_CODEC_ID_NONE)
3905 audio = TRUE;
3906 }
3907 } else if (!strcmp (mimetype, "audio/x-mulaw")) {
3908 id = AV_CODEC_ID_PCM_MULAW;
3909 audio = TRUE;
3910 } else if (!strcmp (mimetype, "audio/x-alaw")) {
3911 id = AV_CODEC_ID_PCM_ALAW;
3912 audio = TRUE;
3913 } else if (!strcmp (mimetype, "video/x-dv")) {
3914 gboolean sys_strm;
3915
3916 if (gst_structure_get_boolean (structure, "systemstream", &sys_strm) &&
3917 !sys_strm) {
3918 id = AV_CODEC_ID_DVVIDEO;
3919 video = TRUE;
3920 }
3921 } else if (!strcmp (mimetype, "audio/x-dv")) { /* ??? */
3922 id = AV_CODEC_ID_DVAUDIO;
3923 audio = TRUE;
3924 } else if (!strcmp (mimetype, "video/x-h263")) {
3925 const gchar *h263version =
3926 gst_structure_get_string (structure, "h263version");
3927 if (h263version && !strcmp (h263version, "h263p"))
3928 id = AV_CODEC_ID_H263P;
3929 else
3930 id = AV_CODEC_ID_H263;
3931 video = TRUE;
3932 } else if (!strcmp (mimetype, "video/x-intel-h263")) {
3933 id = AV_CODEC_ID_H263I;
3934 video = TRUE;
3935 } else if (!strcmp (mimetype, "video/x-h261")) {
3936 id = AV_CODEC_ID_H261;
3937 video = TRUE;
3938 } else if (!strcmp (mimetype, "video/mpeg")) {
3939 gboolean sys_strm;
3940 gint mpegversion;
3941
3942 if (gst_structure_get_boolean (structure, "systemstream", &sys_strm) &&
3943 gst_structure_get_int (structure, "mpegversion", &mpegversion) &&
3944 !sys_strm) {
3945 switch (mpegversion) {
3946 case 1:
3947 id = AV_CODEC_ID_MPEG1VIDEO;
3948 break;
3949 case 2:
3950 id = AV_CODEC_ID_MPEG2VIDEO;
3951 break;
3952 case 4:
3953 id = AV_CODEC_ID_MPEG4;
3954 break;
3955 }
3956 }
3957 if (id != AV_CODEC_ID_NONE)
3958 video = TRUE;
3959 } else if (!strcmp (mimetype, "image/jpeg")) {
3960 id = AV_CODEC_ID_MJPEG; /* A... B... */
3961 video = TRUE;
3962 } else if (!strcmp (mimetype, "video/x-jpeg-b")) {
3963 id = AV_CODEC_ID_MJPEGB;
3964 video = TRUE;
3965 } else if (!strcmp (mimetype, "video/x-wmv")) {
3966 gint wmvversion = 0;
3967
3968 if (gst_structure_get_int (structure, "wmvversion", &wmvversion)) {
3969 switch (wmvversion) {
3970 case 1:
3971 id = AV_CODEC_ID_WMV1;
3972 break;
3973 case 2:
3974 id = AV_CODEC_ID_WMV2;
3975 break;
3976 case 3:
3977 {
3978 const gchar *format;
3979
3980 /* WMV3 unless the fourcc exists and says otherwise */
3981 id = AV_CODEC_ID_WMV3;
3982
3983 if ((format = gst_structure_get_string (structure, "format")) &&
3984 (g_str_equal (format, "WVC1") || g_str_equal (format, "WMVA")))
3985 id = AV_CODEC_ID_VC1;
3986
3987 break;
3988 }
3989 }
3990 }
3991 if (id != AV_CODEC_ID_NONE)
3992 video = TRUE;
3993 } else if (!strcmp (mimetype, "audio/x-vorbis")) {
3994 id = AV_CODEC_ID_VORBIS;
3995 audio = TRUE;
3996 } else if (!strcmp (mimetype, "audio/x-qdm2")) {
3997 id = AV_CODEC_ID_QDM2;
3998 audio = TRUE;
3999 } else if (!strcmp (mimetype, "audio/mpeg")) {
4000 gint layer = 0;
4001 gint mpegversion = 0;
4002
4003 if (gst_structure_get_int (structure, "mpegversion", &mpegversion)) {
4004 switch (mpegversion) {
4005 case 2: /* ffmpeg uses faad for both... */
4006 case 4:
4007 id = AV_CODEC_ID_AAC;
4008 break;
4009 case 1:
4010 if (gst_structure_get_int (structure, "layer", &layer)) {
4011 switch (layer) {
4012 case 1:
4013 id = AV_CODEC_ID_MP1;
4014 break;
4015 case 2:
4016 id = AV_CODEC_ID_MP2;
4017 break;
4018 case 3:
4019 id = AV_CODEC_ID_MP3;
4020 break;
4021 }
4022 }
4023 }
4024 }
4025 if (id != AV_CODEC_ID_NONE)
4026 audio = TRUE;
4027 } else if (!strcmp (mimetype, "audio/x-musepack")) {
4028 gint streamversion = -1;
4029
4030 if (gst_structure_get_int (structure, "streamversion", &streamversion)) {
4031 if (streamversion == 7)
4032 id = AV_CODEC_ID_MUSEPACK7;
4033 } else {
4034 id = AV_CODEC_ID_MUSEPACK7;
4035 }
4036 } else if (!strcmp (mimetype, "audio/x-wma")) {
4037 gint wmaversion = 0;
4038
4039 if (gst_structure_get_int (structure, "wmaversion", &wmaversion)) {
4040 switch (wmaversion) {
4041 case 1:
4042 id = AV_CODEC_ID_WMAV1;
4043 break;
4044 case 2:
4045 id = AV_CODEC_ID_WMAV2;
4046 break;
4047 case 3:
4048 id = AV_CODEC_ID_WMAPRO;
4049 break;
4050 }
4051 }
4052 if (id != AV_CODEC_ID_NONE)
4053 audio = TRUE;
4054 } else if (!strcmp (mimetype, "audio/x-wms")) {
4055 id = AV_CODEC_ID_WMAVOICE;
4056 audio = TRUE;
4057 } else if (!strcmp (mimetype, "audio/x-ac3")) {
4058 id = AV_CODEC_ID_AC3;
4059 audio = TRUE;
4060 } else if (!strcmp (mimetype, "audio/x-eac3")) {
4061 id = AV_CODEC_ID_EAC3;
4062 audio = TRUE;
4063 } else if (!strcmp (mimetype, "audio/x-vnd.sony.atrac3") ||
4064 !strcmp (mimetype, "audio/atrac3")) {
4065 id = AV_CODEC_ID_ATRAC3;
4066 audio = TRUE;
4067 } else if (!strcmp (mimetype, "audio/x-dts")) {
4068 id = AV_CODEC_ID_DTS;
4069 audio = TRUE;
4070 } else if (!strcmp (mimetype, "application/x-ape")) {
4071 id = AV_CODEC_ID_APE;
4072 audio = TRUE;
4073 } else if (!strcmp (mimetype, "video/x-msmpeg")) {
4074 gint msmpegversion = 0;
4075
4076 if (gst_structure_get_int (structure, "msmpegversion", &msmpegversion)) {
4077 switch (msmpegversion) {
4078 case 41:
4079 id = AV_CODEC_ID_MSMPEG4V1;
4080 break;
4081 case 42:
4082 id = AV_CODEC_ID_MSMPEG4V2;
4083 break;
4084 case 43:
4085 id = AV_CODEC_ID_MSMPEG4V3;
4086 break;
4087 }
4088 }
4089 if (id != AV_CODEC_ID_NONE)
4090 video = TRUE;
4091 } else if (!strcmp (mimetype, "video/x-svq")) {
4092 gint svqversion = 0;
4093
4094 if (gst_structure_get_int (structure, "svqversion", &svqversion)) {
4095 switch (svqversion) {
4096 case 1:
4097 id = AV_CODEC_ID_SVQ1;
4098 break;
4099 case 3:
4100 id = AV_CODEC_ID_SVQ3;
4101 break;
4102 }
4103 }
4104 if (id != AV_CODEC_ID_NONE)
4105 video = TRUE;
4106 } else if (!strcmp (mimetype, "video/x-huffyuv")) {
4107 id = AV_CODEC_ID_HUFFYUV;
4108 video = TRUE;
4109 } else if (!strcmp (mimetype, "audio/x-mace")) {
4110 gint maceversion = 0;
4111
4112 if (gst_structure_get_int (structure, "maceversion", &maceversion)) {
4113 switch (maceversion) {
4114 case 3:
4115 id = AV_CODEC_ID_MACE3;
4116 break;
4117 case 6:
4118 id = AV_CODEC_ID_MACE6;
4119 break;
4120 }
4121 }
4122 if (id != AV_CODEC_ID_NONE)
4123 audio = TRUE;
4124 } else if (!strcmp (mimetype, "video/x-theora")) {
4125 id = AV_CODEC_ID_THEORA;
4126 video = TRUE;
4127 } else if (!strcmp (mimetype, "video/x-vp3")) {
4128 id = AV_CODEC_ID_VP3;
4129 video = TRUE;
4130 } else if (!strcmp (mimetype, "video/x-vp5")) {
4131 id = AV_CODEC_ID_VP5;
4132 video = TRUE;
4133 } else if (!strcmp (mimetype, "video/x-vp6")) {
4134 id = AV_CODEC_ID_VP6;
4135 video = TRUE;
4136 } else if (!strcmp (mimetype, "video/x-vp6-flash")) {
4137 id = AV_CODEC_ID_VP6F;
4138 video = TRUE;
4139 } else if (!strcmp (mimetype, "video/x-vp6-alpha")) {
4140 id = AV_CODEC_ID_VP6A;
4141 video = TRUE;
4142 } else if (!strcmp (mimetype, "video/x-vp8")) {
4143 id = AV_CODEC_ID_VP8;
4144 video = TRUE;
4145 } else if (!strcmp (mimetype, "video/x-vp9")) {
4146 id = AV_CODEC_ID_VP9;
4147 video = TRUE;
4148 } else if (!strcmp (mimetype, "video/x-flash-screen")) {
4149 id = AV_CODEC_ID_FLASHSV;
4150 video = TRUE;
4151 } else if (!strcmp (mimetype, "video/x-flash-screen2")) {
4152 id = AV_CODEC_ID_FLASHSV2;
4153 video = TRUE;
4154 } else if (!strcmp (mimetype, "video/x-cineform")) {
4155 id = AV_CODEC_ID_CFHD;
4156 video = TRUE;
4157 } else if (!strcmp (mimetype, "video/x-indeo")) {
4158 gint indeoversion = 0;
4159
4160 if (gst_structure_get_int (structure, "indeoversion", &indeoversion)) {
4161 switch (indeoversion) {
4162 case 5:
4163 id = AV_CODEC_ID_INDEO5;
4164 break;
4165 case 4:
4166 id = AV_CODEC_ID_INDEO4;
4167 break;
4168 case 3:
4169 id = AV_CODEC_ID_INDEO3;
4170 break;
4171 case 2:
4172 id = AV_CODEC_ID_INDEO2;
4173 break;
4174 }
4175 if (id != AV_CODEC_ID_NONE)
4176 video = TRUE;
4177 }
4178 } else if (!strcmp (mimetype, "video/x-divx")) {
4179 gint divxversion = 0;
4180
4181 if (gst_structure_get_int (structure, "divxversion", &divxversion)) {
4182 switch (divxversion) {
4183 case 3:
4184 id = AV_CODEC_ID_MSMPEG4V3;
4185 break;
4186 case 4:
4187 case 5:
4188 id = AV_CODEC_ID_MPEG4;
4189 break;
4190 }
4191 }
4192 if (id != AV_CODEC_ID_NONE)
4193 video = TRUE;
4194 } else if (!strcmp (mimetype, "video/x-ffv")) {
4195 gint ffvversion = 0;
4196
4197 if (gst_structure_get_int (structure, "ffvversion", &ffvversion) &&
4198 ffvversion == 1) {
4199 id = AV_CODEC_ID_FFV1;
4200 video = TRUE;
4201 }
4202 } else if (!strcmp (mimetype, "video/x-apple-intermediate-codec")) {
4203 id = AV_CODEC_ID_AIC;
4204 video = TRUE;
4205 } else if (!strcmp (mimetype, "audio/x-adpcm")) {
4206 const gchar *layout;
4207
4208 layout = gst_structure_get_string (structure, "layout");
4209 if (layout == NULL) {
4210 /* break */
4211 } else if (!strcmp (layout, "quicktime")) {
4212 id = AV_CODEC_ID_ADPCM_IMA_QT;
4213 } else if (!strcmp (layout, "microsoft")) {
4214 id = AV_CODEC_ID_ADPCM_MS;
4215 } else if (!strcmp (layout, "dvi")) {
4216 id = AV_CODEC_ID_ADPCM_IMA_WAV;
4217 } else if (!strcmp (layout, "4xm")) {
4218 id = AV_CODEC_ID_ADPCM_4XM;
4219 } else if (!strcmp (layout, "smjpeg")) {
4220 id = AV_CODEC_ID_ADPCM_IMA_SMJPEG;
4221 } else if (!strcmp (layout, "dk3")) {
4222 id = AV_CODEC_ID_ADPCM_IMA_DK3;
4223 } else if (!strcmp (layout, "dk4")) {
4224 id = AV_CODEC_ID_ADPCM_IMA_DK4;
4225 } else if (!strcmp (layout, "westwood")) {
4226 id = AV_CODEC_ID_ADPCM_IMA_WS;
4227 } else if (!strcmp (layout, "iss")) {
4228 id = AV_CODEC_ID_ADPCM_IMA_ISS;
4229 } else if (!strcmp (layout, "xa")) {
4230 id = AV_CODEC_ID_ADPCM_XA;
4231 } else if (!strcmp (layout, "adx")) {
4232 id = AV_CODEC_ID_ADPCM_ADX;
4233 } else if (!strcmp (layout, "ea")) {
4234 id = AV_CODEC_ID_ADPCM_EA;
4235 } else if (!strcmp (layout, "g726")) {
4236 id = AV_CODEC_ID_ADPCM_G726;
4237 } else if (!strcmp (layout, "g721")) {
4238 id = AV_CODEC_ID_ADPCM_G726;
4239 } else if (!strcmp (layout, "ct")) {
4240 id = AV_CODEC_ID_ADPCM_CT;
4241 } else if (!strcmp (layout, "swf")) {
4242 id = AV_CODEC_ID_ADPCM_SWF;
4243 } else if (!strcmp (layout, "yamaha")) {
4244 id = AV_CODEC_ID_ADPCM_YAMAHA;
4245 } else if (!strcmp (layout, "sbpro2")) {
4246 id = AV_CODEC_ID_ADPCM_SBPRO_2;
4247 } else if (!strcmp (layout, "sbpro3")) {
4248 id = AV_CODEC_ID_ADPCM_SBPRO_3;
4249 } else if (!strcmp (layout, "sbpro4")) {
4250 id = AV_CODEC_ID_ADPCM_SBPRO_4;
4251 }
4252 if (id != AV_CODEC_ID_NONE)
4253 audio = TRUE;
4254 } else if (!strcmp (mimetype, "video/x-4xm")) {
4255 id = AV_CODEC_ID_4XM;
4256 video = TRUE;
4257 } else if (!strcmp (mimetype, "audio/x-dpcm")) {
4258 const gchar *layout;
4259
4260 layout = gst_structure_get_string (structure, "layout");
4261 if (!layout) {
4262 /* .. */
4263 } else if (!strcmp (layout, "roq")) {
4264 id = AV_CODEC_ID_ROQ_DPCM;
4265 } else if (!strcmp (layout, "interplay")) {
4266 id = AV_CODEC_ID_INTERPLAY_DPCM;
4267 } else if (!strcmp (layout, "xan")) {
4268 id = AV_CODEC_ID_XAN_DPCM;
4269 } else if (!strcmp (layout, "sol")) {
4270 id = AV_CODEC_ID_SOL_DPCM;
4271 }
4272 if (id != AV_CODEC_ID_NONE)
4273 audio = TRUE;
4274 } else if (!strcmp (mimetype, "audio/x-flac")) {
4275 id = AV_CODEC_ID_FLAC;
4276 audio = TRUE;
4277 } else if (!strcmp (mimetype, "audio/x-shorten")) {
4278 id = AV_CODEC_ID_SHORTEN;
4279 audio = TRUE;
4280 } else if (!strcmp (mimetype, "audio/x-alac")) {
4281 id = AV_CODEC_ID_ALAC;
4282 audio = TRUE;
4283 } else if (!strcmp (mimetype, "video/x-cinepak")) {
4284 id = AV_CODEC_ID_CINEPAK;
4285 video = TRUE;
4286 } else if (!strcmp (mimetype, "video/x-pn-realvideo")) {
4287 gint rmversion;
4288
4289 if (gst_structure_get_int (structure, "rmversion", &rmversion)) {
4290 switch (rmversion) {
4291 case 1:
4292 id = AV_CODEC_ID_RV10;
4293 break;
4294 case 2:
4295 id = AV_CODEC_ID_RV20;
4296 break;
4297 case 3:
4298 id = AV_CODEC_ID_RV30;
4299 break;
4300 case 4:
4301 id = AV_CODEC_ID_RV40;
4302 break;
4303 }
4304 }
4305 if (id != AV_CODEC_ID_NONE)
4306 video = TRUE;
4307 } else if (!strcmp (mimetype, "audio/x-sipro")) {
4308 id = AV_CODEC_ID_SIPR;
4309 audio = TRUE;
4310 } else if (!strcmp (mimetype, "audio/x-pn-realaudio")) {
4311 gint raversion;
4312
4313 if (gst_structure_get_int (structure, "raversion", &raversion)) {
4314 switch (raversion) {
4315 case 1:
4316 id = AV_CODEC_ID_RA_144;
4317 break;
4318 case 2:
4319 id = AV_CODEC_ID_RA_288;
4320 break;
4321 case 8:
4322 id = AV_CODEC_ID_COOK;
4323 break;
4324 }
4325 }
4326 if (id != AV_CODEC_ID_NONE)
4327 audio = TRUE;
4328 } else if (!strcmp (mimetype, "video/x-rle")) {
4329 const gchar *layout;
4330
4331 if ((layout = gst_structure_get_string (structure, "layout"))) {
4332 if (!strcmp (layout, "microsoft")) {
4333 id = AV_CODEC_ID_MSRLE;
4334 video = TRUE;
4335 }
4336 }
4337 } else if (!strcmp (mimetype, "video/x-xan")) {
4338 gint wcversion = 0;
4339
4340 if ((gst_structure_get_int (structure, "wcversion", &wcversion))) {
4341 switch (wcversion) {
4342 case 3:
4343 id = AV_CODEC_ID_XAN_WC3;
4344 video = TRUE;
4345 break;
4346 case 4:
4347 id = AV_CODEC_ID_XAN_WC4;
4348 video = TRUE;
4349 break;
4350 default:
4351 break;
4352 }
4353 }
4354 } else if (!strcmp (mimetype, "audio/AMR")) {
4355 audio = TRUE;
4356 id = AV_CODEC_ID_AMR_NB;
4357 } else if (!strcmp (mimetype, "audio/AMR-WB")) {
4358 id = AV_CODEC_ID_AMR_WB;
4359 audio = TRUE;
4360 } else if (!strcmp (mimetype, "audio/qcelp")) {
4361 id = AV_CODEC_ID_QCELP;
4362 audio = TRUE;
4363 } else if (!strcmp (mimetype, "video/x-h264")) {
4364 id = AV_CODEC_ID_H264;
4365 video = TRUE;
4366 } else if (!strcmp (mimetype, "video/x-h265")) {
4367 id = AV_CODEC_ID_HEVC;
4368 video = TRUE;
4369 } else if (!strcmp (mimetype, "video/x-flash-video")) {
4370 gint flvversion = 0;
4371
4372 if ((gst_structure_get_int (structure, "flvversion", &flvversion))) {
4373 switch (flvversion) {
4374 case 1:
4375 id = AV_CODEC_ID_FLV1;
4376 video = TRUE;
4377 break;
4378 default:
4379 break;
4380 }
4381 }
4382
4383 } else if (!strcmp (mimetype, "audio/x-nellymoser")) {
4384 id = AV_CODEC_ID_NELLYMOSER;
4385 audio = TRUE;
4386 } else if (!strncmp (mimetype, "audio/x-gst-av-", 15)) {
4387 gchar ext[16];
4388 AVCodec *codec;
4389
4390 if (strlen (mimetype) <= 30 &&
4391 sscanf (mimetype, "audio/x-gst-av-%s", ext) == 1) {
4392 if ((codec = avcodec_find_decoder_by_name (ext)) ||
4393 (codec = avcodec_find_encoder_by_name (ext))) {
4394 id = codec->id;
4395 audio = TRUE;
4396 }
4397 }
4398 } else if (!strncmp (mimetype, "video/x-gst-av-", 15)) {
4399 gchar ext[16];
4400 AVCodec *codec;
4401
4402 if (strlen (mimetype) <= 30 &&
4403 sscanf (mimetype, "video/x-gst-av-%s", ext) == 1) {
4404 if ((codec = avcodec_find_decoder_by_name (ext)) ||
4405 (codec = avcodec_find_encoder_by_name (ext))) {
4406 id = codec->id;
4407 video = TRUE;
4408 }
4409 }
4410 }
4411
4412 if (context != NULL) {
4413 if (video == TRUE) {
4414 context->codec_type = AVMEDIA_TYPE_VIDEO;
4415 } else if (audio == TRUE) {
4416 context->codec_type = AVMEDIA_TYPE_AUDIO;
4417 } else {
4418 context->codec_type = AVMEDIA_TYPE_UNKNOWN;
4419 }
4420 context->codec_id = id;
4421 gst_ffmpeg_caps_with_codecid (id, context->codec_type, caps, context);
4422 }
4423
4424 if (id != AV_CODEC_ID_NONE) {
4425 GST_DEBUG ("The id=%d belongs to the caps %" GST_PTR_FORMAT, id, caps);
4426 } else {
4427 GST_WARNING ("Couldn't figure out the id for caps %" GST_PTR_FORMAT, caps);
4428 }
4429
4430 return id;
4431 }
4432