Combine two audio files

@param string       $method  'concatenate', 'merge', 'mix', 'mix-power', 'multiply', 'sequence'
@param string|Track $in      File to mix with
@param string       $out     New filename
@return Track
168573
public function combine($method, $in, $out)
    {
        if ($in instanceof self) $in = $in->filename;

        $this->sox('--combine', $method, $in, $out);
        return new static($out);
    }
862521
protected static function _generateSignature($method)
    {
        $params = [];
        $isVariadic = Suite::$PHP >= 7 ? $method->isVariadic() : false;

        foreach ($method->getParameters() as $num => $parameter) {
            $typehint = Inspector::typehint($parameter);
            $name = $parameter->getName();
            $name = ($name && $name !== '...') ? $name : 'param' . $num;
            $reference = $parameter->isPassedByReference() ? '&' : '';
            $default = '';
            if ($parameter->isDefaultValueAvailable()) {
                $default = var_export($parameter->getDefaultValue(), true);
                $default = ' = ' . preg_replace('/\s+/', '', $default);
            } elseif ($parameter->isOptional()) {
                if ($isVariadic && $parameter->isVariadic()) {
                    $reference = '...';
                    $default = '';
                } else {
                    $default = ' = NULL';
                }
            }
            $allowsNull = '';
            $typehint = $typehint ? $typehint . ' ' : $typehint;
            if (Suite::$PHP >= 7) {
                $type = $parameter->getType();
                if ($type && method_exists($type, 'allowsNull') && $type->allowsNull()) {
                    $allowsNull = '?';
                }
            }
            $params[] = "{$allowsNull}{$typehint}{$reference}\${$name}{$default}";
        }
        return join(', ', $params);
    }
644245
public function getMethodCode($method)
    {
        $methodFile = $method->getFileName();
        $contents = file_get_contents($methodFile, true);
        if (!empty($contents)) {
            $contents = explode("\n", $contents);

            return trim(implode("\n", array_slice($contents, $method->getStartLine()-1, $method->getEndLine()-$method->getStartLine()+1)));
        }

        return false;
    }
402521
public function each($method)
    {
        foreach ($this as $rec) {
            if (is_string($method)) {
                $rec->$method();
            } elseif (is_callable($method)) {
                call_user_func($method, $rec);
            }
        }

        return $this;
    }
460995
public function inflectionMethod($method = null)
    {
        if ($method !== null) {
            $this->setInflectionMethod($method);
        }

        return $this->getInflectionMethod();
    }
737836
public function transmute($inFilename, Specification $targetFormat, $outFilename)
    {
        $extractedFile = $this->extractor->extract($inFilename, $targetFormat);

        if (!$extractedFile) {
            return null;
        }

        $this->converter->convert($extractedFile, $targetFormat, $outFilename);

        return $outFilename;
    }
1349213
public function filter($in, $out, &$consumed, $closing)
    {
        while ($bucket = stream_bucket_make_writeable($in)) {
            $bucket->data = $this->transformCode($bucket->data);
            $consumed += $bucket->datalen;
            stream_bucket_append($out, $bucket);
        }

        return PSFS_PASS_ON;
    }
806356
function mix($mix)
    {
        if (!empty($mix) && is_array($mix)) {
            $this->input = array_replace_recursive($this->input, $mix);
        }
        return $this;
    }
289104
public function add($method)
    {
        if (is_array($method)) {
            $this->collection[] = new DeliveryMethod($method);
        } elseif (is_object($method) && $method instanceof DeliveryMethod) {
            $this->collection[] = $method;
        }

        return $this;
    }
1219300
public function dispatch($method)
	{
		// Save original input.
		$original_input = Request::input();
		
		// Create request.
		$request = Request::create($this->uri, $method, $this->params);
		
		// Replace input (maintain api auth parameters).
		Request::replace(array_merge($request->input(), array(
			'client_id'     => Request::input('client_id'),
			'client_secret' => Request::input('client_secret'),
			'access_token'  => Request::input('access_token'),
		)));
		
		// Dispatch request.
		$response = Route::dispatch($request);
		
		// Restore original input.
		Request::replace($original_input);
		
		$content = $response->getContent();
		return empty($content) ? null : json_decode($response->getContent(), true);
	}
409510
public function createCall($method, $params = array())
	{
		$params = array_values($params);

		if ($this->isAsync())
		{
			$output = "_gaq.push(['{$method}',";
			$output .= substr(json_encode($params), 1, -1);
			$output .= ']);';
		}
		else
		{
			$output = "pageTracker.{$method}(";
			$output .= substr(json_encode($params), 1, -1);
			$output .= ');';
		}

		return $output;
	}
201333
public function isOpenInvoiceMethod($method)
    {
        $openinvoiceType = $this->getConfigData('openinvoicetypes', Adyen_Payment_Model_Adyen_Openinvoice::METHODCODE);

        if ($method == Adyen_Payment_Model_Adyen_Openinvoice::METHODCODE && $openinvoiceType == self::AFTERPAY_DEFAULT) {
            return true;
        }

        return false;
    }
881981
public void out2in(Object from, String from_out, Object... tos) {
        for (Object co : tos) {
            out2in(from, from_out, co, from_out);
        }
    }
200565
def _merge_out_from_infiles(in_files):
    
    fname = os.path.commonprefix([os.path.basename(f) for f in in_files])
    while fname.endswith(("-", "_", ".")):
        fname = fname[:-1]
    ext = os.path.splitext(in_files[0])[-1]
    dirname = os.path.dirname(in_files[0])
    while dirname.endswith(("split", "merge")):
        dirname = os.path.dirname(dirname)
    return os.path.join(dirname, "%s%s" % (fname, ext))
1258886
protected function mergeParams($method, Array $params = [])
    {
        $mergedParams = array_merge($this->defaultParams, $params);
        $newParams = [$method => $mergedParams];

        return $newParams;
    }
595687
public static function combine(?string ...$parts) : ?string
    {
        if (empty($parts)) {
            return null;
        }

        $key = hash('crc32', json_encode($parts));

        if (isset(self::$cache[$key])) {
            return self::$cache[$key];
        }

        $maxIndex = count($parts) - 1;
        $path = [];

        foreach ($parts as $index => $part) {
            if ($part !== '0' && empty($part)) {
                continue;
            }

            $part = str_replace('\\', '/', $part);

            if ($index === 0) {
                $path[] = rtrim($part, '/');
            } elseif ($index === $maxIndex) {
                $path[] = ltrim($part, '/');
            } else {
                $path[] = trim($part, '/');
            }
        }

        if (empty($path)) {
            return null;
        }

        $fullPath = implode('/', $path);

        if (is_dir($fullPath) || is_file($fullPath)) {
            return realpath($fullPath);
        }

        return self::$cache[$key] = $fullPath;
    }
87784
private function addMethod($method)
    {
        $tokens = $this->methodParser->parse($method);
        $query = $this->queryBuilder->build($tokens, $this->tableName, $this->namingContention, $this->entityClass);
        if ($query->getResultMode() <= QueryBuilderResult::RESULT_SELECT_MULTIPLE) {
            $this->addSelectionMethod($query, $method);
        } else {
            $this->addIntResultMethod($query, $method);
        }

    }