renderers.setExtensionRendererMode(DefaultRenderersFactory.EXTENSION_RENDERER_MODE_PREFER)
        val trackSelectionFactory: ExoTrackSelection.Factory = AdaptiveTrackSelection.Factory()
        val trackSelector = DefaultTrackSelector(context, trackSelectionFactory)
        exoPlayer = ExoPlayer.Builder(context, renderers).setTrackSelector(trackSelector).setLoadControl(loadControl).build()
        currentContainerPlayer = containerPlayer
        currentTvHoldSec = tvHoldOk3Sec;

        if(Build.VERSION.SDK_INT <= Build.VERSION_CODES.M) {

        }

        exoPlayer!!.setTrackSelectionParameters(
            exoPlayer!!.getTrackSelectionParameters()
                .buildUpon()
                .setMaxVideoSizeSd()
                .setForceLowestBitrate(true)
                .setPreferredAudioLanguage("hu")
                .build()
        )
        playerView.player = exoPlayer
        playerView.setEnabledShutterView(false)
        exoPlayer!!.setVideoFrameMetadataListener(VideoFrameMetadataListener { presentationTimeUs, releaseTimeNs, format, mediaFormat ->
       //     Log.w(TAG, "New Frame: $presentationTimeUs -- || -- ${releaseTimeNs} ---- ")
            PlayerActivity.lastFrameTimeInMillis = System.currentTimeMillis()
            if (!isReady) isReady = true
        })
         
        
        
        //// METHOD ENCHARGED TO PLAY STREAM
        
        
        val extractorsFactory = DefaultExtractorsFactory()
            .setTsExtractorFlags(DefaultTsPayloadReaderFactory.FLAG_ALLOW_NON_IDR_KEYFRAMES)
            .setConstantBitrateSeekingAlwaysEnabled(true)
        val defaultFactory = DefaultHttpDataSource.Factory()
        val token = mPreferences.getString(KEY_PREF_TOKEN_STREAM, "noToken")
        defaultFactory.setDefaultRequestProperties(mapOf("Authorization" to "Bearer $token"))
        val dataSource: DataSource.Factory = defaultFactory
    //    val uri = Uri.parse(url.trim())
        var newUrl : String = url
       // val uri = getUriConvertedToLocal(newUrl)
        val uri = Uri.parse(newUrl)
        Log.w(TAG, "**************** NEW URI:::::::::::::: $uri")
        val drmSchemeUuid: UUID = C.WIDEVINE_UUID
        val type: Int = Util.inferContentType(uri)
        var mediaSource: MediaSource? = null
        val mediaItemBuilder: MediaItem.Builder = MediaItem.Builder(
        ).setUri(uri)

        //non drm streams will be played normally - change drm here

        //non drm streams will be played normally - change drm here
        if (true) {
            mediaItemBuilder.setDrmConfiguration(
                MediaItem.DrmConfiguration.Builder(drmSchemeUuid)
                    .setLicenseUri(drmLicenseUrl).build()
            )
        }

        when (type) {
            C.TYPE_DASH -> {
                Log.i(TAG, "onStart: type dash")
                mediaSource = DashMediaSource.Factory(dataSource)
                    .createMediaSource(mediaItemBuilder.build())
            }
            C.TYPE_SS -> Log.i(TAG, "onStart: type ss")
            C.TYPE_HLS -> {
                Log.i(TAG, "onStart: type hls")
                mediaSource = HlsMediaSource.Factory(dataSource)
                    .createMediaSource(mediaItemBuilder.build())
            }
            C.TYPE_OTHER -> {
                Log.i(TAG, "onStart: type other")
                mediaSource =
                    ProgressiveMediaSource.Factory(dataSource, extractorsFactory)
                        .createMediaSource(
                            mediaItemBuilder.build()
                    )
            }
            else -> {}
        }

        mediaSource?.let { source ->
            player.playWhenReady = playWhenReady
            player.setMediaSource(source, false)
            player.prepare()
        }

        val ratio = mPreferences.getInt("ASPECT_RATIO", 3)
        setRatio(playerView, player, ratio)```