sbIDeviceCapabilities.idl

Go to the documentation of this file.

/*
 *=BEGIN SONGBIRD GPL
 *
 * This file is part of the Songbird web player.
 *
 * Copyright(c) 2005-2010 POTI, Inc.
 * http://www.songbirdnest.com
 *
 * This file may be licensed under the terms of of the
 * GNU General Public License Version 2 (the ``GPL'').
 *
 * Software distributed under the License is distributed
 * on an ``AS IS'' basis, WITHOUT WARRANTY OF ANY KIND, either
 * express or implied. See the GPL for the specific language
 * governing rights and limitations.
 *
 * You should have received a copy of the GPL along with this
 * program. If not, go to http://www.gnu.org/licenses/gpl.html
 * or write to the Free Software Foundation, Inc.,
 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
 *
 *=END SONGBIRD GPL
 */

#include "nsISupports.idl"

interface nsIArray;
interface sbIDevice;
interface nsIVariant;
interface nsIStringEnumerator;

[scriptable, uuid(3d8c5686-26b7-47a9-a18d-2254b77a6c9a)]
interface sbIImageSize : nsISupports
{
  void Initialize(in long width, in long height);
  
  /* \brief The supported width */
  readonly attribute long width;

  /* \brief The supported height */
  readonly attribute long height;
};

%{C++
#define SB_IMAGESIZE_DESCRIPTION             \
  "Songbird Device Capabilities Image Size Component"
#define SB_IMAGESIZE_CONTRACTID              \
  "@songbirdnest.com/Songbird/Device/sbimagesize;1"
#define SB_IMAGESIZE_CLASSNAME               \
  "Songbird Device Capabilities Image Size"
#define SB_IMAGESIZE_CID                     \
{ 0xf2915d0, 0xf43, 0x46fd, { 0x90, 0xbd, 0x84, 0x22, 0x48, 0x43, 0xb, 0xf } }
%}

[scriptable, uuid(8A62D336-9489-46f3-BB16-AED90DA7F775)]
interface sbIDevCapRange : nsISupports
{
  void Initialize(in long aMin,
                  in long aMax,
                  in long aStep);
  long GetValue(in unsigned long aIndex);
  
  void AddValue(in long aValue);
  readonly attribute unsigned long valueCount;

  /* \brief The minimum supported value */
  readonly attribute long min;

  /* \brief The maximum supported value */
  readonly attribute long max;

  /* \brief If non-zero, the range is not continuous, but instead only
     increments of 'step' are permitted */
  readonly attribute long step;
  
  /* \brief Determine whether the value is in range. The range could be
   *        discrete values, or value array.
   * \returns true if the value is in range.
   */
  boolean IsValueInRange(in long aValue);
};

%{C++
#define SB_IDEVCAPRANGE_DESCRIPTION             \
  "Songbird Device Capabilities Range Component"
#define SB_IDEVCAPRANGE_CONTRACTID              \
  "@songbirdnest.com/Songbird/Device/sbrange;1"
#define SB_IDEVCAPRANGE_CLASSNAME               \
  "Songbird Device Capabilities Range"
#define SB_IDEVCAPRANGE_CID                     \
{ 0x491604ba, 0x51e1, 0x45e4, { 0x9d, 0x11, 0xce, 0x1e, 0xc6, 0x3d, 0xe, 0xae } }
%}

[scriptable, uuid(0168409c-1dd2-11b2-a064-b25ec073dc48)]
interface sbIDevCapFraction : nsISupports
{
  readonly attribute unsigned long numerator;
  readonly attribute unsigned long denominator;

  void initialize(in unsigned long aNumerator,
                  in unsigned long aDenominator);
};

%{C++
#define SB_IDEVCAPFRACTION_DESCRIPTION             \
  "Songbird Device Capabilities Fraction Component"
#define SB_IDEVCAPFRACTION_CONTRACTID              \
  "@songbirdnest.com/Songbird/Device/sbfraction;1"
#define SB_IDEVCAPFRACTION_CLASSNAME               \
  "Songbird Device Capabilities Fraction"
#define SB_IDEVCAPFRACTION_CID                     \
{0xb8b158a2, 0x1dd1, 0x11b2, {0x9f, 0x1d, 0xb9, 0x56, 0x08, 0x79, 0x0a, 0xb8}}
%}

[scriptable, uuid(eb46c4ab-1842-4e0b-ba69-e60b3dd9c792)]
interface sbIFormatTypeConstraint : nsISupports
{
  void Initialize(in AString aConstraintName,
                  in nsIVariant aMinValue,
                  in nsIVariant aMaxValue);
                  
  readonly attribute AString constraintName;

  readonly attribute nsIVariant constraintMinValue;

  readonly attribute nsIVariant constraintMaxValue;
};

%{C++
#define SB_IFORMATTYPECONSTRAINT_DESCRIPTION             \
  "Songbird Device Capabilities Format Type Constraint Component"
#define SB_IFORMATTYPECONSTRAINT_CONTRACTID              \
  "@songbirdnest.com/Songbird/Device/sbformattypeconstraint;1"
#define SB_IFORMATTYPECONSTRAINT_CLASSNAME               \
  "Songbird Device Capabilities Format Type Constraint"
#define SB_IFORMATTYPECONSTRAINT_CID                     \
{ 0x5d73ba28, 0xf460, 0x48bd, { 0x92, 0x3b, 0x68, 0xd4, 0xa8, 0x8e, 0x92, 0xda } }
%}

[scriptable, uuid(3dac965e-be7b-4792-ba4d-2af3f683caad)]
interface sbIImageFormatType : nsISupports
{
  void Initialize(in ACString aImageFormat, 
                  in nsIArray aSupportedExplicitSizes,
                  in sbIDevCapRange aSupportedWidths,
                  in sbIDevCapRange aSupportedHeights);
  readonly attribute ACString imageFormat;

  /* Array of supported sizes. Each item in the array is an sbIImageSize giving
     an explicit width and height.

     The array MUST NOT be empty; if arbitrary dimensions are supported then
     this array should contain a single 'recommended' size
   */
  readonly attribute nsIArray supportedExplicitSizes;

  /* Range of supported widths.

     May be null, in which case only the explicit sizes are permitted.
   */
  readonly attribute sbIDevCapRange supportedWidths;

  /* Range of supported heights.

     May be null, in which case only the explicit sizes are permitted.
   */
  readonly attribute sbIDevCapRange supportedHeights;
};

%{C++
#define SB_IIMAGEFORMATTYPE_DESCRIPTION             \
  "Songbird Device Capabilities Image Format Type Component"
#define SB_IIMAGEFORMATTYPE_CONTRACTID              \
  "@songbirdnest.com/Songbird/Device/sbimageformattype;1"
#define SB_IIMAGEFORMATTYPE_CLASSNAME               \
  "Songbird Device Capabilities Image Format Type"
#define SB_IIMAGEFORMATTYPE_CID                     \
{ 0x496881cb, 0xed03, 0x435f, { 0x9d, 0xa5, 0xdf, 0x99, 0x63, 0x6f, 0x9e, 0xe3 } }
%}

[scriptable, uuid(5ec50372-7137-4671-8e75-e8f8dc237dd7)]
interface sbIAudioFormatType : nsISupports
{
  void Initialize(in ACString aFormat,
                  in ACString aCodec,
                  in sbIDevCapRange aBitRates,
                  in sbIDevCapRange aSampleRates,
                  in sbIDevCapRange aChannels,
                  in nsIArray aFormatSpecificConstraints);
  /* Mime type of the container format.
   *
   * May be empty if there is no container format (e.g. a raw FLAC bitstream)
   */
  readonly attribute ACString containerFormat;

  /* Mime type of the audio codec in use.
   */
  readonly attribute ACString audioCodec;

  /* The supported bitrates.
   */
  readonly attribute sbIDevCapRange supportedBitrates;

  /* The supported sample rates.
   */
  readonly attribute sbIDevCapRange supportedSampleRates;

  /* The supported numbers of channels
   */
  readonly attribute sbIDevCapRange supportedChannels;

  /* An array of sbIFormatTypeConstraint specific to this content type.
   *
   * For example, if audioCodec is audio/aac, this might have a constraint 
   *   profile=LC
   * to indicate that only the low complexity profile is supported (as is the
   * case for ipods, for example).
   */
  readonly attribute nsIArray formatSpecificConstraints;
};

%{C++
#define SB_IAUDIOFORMATTYPE_DESCRIPTION             \
  "Songbird Device Capabilities Audio Format Type Component"
#define SB_IAUDIOFORMATTYPE_CONTRACTID              \
  "@songbirdnest.com/Songbird/Device/sbaudioformattype;1"
#define SB_IAUDIOFORMATTYPE_CLASSNAME               \
  "Songbird Device Capabilities Audio Format Type"
#define SB_IAUDIOFORMATTYPE_CID                     \
{ 0xfbfadb32, 0xb95b, 0x49cb, { 0xb5, 0xf0, 0x8, 0xf9, 0xa8, 0x70, 0x57, 0xe5 } }
%}

[scriptable, uuid(7062120d-eb8b-469c-9606-bbe86502735c)]
interface sbIDevCapVideoStream : nsISupports
{
  void initialize(in ACString aType,
                  in nsIArray aExplicitSizes,
                  in sbIDevCapRange aWidths,
                  in sbIDevCapRange aHeights,
                  in nsIArray aSupportedPARs,
                  in boolean aSupportedPARsIsRange,
                  in nsIArray aSupportedFrameRates,
                  in boolean aSupportedFrameRatesIsRange,
                  in sbIDevCapRange aBitRates);
  
  readonly attribute ACString type;
  
  readonly attribute nsIArray supportedExplicitSizes;

  readonly attribute sbIDevCapRange supportedWidths;

  readonly attribute sbIDevCapRange supportedHeights;

  readonly attribute boolean doesSupportPARRange;

  readonly attribute nsIArray supportedPARs;

  readonly attribute sbIDevCapFraction minimumSupportedPAR;
  readonly attribute sbIDevCapFraction maximumSupportedPAR;

  readonly attribute boolean doesSupportFrameRateRange;

  readonly attribute nsIArray supportedFrameRates;

  readonly attribute sbIDevCapFraction minimumSupportedFrameRate;
  readonly attribute sbIDevCapFraction maximumSupportedFrameRate;

  readonly attribute sbIDevCapRange supportedBitRates;
};

%{C++
#define SB_IDEVCAPVIDEOSTREAM_DESCRIPTION             \
  "Songbird Device Capabilities Video Stream Component"
#define SB_IDEVCAPVIDEOSTREAM_CONTRACTID              \
  "@songbirdnest.com/Songbird/Device/sbdevcapvideostream;1"
#define SB_IDEVCAPVIDEOSTREAM_CLASSNAME               \
  "Songbird Device Capabilities Video Stream"
#define SB_IDEVCAPVIDEOSTREAM_CID                     \
  {0x1eb66418, 0x11bd, 0x493c, {0x93, 0x29, 0x29, 0x0d, 0x0e, 0x4f, 0xb7, 0x8a}}
%}

[scriptable, uuid(5651ca06-284a-457f-8dd8-9e60da4471f0)]
interface sbIDevCapAudioStream : nsISupports
{
  void initialize(in ACString aType,
                  in sbIDevCapRange aBitRates,
                  in sbIDevCapRange aSampleRates,
                  in sbIDevCapRange aChannels); 
  readonly attribute ACString type;

  readonly attribute sbIDevCapRange supportedBitRates;

  readonly attribute sbIDevCapRange supportedSampleRates;

  readonly attribute sbIDevCapRange supportedChannels;
};

%{C++
#define SB_IDEVCAPAUDIOSTREAM_DESCRIPTION             \
  "Songbird Device Capabilities Audio Stream Component"
#define SB_IDEVCAPAUDIOSTREAM_CONTRACTID              \
  "@songbirdnest.com/Songbird/Device/sbdevcapaudiostream;1"
#define SB_IDEVCAPAUDIOSTREAM_CLASSNAME               \
  "Songbird Device Capabilities Audio Stream"
#define SB_IDEVCAPAUDIOSTREAM_CID                     \
  {0xa8e9d2f7, 0x6640, 0x41a1, {0x9b, 0xd7, 0xb6, 0xce, 0xf2, 0x84, 0xb9, 0x47}}
%}

[scriptable, uuid(39fe77d1-f46d-4ca8-acff-435ccec8af1b)]
interface sbIVideoFormatType : nsISupports
{
  void initialize(in ACString aContainerType,
                  in sbIDevCapVideoStream aVideoStream,
                  in sbIDevCapAudioStream aAudioStream);
  readonly attribute ACString containerType;
  
  readonly attribute sbIDevCapVideoStream videoStream;
  
  readonly attribute sbIDevCapAudioStream audioStream;
};

%{C++
#define SB_IVIDEOORMATTYPE_DESCRIPTION             \
  "Songbird Device Capabilities Video Format Type Component"
#define SB_IVIDEOFORMATTYPE_CONTRACTID              \
  "@songbirdnest.com/Songbird/Device/sbvideoformattype;1"
#define SB_IVIDEOFORMATTYPE_CLASSNAME               \
  "Songbird Device Capabilities Video Format Type"
#define SB_IVIDEOFORMATTYPE_CID                     \
  {0x87cced11, 0x258e, 0x4131, {0xae, 0x51, 0xa5, 0x2a, 0xf7, 0x6d, 0xaa, 0xbc}}
%}

[scriptable, uuid(1042b7ea-eb3f-4b82-b730-b0a3d0b8e2ec)]
interface sbIPlaylistFormatType : nsISupports
{
  void initialize(in ACString aPathSeparator);

  readonly attribute ACString pathSeparator;
};

%{C++
#define SB_IPLAYLISTFORMATTYPE_DESCRIPTION         \
  "Songbird Device Capabilities Playlist Format Type Component"
#define SB_IPLAYLISTFORMATTYPE_CONTRACTID          \
  "@songbirdnest.com/Songbird/Device/sbplaylistformattype;1"
#define SB_IPLAYLISTFORMATTYPE_CLASSNAME           \
  "Songbird Device Capabilities Playlist Format Type"
#define SB_IPLAYLISTFORMATTYPE_CID                 \
  {0xdc2b0702, 0xb8d7, 0x4ef5, {0x83, 0xb6, 0x64, 0x85, 0xe5, 0xef, 0xd5, 0xf1}}
%}

[scriptable, uuid(7ce2a138-d1b4-4980-9c36-04c0389c6ce2)]
interface sbIDeviceCapabilities : nsISupports
{
  void init();

  void setFunctionTypes([array, size_is(aFunctionTypesCount)]
                         in PRUint32 aFunctionTypes,
                        in unsigned long aFunctionTypesCount);

  void setEventTypes([array, size_is(aEventTypesCount)]
                       in unsigned long aEventTypes,
                     in unsigned long aEventTypesCount);

  void addContentTypes(in PRUint32 aFunctionType,
                       [array, size_is(aContentTypesCount)]
                         in unsigned long aContentTypes,
                       in unsigned long aContentTypesCount);
  
  void addMimeTypes(in PRUint32 aContentType,
                  [array, size_is(aMimeTypesCount)] in string aMimeTypes,
                  in unsigned long aMimeTypesCount);

  void AddFormatType(in PRUint32 aContentType,
                     in AString aMimeType,
                     in nsISupports aFormatType);

  void AddPreferredFormatType(in PRUint32 aContentType,
                     in AString aMimeType,
                     in nsISupports aFormatType);
                           
  void addCapabilities(in sbIDeviceCapabilities aCapabilities);

  void configureDone();
  
  const PRUint32 FUNCTION_UNKNOWN        = 0x00;
  const PRUint32 FUNCTION_DEVICE         = 0x01;
  const PRUint32 FUNCTION_AUDIO_PLAYBACK = 0x02;
  const PRUint32 FUNCTION_AUDIO_CAPTURE  = 0x03;
  const PRUint32 FUNCTION_IMAGE_DISPLAY  = 0x04;
  const PRUint32 FUNCTION_IMAGE_CAPTURE  = 0x05;
  const PRUint32 FUNCTION_VIDEO_PLAYBACK = 0x06;
  const PRUint32 FUNCTION_VIDEO_CAPTURE  = 0x07;

  const PRUint32 FUNCTION_CLIENT_DEFINED = 0x80000000;

  // 
  void getSupportedFunctionTypes(out unsigned long aArrayCount,
                                 [retval, array, size_is(aArrayCount)]
                                  out PRUint32 aFunctionTypes);

  const PRUint32 CONTENT_UNKNOWN  = 0x00;
  const PRUint32 CONTENT_FILE     = 0x01;
  const PRUint32 CONTENT_FOLDER   = 0x02;
  const PRUint32 CONTENT_AUDIO    = 0x03;
  const PRUint32 CONTENT_IMAGE    = 0x04;
  const PRUint32 CONTENT_VIDEO    = 0x05;
  const PRUint32 CONTENT_PLAYLIST = 0x06;
  const PRUint32 CONTENT_ALBUM    = 0x07;
  const PRUint32 CONTENT_MAX_TYPES= 0x08; // Must be last

  const PRUint32 CONTENT_CLIENT_DEFINED = 0x80000000;

  void getSupportedContentTypes(in PRUint32 aFunctionType,
                                out unsigned long aArrayCount,
                                [retval, array, size_is(aArrayCount)]
                                  out PRUint32 aContentTypes);

  void getSupportedMimeTypes(in PRUint32 aContentType,
                             out unsigned long aArrayCount,
                             [retval, array, size_is(aArrayCount)]
                               out string aSupportedMimeTypes);

  void getFormatTypes(in PRUint32 aContentType,
                      in AString aMimeType,
                      out unsigned long aArrayCount,
                      [retval, array, size_is(aArrayCount)]
                        out nsISupports aSupportedFormats);

  void getPreferredFormatTypes(in PRUint32 aContentType,
                               in AString aMimeType,
                               out unsigned long aArrayCount,
                               [retval, array, size_is(aArrayCount)]
                                  out nsISupports aPreferredFormats);
 
  void getSupportedEvents(out unsigned long aArrayCount,
                          [retval, array, size_is(aArrayCount)]
                            out unsigned long aSupportedEvents);

  boolean supportsContent(in PRUint32 aFunctionType, in PRUint32 aContentType);

  nsIStringEnumerator getSupportedFileExtensions(in sbIDevice aDevice,
                                                 in PRUint32 aContentType);
};

%{C++
#define SONGBIRD_DEVICECAPABILITIES_DESCRIPTION             \
  "Songbird Device Capabilities Component"
#define SONGBIRD_DEVICECAPABILITIES_CONTRACTID              \
  "@songbirdnest.com/Songbird/Device/DeviceCapabilities;1"
#define SONGBIRD_DEVICECAPABILITIES_CLASSNAME               \
  "Songbird Device Capabilities"
#define SONGBIRD_DEVICECAPABILITIES_CID                     \
{ /* 54d42a87-9031-4928-991e-e66f4916a90b */              \
  0x54d42a87,                                             \
  0x9031,                                                 \
  0x4928,                                                 \
  {0x99, 0x1e, 0xe6, 0x6f, 0x49, 0x16, 0xa9, 0x0b}        \
}
%}

[scriptable, uuid(9e1f9988-1dd1-11b2-a7fc-80bbd1fa9089)]
interface sbIDeviceCapabilitiesUtils : nsISupports
{
  nsIStringEnumerator mapContentTypeToFileExtensions(in AString aMimeType,
                                                     in PRUint32 aContentType);
};

%{C++
#define SONGBIRD_DEVICECAPABILITIESUTILS_DESCRIPTION \
  "Songbird Device Capabilities Utils Component"
#define SONGBIRD_DEVICECAPABILITIESUTILS_CONTRACTID \
  "@songbirdnest.com/Songbird/Device/DeviceCapabilitiesUtils;1"
#define SONGBIRD_DEVICECAPABILITIESUTILS_CLASSNAME \
  "Songbird Device Capabilities Utils"
#define SONGBIRD_DEVICECAPABILITIESUTILS_CID \
{ /* 9e1f9988-1dd1-11b2-a7fc-80bbd1fa9089 */ \
  0xc20c7dfa, \
  0x1dd1,     \
  0x11b2,     \
  {0xa4, 0xa6, 0xb9, 0x8b, 0xb9, 0xa0, 0xaa, 0x47} \
}
%}