How to use

Media

in

org.videolan.libvlc

public static byte[] getThumbnail(Media media, int i_width, int i_height) {
  media.addOption(":no-audio");
  media.addOption(":no-spu");
  media.addOption(":no-osd");
  media.addOption(":input-fast-seek");
  return nativeGetThumbnail(media, i_width, i_height);
}

  @Override
  void release() {
    if (retain)
      media.release();
  }
}

/**
 * Enable HWDecoder options if not already set
 */
protected void setDefaultMediaPlayerOptions() {
  boolean codecOptionSet;
  synchronized (this) {
    codecOptionSet = mCodecOptionSet;
    mCodecOptionSet = true;
  }
  if (!codecOptionSet)
    setHWDecoderEnabled(true, false);
}

/**
 * Browse to the specified local path starting with '/'.
 *
 * @param path
 * @param flags see {@link MediaBrowser.Flag}
 */
@MainThread
public void browse(String path, int flags) {
  final Media media = new Media(mLibVlc, path);
  browse(media, flags);
  media.release();
}

  isSaveState = false;
  Media media = mMediaPlayer.getMedia();
  if (media != null && !media.isReleased()) {
    canSeek = true;
    canPause = true;
  final Media media = new Media(libVLC, Uri.parse(path));
  if (Build.VERSION.SDK_INT <= KITKAT) {
    media.setHWDecoderEnabled(false, false);
  media.setEventListener(mMediaListener);
  media.parseAsync(Media.Parse.FetchNetwork, 5 * 1000);
  mMediaPlayer.setMedia(media);
  media.release();
} else {
  final Media media = new Media(libVLC, path);
  if (Build.VERSION.SDK_INT <= KITKAT) {
    media.setHWDecoderEnabled(false, false);
  media.setEventListener(mMediaListener);
  media.release();

/**
 * Browse to the specified media.
 *
 * @param media Can be a media returned by MediaBrowser.
 * @param flags see {@link MediaBrowser.Flag}
 */
@MainThread
public void browse(Media media, int flags) {
  /* media can be associated with a medialist,
   * so increment ref count in order to don't clean it with the medialist
   */
  media.retain();
  media.addOption(IGNORE_LIST_OPTION + mIgnoreList);
  if ((flags & Flag.NoSlavesAutodetect) != 0)
    media.addOption(":no-sub-autodetect-file");
  if ((flags & Flag.ShowHiddenFiles) != 0)
    media.addOption(":show-hiddenfiles");
  int mediaFlags = Media.Parse.ParseNetwork;
  if ((flags & Flag.Interact) != 0)
    mediaFlags |= Media.Parse.DoInteract;
  reset();
  mBrowserMediaList = media.subItems();
  mBrowserMediaList.setEventListener(mBrowserMediaListEventListener, mHandler);
  media.parseAsync(mediaFlags, 0);
  mMedia = media;
}

private synchronized Media insertMediaFromEvent(int index) {
  mCount++;
  for (int i = mCount - 1; i >= index; --i)
    mMediaArray.put(i + 1, mMediaArray.valueAt(i));
  final Media media = new Media(this, index);
  mMediaArray.put(index, media);
  return media;
}

final Media media = new Media(VLCMediaPlayer.getLibVlcInstance(),
    Uri.parse(fileURI));
media.parse();
parseCounter++;
if ((media.getDuration() == 0 || (media.getTrackCount() != 0
    && TextUtils.isEmpty(media.getTrack(0).codec)))
    && fileURI.endsWith(".mod")) {
  Log.d(TAG, "File skipped: " + fileURI);
media.release();
mw.setLastModified(file.lastModified());
mediaWrappers.add(mw);

@Override
public void onCreate(Bundle savedInstanceState) {
  super.onCreate(savedInstanceState);
  libVLC = VLCInstance.get(getContext());
  mediaPlayer = new MediaPlayer(libVLC);
  Media media = new Media(libVLC, Uri.parse(path));
  media.setHWDecoderEnabled(false, false);
  media.parseAsync(Media.Parse.FetchNetwork, 10 * 1000);
  mediaPlayer.setMedia(media);
  mediaPlayer.setEventListener(new MediaPlayer.EventListener() {
    @Override
    public void onEvent(MediaPlayer.Event event) {
      switch (event.type) {
        case MediaPlayer.Event.Opening:
          Log.i(tag, "Event Opening");
          break;
        case MediaPlayer.Event.Buffering:
          Log.i(tag, "Event Buffering=" + event.getBuffering());
          break;
        case MediaPlayer.Event.Stopped:
          Log.i(tag, "Event Stopped");
          break;
      }
    }
  });
  mediaPlayer.getVLCVout().addCallback(this);
}

  addOption(":codec=all");
  return;
addOption(":file-caching=1500");
addOption(":network-caching=1500");
  sb.append(getMediaCodecModule()).append(",");
if (force && (decoder == HWDecoderUtil.Decoder.OMX || decoder == HWDecoderUtil.Decoder.ALL))
  sb.append("iomx,");
sb.append("all");
addOption(sb.toString());

Media m = new Media(mVlc, Uri.parse(url));
int cache = 1500;
m.addOption(":network-caching=" + cache);
m.addOption(":file-caching=" + cache);
m.addOption(":live-cacheing=" + cache);
m.addOption(":sout-mux-caching=" + cache);
m.addOption(":codec=mediacodec,iomx,all");
mMediaPlayer.setMedia(m);
mMediaPlayer.play();

private void init(Media media) {
  mType = TYPE_ALL;
  if (media != null) {
    if (media.isParsed()) {
      mLength = media.getDuration();
      for (int i = 0; i < media.getTrackCount(); ++i) {
        final Media.Track track = media.getTrack(i);
        if (track == null)
          continue;
        if (track.type == Media.Track.Type.Video) {
          final Media.VideoTrack videoTrack = (VideoTrack) track;
          mType = TYPE_VIDEO;
          mWidth = videoTrack.width;
          mHeight = videoTrack.height;
        } else if (mType == TYPE_ALL && track.type == Media.Track.Type.Audio){
          mType = TYPE_AUDIO;
        }
      }
    }
    updateMeta(media);
    if (mType == TYPE_ALL && media.getType() == Media.Type.Directory)
      mType = TYPE_DIR;
  }
  defineType();
}

public static void setMediaOptions(Media media, Context context, int flags) {
  boolean noHardwareAcceleration = (flags & MediaWrapper.MEDIA_NO_HWACCEL) != 0;
  boolean noVideo = (flags & MediaWrapper.MEDIA_VIDEO) == 0;
  final boolean paused = (flags & MediaWrapper.MEDIA_PAUSED) != 0;
  int hardwareAcceleration = HW_ACCELERATION_DISABLED;
  if (!noHardwareAcceleration) {
    try {
      final SharedPreferences pref = PreferenceManager.getDefaultSharedPreferences(context);
      hardwareAcceleration = Integer.parseInt(pref.getString("hardware_acceleration", "-1"));
    } catch (NumberFormatException ignored) {
    }
  }
  if (hardwareAcceleration == HW_ACCELERATION_DISABLED)
    media.setHWDecoderEnabled(false, false);
  else if (hardwareAcceleration == HW_ACCELERATION_FULL || hardwareAcceleration == HW_ACCELERATION_DECODING) {
    media.setHWDecoderEnabled(true, true);
    if (hardwareAcceleration == HW_ACCELERATION_DECODING) {
      media.addOption(":no-mediacodec-dr");
      media.addOption(":no-omxil-dr");
    }
  } /* else automatic: use default options */
  if (noVideo)
    media.addOption(":no-video");
  if (paused)
    media.addOption(":start-paused");
}

/**
 * Parse the media and local art asynchronously. This Media should be alive (not released).
 *
 * @see #parseAsync(int)
 */
public boolean parseAsync() {
  return parseAsync(Parse.FetchLocal);
}

/**
 * Get the current video track
 */
public Media.VideoTrack getCurrentVideoTrack() {
  if (getVideoTrack() == -1)
    return null;
  final int trackCount = mMedia.getTrackCount();
  for (int i = 0; i < trackCount; ++i) {
    final Media.Track  track = mMedia.getTrack(i);
    if (track.type == Media.Track.Type.Video)
      return (Media.VideoTrack) track;
  }
  return null;
}

/**
 * Get the Track count.
 */
public int getTrackCount() {
  final Track[] tracks = getTracks();
  return tracks != null ? tracks.length : 0;
}

/**
 * Parse the media and local art synchronously. This Media should be alive (not released).
 *
 * @return true in case of success, false otherwise.
 */
public boolean parse() {
  return parse(Parse.FetchLocal);
}

/**
 * Browse to the specified uri.
 *
 * @param uri
 * @param flags see {@link MediaBrowser.Flag}
 */
@MainThread
public void browse(Uri uri, int flags) {
  final Media media = new Media(mLibVlc, uri);
  browse(media, flags);
  media.release();
}

/**
 * Browse to the specified media.
 *
 * @param media Can be a media returned by MediaBrowser.
 * @param flags see {@link MediaBrowser.Flag}
 */
@MainThread
public void browse(Media media, int flags) {
  /* media can be associated with a medialist,
   * so increment ref count in order to don't clean it with the medialist
   */
  media.retain();
  media.addOption(IGNORE_LIST_OPTION + mIgnoreList);
  if ((flags & Flag.NoSlavesAutodetect) != 0)
    media.addOption(":no-sub-autodetect-file");
  if ((flags & Flag.ShowHiddenFiles) != 0)
    media.addOption(":show-hiddenfiles");
  int mediaFlags = Media.Parse.ParseNetwork;
  if ((flags & Flag.Interact) != 0)
    mediaFlags |= Media.Parse.DoInteract;
  reset();
  mBrowserMediaList = media.subItems();
  mBrowserMediaList.setEventListener(mBrowserMediaListEventListener, mHandler);
  media.parseAsync(mediaFlags, 0);
  mMedia = media;
}

private synchronized Media insertMediaFromEvent(int index) {
  mCount++;
  for (int i = mCount - 1; i >= index; --i)
    mMediaArray.put(i + 1, mMediaArray.valueAt(i));
  final Media media = new Media(this, index);
  mMediaArray.put(index, media);
  return media;
}