Get codec description from media elementary stream.
    @param i_type: i_type from L{MediaTrack}.
    @param i_codec: i_codec or i_original_fourcc from L{MediaTrack}.
    @return: codec description.
    @version: LibVLC 3.0.0 and later. See L{MediaTrack}.
427799
def libvlc_media_get_codec_description(i_type, i_codec):
    '''
    '''
    f = _Cfunctions.get('libvlc_media_get_codec_description', None) or \
        _Cfunction('libvlc_media_get_codec_description', ((1,), (1,),), None,
                    ctypes.c_char_p, TrackType, ctypes.c_uint32)
    return f(i_type, i_codec)
178329
public static List<Class<? extends CompressionCodec>> getCodecClasses(Configuration conf) {
    String codecsString = conf.get("io.compression.codecs");
    if (codecsString != null) {
      List<Class<? extends CompressionCodec>> result
        = new ArrayList<Class<? extends CompressionCodec>>();
      StringTokenizer codecSplit = new StringTokenizer(codecsString, ",");
      while (codecSplit.hasMoreElements()) {
        String codecSubstring = codecSplit.nextToken();
        if (codecSubstring.length() != 0) {
          try {
            Class<?> cls = conf.getClassByName(codecSubstring);
            if (!CompressionCodec.class.isAssignableFrom(cls)) {
              throw new IllegalArgumentException("Class " + codecSubstring +
                                                 " is not a CompressionCodec");
            }
            result.add(cls.asSubclass(CompressionCodec.class));
          } catch (ClassNotFoundException ex) {
            throw new IllegalArgumentException("Compression codec " + 
                                               codecSubstring + " not found.",
                                               ex);
          }
        }
      }
      return result;
    } else {
      return null;
    }
  }
995962
public static WaveletDescription<WlCoef_F32> generate_F32( int I ) {
		if( I != 6 ) {
			throw new IllegalArgumentException("Only 6 is currently supported");
		}

		WlCoef_F32 coef = new WlCoef_F32();

		coef.offsetScaling = -2;
		coef.offsetWavelet = -2;

		coef.scaling = new float[6];
		coef.wavelet = new float[6];

		double sqrt7 = Math.sqrt(7);
		double div = 16.0*Math.sqrt(2);
		coef.scaling[0] = (float)((1.0-sqrt7)/div);
		coef.scaling[1] = (float)((5.0+sqrt7)/div);
		coef.scaling[2] = (float)((14.0+2.0*sqrt7)/div);
		coef.scaling[3] = (float)((14.0-2.0*sqrt7)/div);
		coef.scaling[4] = (float)((1.0-sqrt7)/div);
		coef.scaling[5] = (float)((-3.0+sqrt7)/div);

		coef.wavelet[0] = coef.scaling[5];
		coef.wavelet[1] = -coef.scaling[4];
		coef.wavelet[2] = coef.scaling[3];
		coef.wavelet[3] = -coef.scaling[2];
		coef.wavelet[4] = coef.scaling[1];
		coef.wavelet[5] = -coef.scaling[0];

		WlBorderCoefStandard<WlCoef_F32> inverse = new WlBorderCoefStandard<>(coef);

		return new WaveletDescription<>(new BorderIndex1D_Wrap(), coef, inverse);
	}
527912
public ResponseBuilder getRepresentation(final Resource res) {
        final String identifier = getBaseUrl() + req.getPartition() + req.getPath();

        // Check if this is already deleted
        checkDeleted(res, identifier);

        LOGGER.debug("Acceptable media types: {}", req.getHeaders().getAcceptableMediaTypes());
        final Optional<RDFSyntax> syntax = getSyntax(req.getHeaders().getAcceptableMediaTypes(), res.getBinary()
                .map(b -> b.getMimeType().orElse(APPLICATION_OCTET_STREAM)));

        if (ACL.equals(req.getExt()) && !res.hasAcl()) {
            throw new NotFoundException();
        }

        final ResponseBuilder builder = basicGetResponseBuilder(res, syntax);

        // Add NonRDFSource-related "describe*" link headers
        res.getBinary().ifPresent(ds -> {
            if (syntax.isPresent()) {
                builder.link(identifier + "#description", "canonical").link(identifier, "describes");
            } else {
                builder.link(identifier, "canonical").link(identifier + "#description", "describedby")
                    .type(ds.getMimeType().orElse(APPLICATION_OCTET_STREAM));
            }
        });

        // Only show memento links for the user-managed graph (not ACL)
        if (!ACL.equals(req.getExt())) {
            builder.link(identifier, "original timegate")
                .links(MementoResource.getMementoLinks(identifier, res.getMementos()).toArray(Link[]::new));
        }

        // URI Template
        builder.header(LINK_TEMPLATE, "<" + identifier + "{?version}>; rel=\"" + Memento.Memento.getIRIString() + "\"");

        // NonRDFSources responses (strong ETags, etc)
        if (res.getBinary().isPresent() && !syntax.isPresent()) {
            return getLdpNr(identifier, res, builder);
        }

        // RDFSource responses (weak ETags, etc)
        final RDFSyntax s = syntax.orElse(TURTLE);
        final IRI profile = getProfile(req.getHeaders().getAcceptableMediaTypes(), s);
        return getLdpRs(identifier, res, builder, s, profile);
    }
1276428
def libvlc_media_player_set_time(p_mi, i_time):
    '''
    '''
    f = _Cfunctions.get('libvlc_media_player_set_time', None) or \
        _Cfunction('libvlc_media_player_set_time', ((1,), (1,),), None,
                    None, MediaPlayer, ctypes.c_longlong)
    return f(p_mi, i_time)
405213
def libvlc_video_set_spu(p_mi, i_spu):
    '''
    '''
    f = _Cfunctions.get('libvlc_video_set_spu', None) or \
        _Cfunction('libvlc_video_set_spu', ((1,), (1,),), None,
                    ctypes.c_int, MediaPlayer, ctypes.c_int)
    return f(p_mi, i_spu)
1339877
def libvlc_media_get_type(p_md):
    '''
    '''
    f = _Cfunctions.get('libvlc_media_get_type', None) or \
        _Cfunction('libvlc_media_get_type', ((1,),), None,
                    MediaType, Media)
    return f(p_md)
894735
static Codec<Tuple, DoubleGene> codec(
		final IntRange v1Domain,
		final LongRange v2Domain,
		final DoubleRange v3Domain
	) {
		return Codec.of(
			Genotype.of(
				DoubleChromosome.of(DoubleRange.of(v1Domain.getMin(), v1Domain.getMax())),
				DoubleChromosome.of(DoubleRange.of(v2Domain.getMin(), v2Domain.getMax())),
				DoubleChromosome.of(v3Domain)
			),
			gt -> new Tuple(
				gt.getChromosome(0).getGene().intValue(),
				gt.getChromosome(1).getGene().longValue(),
				gt.getChromosome(2).getGene().doubleValue()
			)
		);
	}
418268
public com.google.cloud.datalabeling.v1beta1.LabelVideoObjectDetectionOperationMetadataOrBuilder
      getVideoObjectDetectionDetailsOrBuilder() {
    if (detailsCase_ == 6) {
      return (com.google.cloud.datalabeling.v1beta1.LabelVideoObjectDetectionOperationMetadata)
          details_;
    }
    return com.google.cloud.datalabeling.v1beta1.LabelVideoObjectDetectionOperationMetadata
        .getDefaultInstance();
  }
910291
function getTypeFromFileExtension(url) {
	url = url.toLowerCase().split('?')[0];
	var _ext = url.substring(url.lastIndexOf('.') + 1);
	var _av = /mp4|m4v|ogg|ogv|m3u8|webm|webmv|wmv|mpeg|mov/gi.test(_ext) ? 'video/' : 'audio/';

	switch (_ext) {
		case 'mp4':
		case 'm4v':
		case 'm4a':
			return _av + 'mp4';
		case 'webm':
		case 'webma':
		case 'webmv':
			return _av + 'webm';
		case 'ogg':
		case 'oga':
		case 'ogv':
			return _av + 'ogg';
		case 'm3u8':
			return 'application/x-mpegurl';
		case 'ts':
			return _av + 'mp2t';
		default:
			return _av + _ext;
	}
}
1273309
def libvlc_media_list_new(p_instance):
    '''
    '''
    f = _Cfunctions.get('libvlc_media_list_new', None) or \
        _Cfunction('libvlc_media_list_new', ((1,),), class_result(MediaList),
                    ctypes.c_void_p, Instance)
    return f(p_instance)
1153012
private static WlCoef_I32 generateInv_I32() {
		WlCoef_I32 ret = new WlCoef_I32();

		ret.scaling = new int[]{1,1};
		ret.wavelet = new int[]{ret.scaling[0],-ret.scaling[0]};
		ret.denominatorScaling = 2;
		ret.denominatorWavelet = 2;

		return ret;
	}
706689
public static Class<?> getPrimitiveClass(Type type) {
        switch (type.getDescriptor().charAt(0)) {
            case 'B':
                return byte.class;
            case 'C':
                return char.class;
            case 'D':
                return double.class;
            case 'F':
                return float.class;
            case 'I':
                return int.class;
            case 'J':
                return long.class;
            case 'S':
                return short.class;
            case 'V':
                return void.class;
            case 'Z':
                return boolean.class;

            default:
                throw new IllegalArgumentException("Unrecognized type [ " + type.getDescriptor() + " ]");
        }
    }
1243477
function(codec)
	{
		if (codec != null)
		{
			var name = codec.getName();
			mxCodecRegistry.codecs[name] = codec;
			
			var classname = mxUtils.getFunctionName(codec.template.constructor);

			if (classname != name)
			{
				mxCodecRegistry.addAlias(classname, name);
			}
		}

		return codec;
	}
303227
def libvlc_media_player_get_media(p_mi):
    '''
    '''
    f = _Cfunctions.get('libvlc_media_player_get_media', None) or \
        _Cfunction('libvlc_media_player_get_media', ((1,),), class_result(Media),
                    ctypes.c_void_p, MediaPlayer)
    return f(p_mi)
437024
def libvlc_video_get_chapter_description(p_mi, i_title):
    '''
    '''
    f = _Cfunctions.get('libvlc_video_get_chapter_description', None) or \
        _Cfunction('libvlc_video_get_chapter_description', ((1,), (1,),), None,
                    ctypes.POINTER(TrackDescription), MediaPlayer, ctypes.c_int)
    return f(p_mi, i_title)
1066850
function detectType(media, options, src) {
	var mediaFiles = [];
	var i;
	var n;
	var isCanPlay;

	// Get URL and type
	if (options.type) {
		// Accept either string or array of types
		if (typeof options.type == 'string') {
			mediaFiles.push({
				type: options.type,
				url: src
			});
		} else {
			for (i = 0; i < options.type.length; i++) {
				mediaFiles.push({
					type: options.type[i],
					url: src
				});
			}
		}
	} else if (src !== null) {
		// If src attribute
		mediaFiles.push({
			type: getType(src, media.getAttribute('type')),
			url: src
		});
	} else {
		// If <source> elements
		for (i = 0; i < media.children.length; i++) {
			n = media.children[i];

			if (n.nodeType == 1 && n.tagName.toLowerCase() == 'source') {
				src = n.getAttribute('src');
				mediaFiles.push({
					type: getType(src, n.getAttribute('type')),
					url: src
				});
			}
		}
	}

	// For Android which doesn't implement the canPlayType function (always returns '')
	if (zyMedia.features.isBustedAndroid) {
		media.canPlayType = function(type) {
			return /video\/(mp4|m4v)/i.test(type) ? 'maybe' : ''
		};
	}
	// For Chromium to specify natively supported video codecs (i.e. WebM and Theora) 
	if (zyMedia.features.isChromium) {
		media.canPlayType = function(type) {
			return /video\/(webm|ogv|ogg)/i.test(type) ? 'maybe' : ''
		};
	}

	if (zyMedia.features.supportsCanPlayType) {
		for (i = 0; i < mediaFiles.length; i++) {
			// Normal detect
			if (mediaFiles[i].type == "video/m3u8" || media.canPlayType(mediaFiles[i].type).replace(/no/, '') !== ''
				// For Mac/Safari 5.0.3 which answers '' to canPlayType('audio/mp3') but 'maybe' to canPlayType('audio/mpeg')
				|| media.canPlayType(mediaFiles[i].type.replace(/mp3/, 'mpeg')).replace(/no/, '') !== ''
				// For m4a supported by detecting mp4 support
				|| media.canPlayType(mediaFiles[i].type.replace(/m4a/, 'mp4')).replace(/no/, '') !== '') {
				isCanPlay = true;
				break
			}
		}
	}

	return isCanPlay
}