Get the audio data line.

@param input The audio input.
@return The audio source data.
@throws IOException If no audio line available (may be already opened).
964205
@SuppressWarnings("resource")
    private static SourceDataLine getDataLine(AudioInputStream input) throws IOException
    {
        final AudioFormat format = input.getFormat();
        try
        {
            final SourceDataLine dataLine;
            if (WavFormat.mixer != null)
            {
                dataLine = AudioSystem.getSourceDataLine(format, WavFormat.mixer);
            }
            else
            {
                dataLine = AudioSystem.getSourceDataLine(format);
            }
            dataLine.open(format);

            return dataLine;
        }
        catch (final LineUnavailableException exception)
        {
            throw new IOException(exception);
        }
    }
178648
@Override
  public InputStream getInputStream()
    throws IOException
  {
    InputStream is = _is;
    _is = null;

    return is;
  }
1024973
public OggData getData(InputStream input) throws IOException {
		if (input == null) {
			throw new IOException("Failed to read OGG, source does not exist?");
		}
		ByteArrayOutputStream dataout = new ByteArrayOutputStream();
		
//		SyncState oy = new SyncState(); // sync and verify incoming physical bitstream
//		StreamState os = new StreamState(); // take physical pages, weld into a logical stream of packets
//		Page og = new Page(); // one Ogg bitstream page.  Vorbis packets are inside
//		Packet op = new Packet(); // one raw packet of data for decode
//
//		Info vi = new Info(); // struct that stores all the static vorbis bitstream settings
//		Comment vc = new Comment(); // struct that stores all the bitstream user comments
//		DspState vd = new DspState(); // central working state for the packet->PCM decoder
//		Block vb = new Block(vd); // local working space for packet->PCM decode
//
//		byte[] buffer;
//		int bytes = 0;
//
//		boolean bigEndian = ByteOrder.nativeOrder().equals(ByteOrder.BIG_ENDIAN);
//		// Decode setup
//
//		oy.init(); // Now we can read pages
//
//		while (true) { // we repeat if the bitstream is chained
//			int eos = 0;
//
//			// grab some data at the head of the stream.  We want the first page
//			// (which is guaranteed to be small and only contain the Vorbis
//			// stream initial header) We need the first page to get the stream
//			// serialno.
//
//			// submit a 4k block to libvorbis' Ogg layer
//			int index = oy.buffer(4096);
//			
//			buffer = oy.data;
//			try {
//				bytes = input.read(buffer, index, 4096);
//			} catch (Exception e) {
//				Log.error("Failure reading in vorbis");
//				Log.error(e);
//				System.exit(0);
//			}
//			oy.wrote(bytes);
//
//			// Get the first page.
//			if (oy.pageout(og) != 1) {
//				// have we simply run out of data?  If so, we're done.
//				if (bytes < 4096)
//					break;
//
//				// error case.  Must not be Vorbis data
//				Log.error("Input does not appear to be an Ogg bitstream.");
//				System.exit(0);
//			}
//
//			// Get the serial number and set up the rest of decode.
//			// serialno first; use it to set up a logical stream
//			os.init(og.serialno());
//
//			// extract the initial header from the first page and verify that the
//			// Ogg bitstream is in fact Vorbis data
//
//			// I handle the initial header first instead of just having the code
//			// read all three Vorbis headers at once because reading the initial
//			// header is an easy way to identify a Vorbis bitstream and it's
//			// useful to see that functionality seperated out.
//
//			vi.init();
//			vc.init();
//			if (os.pagein(og) < 0) {
//				// error; stream version mismatch perhaps
//				Log.error("Error reading first page of Ogg bitstream data.");
//				System.exit(0);
//			}
//
//			if (os.packetout(op) != 1) {
//				// no page? must not be vorbis
//				Log.error("Error reading initial header packet.");
//				System.exit(0);
//			}
//
//			if (vi.synthesis_headerin(vc, op) < 0) {
//				// error case; not a vorbis header
//				Log.error("This Ogg bitstream does not contain Vorbis audio data.");
//				System.exit(0);
//			}
//
//			// At this point, we're sure we're Vorbis.  We've set up the logical
//			// (Ogg) bitstream decoder.  Get the comment and codebook headers and
//			// set up the Vorbis decoder
//
//			// The next two packets in order are the comment and codebook headers.
//			// They're likely large and may span multiple pages.  Thus we reead
//			// and submit data until we get our two pacakets, watching that no
//			// pages are missing.  If a page is missing, error out; losing a
//			// header page is the only place where missing data is fatal. */
//
//			int i = 0;
//			while (i < 2) {
//				while (i < 2) {
//
//					int result = oy.pageout(og);
//					if (result == 0)
//						break; // Need more data
//					// Don't complain about missing or corrupt data yet.  We'll
//					// catch it at the packet output phase
//
//					if (result == 1) {
//						os.pagein(og); // we can ignore any errors here
//						// as they'll also become apparent
//						// at packetout
//						while (i < 2) {
//							result = os.packetout(op);
//							if (result == 0)
//								break;
//							if (result == -1) {
//								// Uh oh; data at some point was corrupted or missing!
//								// We can't tolerate that in a header.  Die.
//								Log.error("Corrupt secondary header.  Exiting.");
//								System.exit(0);
//							}
//							vi.synthesis_headerin(vc, op);
//							i++;
//						}
//					}
//				}
//				// no harm in not checking before adding more
//				index = oy.buffer(4096);
//				buffer = oy.data;
//				try {
//					bytes = input.read(buffer, index, 4096);
//				} catch (Exception e) {
//					Log.error("Failed to read Vorbis: ");
//					Log.error(e);
//					System.exit(0);
//				}
//				if (bytes == 0 && i < 2) {
//					Log.error("End of file before finding all Vorbis headers!");
//					System.exit(0);
//				}
//				oy.wrote(bytes);
//			}
//
//			convsize = 4096 / vi.channels;
//
//			// OK, got and parsed all three headers. Initialize the Vorbis
//			//  packet->PCM decoder.
//			vd.synthesis_init(vi); // central decode state
//			vb.init(vd); // local state for most of the decode
//			// so multiple block decodes can
//			// proceed in parallel.  We could init
//			// multiple vorbis_block structures
//			// for vd here
//
//			float[][][] _pcm = new float[1][][];
//			int[] _index = new int[vi.channels];
//			// The rest is just a straight decode loop until end of stream
//			while (eos == 0) {
//				while (eos == 0) {
//
//					int result = oy.pageout(og);
//					if (result == 0)
//						break; // need more data
//					if (result == -1) { // missing or corrupt data at this page position
//						Log.error("Corrupt or missing data in bitstream; continuing...");
//					} else {
//						os.pagein(og); // can safely ignore errors at
//						// this point
//						while (true) {
//							result = os.packetout(op);
//
//							if (result == 0)
//								break; // need more data
//							if (result == -1) { // missing or corrupt data at this page position
//								// no reason to complain; already complained above
//							} else {
//								// we have a packet.  Decode it
//								int samples;
//								if (vb.synthesis(op) == 0) { // test for success!
//									vd.synthesis_blockin(vb);
//								}
//
//								// **pcm is a multichannel float vector.  In stereo, for
//								// example, pcm[0] is left, and pcm[1] is right.  samples is
//								// the size of each channel.  Convert the float values
//								// (-1.<=range<=1.) to whatever PCM format and write it out
//
//								while ((samples = vd.synthesis_pcmout(_pcm,
//										_index)) > 0) {
//									float[][] pcm = _pcm[0];
//									//boolean clipflag = false;
//									int bout = (samples < convsize ? samples
//											: convsize);
//
//									// convert floats to 16 bit signed ints (host order) and
//									// interleave
//									for (i = 0; i < vi.channels; i++) {
//										int ptr = i * 2;
//										//int ptr=i;
//										int mono = _index[i];
//										for (int j = 0; j < bout; j++) {
//											int val = (int) (pcm[i][mono + j] * 32767.);
//											//			      short val=(short)(pcm[i][mono+j]*32767.);
//											//			      int val=(int)Math.round(pcm[i][mono+j]*32767.);
//											// might as well guard against clipping
//											if (val > 32767) {
//												val = 32767;
//												//clipflag = true;
//											}
//											if (val < -32768) {
//												val = -32768;
//												//clipflag = true;
//											}
//											if (val < 0)
//												val = val | 0x8000;
//				
//											if (bigEndian) {
//												convbuffer[ptr] = (byte) (val >>> 8);
//												convbuffer[ptr + 1] = (byte) (val);
//											} else {
//												convbuffer[ptr] = (byte) (val);
//												convbuffer[ptr + 1] = (byte) (val >>> 8);
//											}
//											ptr += 2 * (vi.channels);
//										}
//									}
//
//									dataout.write(convbuffer, 0, 2 * vi.channels * bout);
//
//									vd.synthesis_read(bout); // tell libvorbis how
//									// many samples we
//									// actually consumed
//								}
//							}
//						}
//						if (og.eos() != 0)
//							eos = 1;
//					}
//				}
//				if (eos == 0) {
//					index = oy.buffer(4096);
//					if (index >= 0) {
//						buffer = oy.data;
//						try {
//							bytes = input.read(buffer, index, 4096);
//						} catch (Exception e) {
//							Log.error("Failure during vorbis decoding");
//							Log.error(e);
//							return null;
//						}
//					} else {
//						bytes = 0;
//					}
//					oy.wrote(bytes);
//					if (bytes == 0)
//						eos = 1;
//				}
//			}
//
//			// clean up this logical bitstream; before exit we see if we're
//			// followed by another [chained]
//
//			os.clear();
//
//			// ogg_page and ogg_packet structs always point to storage in
//			// libvorbis.  They're never freed or manipulated directly
//
//			vb.clear();
//			vd.clear();
//			vi.clear(); // must be called last
//		}
//
//		// OK, clean up the framer
//		oy.clear();
//		OggData ogg = new OggData();
//		ogg.channels = vi.channels;
//		ogg.rate = vi.rate;

		OggInputStream oggInput = new OggInputStream(input);
		
		boolean done = false;
		while (!oggInput.atEnd()) {
			dataout.write(oggInput.read());
		}
	
		OggData ogg = new OggData();
		ogg.channels = oggInput.getChannels();
		ogg.rate = oggInput.getRate();
		
		byte[] data = dataout.toByteArray();
		ogg.data = ByteBuffer.allocateDirect(data.length);
		ogg.data.put(data);
		ogg.data.rewind();
		
		return ogg;
	}
319996
@Override
    public AudioFileFormat getAudioFileFormat(InputStream inputStream, long medialength) throws UnsupportedAudioFileException, IOException {
        return getAudioFileFormat(inputStream, (int) medialength, AudioSystem.NOT_SPECIFIED);
    }
144175
@Override
    public synchronized InputStream getInputStream() throws IOException {
        if (connected == false) {
            // Implicitly open the connection if it has not yet been done so.
            connect();
        }

        Object token = ThreadIdentityManager.runAsServer();
        try {
            if (inputStream == null) {
                if ("".equals(archivePath)) {
                    inputStream = new FileInputStream(urlTargetFile);
                } else {
                    inputStream = new FilterZipFileInputStream(urlTargetFile, archivePath);
                }
            }
        } finally {
            ThreadIdentityManager.reset(token);
        }

        return inputStream;
    }
46714
public static int readRawVarint32(InputStream input) throws IOException {
    int firstByte = input.read();
    return CodedInputStream.readRawVarint32(firstByte, input);
  }
823386
public static String convertToString(InputStream input) throws IOException {
		try {
			if (input == null) {
				throw new IOException("Input Stream Cannot be NULL");
			}
			StringBuilder sb1 = new StringBuilder();
			String line;
			try {
				BufferedReader r1 = new BufferedReader(new InputStreamReader(input, "UTF-8"));
				while ((line = r1.readLine()) != null) {
					sb1.append(line);
				}
			} finally {
				input.close();
			}
			return sb1.toString();
		} catch (IOException e) {
			throw new JKException(e);
		}
	}
854027
public static String readline(InputStream input, boolean includeLF) throws IOException {
		StringBuilder sb = new StringBuilder();
		while (true) {
			int c = input.read();
			if (c == -1) {
				if (sb.length() == 0)
					throw new IOException("premature end of file");
				break;
			}
			if (c != '\n' || includeLF)
				sb.append((char) c);
			if (c == '\n')
				break;
		}
		return sb.toString();
	}
146240
public static int[] getImageSize(InputStream input) throws IOException
    {
        try {
            ImageInputStream imageInput = ImageIO.createImageInputStream(input);
            BufferedImage image = ImageIO.read(imageInput);
            return new int[]{image.getWidth(), image.getHeight()};
        } finally {
            input.close();
        }
    }
985732
public static Map<String, Object> read(StreamingInput input)
		throws IOException
	{
		Token next = input.peek();
		if(next == null) return Collections.emptyMap();

		switch(next)
		{
			case LIST_START:
			case LIST_END:
			case OBJECT_END:
			case VALUE:
			case NULL:
				throw new SerializationException("Error in configuration file, should be in in key, value format");
		}

		return readMap(input);
	}
112915
function gotStream(stream) {
    console.log("AudioInputCaptureProxy: gotStream");

    inputPoint = audioContext.createGain();

    // Create an AudioNode from the stream.
    audioStream = stream;
    realAudioInput = audioContext.createMediaStreamSource(stream);
    if (channels = 1) {
        audioInput = convertToMono(realAudioInput);
    }
    else {
        audioInput = realAudioInput;
    }

    // we will end up downsampling, but recorderWorker.js does this by simply dropping samples
    // so we use a low pass filter to prevent aliasing of higher frequencies
    if (sampleRate < audioContext.sampleRate) {
        var lowPassFilter = audioContext.createBiquadFilter();
        audioInput.connect(lowPassFilter);
        lowPassFilter.connect(inputPoint);
        lowPassFilter.type = lowPassFilter.LOWPASS || "lowpass";
        lowPassFilter.frequency.value = sampleRate / 2;
        lowPassFilter.connect(inputPoint);
    }
    else {
        audioInput.connect(inputPoint);
    }

    console.log("AudioInputCaptureProxy: creating audioRecorder");
    audioRecorder = new Recorder(inputPoint, {sampleRate: sampleRate});

    // pump through zero gain so that the microphone input doesn't play out the speakers causing feedback
    zeroGain = audioContext.createGain();
    zeroGain.gain.value = 0.0;
    inputPoint.connect(zeroGain);
    zeroGain.connect(audioContext.destination);

    microphonePermission = true;
    onSuccessGotStream(microphonePermission);
}
616204
@Override
	public ChannelInput<ByteBuf> getInput() {
		return input -> {
			this.input = sanitize(input);
			//noinspection ConstantConditions
			if (this.input != null && this.output != null) startProcess();
			return getProcessCompletion();
		};
	}
256866
public String getString() throws IOException {
        ByteArrayInputStream in = new ByteArrayInputStream(buf);
        int                  c;
        StringWriter         w = new StringWriter();
        while (((c = in.read()) != 0) && (c != -1)) {
            w.write((char) c);
        }
        return w.getBuffer().toString();
    }
1126975
@SuppressWarnings("PMD.AvoidInstantiatingObjectsInLoops")
    private static Request parse(final InputStream input) throws IOException {
        boolean eof = true;
        final Collection<String> head = new LinkedList<>();
        final ByteArrayOutputStream baos = new ByteArrayOutputStream();
        Opt<Integer> data = new Opt.Empty<>();
        data = RqLive.data(input, data, false);
        while (data.get() > 0) {
            eof = false;
            if (data.get() == '\r') {
                RqLive.checkLineFeed(input, baos, head.size() + 1);
                if (baos.size() == 0) {
                    break;
                }
                data = new Opt.Single<>(input.read());
                final Opt<String> header = RqLive.newHeader(data, baos);
                if (header.has()) {
                    head.add(header.get());
                }
                data = RqLive.data(input, data, false);
                continue;
            }
            baos.write(RqLive.legalCharacter(data, baos, head.size() + 1));
            data = RqLive.data(input, new Opt.Empty<>(), true);
        }
        if (eof) {
            throw new IOException("empty request");
        }
        return new Request() {
            @Override
            public Iterable<String> head() {
                return head;
            }

            @Override
            public InputStream body() {
                return input;
            }
        };
    }
1242609
public InputStream openInputStream()
    throws IOException
  {
    StreamSource indirectSource = _indirectSource;
    
    if (indirectSource != null) {
      return indirectSource.openInputStream();
    }
    
    TempOutputStream out = _out;
    if (out != null) {
      return out.openInputStreamNoFree();
    }
    
    // System.err.println("OpenInputStream: fail to open input stream for " + this);
    throw new IOException(L.l("{0}: no input stream is available",
                              this));
  }
86944
public void process(File input) throws IOException {
        File filtered = getFilteredVersion(input);
        if (filtered == null) {
            // It was not copied.
            getLog().warn("Cannot find the filtered version of " + input.getAbsolutePath() + ", " +
                    "using source file.");
            filtered = input;
        }

        // Actual processing.
        String result = instance.markdownToHtml(FileUtils.readFileToString(filtered));

        FileUtils.write(getOutputFile(input, "html"), result);
    }
1162835
public Audio[] getAudio() {
		List<Audio> list = getComponentModel().audio;
		return list == null ? null : list.toArray(new Audio[]{});
	}