/*
(non-Javadoc)

@see javax.sound.sampled.spi.AudioFileWriter#getAudioFileTypes()
429438
@Override
  public Type[] getAudioFileTypes() {
    AudioFileFormat.Type[] localArray = new AudioFileFormat.Type[flacTypes.length];
    System.arraycopy(flacTypes, 0, localArray, 0, flacTypes.length);
    return localArray;
  }
262120
@Override
    protected FileType doGetType() throws Exception {
        // JDK BUG: 6192331
        // if (!file.exists())
        if (!file.exists() && file.length() < 1) {
            return FileType.IMAGINARY;
        }

        if (file.isDirectory()) {
            return FileType.FOLDER;
        }

        // In doubt, treat an existing file as file
        // if (file.isFile())
        // {
        return FileType.FILE;
        // }

        // throw new FileSystemException("vfs.provider.local/get-type.error", file);
    }
1289149
@Override
  public Set<String> basicRecordTypes() {
    Set<String> types = new LinkedHashSet<String>();
    types.addAll(Arrays.asList("A", "AAAA", "CNAME", "MX", "NS", "SRV", "TXT"));
    return types;
  }
393320
public static String fileTypeAsString( int fileType ) {

		String result;
		switch( fileType ) {
		case AGGREGATOR:
			result = "aggregator";
			break;

		case GRAPH:
			result = "graph";
			break;

		case INSTANCE:
			result = "intsnace";
			break;

		case UNDETERMINED:
			result = "undetermined";
			break;

		default:
			result = "unknown";
			break;
		}

		return result;
	}
349490
@Override
    public AudioFormat[] getTargetFormats(AudioFormat.Encoding targetEncoding, AudioFormat sourceFormat) {
        for (Entry<AudioFormat, Map<AudioFormat.Encoding, Collection<AudioFormat>>> entry : m_targetFormatsFromSourceFormat.entrySet()) {
            AudioFormat format = entry.getKey();
            if (AudioFormats.matches(format, sourceFormat)) {
                Map<AudioFormat.Encoding, Collection<AudioFormat>> targetEncodings = entry.getValue();
                Collection<AudioFormat> targetFormats = targetEncodings.get(targetEncoding);
                if (targetFormats != null) {
                    return targetFormats.toArray(EMPTY_FORMAT_ARRAY);
                }
                return EMPTY_FORMAT_ARRAY;
            }
        }
        return EMPTY_FORMAT_ARRAY;
    }
256550
public java.util.List<String> getPermittedFileTypes() {
        if (permittedFileTypes == null) {
            permittedFileTypes = new com.amazonaws.internal.SdkInternalList<String>();
        }
        return permittedFileTypes;
    }
656593
public static function getRecordTypes()
    {
        return [
            self::RECORD_TYPE_A,
            self::RECORD_TYPE_AAAA,
            self::RECORD_TYPE_CNAME,
            self::RECORD_TYPE_HINFO,
            self::RECORD_TYPE_MX,
            self::RECORD_TYPE_NS,
            self::RECORD_TYPE_PTR,
            self::RECORD_TYPE_SOA,
            self::RECORD_TYPE_SRV,
            self::RECORD_TYPE_TLSA,
            self::RECORD_TYPE_TXT,
        ];
    }
258100
public static String getSupportedImageTypes() {
        String[] readers = ImageIO.getReaderFormatNames();
        ArrayList<String> imageArray = new ArrayList<String>();
        String str = "";
        for (int i = 0; i < readers.length; i++) {
            String current = readers[i].toLowerCase();
            if (!imageArray.contains(current)) {
                imageArray.add(current);
                str += current + ",";
            }
        }
        return str.substring(0, str.lastIndexOf(","));
    }
1230438
private function ffprobeHasAudio()
	{
		if (isset($this->metadata['streams']))
		{
			foreach ($this->metadata['streams'] as $streamIndex => $stream)
			{
				if (isset($stream['codec_type']) && $stream['codec_type'] === "audio")
				{
					return $streamIndex;
				}
			}
		}

		return false;
	}
1207439
public FileChannel getFileChannel() {
        if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
            Tr.debug(tc, "getFileChannel(): " + fc);
        }
        return this.fc;
    }
709217
public java.util.List<String> getExportableLogTypes() {
        if (exportableLogTypes == null) {
            exportableLogTypes = new com.amazonaws.internal.SdkInternalList<String>();
        }
        return exportableLogTypes;
    }
1218071
@Pure
	public List<String> getMimeTypes() {
		if (this.mimeTypes.isEmpty()) {
			return Arrays.asList("text/x-" + getLanguageSimpleName().toLowerCase()); //$NON-NLS-1$
		}
		return this.mimeTypes;
	}
1208546
public static AudioFormat getAudioFormat(PayloadType payloadtype) {

        switch (payloadtype.getId()) {
            case 0:
                return new AudioFormat(AudioFormat.ULAW_RTP);
            case 3:
                return new AudioFormat(AudioFormat.GSM_RTP);
            case 4:
                return new AudioFormat(AudioFormat.G723_RTP);
            default:
                return null;
        }

    }
195786
public ChannelLayout[] getSupportedChannelLayouts() {
		LongPointer layoutsPointer = avCodec.channel_layouts();

		if (getType() != MediaType.AUDIO || layoutsPointer == null)
			return null;

		List<ChannelLayout> layouts = new ArrayList<ChannelLayout>();

		long layout;
		int index = 0;
		while ((layout = layoutsPointer.get(index++)) != 0)
			layouts.add(ChannelLayout.byId(layout));

		return layouts.toArray(new ChannelLayout[0]);
	}
1345851
public static function getAudioList() {
        if (self::$_audio) {
            return self::$_audio;
        }

        self::$_audio = self::_getList('audio');

        return self::$_audio;
    }
379913
public function getFileType(): ?array
    {
        if (empty($this->byteCache)) {
            return null;
        }

        /** cache */
        if (is_null($this->fileType)) {
            $this->fileType = $this->checkFileType();
        }

        return $this->fileType;
    }
1168083
public Class[] getArgTypes() {
        List<Class> types = new ArrayList<>();

        if (args != null) {
            for (MethodArg arg : args.getArgs()) {
                try {
                    types.add(Class.forName(arg.getType()));
                } catch (ClassNotFoundException e) {
                    throw new CitrusRuntimeException("Failed to access method argument type", e);
                }
            }
        }

        return types.toArray(new Class[types.size()]);
    }