Convert Figma logo to code with AI

nova-video-player logoaos-AVP

NOVA opeN sOurce Video plAyer: main repository to build them all

3,326
198
3,326
564

Top Related Projects

18,228

Kodi is an award-winning free and open source home theater/media center software and entertainment hub for digital media. With its beautiful interface and powerful skinning engine, it's available for Android, BSD, Linux, macOS, iOS, tvOS and Windows.

34,085

The Free Software Media System

VLC for Android, Android TV and ChromeOS

31,338

A libre lightweight streaming front-end for Android.

#mpv-android @ libera.chat

21,714

This project is deprecated and stale. The latest ExoPlayer code is available in https://github.com/androidx/media

Quick Overview

Nova Video Player (AVP) is an open-source video player for Android devices. It supports a wide range of video formats and features a modern, user-friendly interface. The player is designed to provide a seamless viewing experience with advanced playback controls and customization options.

Pros

  • Supports a wide variety of video formats and codecs
  • Offers advanced features like subtitle support, audio track selection, and gesture controls
  • Regularly updated and maintained by an active community
  • Free and open-source, allowing for customization and contributions

Cons

  • May have occasional stability issues on certain Android devices
  • Some advanced features may require a learning curve for new users
  • Limited documentation for developers looking to contribute or customize
  • Performance may vary depending on the device's hardware capabilities

Code Examples

As Nova Video Player is primarily an Android application and not a code library, there are no specific code examples to showcase. The project consists of Java and Kotlin code for the Android app implementation.

Getting Started

Since Nova Video Player is an Android application and not a code library, there's no code-specific getting started guide. However, users can follow these steps to start using the app:

  1. Visit the project's GitHub repository: https://github.com/nova-video-player/aos-AVP
  2. Download the latest APK file from the releases section
  3. Install the APK on your Android device
  4. Open the app and grant necessary permissions
  5. Start playing your local video files or add network sources

For developers interested in contributing to the project:

  1. Fork the repository
  2. Clone your forked repository to your local machine
  3. Set up Android Studio with the required SDK versions
  4. Open the project in Android Studio
  5. Make your changes and submit pull requests to the main repository

Competitor Comparisons

18,228

Kodi is an award-winning free and open source home theater/media center software and entertainment hub for digital media. With its beautiful interface and powerful skinning engine, it's available for Android, BSD, Linux, macOS, iOS, tvOS and Windows.

Pros of XBMC

  • More comprehensive media center solution with support for various content types
  • Cross-platform compatibility (Windows, macOS, Linux, Android, iOS)
  • Extensive plugin ecosystem and customization options

Cons of XBMC

  • Heavier resource usage due to its full-featured nature
  • Steeper learning curve for configuration and customization
  • May be overkill for users primarily interested in video playback

Code Comparison

XBMC (C++):

bool CVideoPlayer::OpenDemuxStream()
{
  if (m_pDemuxer)
  {
    m_pDemuxer->Open(m_item.GetDemuxOptions());
    return true;
  }
  return false;
}

AVP (Java):

public boolean openVideoPlayer(Uri uri) {
    try {
        mMediaPlayer.setDataSource(getApplicationContext(), uri);
        mMediaPlayer.prepare();
        return true;
    } catch (IOException e) {
        Log.e(TAG, "Error opening video player", e);
        return false;
    }
}

The code comparison shows that XBMC uses C++ and has a more complex architecture with separate demuxer handling, while AVP uses Java and relies on Android's MediaPlayer for simpler video playback implementation.

34,085

The Free Software Media System

Pros of Jellyfin

  • Open-source media server with a larger community and more active development
  • Supports a wide range of client devices and platforms
  • Offers advanced features like live TV and DVR functionality

Cons of Jellyfin

  • May be more resource-intensive, especially for larger media libraries
  • Setup and configuration can be more complex for beginners
  • Requires a dedicated server or always-on device to host the media

Code Comparison

Jellyfin (C#):

public class MediaBrowser : IDisposable
{
    private readonly ILogger<MediaBrowser> _logger;
    private readonly IFileSystem _fileSystem;
    private readonly ILibraryManager _libraryManager;
}

aos-AVP (Java):

public class VideoDbHelper extends SQLiteOpenHelper {
    private static final String DATABASE_NAME = "videodb";
    private static final int DATABASE_VERSION = 31;
    private static final String VIDEO_TABLE_NAME = "video";
}

The code snippets show different approaches to media management. Jellyfin uses a more modular structure with dependency injection, while aos-AVP employs a simpler SQLite database helper for video management.

VLC for Android, Android TV and ChromeOS

Pros of VLC-Android

  • More comprehensive codec support and media playback capabilities
  • Larger and more active community, resulting in frequent updates and bug fixes
  • Advanced features like network streaming and subtitle synchronization

Cons of VLC-Android

  • Larger app size due to extensive feature set
  • More complex user interface, which may be overwhelming for some users
  • Higher battery consumption due to advanced processing capabilities

Code Comparison

VLC-Android (Media playback initialization):

@Override
public void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    mLibVLC = new LibVLC(this);
    mMediaPlayer = new MediaPlayer(mLibVLC);
    mMediaPlayer.setEventListener(mPlayerListener);
}

aos-AVP (Media playback initialization):

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    mPlayer = new Player(this);
    mPlayer.setOnCompletionListener(mCompletionListener);
    mPlayer.setOnErrorListener(mErrorListener);
}

Both repositories focus on Android video playback, but VLC-Android offers a more feature-rich experience at the cost of complexity and resource usage. aos-AVP provides a simpler, lightweight alternative that may be more suitable for basic video playback needs. The code comparison shows that VLC-Android uses a custom LibVLC implementation, while aos-AVP relies on a more straightforward Player class for media playback.

31,338

A libre lightweight streaming front-end for Android.

Pros of NewPipe

  • Open-source and ad-free YouTube client with additional features like background playback and downloads
  • Supports multiple video platforms beyond YouTube, including SoundCloud and PeerTube
  • Lightweight and privacy-focused, doesn't require Google Services Framework

Cons of NewPipe

  • Lacks integration with official YouTube account features (e.g., subscriptions, likes)
  • May experience occasional issues with video playback due to changes in YouTube's API
  • Limited social features compared to the official YouTube app

Code Comparison

NewPipe (Java):

@Override
public void onLoadingComplete(String imageUri, View view, Bitmap loadedImage) {
    if (loadedImage != null) {
        thumbnailView.setImageBitmap(loadedImage);
    }
}

aos-AVP (Kotlin):

override fun onLoadingComplete(imageUri: String?, view: View?, loadedImage: Bitmap?) {
    loadedImage?.let {
        thumbnailImageView.setImageBitmap(it)
    }
}

Both projects use similar image loading patterns, but aos-AVP utilizes Kotlin's null-safety features and more concise syntax.

#mpv-android @ libera.chat

Pros of mpv-android

  • Built on the powerful mpv media player, offering extensive codec support and advanced playback features
  • Lightweight and efficient, with minimal resource usage
  • Highly customizable through lua scripts and config files

Cons of mpv-android

  • Less user-friendly interface compared to aos-AVP
  • Fewer built-in features for media library management
  • May require more technical knowledge to fully utilize its capabilities

Code Comparison

mpv-android:

override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    MPVLib.create(this)
    setContentView(R.layout.player)
    // ... more initialization code
}

aos-AVP:

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_player);
    mPlayerView = findViewById(R.id.player_view);
    // ... more initialization code
}

Both projects use similar Android lifecycle methods, but mpv-android initializes its custom MPVLib, while aos-AVP focuses on setting up a more traditional player view. aos-AVP appears to have a more straightforward setup process, which aligns with its user-friendly approach. mpv-android's initialization suggests a deeper integration with the mpv core, potentially offering more advanced features at the cost of complexity.

21,714

This project is deprecated and stale. The latest ExoPlayer code is available in https://github.com/androidx/media

Pros of ExoPlayer

  • Extensive documentation and community support
  • Wider range of supported formats and codecs
  • More frequent updates and active development

Cons of ExoPlayer

  • Larger library size, potentially increasing app size
  • Steeper learning curve for beginners
  • May include unnecessary features for simple playback needs

Code Comparison

ExoPlayer initialization:

val player = SimpleExoPlayer.Builder(context).build()
player.setMediaItem(MediaItem.fromUri(videoUri))
player.prepare()
player.play()

AVP initialization:

val player = Player.newInstance(context)
player.setDataSource(videoUri)
player.prepareAsync()
player.start()

Key Differences

  • ExoPlayer offers more advanced features and customization options
  • AVP focuses on simplicity and ease of use for basic video playback
  • ExoPlayer has better support for adaptive streaming and DRM
  • AVP may be more suitable for projects with simpler video requirements

Performance Considerations

  • ExoPlayer generally offers better performance for complex scenarios
  • AVP may have a slight edge in resource usage for basic playback
  • ExoPlayer's extensive feature set can lead to better optimization for various devices and network conditions

Integration Complexity

  • AVP is typically easier to integrate for simple use cases
  • ExoPlayer requires more setup but provides greater flexibility
  • Both libraries offer good Android ecosystem integration

Convert Figma logo designs to code with AI

Visual Copilot

Introducing Visual Copilot: A new AI model to turn Figma designs to high quality code using your components.

Try Visual Copilot

README

NOVA: opeN sOurce Video plAyer

GitHub release GitHub downloads Google Play version Google Play rating Google Play downloads Get it on Amazon Appstore Get it on F-Droid Get it on IzzyOnDroid Crowdin License Reddit Nova Community Chat on irc Build status Donate paypal Donate paypal Donate liberapay Donate github sponsor Donate opencollective

Overview

NOVA is an open source video player for Android. It consists in a fork of the original Archos Video Player Community Edition that is hosted here: https://github.com/archos-sa/aos-AVP intended to support new features.

Before asking any question please make sure that you have read the application FAQ.

This is the entry point repo. Its purpose is to provide the manifest to fetch all needed git repos with sources and then bootstrap the build environment.

More interesting sources can be found there:

  • Video: nova's Video UI code
  • MediaLib: nova's media library management code
  • FileCoreLibrary: nova's file management code
  • avos: C core multimedia engine using ffmpeg

For the full list, please look at this manifest https://github.com/nova-video-player/aos-AVP/default.xml

Building

Get the repo tool, then type:

mkdir aos; cd aos
repo init -u https://github.com/nova-video-player/aos-AVP -b nova
repo sync -j4
repo forall -c 'git checkout -t $REPO_REMOTE/$REPO_RREV'
make

Alternatively, for those not under Linux with a properly installed Android SDK/NDK, you can launch the video player build through:

cd Video
./gradlew -Puniversal assembleNoamazonRelease

In order to speed up the build, build is performed using dav1d, ffmpeg and other pre-built binaries and using local git clone of ffmpeg and dav1d repos. In order to trigger full update rebuild, you need in case of version upstep to manually do:

rm -rf native/torrentd/libs
cd native/dav1d-android-builder; git clean -fdx; rm -rf built-*
cd native/ffmpeg-android-builder; git clean -fdx; rm -rf dist-*

Note that the following packages are required to build:

sudo curl https://storage.googleapis.com/git-repo-downloads/repo > /usr/local/bin/repo
sudo chmod a+x /usr/local/bin/repo
sudo apt install build-essential python3 python3-pip python3-setuptools ninja-build maven file wget curl unzip git pkg-config meson nasm openjdk-17-jdk-headless openjdk-8-jdk-headless

Alternatively, you can use the provided docker image to build nova:

cd nova/AVP/docker
docker build -t nova .
docker run --rm -ti --entrypoint=/bin/bash nova
make

Github workflow build configuration file is also provided here

Binaries prebuilt of torrentd, ffmpeg, dav1d have been committed in order to reduce compilation time and remove nasm, meson dependencies. If you need to regenerate torrentd, ffmpeg and dav1d libs, please run make clean_prebuilt.

Latest stable apk

The compiled application is available for installation on:

Get it on Google Play Get it on Amazon Appstore Get it on GitHub Get it on IzzyOnDroid Get it on F-Droid

But for me the best way to get the latest nova video player apk is through obtainium which I recommend to use.

Scraping and Scrobbling

Scraping and scrobbling features rely on external services such as TMDb and Trakt.

In order to enable NOVA video player to perform these tasks, you need to register to this services and enable the API and inject the corresponding keys inside the following files: MediaLib/src/community/res/values/donottranslate.xml replacing the fake values below:

    <?xml version="1.0" encoding="utf-8"?>
    <resources xmlns:android="http://schemas.android.com/apk/res/android">
        <string name="tmdb_api_key">0123456789abcdef0123456789abcdef</string>
        <string name="trakt_api_key">0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef</string>
        <string name="trakt_api_secret">0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef</string>
    </resources>

Please note that enabling TMDB API registration can be completed following this link.

To create a Trakt api, first register to trakt then add a new app here.

Redirect URI should be http://localhost and be aware to grant all permissions.

Localization

You are welcome to contribute to the translation of the application using crowdin platform here.

Donate

Any contribution to show your gratitude and appreciation is always welcome, keeping the small team of developers working on their personal time motivated and aware that their dedication means something.

If you are up for it, please use any of the following links to make a donation: paypal, liberapay, github sponsor and opencollective.

Funds collected are essentially used to buy devices on which problems are reported for analysis and fix in order to cope with Android fragmentation.

Please bear in mind that the work carried out here results from a small community effort done with good will on scarce personal time. If need be, we might in the future introduce some extra bounty programs for specific feature development requests.

Support community and chat room

NovaVideoPlayer reddit community community is used as the support community for the Nova Video Player application. It is possible to chat with Nova Video Player developers on #novavideoplayer liberachat IRC channel.