void register_encoder()
{
status_t err;
media_format tempFormat, mediaFormat;
media_format_description formatDescription;
BMediaFormats formatObject;
formatObject.Lock();
/* register as a WAV codec */
memset(&mediaFormat, 0, sizeof(media_format));
mediaFormat.type = B_MEDIA_ENCODED_AUDIO;
mediaFormat.u.encoded_audio = media_encoded_audio_format::wildcard;
memset(&formatDescription, 0, sizeof(media_format_description));
formatDescription.family = B_WAV_FORMAT_FAMILY;
formatDescription.u.wav.codec = WAVE_FORMAT_MPEG;
err = formatObject.MakeFormatFor(formatDescription, mediaFormat, &tempFormat);
if (err == B_MEDIA_DUPLICATE_FORMAT)
formatObject.GetFormatFor(formatDescription, &tempFormat);
s_wavFormat = tempFormat;
/* register as a MPEG codec */
memset(&mediaFormat, 0, sizeof(media_format));
mediaFormat.type = B_MEDIA_ENCODED_AUDIO;
mediaFormat.u.encoded_audio = media_encoded_audio_format::wildcard;
memset(&formatDescription, 0, sizeof(media_format_description));
formatDescription.family = B_MPEG_FORMAT_FAMILY;
formatDescription.u.mpeg.id = B_MPEG_1_AUDIO_LAYER_3;
err = formatObject.MakeFormatFor(formatDescription, mediaFormat, &tempFormat);
if (err == B_MEDIA_DUPLICATE_FORMAT)
formatObject.GetFormatFor(formatDescription, &tempFormat);
s_mpegFormat = tempFormat;
formatObject.Unlock();
}
status_t
RawDecoderPlugin::GetSupportedFormats(media_format ** formats, size_t * count)
{
BMediaFormats mediaFormats;
media_format_description description;
media_format format;
// audio decoder
description.family = B_BEOS_FORMAT_FAMILY;
description.u.beos.format = B_BEOS_FORMAT_RAW_AUDIO;
format.type = B_MEDIA_RAW_AUDIO;
format.u.raw_audio = media_multi_audio_format::wildcard;
status_t status = mediaFormats.MakeFormatFor(&description, 1, &format);
if (status < B_OK)
return status;
raw_formats[0] = format;
// video decoder
description.u.beos.format = B_BEOS_FORMAT_RAW_VIDEO;
format.type = B_MEDIA_RAW_VIDEO;
format.u.raw_video = media_raw_video_format::wildcard;
status = mediaFormats.MakeFormatFor(&description, 1, &format);
if (status < B_OK)
return status;
raw_formats[1] = format;
*formats = raw_formats;
*count = 2;
return B_OK;
}
status_t OpenSoundDevice::register_media_formats()
{
status_t err;
int i, count;
BMediaFormats formats;
if (formats.InitCheck() < B_OK)
return formats.InitCheck();
media_format format;
for (i = 0; gSupportedFormats[i]; i++) {
media_format_description desc[10];
err = count = get_media_format_description_for(gSupportedFormats[i], desc, 10);
if (err < 1)
continue;
if (gSupportedFormats[i] & AFMT_SUPPORTED_PCM) {
format.type = B_MEDIA_RAW_AUDIO;
format.u.raw_audio = media_multi_audio_format::wildcard;
} else {
format.type = B_MEDIA_ENCODED_AUDIO;
format.u.encoded_audio = media_encoded_audio_format::wildcard;
}
err = formats.MakeFormatFor(desc, count, &format);
PRINT(("OpenSoundDevice::register_media_formats: MakeFormatFor: %s\n", strerror(err)));
}
return B_OK;
};
status_t
MusePackPlugin::GetSupportedFormats(media_format ** formats, size_t * count)
{
media_format_description description;
description.family = B_MISC_FORMAT_FAMILY;
description.u.misc.file_format = 'mpc ';
description.u.misc.codec = 'MPC7';
// 7 is the most recent stream version
media_format format;
format.type = B_MEDIA_ENCODED_AUDIO;
format.u.encoded_audio = media_encoded_audio_format::wildcard;
BMediaFormats mediaFormats;
status_t result = mediaFormats.InitCheck();
if (result != B_OK) {
return result;
}
result = mediaFormats.MakeFormatFor(&description, 1, &format);
if (result != B_OK) {
return result;
}
muse_pack_formats[0] = format;
*formats = muse_pack_formats;
*count = 1;
return B_OK;
}
status_t
mp3DecoderPlugin::GetSupportedFormats(media_format ** formats, size_t * count)
{
const mpeg_id ids[] = {
B_MPEG_1_AUDIO_LAYER_1,
B_MPEG_1_AUDIO_LAYER_2,
B_MPEG_1_AUDIO_LAYER_3, // "MP3"
B_MPEG_2_AUDIO_LAYER_1,
B_MPEG_2_AUDIO_LAYER_2,
B_MPEG_2_AUDIO_LAYER_3,
B_MPEG_2_5_AUDIO_LAYER_1,
B_MPEG_2_5_AUDIO_LAYER_2,
B_MPEG_2_5_AUDIO_LAYER_3,
};
const size_t otherIDs = 6;
const size_t numIDs = otherIDs + sizeof(ids) / sizeof(mpeg_id);
media_format_description descriptions[numIDs];
descriptions[0].family = B_WAV_FORMAT_FAMILY;
descriptions[0].u.wav.codec = 0x0050;
descriptions[1].family = B_WAV_FORMAT_FAMILY;
descriptions[1].u.wav.codec = 0x0055;
descriptions[2].family = B_QUICKTIME_FORMAT_FAMILY;
descriptions[2].u.quicktime.codec = '.mp3';
descriptions[3].family = B_QUICKTIME_FORMAT_FAMILY;
descriptions[3].u.quicktime.codec = '3pm.';
descriptions[4].family = B_AVI_FORMAT_FAMILY;
descriptions[4].u.avi.codec = '.mp3';
descriptions[5].family = B_AVI_FORMAT_FAMILY;
descriptions[5].u.avi.codec = '3pm.';
for (size_t i = otherIDs; i < numIDs; i++) {
descriptions[i].family = B_MPEG_FORMAT_FAMILY;
descriptions[i].u.mpeg.id = ids[i-otherIDs];
}
media_format format;
format.type = B_MEDIA_ENCODED_AUDIO;
format.u.encoded_audio = media_encoded_audio_format::wildcard;
format.u.encoded_audio.output.format = media_raw_audio_format::B_AUDIO_SHORT;
format.u.encoded_audio.output.byte_order = B_MEDIA_HOST_ENDIAN;
BMediaFormats mediaFormats;
status_t result = mediaFormats.InitCheck();
if (result != B_OK) {
return result;
}
result = mediaFormats.MakeFormatFor(descriptions, numIDs, &format);
if (result != B_OK) {
return result;
}
mp3_formats[0] = format;
*formats = mp3_formats;
*count = 1;
return result;
}
status_t
build_decoder_formats(media_format** _formats, size_t* _count)
{
BMediaFormats mediaFormats;
if (mediaFormats.InitCheck() != B_OK)
return B_ERROR;
int32 index = 0;
AVCodec* codec = NULL;
while ((codec = av_codec_next(codec)) != NULL) {
if (index >= sMaxFormatCount) {
fprintf(stderr, "Maximum format count reached for auto-generated "
"AVCodec to media_format mapping, but there are still more "
"AVCodecs compiled into libavcodec!\n");
break;
}
media_format format;
// Determine media type
switch (codec->type) {
case AVMEDIA_TYPE_VIDEO:
format.type = B_MEDIA_ENCODED_VIDEO;
break;
case AVMEDIA_TYPE_AUDIO:
format.type = B_MEDIA_ENCODED_AUDIO;
break;
default:
// ignore this AVCodec
continue;
}
media_format_description description;
memset(&description, 0, sizeof(description));
// Hard-code everything to B_MISC_FORMAT_FAMILY to ease matching
// later on.
description.family = B_MISC_FORMAT_FAMILY;
description.u.misc.file_format = 'ffmp';
description.u.misc.codec = codec->id;
format.require_flags = 0;
format.deny_flags = B_MEDIA_MAUI_UNDEFINED_FLAGS;
if (mediaFormats.MakeFormatFor(&description, 1, &format) != B_OK)
return B_ERROR;
gAVCodecFormats[index] = format;
index++;
}
*_formats = gAVCodecFormats;
*_count = index;
return B_OK;
}
status_t
XvidPlugin::GetSupportedFormats(media_format** _mediaFormatArray, size_t *_count)
{
PRINT(("XvidDecoder::register_decoder()\n"));
static bool codecsRegistered = false;
if (codecsRegistered)
return B_OK;
codecsRegistered = true;
PRINT(("XvidDecoder: registering %d codecs\n", gSupportedCodecsCount));
media_format_description descr[gSupportedCodecsCount];
for (int i = 0; i < gSupportedCodecsCount; i++) {
descr[i].family = gCodecTable[i].family;
switch(descr[i].family) {
case B_AVI_FORMAT_FAMILY:
descr[i].u.avi.codec = gCodecTable[i].fourcc;
break;
case B_MPEG_FORMAT_FAMILY:
descr[i].u.mpeg.id = gCodecTable[i].fourcc;
break;
case B_QUICKTIME_FORMAT_FAMILY:
descr[i].u.quicktime.codec = gCodecTable[i].fourcc;
break;
default:
break;
}
}
BMediaFormats formats;
for (int i = 0; i < gSupportedCodecsCount; i++) {
media_format format;
format.type = B_MEDIA_ENCODED_VIDEO;
format.u.encoded_video = media_encoded_video_format::wildcard;
format.require_flags = 0;
format.deny_flags = B_MEDIA_MAUI_UNDEFINED_FLAGS;
status_t err = formats.MakeFormatFor(&descr[i], 1, &format);
if (err < B_OK) {
fprintf(stderr, "XvidDecoder: BMediaFormats::MakeFormatFor: "
"error %s\n", strerror(err));
continue;
}
gXvidFormats[i] = format;
}
*_mediaFormatArray = gXvidFormats;
*_count = gSupportedCodecsCount;
return B_OK;
}
status_t
register_avcodec_tags(media_format_family family, const char *avname, int &index)
{
AVInputFormat *inputFormat = av_find_input_format(avname);
if (inputFormat == NULL)
return B_MEDIA_NO_HANDLER;
BMediaFormats mediaFormats;
if (mediaFormats.InitCheck() != B_OK)
return B_ERROR;
for (int tagSet = 0; inputFormat->codec_tag[tagSet]; tagSet++) {
const AVCodecTag *tags = inputFormat->codec_tag[tagSet];
if (tags == NULL)
continue;
for (; tags->id != CODEC_ID_NONE; tags++) {
// XXX: we might want to keep some strange PCM codecs too...
// skip unwanted codec tags
if (tags->tag == CODEC_ID_RAWVIDEO
|| (tags->tag >= CODEC_ID_PCM_S16LE
&& tags->tag < CODEC_ID_ADPCM_IMA_QT)
|| tags->tag >= CODEC_ID_DVD_SUBTITLE)
continue;
if (index >= sMaxFormatCount) {
fprintf(stderr, "Maximum format count reached for auto-generated "
"AVCodec to media_format mapping, but there are still more "
"AVCodecs compiled into libavcodec!\n");
break;
}
media_format format;
// Determine media type
if (tags->tag < CODEC_ID_PCM_S16LE)
format.type = B_MEDIA_ENCODED_VIDEO;
else
format.type = B_MEDIA_ENCODED_AUDIO;
media_format_description description;
memset(&description, 0, sizeof(description));
// Hard-code everything to B_MISC_FORMAT_FAMILY to ease matching
// later on.
description.family = family;
switch (family) {
case B_AIFF_FORMAT_FAMILY:
description.u.aiff.codec = tags->tag;
break;
case B_AVI_FORMAT_FAMILY:
description.u.avi.codec = tags->tag;
break;
case B_MPEG_FORMAT_FAMILY:
description.u.mpeg.id = tags->tag;
break;
case B_QUICKTIME_FORMAT_FAMILY:
description.u.quicktime.codec = tags->tag;
break;
case B_WAV_FORMAT_FAMILY:
description.u.wav.codec = tags->tag;
break;
default:
break;
}
format.require_flags = 0;
format.deny_flags = B_MEDIA_MAUI_UNDEFINED_FLAGS;
if (mediaFormats.MakeFormatFor(&description, 1, &format) != B_OK)
return B_ERROR;
gAVCodecFormats[index] = format;
index++;
}
}
return B_OK;
}
