/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */

/* This Source Code Form is subject to the terms of the Mozilla Public

 * License, v. 2.0. If a copy of the MPL was not distributed with this

 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

#include "AudioDeviceInfo.h"

NS_IMPL_ISUPPORTS(AudioDeviceInfo, nsIAudioDeviceInfo)

using namespace mozilla;

using namespace mozilla::CubebUtils;

AudioDeviceInfo::AudioDeviceInfo(cubeb_device_info* aInfo)

:AudioDeviceInfo(aInfo->devid,

                 NS_ConvertUTF8toUTF16(aInfo->friendly_name),

                 NS_ConvertUTF8toUTF16(aInfo->group_id),

                 NS_ConvertUTF8toUTF16(aInfo->vendor_name),

                 aInfo->type,

                 aInfo->state,

                 aInfo->preferred,

                 aInfo->format,

                 aInfo->default_format,

                 aInfo->max_channels,

                 aInfo->default_rate,

                 aInfo->max_rate,

                 aInfo->min_rate,

                 aInfo->latency_lo,

                 aInfo->latency_hi)

{

}

AudioDeviceInfo::AudioDeviceInfo(AudioDeviceID aID,

                                 const nsAString& aName,

                                 const nsAString& aGroupId,

                                 const nsAString& aVendor,

                                 uint16_t aType,

                                 uint16_t aState,

                                 uint16_t aPreferred,

                                 uint16_t aSupportedFormat,

                                 uint16_t aDefaultFormat,

                                 uint32_t aMaxChannels,

                                 uint32_t aDefaultRate,

                                 uint32_t aMaxRate,

                                 uint32_t aMinRate,

                                 uint32_t aMaxLatency,

                                 uint32_t aMinLatency)

  : mDeviceId(aID)

  , mName(aName)

  , mGroupId(aGroupId)

  , mVendor(aVendor)

  , mType(aType)

  , mState(aState)

  , mPreferred(aPreferred)

  , mSupportedFormat(aSupportedFormat)

  , mDefaultFormat(aDefaultFormat)

  , mMaxChannels(aMaxChannels)

  , mDefaultRate(aDefaultRate)

  , mMaxRate(aMaxRate)

  , mMinRate(aMinRate)

  , mMaxLatency(aMaxLatency)

  , mMinLatency(aMinLatency)

{

  MOZ_ASSERT(mType == TYPE_UNKNOWN ||

             mType == TYPE_INPUT ||

             mType == TYPE_OUTPUT, "Wrong type");

  MOZ_ASSERT(mState == STATE_DISABLED ||

             mState == STATE_UNPLUGGED ||

             mState == STATE_ENABLED, "Wrong state");

  MOZ_ASSERT(mPreferred == PREF_NONE ||

             mPreferred == PREF_ALL ||

             mPreferred & (PREF_MULTIMEDIA | PREF_VOICE | PREF_NOTIFICATION),

             "Wrong preferred value");

  MOZ_ASSERT(mSupportedFormat & (FMT_S16LE | FMT_S16BE | FMT_F32LE | FMT_F32BE),

             "Wrong supported format");

  MOZ_ASSERT(mDefaultFormat == FMT_S16LE ||

             mDefaultFormat == FMT_S16BE ||

             mDefaultFormat == FMT_F32LE ||

             mDefaultFormat == FMT_F32BE, "Wrong default format");

}

AudioDeviceID

AudioDeviceInfo::DeviceID() const

{

  return mDeviceId;

}

const nsString& AudioDeviceInfo::Name() const

{

  return mName;

}

uint32_t AudioDeviceInfo::MaxChannels() const

{

  return mMaxChannels;

}

uint32_t AudioDeviceInfo::Type() const

{

  return mType;

}

uint32_t AudioDeviceInfo::State() const

{

  return mState;

}

bool AudioDeviceInfo::Preferred() const

{

  return mPreferred;

}

/* readonly attribute DOMString name; */

NS_IMETHODIMP

AudioDeviceInfo::GetName(nsAString& aName)

{

  aName = mName;

  return NS_OK;

}

/* readonly attribute DOMString groupId; */

NS_IMETHODIMP

AudioDeviceInfo::GetGroupId(nsAString& aGroupId)

{

  aGroupId = mGroupId;

  return NS_OK;

}

/* readonly attribute DOMString vendor; */

NS_IMETHODIMP

AudioDeviceInfo::GetVendor(nsAString& aVendor)

{

  aVendor = mVendor;

  return NS_OK;

}

/* readonly attribute unsigned short type; */

NS_IMETHODIMP

AudioDeviceInfo::GetType(uint16_t* aType)

{

  *aType = mType;

  return NS_OK;

}

/* readonly attribute unsigned short state; */

NS_IMETHODIMP

AudioDeviceInfo::GetState(uint16_t* aState)

{

  *aState = mState;

  return NS_OK;

}

/* readonly attribute unsigned short preferred; */

NS_IMETHODIMP

AudioDeviceInfo::GetPreferred(uint16_t* aPreferred)

{

  *aPreferred = mPreferred;

  return NS_OK;

}

/* readonly attribute unsigned short supportedFormat; */

NS_IMETHODIMP

AudioDeviceInfo::GetSupportedFormat(uint16_t* aSupportedFormat)

{

  *aSupportedFormat = mSupportedFormat;

  return NS_OK;

}

/* readonly attribute unsigned short defaultFormat; */

NS_IMETHODIMP

AudioDeviceInfo::GetDefaultFormat(uint16_t* aDefaultFormat)

{

  *aDefaultFormat = mDefaultFormat;

  return NS_OK;

}

/* readonly attribute unsigned long maxChannels; */

NS_IMETHODIMP

AudioDeviceInfo::GetMaxChannels(uint32_t* aMaxChannels)

{

  *aMaxChannels = mMaxChannels;

  return NS_OK;

}

/* readonly attribute unsigned long defaultRate; */

NS_IMETHODIMP

AudioDeviceInfo::GetDefaultRate(uint32_t* aDefaultRate)

{

  *aDefaultRate = mDefaultRate;

  return NS_OK;

}

/* readonly attribute unsigned long maxRate; */

NS_IMETHODIMP

AudioDeviceInfo::GetMaxRate(uint32_t* aMaxRate)

{

  *aMaxRate = mMaxRate;

  return NS_OK;

}

/* readonly attribute unsigned long minRate; */

NS_IMETHODIMP

AudioDeviceInfo::GetMinRate(uint32_t* aMinRate)

{

  *aMinRate = mMinRate;

  return NS_OK;

}

/* readonly attribute unsigned long maxLatency; */

NS_IMETHODIMP

AudioDeviceInfo::GetMaxLatency(uint32_t* aMaxLatency)

{

  *aMaxLatency = mMaxLatency;

  return NS_OK;

}

/* readonly attribute unsigned long minLatency; */

NS_IMETHODIMP

AudioDeviceInfo::GetMinLatency(uint32_t* aMinLatency)

{

  *aMinLatency = mMinLatency;

  return NS_OK;

}