content: /*
   * Copyright (C) 2014 The Android Open Source Project
   *
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   *      http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  
  package android.hardware.hdmi;
  
  import android.annotation.Nullable;
  import android.annotation.SystemApi;
  import android.util.Log;
  
  /**
   * Container for record source used for one touch record.
   * Use one of helper method by source type.
   * <ul>
   * <li>Own source: {@link #ofOwnSource()}
   * <li>Digital service(channel id): {@link #ofDigitalChannelId(int, DigitalChannelData)}
   * <li>Digital service(ARIB): {@link #ofArib(int, AribData)}
   * <li>Digital service(ATSC): {@link #ofAtsc(int, AtscData)}
   * <li>Digital service(DVB): {@link #ofDvb(int, DvbData)}
   * <li>Analogue: {@link #ofAnalogue(int, int, int)}
   * <li>External plug: {@link #ofExternalPlug(int)}
   * <li>External physical address: {@link #ofExternalPhysicalAddress(int)}.
   * <ul>
   *
   * @hide
   */
  @SystemApi
  public final class HdmiRecordSources {
      private static final String TAG = "HdmiRecordSources";
  
      /** Record source type for "Own Source". */
      private static final int RECORD_SOURCE_TYPE_OWN_SOURCE = 1;
      /** Record source type for "Digital Service". */
      private static final int RECORD_SOURCE_TYPE_DIGITAL_SERVICE = 2;
      /** Record source type for "Analogue Service". */
      private static final int RECORD_SOURCE_TYPE_ANALOGUE_SERVICE = 3;
      /** Record source type for "Exteranl Plug". */
      private static final int RECORD_SOURCE_TYPE_EXTERNAL_PLUG = 4;
      /** Record source type for "External Physical Address". */
      private static final int RECORD_SOURCE_TYPE_EXTERNAL_PHYSICAL_ADDRESS = 5;
  
      private HdmiRecordSources() {}
  
      /**
       * Base class for each record source.
       * @hide
       */
      @SystemApi
      public static abstract class RecordSource {
          /* package */ final int mSourceType;
          /* package */ final int mExtraDataSize;
  
          /* package */ RecordSource(int sourceType, int extraDataSize) {
              mSourceType = sourceType;
              mExtraDataSize = extraDataSize;
          }
  
          /* package */ abstract int extraParamToByteArray(byte[] data, int index);
  
          /* package */ final int getDataSize(boolean includeType)  {
              return includeType ? mExtraDataSize + 1 : mExtraDataSize;
          }
  
          /* package */ final int toByteArray(boolean includeType, byte[] data, int index) {
              if (includeType) {
                  // 1 to 8 bytes (depends on source).
                  // {[Record Source Type]} |
                  // {[Record Source Type] [Digital Service Identification]} |
                  // {[Record Source Type] [Analogue Broadcast Type] [Analogue Frequency]
                  // [Broadcast System]} |
                  // {[Record Source Type] [External Plug]} |
                  // {[Record Source Type] [External Physical Address]}
                  // The first byte is used for record source type.
                  data[index++] = (byte) mSourceType;
              }
              extraParamToByteArray(data, index);
              return getDataSize(includeType);
          }
      }
  
      // ---------------------------------------------------------------------------------------------
      // ---- Own source -----------------------------------------------------------------------------
      // ---------------------------------------------------------------------------------------------
      /**
       * Creates {@link OwnSource} of own source.
       */
      public static OwnSource ofOwnSource() {
          return new OwnSource();
      }
  
      /**
       * @hide
       */
      @SystemApi
      public static final class OwnSource extends RecordSource {
          private static final int EXTRA_DATA_SIZE = 0;
  
          private OwnSource() {
              super(RECORD_SOURCE_TYPE_OWN_SOURCE, EXTRA_DATA_SIZE);
          }
  
          @Override
          int extraParamToByteArray(byte[] data, int index) {
              return 0;
          }
      }
  
  
      // ---------------------------------------------------------------------------------------------
      // ---- Digital service data -------------------------------------------------------------------
      // ---------------------------------------------------------------------------------------------
      /**
       * Digital broadcast general types
       */
      /** @hide */
      public static final int DIGITAL_BROADCAST_TYPE_ARIB = 0x0;
      /** @hide */
      public static final int DIGITAL_BROADCAST_TYPE_ATSC = 0x1;
      /** @hide */
      public static final int DIGITAL_BROADCAST_TYPE_DVB = 0x2;
  
      /**
       * Digital broadcast specific types
       */
      /** @hide */
      public static final int DIGITAL_BROADCAST_TYPE_ARIB_BS = 0x8;
      /** @hide */
      public static final int DIGITAL_BROADCAST_TYPE_ARIB_CS = 0x9;
      /** @hide */
      public static final int DIGITAL_BROADCAST_TYPE_ARIB_T = 0xA;
      /** @hide */
      public static final int DIGITAL_BROADCAST_TYPE_ATSC_CABLE = 0x10;
      /** @hide */
      public static final int DIGITAL_BROADCAST_TYPE_ATSC_SATELLITE = 0x11;
      /** @hide */
      public static final int DIGITAL_BROADCAST_TYPE_ATSC_TERRESTRIAL = 0x12;
      /** @hide */
      public static final int DIGITAL_BROADCAST_TYPE_DVB_C = 0x18;
      /** @hide */
      public static final int DIGITAL_BROADCAST_TYPE_DVB_S = 0x19;
      /** @hide */
      public static final int DIGITAL_BROADCAST_TYPE_DVB_S2 = 0x1A;
      /** @hide */
      public static final int DIGITAL_BROADCAST_TYPE_DVB_T = 0x1B;
  
      /** Channel number formats. */
      private static final int CHANNEL_NUMBER_FORMAT_1_PART = 0x01;
      private static final int CHANNEL_NUMBER_FORMAT_2_PART = 0x02;
  
      /**
       * Interface for digital source identification.
       */
      private interface DigitalServiceIdentification {
          int toByteArray(byte[] data, int index);
      }
  
      /**
       * Digital service identification for ARIB.
       * <p>
       * It consists of the following fields
       * <ul>
       * <li>transport stream id: 2bytes
       * <li>service id: 2bytes
       * <li>original network id: 2bytes
       * </ul>
       * @hide
       */
      public static final class AribData implements DigitalServiceIdentification {
          /** The transport_stream_ID of the transport stream carrying the required service */
          private final int mTransportStreamId;
          /** The service_ID of the required service */
          private final int mServiceId;
          /**
           * The original_network_ID of the network carrying the transport stream for the required
           * service
           */
          private final int mOriginalNetworkId;
  
          public AribData(int transportStreamId, int serviceId, int originalNetworkId) {
              mTransportStreamId = transportStreamId;
              mServiceId = serviceId;
              mOriginalNetworkId = originalNetworkId;
          }
  
          @Override
          public int toByteArray(byte[] data, int index) {
              return threeFieldsToSixBytes(mTransportStreamId, mServiceId, mOriginalNetworkId, data,
                      index);
          }
      }
  
      /**
       * Digital service identification for ATSC.
       * <p>
       * It consists of the following fields
       * <ul>
       * <li>transport stream id: 2bytes
       * <li>program number: 2bytes
       * <li>reserved: 2bytes
       * </ul>
       * @hide
       */
      public static final class AtscData implements DigitalServiceIdentification {
          /** The transport_stream_ID of the transport stream carrying the required service */
          private final int mTransportStreamId;
          /** The Program_number of the required service */
          private final int mProgramNumber;
  
          public AtscData(int transportStreamId, int programNumber) {
              mTransportStreamId = transportStreamId;
              mProgramNumber = programNumber;
          }
  
          @Override
          public int toByteArray(byte[] data, int index) {
              return threeFieldsToSixBytes(mTransportStreamId, mProgramNumber, 0, data, index);
          }
      }
  
      /**
       * Digital service identification for DVB.
       * <p>
       * It consists of the following fields
       * <ul>
       * <li>transport stream id: 2bytes
       * <li>service id: 2bytes
       * <li>original network id: 2bytes
       * </ul>
       * @hide
       */
      public static final class DvbData implements DigitalServiceIdentification {
          /** The transport_stream_ID of the transport stream carrying the required service */
          private final int mTransportStreamId;
          /** The service_ID of the required service */
          private final int mServiceId;
          /**
           * The original_network_ID of the network carrying the transport stream for the required
           * service
           */
          private final int mOriginalNetworkId;
  
          public DvbData(int transportStreamId, int serviceId, int originalNetworkId) {
              mTransportStreamId = transportStreamId;
              mServiceId = serviceId;
              mOriginalNetworkId = originalNetworkId;
          }
  
          @Override
          public int toByteArray(byte[] data, int index) {
              return threeFieldsToSixBytes(mTransportStreamId, mServiceId, mOriginalNetworkId, data,
                      index);
          }
      }
  
      /**
       * Identifies a 1-part Logical or Virtual Channel Number or a 2-part Major and Minor channel
       * combination.
       */
      private static final class ChannelIdentifier {
          /** Identifies Channel Format */
          private final int mChannelNumberFormat;
          /**
           * Major Channel Number (if Channel Number Format is 2-part). If format is
           * CHANNEL_NUMBER_FORMAT_1_PART, this will be ignored(0).
           */
          private final int mMajorChannelNumber;
          /**
           * 1-part Channel Number, or a Minor Channel Number (if Channel Number Format is 2-part).
           */
          private final int mMinorChannelNumber;
  
          private ChannelIdentifier(int format, int majorNumber, int minorNumer) {
              mChannelNumberFormat = format;
              mMajorChannelNumber = majorNumber;
              mMinorChannelNumber = minorNumer;
          }
  
          private int toByteArray(byte[] data, int index) {
              // The first 6 bits for format, the 10 bits for major number.
              data[index] = (byte) (((mChannelNumberFormat << 2) | (mMajorChannelNumber >>> 8) & 0x3));
              data[index + 1] = (byte) (mMajorChannelNumber & 0xFF);
              // Minor number uses the next 16 bits.
              shortToByteArray((short) mMinorChannelNumber, data, index + 2);
              return 4;
          }
      }
  
      /**
       * Digital channel id.
       * <p>
       * It consists of the following fields
       * <ul>
       * <li>channel number format: 6bits
       * <li>major number: 10bits
       * <li>minor number: 16bits
       * <li>reserved: 2bytes
       * </ul>
       * @hide
       */
      public static final class DigitalChannelData implements DigitalServiceIdentification {
          /** Identifies the logical or virtual channel number of a service. */
          private final ChannelIdentifier mChannelIdentifier;
  
          public static DigitalChannelData ofTwoNumbers(int majorNumber, int minorNumber) {
              return new DigitalChannelData(
                      new ChannelIdentifier(CHANNEL_NUMBER_FORMAT_2_PART, majorNumber, minorNumber));
          }
  
          public static DigitalChannelData ofOneNumber(int number) {
              return new DigitalChannelData(
                      new ChannelIdentifier(CHANNEL_NUMBER_FORMAT_1_PART, 0, number));
          }
  
          private DigitalChannelData(ChannelIdentifier id) {
              mChannelIdentifier = id;
          }
  
          @Override
          public int toByteArray(byte[] data, int index) {
              mChannelIdentifier.toByteArray(data, index);
              // The last 2 bytes is reserved for future use.
              data[index + 4] = 0;
              data[index + 5] = 0;
              return 6;
          }
      }
  
      /**
       * Creates {@link DigitalServiceSource} with channel type.
       *
       * @param broadcastSystem digital broadcast system. It should be one of
       *            <ul>
       *            <li>{@link #DIGITAL_BROADCAST_TYPE_ARIB}
       *            <li>{@link #DIGITAL_BROADCAST_TYPE_ATSC}
       *            <li>{@link #DIGITAL_BROADCAST_TYPE_DVB}
       *            <li>{@link #DIGITAL_BROADCAST_TYPE_ARIB_BS}
       *            <li>{@link #DIGITAL_BROADCAST_TYPE_ARIB_CS}
       *            <li>{@link #DIGITAL_BROADCAST_TYPE_ARIB_T}
       *            <li>{@link #DIGITAL_BROADCAST_TYPE_ATSC_CABLE}
       *            <li>{@link #DIGITAL_BROADCAST_TYPE_ATSC_SATELLITE}
       *            <li>{@link #DIGITAL_BROADCAST_TYPE_ATSC_TERRESTRIAL}
       *            <li>{@link #DIGITAL_BROADCAST_TYPE_DVB_C}
       *            <li>{@link #DIGITAL_BROADCAST_TYPE_DVB_S}
       *            <li>{@link #DIGITAL_BROADCAST_TYPE_DVB_S2}
       *            <li>{@link #DIGITAL_BROADCAST_TYPE_DVB_T}
       *            </ul>
       * @hide
       */
      public static DigitalServiceSource ofDigitalChannelId(int broadcastSystem,
              DigitalChannelData data) {
          if (data == null) {
              throw new IllegalArgumentException("data should not be null.");
          }
          switch (broadcastSystem) {
              case DIGITAL_BROADCAST_TYPE_ARIB:
              case DIGITAL_BROADCAST_TYPE_ATSC:
              case DIGITAL_BROADCAST_TYPE_DVB:
              case DIGITAL_BROADCAST_TYPE_ARIB_BS:
              case DIGITAL_BROADCAST_TYPE_ARIB_CS:
              case DIGITAL_BROADCAST_TYPE_ARIB_T:
              case DIGITAL_BROADCAST_TYPE_ATSC_CABLE:
              case DIGITAL_BROADCAST_TYPE_ATSC_SATELLITE:
              case DIGITAL_BROADCAST_TYPE_ATSC_TERRESTRIAL:
              case DIGITAL_BROADCAST_TYPE_DVB_C:
              case DIGITAL_BROADCAST_TYPE_DVB_S:
              case DIGITAL_BROADCAST_TYPE_DVB_S2:
              case DIGITAL_BROADCAST_TYPE_DVB_T:
                  return new DigitalServiceSource(
                          DigitalServiceSource.DIGITAL_SERVICE_IDENTIFIED_BY_CHANNEL,
                          broadcastSystem,
                          data);
              default:
                  Log.w(TAG, "Invalid broadcast type:" + broadcastSystem);
                  throw new IllegalArgumentException(
                          "Invalid broadcast system value:" + broadcastSystem);
          }
      }
  
      /**
       * Creates {@link DigitalServiceSource} of ARIB type.
       *
       * @param aribType ARIB type. It should be one of
       *            <ul>
       *            <li>{@link #DIGITAL_BROADCAST_TYPE_ARIB}
       *            <li>{@link #DIGITAL_BROADCAST_TYPE_ARIB_BS}
       *            <li>{@link #DIGITAL_BROADCAST_TYPE_ARIB_CS}
       *            <li>{@link #DIGITAL_BROADCAST_TYPE_ARIB_T}
       *            </ul>
       * @hide
       */
      @Nullable
      public static DigitalServiceSource ofArib(int aribType, AribData data) {
          if (data == null) {
              throw new IllegalArgumentException("data should not be null.");
          }
          switch (aribType) {
              case DIGITAL_BROADCAST_TYPE_ARIB:
              case DIGITAL_BROADCAST_TYPE_ARIB_BS:
              case DIGITAL_BROADCAST_TYPE_ARIB_CS:
              case DIGITAL_BROADCAST_TYPE_ARIB_T:
                  return new DigitalServiceSource(
                          DigitalServiceSource.DIGITAL_SERVICE_IDENTIFIED_BY_DIGITAL_ID,
                          aribType, data);
              default:
                  Log.w(TAG, "Invalid ARIB type:" + aribType);
                  throw new IllegalArgumentException("type should not be null.");
          }
      }
  
      /**
       * Creates {@link DigitalServiceSource} of ATSC type.
       *
       * @param atscType ATSC type. It should be one of
       *            <ul>
       *            <li>{@link #DIGITAL_BROADCAST_TYPE_ATSC}
       *            <li>{@link #DIGITAL_BROADCAST_TYPE_ATSC_CABLE}
       *            <li>{@link #DIGITAL_BROADCAST_TYPE_ATSC_SATELLITE}
       *            <li>{@link #DIGITAL_BROADCAST_TYPE_ATSC_TERRESTRIAL}
       *            </ul>
       * @hide
       */
      @Nullable
      public static DigitalServiceSource ofAtsc(int atscType, AtscData data) {
          if (data == null) {
              throw new IllegalArgumentException("data should not be null.");
          }
          switch (atscType) {
              case DIGITAL_BROADCAST_TYPE_ATSC:
              case DIGITAL_BROADCAST_TYPE_ATSC_CABLE:
              case DIGITAL_BROADCAST_TYPE_ATSC_SATELLITE:
              case DIGITAL_BROADCAST_TYPE_ATSC_TERRESTRIAL:
                  return new DigitalServiceSource(
                          DigitalServiceSource.DIGITAL_SERVICE_IDENTIFIED_BY_DIGITAL_ID,
                          atscType, data);
              default:
                  Log.w(TAG, "Invalid ATSC type:" + atscType);
                  throw new IllegalArgumentException("Invalid ATSC type:" + atscType);
          }
      }
  
      /**
       * Creates {@link DigitalServiceSource} of ATSC type.
       *
       * @param dvbType DVB type. It should be one of
       *            <ul>
       *            <li>{@link #DIGITAL_BROADCAST_TYPE_DVB}
       *            <li>{@link #DIGITAL_BROADCAST_TYPE_DVB_C}
       *            <li>{@link #DIGITAL_BROADCAST_TYPE_DVB_S}
       *            <li>{@link #DIGITAL_BROADCAST_TYPE_DVB_S2}
       *            <li>{@link #DIGITAL_BROADCAST_TYPE_DVB_T}
       *            </ul>
       * @hide
       */
      @Nullable
      public static DigitalServiceSource ofDvb(int dvbType, DvbData data) {
          if (data == null) {
              throw new IllegalArgumentException("data should not be null.");
          }
          switch (dvbType) {
              case DIGITAL_BROADCAST_TYPE_DVB:
              case DIGITAL_BROADCAST_TYPE_DVB_C:
              case DIGITAL_BROADCAST_TYPE_DVB_S:
              case DIGITAL_BROADCAST_TYPE_DVB_S2:
              case DIGITAL_BROADCAST_TYPE_DVB_T:
                  return new DigitalServiceSource(
                          DigitalServiceSource.DIGITAL_SERVICE_IDENTIFIED_BY_DIGITAL_ID,
                          dvbType, data);
              default:
                  Log.w(TAG, "Invalid DVB type:" + dvbType);
                  throw new IllegalArgumentException("Invalid DVB type:" + dvbType);
          }
      }
  
      /**
       * Record source container for "Digital Service".
       * <ul>
       * <li>[Record Source Type] - 1 byte
       * <li>[Digital Identification] - 7 bytes
       * </ul>
       * @hide
       */
      @SystemApi
      public static final class DigitalServiceSource extends RecordSource {
          /** Indicates that a service is identified by digital service IDs. */
          private static final int DIGITAL_SERVICE_IDENTIFIED_BY_DIGITAL_ID = 0;
          /** Indicates that a service is identified by a logical or virtual channel number. */
          private static final int DIGITAL_SERVICE_IDENTIFIED_BY_CHANNEL = 1;
  
          static final int EXTRA_DATA_SIZE = 7;
  
          /**
           * Type of identification. It should be one of DIGITAL_SERVICE_IDENTIFIED_BY_DIGITAL_ID and
           * DIGITAL_SERVICE_IDENTIFIED_BY_CHANNEL
           */
          private final int mIdentificationMethod;
          /**
           * Indicates the Digital Broadcast System of required service. This is present irrespective
           * of the state of [Service Identification Method].
           */
          private final int mBroadcastSystem;
  
          /**
           * Extra parameter for digital service identification.
           */
          private final DigitalServiceIdentification mIdentification;
  
          private DigitalServiceSource(int identificatinoMethod, int broadcastSystem,
                  DigitalServiceIdentification identification) {
              super(RECORD_SOURCE_TYPE_DIGITAL_SERVICE, EXTRA_DATA_SIZE);
              mIdentificationMethod = identificatinoMethod;
              mBroadcastSystem = broadcastSystem;
              mIdentification = identification;
          }
  
          @Override
          int extraParamToByteArray(byte[] data, int index) {
              data[index] = (byte) ((mIdentificationMethod << 7) | (mBroadcastSystem & 0x7F));
              mIdentification.toByteArray(data, index + 1);
              return EXTRA_DATA_SIZE;
  
          }
      }
  
  
      // ---------------------------------------------------------------------------------------------
      // ---- Analogue service data ------------------------------------------------------------------
      // ---------------------------------------------------------------------------------------------
      /**
       * Analogue broadcast types.
       */
      /** @hide */
      public static final int ANALOGUE_BROADCAST_TYPE_CABLE = 0x0;
      /** @hide */
      public static final int ANALOGUE_BROADCAST_TYPE_SATELLITE = 0x1;
      /** @hide */
      public static final int ANALOGUE_BROADCAST_TYPE_TERRESTRIAL = 0x2;
  
      /**
       * Broadcast system values.
       */
      /** @hide */
      public static final int BROADCAST_SYSTEM_PAL_BG = 0;
      /** @hide */
      public static final int BROADCAST_SYSTEM_SECAM_LP = 1;
      /** @hide */
      public static final int BROADCAST_SYSTEM_PAL_M = 2;
      /** @hide */
      public static final int BROADCAST_SYSTEM_NTSC_M = 3;
      /** @hide */
      public static final int BROADCAST_SYSTEM_PAL_I = 4;
      /** @hide */
      public static final int BROADCAST_SYSTEM_SECAM_DK = 5;
      /** @hide */
      public static final int BROADCAST_SYSTEM_SECAM_BG = 6;
      /** @hide */
      public static final int BROADCAST_SYSTEM_SECAM_L = 7;
      /** @hide */
      public static final int BROADCAST_SYSTEM_PAL_DK = 8;
      /** @hide */
      public static final int BROADCAST_SYSTEM_PAL_OTHER_SYSTEM = 31;
  
      /**
       * Creates {@link AnalogueServiceSource} of analogue service.
       *
       * @param broadcastType
       * @param frequency
       * @param broadcastSystem
       * @hide
       */
      @Nullable
      public static AnalogueServiceSource ofAnalogue(int broadcastType, int frequency,
              int broadcastSystem){
          if (broadcastType < ANALOGUE_BROADCAST_TYPE_CABLE
                  || broadcastType > ANALOGUE_BROADCAST_TYPE_TERRESTRIAL) {
              Log.w(TAG, "Invalid Broadcast type:" + broadcastType);
              throw new IllegalArgumentException("Invalid Broadcast type:" + broadcastType);
          }
          if (frequency < 0 || frequency > 0xFFFF) {
              Log.w(TAG, "Invalid frequency value[0x0000-0xFFFF]:" + frequency);
              throw new IllegalArgumentException(
                      "Invalid frequency value[0x0000-0xFFFF]:" + frequency);
          }
          if (broadcastSystem < BROADCAST_SYSTEM_PAL_BG
                  || broadcastSystem > BROADCAST_SYSTEM_PAL_OTHER_SYSTEM) {
  
              Log.w(TAG, "Invalid Broadcast system:" + broadcastSystem);
              throw new IllegalArgumentException(
                      "Invalid Broadcast system:" + broadcastSystem);
          }
  
          return new AnalogueServiceSource(broadcastType, frequency, broadcastSystem);
      }
  
      /**
       * Record source for analogue service data. It consists of
       * <ul>
       * <li>[Record Source Type] - 1 byte
       * <li>[Analogue Broadcast Type] - 1 byte
       * <li>[Analogue Frequency] - 2 bytes
       * <li>[Broadcast System] - 1 byte
       * </ul>
       * @hide
       */
      @SystemApi
      public static final class AnalogueServiceSource extends RecordSource {
          /* package */ static final int EXTRA_DATA_SIZE = 4;
  
          /** Indicates the Analogue broadcast type. */
          private final int mBroadcastType;
          /** Used to specify the frequency used by an analogue tuner. 0x0000<N<0xFFFF. */
          private final int mFrequency;
          /**
           * This specifies information about the color system, the sound carrier and the
           * IF-frequency.
           */
          private final int mBroadcastSystem;
  
          private AnalogueServiceSource(int broadcastType, int frequency, int broadcastSystem) {
              super(RECORD_SOURCE_TYPE_ANALOGUE_SERVICE, EXTRA_DATA_SIZE);
              mBroadcastType = broadcastType;
              mFrequency = frequency;
              mBroadcastSystem = broadcastSystem;
          }
  
          @Override
          /* package */ int extraParamToByteArray(byte[] data, int index) {
              // [Analogue Broadcast Type] - 1 byte
              data[index] = (byte) mBroadcastType;
              // [Analogue Frequency] - 2 bytes
              shortToByteArray((short) mFrequency, data, index + 1);
              // [Broadcast System] - 1 byte
              data[index + 3] = (byte) mBroadcastSystem;
              return EXTRA_DATA_SIZE;
          }
      }
  
  
      // ---------------------------------------------------------------------------------------------
      // ---- External plug data ---------------------------------------------------------------------
      // ---------------------------------------------------------------------------------------------
      /**
       * Creates {@link ExternalPlugData} of external plug type.
       *
       * @param plugNumber plug number. It should be in range of [1, 255]
       * @hide
       */
      public static ExternalPlugData ofExternalPlug(int plugNumber) {
          if (plugNumber < 1 || plugNumber > 255) {
              Log.w(TAG, "Invalid plug number[1-255]" + plugNumber);
              throw new IllegalArgumentException("Invalid plug number[1-255]" + plugNumber);
          }
          return new ExternalPlugData(plugNumber);
      }
  
      /**
       * Record source for external plug (external non-HDMI device connect) type.
       * <ul>
       * <li>[Record Source Type] - 1 byte
       * <li>[External Plug] - 1 byte
       * </ul>
       * @hide
       */
      @SystemApi
      public static final class ExternalPlugData extends RecordSource {
          static final int EXTRA_DATA_SIZE = 1;
  
          /** External Plug number on the Recording Device. */
          private final int mPlugNumber;
  
          private ExternalPlugData(int plugNumber) {
              super(RECORD_SOURCE_TYPE_EXTERNAL_PLUG, EXTRA_DATA_SIZE);
              mPlugNumber = plugNumber;
          }
  
          @Override
          int extraParamToByteArray(byte[] data, int index) {
              data[index] = (byte) mPlugNumber;
              return EXTRA_DATA_SIZE;
          }
      }
  
      // ---------------------------------------------------------------------------------------------
      // ---- External physical address --------------------------------------------------------------
      // ---------------------------------------------------------------------------------------------
      /**
       * Creates {@link ExternalPhysicalAddress} of external physical address.
       *
       * @param physicalAddress
       * @hide
       */
      public static ExternalPhysicalAddress ofExternalPhysicalAddress(int physicalAddress) {
          if ((physicalAddress & ~0xFFFF) != 0) {
              Log.w(TAG, "Invalid physical address:" + physicalAddress);
              throw new IllegalArgumentException("Invalid physical address:" + physicalAddress);
          }
  
          return new ExternalPhysicalAddress(physicalAddress);
      }
  
      /**
       * Record source for external physical address.
       * <ul>
       * <li>[Record Source Type] - 1 byte
       * <li>[Physical address] - 2 byte
       * </ul>
       * @hide
       */
      @SystemApi
      public static final class ExternalPhysicalAddress extends RecordSource {
          static final int EXTRA_DATA_SIZE = 2;
  
          private final int mPhysicalAddress;
  
          private ExternalPhysicalAddress(int physicalAddress) {
              super(RECORD_SOURCE_TYPE_EXTERNAL_PHYSICAL_ADDRESS, EXTRA_DATA_SIZE);
              mPhysicalAddress = physicalAddress;
          }
  
          @Override
          int extraParamToByteArray(byte[] data, int index) {
              shortToByteArray((short) mPhysicalAddress, data, index);
              return EXTRA_DATA_SIZE;
          }
      }
  
  
      // ---------------------------------------------------------------------------------------------
      // ------- Helper methods ----------------------------------------------------------------------
      // ---------------------------------------------------------------------------------------------
      private static int threeFieldsToSixBytes(int first, int second, int third, byte[] data,
              int index) {
          shortToByteArray((short) first, data, index);
          shortToByteArray((short) second, data, index + 2);
          shortToByteArray((short) third, data, index + 4);
          return 6;
      }
  
      private static int shortToByteArray(short value, byte[] byteArray, int index) {
          byteArray[index] = (byte) ((value >>> 8) & 0xFF);
          byteArray[index + 1] = (byte) (value & 0xFF);
          return 2;
      }
  
      /**
       * Checks the byte array of record source.
       * @hide
       */
      @SystemApi
      public static boolean checkRecordSource(byte[] recordSource) {
          if (recordSource == null || recordSource.length == 0) return false;
  
          int recordSourceType = recordSource[0];
          int extraDataSize = recordSource.length - 1;
          switch (recordSourceType) {
              case RECORD_SOURCE_TYPE_OWN_SOURCE:
                  return extraDataSize == OwnSource.EXTRA_DATA_SIZE;
              case RECORD_SOURCE_TYPE_DIGITAL_SERVICE:
                  return extraDataSize == DigitalServiceSource.EXTRA_DATA_SIZE;
              case RECORD_SOURCE_TYPE_ANALOGUE_SERVICE:
                  return extraDataSize == AnalogueServiceSource.EXTRA_DATA_SIZE;
              case RECORD_SOURCE_TYPE_EXTERNAL_PLUG:
                  return extraDataSize == ExternalPlugData.EXTRA_DATA_SIZE;
              case RECORD_SOURCE_TYPE_EXTERNAL_PHYSICAL_ADDRESS:
                  return extraDataSize == ExternalPhysicalAddress.EXTRA_DATA_SIZE;
              default:
                  return false;
          }
      }
  }
  