Release (free) L{TrackDescription}.
    @param p_track_description: the structure to release.
165159
def libvlc_track_description_list_release(p_track_description):
    '''
    '''
    f = _Cfunctions.get('libvlc_track_description_list_release', None) or \
        _Cfunction('libvlc_track_description_list_release', ((1,),), None,
                    None, ctypes.POINTER(TrackDescription))
    return f(p_track_description)
549289
def libvlc_audio_set_track(p_mi, i_track):
    '''
    '''
    f = _Cfunctions.get('libvlc_audio_set_track', None) or \
        _Cfunction('libvlc_audio_set_track', ((1,), (1,),), None,
                    ctypes.c_int, MediaPlayer, ctypes.c_int)
    return f(p_mi, i_track)
567049
public void setDescription(CmsObject cms, String description) {

        if (CmsStringUtil.isEmptyOrWhitespaceOnly(description)) {
            m_description = "";
            if (m_element.element(PARAM_DESCRIPTION) != null) {
                m_element.remove(m_element.element(PARAM_DESCRIPTION));
            }
        } else {
            m_description = description;
            description = CmsEncoder.escapeWBlanks(description, CmsEncoder.ENCODING_UTF_8);
        }
        setParameterValue(cms, PARAM_DESCRIPTION, description);
    }
942730
public void setTracks(final Track[] tracks) {
		List<Track> list = tracks == null ? null : Arrays.asList(tracks);
		getOrCreateComponentModel().tracks = list;
	}
887051
public void spawnTracksFromDetected() {
		// mark detected features with no matches as available
		FastQueue<AssociatedIndex> matches = associate.getMatches();

		int N = detector.getNumberOfFeatures();
		for( int i = 0; i < N; i++ )
			associated[i] = false;

		for( AssociatedIndex i : matches.toList() ) {
			associated[i.dst] = true;
		}

		// spawn new tracks for unassociated detected features
		for( int i = 0; i < N; i++ ) {
			if( associated[i])
				continue;

			Point2D_F64 p = detector.getLocation(i);

			TD d = detectedDesc.get(i);

			CombinedTrack<TD> track;

			if( tracksUnused.size() > 0 ) {
				track = tracksUnused.pop();
			} else {
				track = new CombinedTrack<>();
				track.desc = detector.createDescription();
				track.track = trackerKlt.createNewTrack();
			}

			// create the descriptor for tracking
			trackerKlt.setDescription((float)p.x,(float)p.y,track.track);
			// set track ID and location
			track.featureId = totalTracks++;
			track.desc.setTo(d);
			track.set(p);

			// update list of active tracks
			tracksPureKlt.add(track);
			tracksSpawned.add(track);
		}
	}
326918
public function actionTrack(): void
	{
		if ($this->getPost('leave')) {
			$this->tracking->leave();
		}
		if ($this->getPost('url')) {
			$this->tracking->track();
		}
		$this->terminate();
	}
668317
@Override
    public void release() throws IOException
    {
        if (includeLevel.in != null && end != cursor)
        {
            if (end % size < cursor % size)
            {
                buffer2.position(0);
                buffer2.limit((int)(end % size));
                buffer1.position((int)(cursor % size));
                buffer1.limit(size);
            }
            else
            {
                buffer2.position((int)(cursor % size));
                buffer2.limit((int)(end % size));
                buffer1.position(size);
            }
            if (features.contains(UsePushback))
            {
                if (includeLevel.in instanceof Pushbackable)
                {
                    Pushbackable p = (Pushbackable) includeLevel.in;
                    p.pushback(array2);
                }
                else
                {
                    unread(includeLevel.in);
                }
            }
            else
            {
                if (includeLevel.in instanceof Rewindable)
                {
                    Rewindable rewindable = (Rewindable) includeLevel.in;
                    rewindable.rewind((int)(end-cursor));
                }
                else
                {
                    unread(includeLevel.in);
                }
            }
            buffer1.clear();
            buffer2.clear();
            end = cursor;
        }
    }
74902
@Override
	public boolean dropTrack(PointTrack track) {
		if( !tracksAll.remove(track) )
			return false;

		if( !sets[track.setId].tracks.remove(track) ) {
			return false;
		}
		// the track may or may not be in the active list
		tracksActive.remove(track);
		tracksInactive.remove(track);
		// it must be in the all list
		// recycle the data
		unused.add(track);
		return true;
	}
10369
def _parse_track_id(self,sdp):
        ''''''
        m = re.search(r'a=control:(?P<trackid>[\w=\d]+)',sdp,re.S)
        return (m and m.group('trackid')) or ''
269243
private String trackKindToString(final Track.Kind kind) {
		if (kind == null) {
			return null;
		}

		switch (kind) {
			case SUBTITLES:
				return "subtitles";

			case CAPTIONS:
				return "captions";

			case DESCRIPTIONS:
				return "descriptions";

			case CHAPTERS:
				return "chapters";

			case METADATA:
				return "metadata";

			default:
				LOG.error("Unknown track kind " + kind);
				return null;
		}
	}
651104
function(track, stream) {
    stream.addTrack(track);
    stream.dispatchEvent(new window.MediaStreamTrackEvent('addtrack',
      {track: track}));
  }
239852
public boolean dropTrack( CombinedTrack<TD> track ) {
		if( !tracksPureKlt.remove(track) )
			if( !tracksReactivated.remove(track) )
				if( !tracksDormant.remove(track) )
					return false;

		tracksUnused.add(track);
		return true;
	}
507756
def create_track(self, path_in_ipod=None, checksum=None):
        
        if bool(path_in_ipod) == bool(checksum):
            raise Exception

        if not path_in_ipod:
            path_in_ipod = self.audiodb.get_voice(checksum)

        track = Track(self, path_in_ipod=path_in_ipod)

        return track
466719
public void setDescription(String description) {

        if (CmsStringUtil.isEmptyOrWhitespaceOnly(description)) {
            throw new CmsIllegalArgumentException(
                org.opencms.db.Messages.get().container(org.opencms.db.Messages.ERR_BAD_OU_DESCRIPTION_EMPTY_0));
        }

        m_description = description;
    }
123410
public static void endTrack(final String title){
    if(isClosed){ return; }
    //--Make Task
    final long timestamp = System.currentTimeMillis();
    Runnable endTrack = new Runnable(){
      public void run(){
        assert !isThreaded || control.isHeldByCurrentThread();
        //(check name match)
        String expected = titleStack.pop();
        if(!expected.equalsIgnoreCase(title)){
          throw new IllegalArgumentException("Track names do not match: expected: " + expected + " found: " + title);
        }
        //(decrement depth)
        depth -= 1;
        //(send signal)
        handlers.process(null, MessageType.END_TRACK, depth, timestamp);
        assert !isThreaded || control.isHeldByCurrentThread();
      }
    };
    //--Run Task
    if(isThreaded){
      //(case: multithreaded)
      long threadId = Thread.currentThread().getId();
      attemptThreadControl( threadId, endTrack );
    } else {
      //(case: no threading)
      endTrack.run();
    }
  }
165689
def play_track(self, track_id=DEFAULT_TRACK_ID, position=0):
        """"""
        self.publish(
            action='playTrack',
            resource='audioPlayback/player',
            publish_response=False,
            properties={'trackId': track_id, 'position': position}
        )
497152
protected boolean trackFeature() {

		pairs.reset();
		// total number of tracks which contribute to FB error
		int numTracksFB = 0;
		// tracks which are not dropped
		int numTracksRemaining = 0;

		for( int i = 0; i < tracks.length; i++ ) {
			Track t = tracks[i];
			if( !t.active )
				continue;

			float prevX = t.klt.x;
			float prevY = t.klt.y;

			// track in forwards direction
			tracker.setImage(currentImage,currentDerivX,currentDerivY);
			KltTrackFault result = tracker.track(t.klt);
			if( result != KltTrackFault.SUCCESS ) {
				t.active = false;
				continue;
			}

			float currX = t.klt.x;
			float currY = t.klt.y;

			// track in reverse direction
			tracker.setDescription(t.klt);
			tracker.setImage(previousImage, previousDerivX, previousDerivY);
			result = tracker.track(t.klt);
			if( result != KltTrackFault.SUCCESS ) {
				t.active = false;
				continue;
			}

			// compute forward-backwards error
			double errorForwardBackwards = UtilPoint2D_F32.distanceSq(prevX,prevY,t.klt.x,t.klt.y);

			// put into lists for computing the median error
			errorsFB[numTracksFB++] = errorForwardBackwards;

			// discard if error is too large
			if( errorForwardBackwards > maxErrorFB ) {
				t.active = false;
				continue;
			}

			// create data structure used for group motion estimation
			AssociatedPair p = pairs.grow();
			p.p1.set( prevX, prevY );
			p.p2.set( currX, currY );

			numTracksRemaining++;
		}

		// if the forward-backwards error is too large, give up
		double medianFB = QuickSelect.select(errorsFB,numTracksFB/2,numTracksFB);

//		System.out.println("Median tracking error FB: "+medianFB);

		if( medianFB > maxErrorFB || numTracksRemaining < 4 )
			return false;

		return true;
	}