663 lines
16 KiB
C++
663 lines
16 KiB
C++
/*
|
|
* Copyright (c) 2002, 2003, 2008 Marcus Overhagen <Marcus@Overhagen.de>
|
|
*
|
|
* Permission is hereby granted, free of charge, to any person obtaining
|
|
* a copy of this software and associated documentation files or portions
|
|
* thereof (the "Software"), to deal in the Software without restriction,
|
|
* including without limitation the rights to use, copy, modify, merge,
|
|
* publish, distribute, sublicense, and/or sell copies of the Software,
|
|
* and to permit persons to whom the Software is furnished to do so, subject
|
|
* to the following conditions:
|
|
*
|
|
* * Redistributions of source code must retain the above copyright notice,
|
|
* this list of conditions and the following disclaimer.
|
|
*
|
|
* * Redistributions in binary form must reproduce the above copyright notice
|
|
* in the binary, as well as this list of conditions and the following
|
|
* disclaimer in the documentation and/or other materials provided with
|
|
* the distribution.
|
|
*
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
|
|
* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
|
|
* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
|
* THE SOFTWARE.
|
|
*
|
|
*/
|
|
|
|
|
|
#include <MediaAddOn.h>
|
|
#include <string.h>
|
|
#include <stdlib.h>
|
|
#include <new>
|
|
#include "MediaDebug.h"
|
|
#include "DataExchange.h"
|
|
|
|
|
|
#define MAX_FLAVOR_IN_FORMAT_COUNT 300
|
|
#define MAX_FLAVOR_OUT_FORMAT_COUNT 300
|
|
|
|
#define FLATTEN_MAGIC 'CODE'
|
|
#define FLATTEN_TYPECODE 'DFIT'
|
|
|
|
|
|
static char *
|
|
_newstrdup(const char *str)
|
|
{
|
|
if (str == NULL)
|
|
return NULL;
|
|
int len = strlen(str) + 1;
|
|
char *p = new(std::nothrow) char[len];
|
|
if (p)
|
|
memcpy(p, str, len);
|
|
return p;
|
|
}
|
|
|
|
|
|
// #pragma mark - dormant_node_info
|
|
|
|
|
|
dormant_node_info::dormant_node_info()
|
|
:
|
|
addon(-1),
|
|
flavor_id(-1)
|
|
{
|
|
name[0] = '\0';
|
|
}
|
|
|
|
|
|
dormant_node_info::~dormant_node_info()
|
|
{
|
|
}
|
|
|
|
|
|
// #pragma mark - flavor_info
|
|
|
|
|
|
/* DO NOT IMPLEMENT */
|
|
/*
|
|
flavor_info &flavor_info::operator=(const flavor_info &other)
|
|
*/
|
|
|
|
|
|
// #pragma mark - dormant_flavor_info
|
|
|
|
|
|
dormant_flavor_info::dormant_flavor_info()
|
|
{
|
|
name = NULL;
|
|
info = NULL;
|
|
kinds = 0;
|
|
flavor_flags = 0;
|
|
internal_id = 0;
|
|
possible_count = 0;
|
|
in_format_count = 0;
|
|
in_format_flags = 0;
|
|
in_formats = NULL;
|
|
out_format_count = 0;
|
|
out_format_flags = 0;
|
|
out_formats = NULL;
|
|
}
|
|
|
|
|
|
dormant_flavor_info::~dormant_flavor_info()
|
|
{
|
|
delete[] name;
|
|
delete[] info;
|
|
delete[] in_formats;
|
|
delete[] out_formats;
|
|
}
|
|
|
|
|
|
dormant_flavor_info::dormant_flavor_info(const dormant_flavor_info &clone)
|
|
{
|
|
name = NULL;
|
|
info = NULL;
|
|
in_formats = NULL;
|
|
out_formats = NULL;
|
|
|
|
*this = clone;
|
|
}
|
|
|
|
|
|
dormant_flavor_info &
|
|
dormant_flavor_info::operator=(const dormant_flavor_info &clone)
|
|
{
|
|
// call operator=(const flavor_info &clone) to copy the flavor_info base class
|
|
*this = static_cast<const flavor_info>(clone);
|
|
// copy the dormant_node_info member variable
|
|
node_info = clone.node_info;
|
|
return *this;
|
|
}
|
|
|
|
|
|
dormant_flavor_info &
|
|
dormant_flavor_info::operator=(const flavor_info &clone)
|
|
{
|
|
kinds = clone.kinds;
|
|
flavor_flags = clone.flavor_flags;
|
|
internal_id = clone.internal_id;
|
|
possible_count = clone.possible_count;
|
|
|
|
delete [] info;
|
|
info = _newstrdup(clone.info);
|
|
|
|
delete [] name;
|
|
name = _newstrdup(clone.name);
|
|
|
|
delete [] in_formats;
|
|
in_formats = NULL;
|
|
in_format_count = 0;
|
|
in_format_flags = clone.in_format_flags;
|
|
if ((kinds & B_BUFFER_CONSUMER) != 0) {
|
|
if (clone.in_format_count >= 0
|
|
&& clone.in_format_count <= MAX_FLAVOR_IN_FORMAT_COUNT) {
|
|
in_formats = new(std::nothrow) media_format[clone.in_format_count];
|
|
if (in_formats != NULL && clone.in_formats != NULL) {
|
|
in_format_count = clone.in_format_count;
|
|
for (int i = 0; i < in_format_count; i++) {
|
|
const_cast<media_format &>(in_formats[i])
|
|
= clone.in_formats[i];
|
|
}
|
|
}
|
|
} else {
|
|
fprintf(stderr, "error: dormant_flavor_info::operator= clone.in_"
|
|
"format_count is invalid\n");
|
|
}
|
|
} else if (clone.in_format_count) {
|
|
fprintf(stderr, "warning: dormant_flavor_info::operator= not "
|
|
"B_BUFFER_CONSUMER and clone.in_format_count is != 0\n");
|
|
}
|
|
|
|
delete [] out_formats;
|
|
out_formats = NULL;
|
|
out_format_count = 0;
|
|
out_format_flags = clone.out_format_flags;
|
|
if (kinds & B_BUFFER_PRODUCER) {
|
|
if (clone.out_format_count >= 0
|
|
&& clone.out_format_count <= MAX_FLAVOR_OUT_FORMAT_COUNT) {
|
|
out_formats = new(std::nothrow) media_format[clone.out_format_count];
|
|
if (out_formats != NULL && clone.out_formats != NULL) {
|
|
out_format_count = clone.out_format_count;
|
|
for (int i = 0; i < out_format_count; i++) {
|
|
const_cast<media_format &>(out_formats[i])
|
|
= clone.out_formats[i];
|
|
}
|
|
}
|
|
} else {
|
|
fprintf(stderr, "error dormant_flavor_info::operator= clone.out_"
|
|
"format_count is invalid\n");
|
|
}
|
|
} else if (clone.out_format_count) {
|
|
fprintf(stderr, "warning: dormant_flavor_info::operator= not "
|
|
"B_BUFFER_PRODUCER and clone.out_format_count is != 0\n");
|
|
}
|
|
|
|
// initialize node_info with default values
|
|
dormant_node_info defaultValues;
|
|
node_info = defaultValues;
|
|
|
|
return *this;
|
|
}
|
|
|
|
|
|
void
|
|
dormant_flavor_info::set_name(const char *newName)
|
|
{
|
|
delete[] name;
|
|
name = _newstrdup(newName);
|
|
}
|
|
|
|
|
|
void
|
|
dormant_flavor_info::set_info(const char *newInfo)
|
|
{
|
|
delete[] info;
|
|
info = _newstrdup(newInfo);
|
|
}
|
|
|
|
|
|
void
|
|
dormant_flavor_info::add_in_format(const media_format &in_format)
|
|
{
|
|
media_format *p = new(std::nothrow) media_format[in_format_count + 1];
|
|
if (p) {
|
|
for (int i = 0; i < in_format_count; i++)
|
|
p[i] = in_formats[i];
|
|
p[in_format_count] = in_format;
|
|
delete [] in_formats;
|
|
in_formats = p;
|
|
in_format_count += 1;
|
|
}
|
|
}
|
|
|
|
|
|
void
|
|
dormant_flavor_info::add_out_format(const media_format &out_format)
|
|
{
|
|
media_format *p = new(std::nothrow) media_format[out_format_count + 1];
|
|
if (p) {
|
|
for (int i = 0; i < out_format_count; i++)
|
|
p[i] = out_formats[i];
|
|
p[out_format_count] = out_format;
|
|
delete [] out_formats;
|
|
out_formats = p;
|
|
out_format_count += 1;
|
|
}
|
|
}
|
|
|
|
|
|
bool
|
|
dormant_flavor_info::IsFixedSize() const
|
|
{
|
|
return false;
|
|
}
|
|
|
|
|
|
type_code
|
|
dormant_flavor_info::TypeCode() const
|
|
{
|
|
return FLATTEN_TYPECODE;
|
|
}
|
|
|
|
|
|
ssize_t
|
|
dormant_flavor_info::FlattenedSize() const
|
|
{
|
|
ssize_t size = 0;
|
|
// magic
|
|
size += sizeof(int32);
|
|
// size
|
|
size += sizeof(int32);
|
|
// struct flavor_info
|
|
size += sizeof(int32) + strlen(name);
|
|
size += sizeof(int32) + strlen(info);
|
|
size += sizeof(kinds);
|
|
size += sizeof(flavor_flags);
|
|
size += sizeof(internal_id);
|
|
size += sizeof(possible_count);
|
|
size += sizeof(in_format_count);
|
|
size += sizeof(in_format_flags);
|
|
if (in_format_count > 0 && in_format_count <= MAX_FLAVOR_IN_FORMAT_COUNT
|
|
&& in_formats != NULL)
|
|
size += in_format_count * sizeof(media_format);
|
|
size += sizeof(out_format_count);
|
|
size += sizeof(out_format_flags);
|
|
if (out_format_count > 0 && out_format_count <= MAX_FLAVOR_OUT_FORMAT_COUNT
|
|
&& out_formats != NULL)
|
|
size += out_format_count * sizeof(media_format);
|
|
// struct dormant_node_info node_info
|
|
size += sizeof(node_info);
|
|
|
|
return size;
|
|
}
|
|
|
|
|
|
status_t
|
|
dormant_flavor_info::Flatten(void *buffer, ssize_t size) const
|
|
{
|
|
if (size < FlattenedSize())
|
|
return B_ERROR;
|
|
|
|
char *buf = (char *)buffer;
|
|
int32 nameLength = name ? (int32)strlen(name) : -1;
|
|
int32 infoLength = info ? (int32)strlen(info) : -1;
|
|
int32 inFormatCount = 0;
|
|
size_t inFormatSize = 0;
|
|
int32 outFormatCount = 0;
|
|
size_t outFormatSize = 0;
|
|
|
|
if ((kinds & B_BUFFER_CONSUMER) != 0 && in_format_count > 0
|
|
&& in_formats != NULL) {
|
|
if (in_format_count <= MAX_FLAVOR_IN_FORMAT_COUNT) {
|
|
inFormatCount = in_format_count;
|
|
inFormatSize = in_format_count * sizeof(media_format);
|
|
} else {
|
|
fprintf(stderr, "error dormant_flavor_info::Flatten: "
|
|
"in_format_count is too large\n");
|
|
return B_ERROR;
|
|
}
|
|
}
|
|
|
|
if ((kinds & B_BUFFER_PRODUCER) != 0 && out_format_count > 0
|
|
&& out_formats != NULL) {
|
|
if (out_format_count <= MAX_FLAVOR_OUT_FORMAT_COUNT) {
|
|
outFormatCount = out_format_count;
|
|
outFormatSize = out_format_count * sizeof(media_format);
|
|
} else {
|
|
fprintf(stderr, "error dormant_flavor_info::Flatten: "
|
|
"out_format_count is too large\n");
|
|
return B_ERROR;
|
|
}
|
|
}
|
|
|
|
// magic
|
|
*(int32*)buf = FLATTEN_MAGIC; buf += sizeof(int32);
|
|
|
|
// size
|
|
*(int32*)buf = FlattenedSize(); buf += sizeof(int32);
|
|
|
|
// struct flavor_info
|
|
*(int32*)buf = nameLength; buf += sizeof(int32);
|
|
if (nameLength > 0) {
|
|
memcpy(buf, name, nameLength);
|
|
buf += nameLength;
|
|
}
|
|
*(int32*)buf = infoLength; buf += sizeof(int32);
|
|
if (infoLength > 0) {
|
|
memcpy(buf, info, infoLength);
|
|
buf += infoLength;
|
|
}
|
|
|
|
*(uint64*)buf = kinds; buf += sizeof(uint64);
|
|
*(uint32*)buf = flavor_flags; buf += sizeof(uint32);
|
|
*(int32*)buf = internal_id; buf += sizeof(int32);
|
|
*(int32*)buf = possible_count; buf += sizeof(int32);
|
|
*(int32*)buf = inFormatCount; buf += sizeof(int32);
|
|
*(uint32*)buf = in_format_flags; buf += sizeof(uint32);
|
|
|
|
// XXX FIXME! we should not!!! make flat copies of media_format
|
|
memcpy(buf, in_formats, inFormatSize); buf += inFormatSize;
|
|
|
|
*(int32*)buf = outFormatCount; buf += sizeof(int32);
|
|
*(uint32*)buf = out_format_flags; buf += sizeof(uint32);
|
|
|
|
// XXX FIXME! we should not!!! make flat copies of media_format
|
|
memcpy(buf, out_formats, outFormatSize); buf += outFormatSize;
|
|
|
|
*(dormant_node_info*)buf = node_info; buf += sizeof(dormant_node_info);
|
|
|
|
return B_OK;
|
|
}
|
|
|
|
|
|
status_t
|
|
dormant_flavor_info::Unflatten(type_code c, const void *buffer, ssize_t size)
|
|
{
|
|
if (c != FLATTEN_TYPECODE)
|
|
return B_ERROR;
|
|
if (size < 8)
|
|
return B_ERROR;
|
|
|
|
const char *buf = (const char *)buffer;
|
|
int32 nameLength;
|
|
int32 infoLength;
|
|
|
|
// check magic
|
|
if (*(int32*)buf != FLATTEN_MAGIC)
|
|
return B_ERROR;
|
|
buf += sizeof(int32);
|
|
|
|
// check size
|
|
if (*(uint32*)buf > (uint32)size)
|
|
return B_ERROR;
|
|
buf += sizeof(int32);
|
|
|
|
delete[] name;
|
|
name = NULL;
|
|
delete[] info;
|
|
info = NULL;
|
|
delete[] in_formats;
|
|
in_formats = NULL;
|
|
in_format_count = 0;
|
|
delete[] out_formats;
|
|
out_formats = NULL;
|
|
out_format_count = 0;
|
|
|
|
// struct flavor_info
|
|
nameLength = *(int32*)buf; buf += sizeof(int32);
|
|
if (nameLength >= 0) { // if nameLength is -1, we leave name = 0
|
|
char* nameStorage = new(std::nothrow) char [nameLength + 1];
|
|
name = nameStorage;
|
|
if (nameStorage) {
|
|
memcpy(nameStorage, buf, nameLength);
|
|
nameStorage[nameLength] = 0;
|
|
buf += nameLength; // XXX not save
|
|
}
|
|
}
|
|
|
|
infoLength = *(int32*)buf; buf += sizeof(int32);
|
|
if (infoLength >= 0) { // if infoLength is -1, we leave info = 0
|
|
char* infoStorage = new(std::nothrow) char [infoLength + 1];
|
|
info = infoStorage;
|
|
if (infoStorage) {
|
|
memcpy(infoStorage, buf, infoLength);
|
|
infoStorage[infoLength] = 0;
|
|
buf += infoLength; // XXX not save
|
|
}
|
|
}
|
|
|
|
int32 count;
|
|
|
|
kinds = *(uint64*)buf; buf += sizeof(uint64);
|
|
flavor_flags = *(uint32*)buf; buf += sizeof(uint32);
|
|
internal_id = *(int32*)buf; buf += sizeof(int32);
|
|
possible_count = *(int32*)buf; buf += sizeof(int32);
|
|
count = *(int32*)buf; buf += sizeof(int32);
|
|
in_format_flags = *(uint32*)buf; buf += sizeof(uint32);
|
|
|
|
if (count > 0) {
|
|
if (count <= MAX_FLAVOR_IN_FORMAT_COUNT) {
|
|
in_formats = new(std::nothrow) media_format[count];
|
|
if (!in_formats)
|
|
return B_NO_MEMORY;
|
|
// TODO: we should not!!! make flat copies of media_format
|
|
for (int32 i = 0; i < count; i++) {
|
|
const_cast<media_format*>
|
|
(&in_formats[i])->Unflatten(buf);
|
|
buf += sizeof(media_format); // TODO: not save
|
|
}
|
|
in_format_count = count;
|
|
}
|
|
}
|
|
|
|
count = *(int32*)buf; buf += sizeof(int32);
|
|
out_format_flags = *(uint32*)buf; buf += sizeof(uint32);
|
|
|
|
if (count > 0) {
|
|
if (count <= MAX_FLAVOR_OUT_FORMAT_COUNT) {
|
|
out_formats = new(std::nothrow) media_format[count];
|
|
if (!out_formats)
|
|
return B_NO_MEMORY;
|
|
// TODO: we should not!!! make flat copies of media_format
|
|
for (int32 i = 0; i < count; i++) {
|
|
const_cast<media_format*>
|
|
(&out_formats[i])->Unflatten(buf);
|
|
buf += sizeof(media_format); // TODO: not save
|
|
}
|
|
out_format_count = count;
|
|
}
|
|
}
|
|
|
|
node_info = *(dormant_node_info*)buf; buf += sizeof(dormant_node_info);
|
|
|
|
return B_OK;
|
|
}
|
|
|
|
|
|
// #pragma mark - BMediaAddOn
|
|
|
|
|
|
BMediaAddOn::BMediaAddOn(image_id image)
|
|
:
|
|
fImage(image),
|
|
fAddon(0)
|
|
{
|
|
CALLED();
|
|
}
|
|
|
|
|
|
BMediaAddOn::~BMediaAddOn()
|
|
{
|
|
CALLED();
|
|
}
|
|
|
|
|
|
status_t
|
|
BMediaAddOn::InitCheck(const char **_failureText)
|
|
{
|
|
CALLED();
|
|
// only to be implemented by derived classes
|
|
*_failureText = "no error";
|
|
return B_OK;
|
|
}
|
|
|
|
|
|
int32
|
|
BMediaAddOn::CountFlavors()
|
|
{
|
|
CALLED();
|
|
// only to be implemented by derived classes
|
|
return 0;
|
|
}
|
|
|
|
|
|
status_t
|
|
BMediaAddOn::GetFlavorAt(int32 n, const flavor_info **_info)
|
|
{
|
|
CALLED();
|
|
// only to be implemented by derived classes
|
|
return B_ERROR;
|
|
}
|
|
|
|
|
|
BMediaNode*
|
|
BMediaAddOn::InstantiateNodeFor(const flavor_info *info, BMessage *config,
|
|
status_t *_error)
|
|
{
|
|
CALLED();
|
|
// only to be implemented by derived classes
|
|
return NULL;
|
|
}
|
|
|
|
|
|
status_t
|
|
BMediaAddOn::GetConfigurationFor(BMediaNode *node, BMessage *toMessage)
|
|
{
|
|
CALLED();
|
|
// only to be implemented by derived classes
|
|
return B_ERROR;
|
|
}
|
|
|
|
|
|
bool
|
|
BMediaAddOn::WantsAutoStart()
|
|
{
|
|
CALLED();
|
|
// only to be implemented by derived classes
|
|
return false;
|
|
}
|
|
|
|
|
|
status_t
|
|
BMediaAddOn::AutoStart(int count, BMediaNode **_node, int32 *_internalID,
|
|
bool *_hasMore)
|
|
{
|
|
CALLED();
|
|
// only to be implemented by derived classes
|
|
return B_ERROR;
|
|
}
|
|
|
|
|
|
status_t
|
|
BMediaAddOn::SniffRef(const entry_ref &file, BMimeType *mimeType,
|
|
float *_quality, int32 *_internalID)
|
|
{
|
|
CALLED();
|
|
// only to be implemented by BFileInterface derived classes
|
|
return B_ERROR;
|
|
}
|
|
|
|
|
|
status_t
|
|
BMediaAddOn::SniffType(const BMimeType &type, float *_quality,
|
|
int32 *_internalID)
|
|
{
|
|
CALLED();
|
|
// only to be implemented by BFileInterface derived classes
|
|
return B_ERROR;
|
|
}
|
|
|
|
|
|
status_t
|
|
BMediaAddOn::GetFileFormatList(int32 flavorID,
|
|
media_file_format *writableFormats, int32 maxWriteItems, int32 *_writeItems,
|
|
media_file_format *readableFormats, int32 maxReadItems, int32 *_readItems,
|
|
void *_reserved)
|
|
{
|
|
CALLED();
|
|
// only to be implemented by BFileInterface derived classes
|
|
return B_ERROR;
|
|
}
|
|
|
|
|
|
status_t
|
|
BMediaAddOn::SniffTypeKind(const BMimeType &type, uint64 kinds, float *_quality,
|
|
int32 *_internalID, void *_reserved)
|
|
{
|
|
CALLED();
|
|
// only to be implemented by BFileInterface derived classes
|
|
return B_ERROR;
|
|
}
|
|
|
|
|
|
image_id
|
|
BMediaAddOn::ImageID()
|
|
{
|
|
return fImage;
|
|
}
|
|
|
|
|
|
media_addon_id
|
|
BMediaAddOn::AddonID()
|
|
{
|
|
return fAddon;
|
|
}
|
|
|
|
|
|
// #pragma mark - protected BMediaAddOn
|
|
|
|
|
|
status_t
|
|
BMediaAddOn::NotifyFlavorChange()
|
|
{
|
|
CALLED();
|
|
if (fAddon == 0)
|
|
return B_ERROR;
|
|
|
|
add_on_server_rescan_flavors_command command;
|
|
command.add_on_id = fAddon;
|
|
return SendToAddOnServer(ADD_ON_SERVER_RESCAN_ADD_ON_FLAVORS, &command,
|
|
sizeof(command));
|
|
}
|
|
|
|
|
|
// #pragma mark - private BMediaAddOn
|
|
|
|
|
|
/*
|
|
unimplemented:
|
|
BMediaAddOn::BMediaAddOn()
|
|
BMediaAddOn::BMediaAddOn(const BMediaAddOn &clone)
|
|
BMediaAddOn & BMediaAddOn::operator=(const BMediaAddOn &clone)
|
|
*/
|
|
|
|
|
|
extern "C" {
|
|
// declared here to remove them from the class header file
|
|
status_t _Reserved_MediaAddOn_0__11BMediaAddOnPv(void *, void *); /* now used for BMediaAddOn::GetFileFormatList */
|
|
status_t _Reserved_MediaAddOn_1__11BMediaAddOnPv(void *, void *); /* now used for BMediaAddOn::SniffTypeKind */
|
|
status_t _Reserved_MediaAddOn_0__11BMediaAddOnPv(void *, void *) { return B_ERROR; }
|
|
status_t _Reserved_MediaAddOn_1__11BMediaAddOnPv(void *, void *) { return B_ERROR; }
|
|
};
|
|
|
|
status_t BMediaAddOn::_Reserved_MediaAddOn_2(void *) { return B_ERROR; }
|
|
status_t BMediaAddOn::_Reserved_MediaAddOn_3(void *) { return B_ERROR; }
|
|
status_t BMediaAddOn::_Reserved_MediaAddOn_4(void *) { return B_ERROR; }
|
|
status_t BMediaAddOn::_Reserved_MediaAddOn_5(void *) { return B_ERROR; }
|
|
status_t BMediaAddOn::_Reserved_MediaAddOn_6(void *) { return B_ERROR; }
|
|
status_t BMediaAddOn::_Reserved_MediaAddOn_7(void *) { return B_ERROR; }
|
|
|