VLC Framework Analysis

Transfer from http://weiyinchao88.iteye.com/blog/1414207 function part:

The core of VLC media player is LIBVLC, which provides interface, application processing functions such as playlist management, audio and video decoding and output, threading system. All LIBVLC source files are located in the/SRC directory and their subdirectories:

# config/: Load configuration from command line and configuration file, provide read and write configuration of function module
# control/: Provides motion control functions such as play/pause, volume management, fullscreen, log, etc.
# extras/: Mostly platform-specific code
# modules/: module Management
# network/: Provides network interface (socket management, network error, etc.)
# osd/: Show actions on the screen
# test/: LIBVLC Test Module
# text/: Character Set
# interface/: Provides the code in the interface that can be called, such as the key after the hardware responds.
# playlist/: Manage playback functions, such as stop, play, next song, Shuffle, etc.
# input/: Creates and reads an input stream, separates the audio and video from it, and sends the separated audio stream and video stream to the decoder.
# video_output/: Initialize the video player, convert the video images from the decoder (from YUV to RGB) and play them
# audio_output/: Initialize the audio mixer to set the correct sync frequency and resample the audio stream coming from the decoder
# stream_output/: Output audio stream and video streaming to the network
# misc/: LIBVLC uses other parts of the functionality, such as threading system, Message Queuing, CPU detection, object lookup system, or platform specific code.

Module part:

VLC Media Player module part, in the subdirectory of/modules (detailed description can refer to the list file below), these modules are only valid when the program loads them. Each module can provide different functions that will fit the specific file or a particular environment. In addition, Audio_ The Output/video_output/interface module is written as a cross-platform code that facilitates the support of new platforms (such as BeOS or service mac OS X).

Plug-in modules can be dynamically loaded and unloaded in the SRC/MODULES.C and include/vlc_modules*.h supply functions

LIBVLC can insert modules directly into an application, such as an operating system that does not support dynamic loading of code. Module static INSERT into the application called built-in.

1.VLC.C is just an entry procedure .

2.LIBVLC.C is the binding point of each module, which is programmed on the interface Vlc_create (): Two important data structures: libvlc_t & vlc_t, all parameters are passed in here Vlc_init (): Initialization parameters, Module_bank Vlc_addinf (): Adding module

3./src/misc/configure.c command line parameters and parameter file analysis
The parameter file is ~/.VNC/VLCRC. Where you can set the log file location

4./include/Collection of all header files

5./src/interface/interface.h Collection of all module

6./SRC/MISC/MODULES.C
where module_t * __module_need (vlc_object_t *p_this, const char *psz_capability,
The const char *psz_name, vlc_bool_t b_strict) method is to find the appropriate interface
If a suitable one is found, call Allocateplugin () to assign it dynamically.

7.how to link to different modules without OOP

The plan to read the VLC source code begins with the framework of its program, sorting through its main files: 1.include/main.h file: Access to all program variables, which mainly defines 2 structures: libvlc_t,vlc_t. A. Struct libvlc_t According to the program note: The struct has only one instance, is assigned in the main function, and can only be accessed in main. It is used to store some data that can only be initialized once, such as CPU capacity or global lock. b. struct vlc_t annotation: This structure is a LIBVLC instance libvlc_t,vlc_t appears in the Vlc_common_members macro, respectively defined libvlc_t * P_LIBVLC; vlc_t * P_VLC; Object, which is known as the root of the evil, shows the importance of its structure. All parameter passes are in here (not yet clear). 2.include/vlc_common.h file: Common definitions,collection of useful common types and macros definitions, common types and macros defined collections The main purpose is to unify the variable definitions in different operating systems, for example, by unifying the unit_8 to represent the unsiged char type. The file also defines the Vlc_common_members macro, which includes all the common member variables of the VLC base object: These members is COMMON for all VLC objects. Defining Export functions
#ifndef __plugin__
# define Vlc_export (type, name, args) type name args
#else
# define Vlc_export (type, name, args) struct _u_n_u_s_e_d_
extern module_symbols_t* P_symbols;
#endif
Define a callback function typedef int (* vlc_callback_t) (vlc_object_t *,/* variable ' s object */
Char CONST *,/* Variable name * *
vlc_value_t,/* Old value */
vlc_value_t,/* NEW value */void *); /* Callback Data */3.include/vlc_objects.h file: definition and handling functions for vlc_object_t definition and manipulation methods,vlc_object_t struct vlc_object_t
{
Vlc_common_members
}; Define a structure to use a public member defined by a macro


VLM introduction of VLC

The code starts with a two-part, a telnet deamon. There is also the implementation of RTSP part. It turns out that they communicate through a bridge VLM media. When the new MEDIANAME VOD enabled, a media was created. If you are prepared for analysis by Setup MEDIANAME input Filename.mpg, establish the input stream when it is requested by RTSP to establish this output stream

In this way, the VOD is consistent with other modules. RTSP is just a module of the output stream.

Code Analysis

1./modules/control/telnet.c
/*****************************************************************************
* Run:main Loop
*****************************************************************************/
static void Run (intf_thread_t *p_intf) {
Vlm_executecommand (P_sys->mediatheque, Cl->buffer_read,
&message);
}2./SRC/MISC/VLM.C
/*****************************************************************************
* Vlm_executecommand:
*****************************************************************************/
int Vlm_executecommand (vlm_t *p_vlm, const char *psz_command,
vlm_message_t **pp_message)
{
} vlm_medianew (vlm_t *vlm, const char *psz_name, int i_type) {vlm_media_t *media = malloc (sizeof (vlm_media_t));
}
*****************************************************
struct vlm_t
{
Vlc_common_members vlc_mutex_t Lock; int I_media;
vlm_media_t **media; int I_vod;
vod_t *vod; int i_schedule;
vlm_schedule_t **schedule;
};
*****************************************************
int Vlm_mediasetup (vlm_t *vlm, vlm_media_t *media, const char *psz_cmd,
const char *psz_value) {

if (P_input = Input_createthread2 (VLM, &media->item, Psz_header
) ) )
{
while (!p_input->b_eof &&!p_input->b_error) msleep (100000);

Input_stopthread (P_input);
Input_destroythread (P_input);
Vlc_object_detach (P_input);
Vlc_object_destroy (P_input);
}
}3./src/input/input.c
input_thread_t *__input_createthread2 (vlc_object_t *p_parent,
Input_item_t *p_item,
Char *psz_header)
{
input_thread_t *p_input = NULL; /* Thread Descriptor */
P_input = Create (p_parent, P_item, Psz_header, Vlc_false);
/* Now we can attach our new input */
Vlc_object_attach (P_input, p_parent);

/* Create thread and wait for its readiness. */
if (Vlc_thread_create (p_input, "input", Run,
Vlc_thread_priority_input, Vlc_true))
{
Msg_err (P_input, "Cannot create input thread");
Vlc_object_detach (P_input);
Vlc_object_destroy (P_input);
return NULL;
}
} static input_thread_t *create (vlc_object_t *p_parent, input_item_t *p_item,
Char *psz_header, vlc_bool_t B_quick)
{
}
/*****************************************************************************
* Run:main Thread loop
* This is the ' normal ' thread that spawns the input processing chain,
* Reads the stream, cleans up and waits
*****************************************************************************/
static int Run (input_thread_t *p_input)
{
}
=====================================================================================
4. \modules\misc\rtsp.c
Static vod_media_t *medianew (vod_t *p_vod, const char *psz_name,
input_item_t *p_item)
{
vod_sys_t *p_sys = p_vod->p_sys;
vod_media_t *p_media = malloc (sizeof (vod_media_t));
int i; if (!p_media)
{
Msg_err (P_vod, "Not enough Memory");
return NULL;
} memset (P_media, 0, sizeof (vod_media_t));
p_media->es = 0;
P_media->psz_mux = 0;
P_MEDIA->RTSP = 0;
P_media->b_raw = Vlc_false; asprintf (&p_media->psz_rtsp_path, "%s%s", P_sys->psz_path, Psz_name);
P_media->p_rtsp_url =
Httpd_urlnewunique (P_sys->p_rtsp_host, P_media->psz_rtsp_path, NULL,
NULL, NULL); if (!p_media->p_rtsp_url)
{
Msg_err (P_vod, "Cannot create RTSP URL (%s)", P_media->psz_rtsp_path);
Free (P_media->psz_rtsp_path);
Free (P_media);
return NULL;
} msg_dbg (P_vod, "created RTSP URL:%s", P_media->psz_rtsp_path); asprintf (&P_MEDIA->PSZ_RTSP_CONTROL_V4,
"A=control:rtsp://%%s:%d%s/trackid=%%d\r\n",
P_sys->i_port, P_media->psz_rtsp_path);
asprintf (&P_MEDIA->PSZ_RTSP_CONTROL_V6,
"A=control:rtsp://[%%s]:%d%s/trackid=%%d\r\n",
P_sys->i_port, P_media->psz_rtsp_path); Httpd_urlcatch (P_media->p_rtsp_url, Httpd_msg_setup,
Rtspcallback, (void*) p_media);
Httpd_urlcatch (P_media->p_rtsp_url, Httpd_msg_describe,
Rtspcallback, (void*) p_media);
Httpd_urlcatch (P_media->p_rtsp_url, Httpd_msg_play,
Rtspcallback, (void*) p_media);
Httpd_urlcatch (P_media->p_rtsp_url, Httpd_msg_pause,
Rtspcallback, (void*) p_media);
Httpd_urlcatch (P_media->p_rtsp_url, Httpd_msg_teardown,
Rtspcallback, (void*) p_media);
} static int Rtspcallback (httpd_callback_sys_t *p_args, httpd_client_t *cl,
httpd_message_t *answer, httpd_message_t *query)
{
Switch (query->i_type)
{
Case Httpd_msg_setup:
{
}
Case Httpd_msg_play:
{
P_RTSP = Rtspclientget (P_media, psz_session);
Vod_mediacontrol (P_vod, P_media, Psz_session, Vod_media_play,
Psz_output);

}
}

}5. Vlc_vod.h
static inline int Vod_mediacontrol (vod_t *p_vod, vod_media_t *p_media,
char *psz_id, int i_query, ...)
{
I_result = P_vod->pf_media_control (P_vod->p_data, P_media, psz_id,
I_query, args);
}

LIBVLC Simple collation of external APIs

libvlc.h

The external API of LIBVLC is defined, and it is possible to embed VLC into our program by referencing this header file.

The LIBVLC object must be initialized before it can be used.LIBVLC CoreLibvlc_new () Initializes an instance of LIBVLC, ARGC represents the number of arguments, argv represents the argument, returns the created instance if an error occurs, returns null Libvlc_release () is used to destroy an instance of LIBVLCLIBVLC error Handling Libvlc_errmsg () returns the most recent LIBVLC error generated in the Idaoyong thread, which is valid until at least one other error occurs (at least once again LIBVLC) and returns NULL when there is no error LIBVLC _clearerr () Clears the error state of the current thread's LIBVLC. This action is optional and by default, the error state is overwritten when a new error occurs. Libvlc_vprinterr () sets the error status and message for the current thread's LIBVLC. Returns a NUL character libvlc_printerr ()/Source comment and the previous identical libvlc_retain () Increase the reference count of LIBVLC, the reference count for any new LIBVLC instance is 1 libvlc_add_intf (): The user interface that tries to start the LIBVLC instance, p_instance represents the instance to start, name is the interface name, NULL represents the default, A return of 0 indicates success-1 indicates an error Libvlc_set_exits_handler (): This function is used to register a callback for an existing LIBVLC event. This method is useful when you have at least one interface open with libvlc_add_intf (). Typical , this function will wake your program from the main loop (from other threads). The parameter p_instance represents the LIBVLC instance, and CB represents the callback to invoke when the LIBVLC to exit. The opaque represents a data pointer to the callback. Warning: This function cannot be called concurrently with libvlc_wait () . Libvlc_wait (): Waits until there is an interface that throws an instance of the eject action. You must first open at least one interface with libvlc_add_intf (). Libvlc_set_user_agent (): Sets the application name, and when there is a protocol requirement, LIBVLC will pass the name as a user-agent string to it. The parameter name should be a readable application name, such as "FooBar player 1.2.3", The HTTP parameter is the HTTP User Agent. For example "foobar/1.2.3 python/2.6.0. Libvlc_get_version (): Returns the version number of LIBVLC Libvlc_get_compiler (): Returns the version of the compiler that compiled LIBVLC. Libvlc_get_changeset (): Returns the changeset of LIBVLC.LIBVLC Asynchronous Events

LIBVLC Out of sync events

Many LIBVLC objects, such as libvlc_instance_t libvlc_media_player_t, produce time in different steps, each of which provides a libvlc_event_manager_t event manager. You can subscribe to these events by Libvlc_event_attach () and use Libvlc_event_detach () to unsubscribe from events. libvlc_event_manager_t is an event manager libvlc_event_type_t that is part of the LIBVLC object: Event libvlc_callback_t () representing LIBVLC: callback function notification function notification translation is inaccurate), the parameter p_event is the time to trigger the callback. Libvlc_event_attach (): Register an event notification. The P_event_manager parameter is the event manager that you want to bind. Usually it is obtained by Vlc_my_object_event_manager (), where My_object is the object you want to listen to, I_event_ Type is the event that you want to listen on, F_callback is the function to invoke when i_event_type occurs. User_data is the data that is passed by user-supplied accompanying events. On success, this function returns 0 and returns Enomem Libvlc_event_detach () When an error occurs notification

Libvlc_event_type_name (): Gets the type name of an event Libvlc_log LIBVLC logging

The

Libvlc_log series function provides a way to access the LIBVLC message log. These functions are used only for advanced users or for debugging purposes. Libvlc_get_log_verbosity (): Get the verbosity level of VLC messages Libvlc_set_log_ Verbosity (): Set verbosity of VLC messages Libvlc_log_open (): Open VLC Message log instance (get its message log instance from a LIBVLC instance) Libvlc_log_close (): Close VLC Message log instance Libvlc_log_count (): Returns the number of messages in the log libvlc_log_clear (): Clears the log instance. All messages in the instance will be deleted, and should be purged frequently in order to prevent messages from being blocked. Libvlc_log_get_iterator (): Locates and returns the iterator Libvlc_log_iterator_free () recorded in a log: releases a previously positioned iterator Libvlc_log_ Iterator_next (): Returns the next log message, returns NULL when Next is empty, or returns the next Message object libvlc_media.h

libvlc_media_t is an abstract representation of the media that can be played. It contains the location of the media and various optional meta-data. libvlc_state_t: The sequence of this enumeration type must be strictly guaranteed and consistent with the source code, as well as reference to Mediacontrol_playerstatus,input_state_ E enumeration types and media statistics for VideoLan.LibVLC.State (in Bindings/cil/src/media.cs) LIBVLC_MEDIA_STATS_T:LIBVLC Libvlc_media_track_ info_t: No comments, mainly FOURCC and docec other information. Libvlc_media_new_location (): Creates a Libvlc_media object with a given media resource path. The parameter PSZ_MRL is the MRL to read (media Resource location). This function returns the newly created object or null. Libvlc_media_new_path (): New from local file system path, other references previous libvlc_media_new_as_node (): Creates a libvlc_media_t with the given name and takes it as an empty node Libvlc_media_add_option (): Add an option to an existing libvlc_media_t that will be used to determine how Media_player reads the media. This allows you to specify the advanced reading/streaming options for each of the respective VLC's on each media. Libvlc_media_add_option_flag (): Price A selection with a configurable mark to an existing libvlc_media_t. The other one. Libvlc_media_retain (): Retains a reference to a Media descriptor object (libvlc_media_t. Use Libvlc_media_release () to reduce the reference count of a media descriptor object Libvlc_media_ Release (): Reduces the reference count of a libvlc_media_t, which, if reduced to 0 o'clock, frees this object (destroyed). It will send a libvlc_mediafreed event to all listeners there. If a libvlc_media_t is released, it can no longer be used. LIBVLC_MEDIA_GET_MRL (): Obtains its MRL libvlc_media_duplicate () from a media description object: Mirroring a media Description object Libvlc_media_get_meta (): reads the metadata of the media. If the media has not yet been parsed, then NULL is returned, and this method automatically calls Libvlc_media_parse_async (), so you can receive a libvlc_mediametachanged event after calling this method. If you want to use a synchronous version, make sure that you call Get_meta () before calling Libvlc_media_parse (); Libvlc_media_set_meta (): Sets the metadata for the media, this method does not save the data, and you need to call Libvlc_media_save_meta () to save it. Libvlc_media_get_state (): Gets the state of the current media description object. The possible states are defined in LIVBLC_STRUCTURES.C. Libvlc_media_subitems (): Gets a child item of a media description object. This method increases the reference count of the media description object and uses Libvlc_media_list_release () to reduce the reference count. Libvlc_media_event_manager (): Gets an event manager for a media description object. Libvlc_media_get_duration (): Gets the duration of a media description object. Returns 1 if an error occurs. Libvlc_media_parse (): Resolves the metadata and track information for a local media, which is synchronous. Libvlc_media_parse_async (): Ditto, this method is out of sync, you can listen to the Libvlc_mediaparsedchanged event to track him, and if it has been parsed, this event will not be triggered. Libvlc_media_is_parsed (): Gets the analysis state of a media description object. Returns true when parsing has been done. Libvlc_media_set_user_data (): Sets the user data for the media descriptor, which is accessed only by the host program, and vlc.framework it as a pointer to a reference to a Libvlc_media_ A pointer to the local object of the T-pointer to use Libvle_media_get_tracks_info (): Gets the basic flow information for the media descriptor. Note You must use the--sout= "#description" to play the media exactly once, otherwise you will get an empty array. Multiple playback results in more than one duplicate of the data.
VLC API Collection: Http://www.videolan.org/developers/vlc/doc/doxygen/html/group__libvlc.html#_details



VLC Introduction and instructions for use

First, Introduction
The full name of VLC is the video Lan Client, an open-source, cross-platform audio player. VLC supports a large number of audio and video transmission, encapsulation and encoding formats, complete feature list can be obtained here http://www.videolan.org/vlc/features.html, here is a brief incomplete list:
Operating systems: Windows, WinCE, Linux, MacOSX, BEOS, BSD
Access forms: File, DVD/VCD/CD, HTTP, FTP, MMS, TCP, UDP, RTP, IP multicast, IPv6, RTSP
Encoding format: mpeg*, DIVX, WMV, MOV, 3GP, FLV, H.263, H, FLAC
Video subtitles: DVD, DVB, Text, Vobsub
Video output: DirectX, X11, XVideo, SDL, FrameBuffer, ASCII
Control interface: WxWidgets, QT4, Web, Telnet, Command Line
Browser plugin: ActiveX, Mozilla (Firefox)
In fact, to be clearer, we can conversely say that VLC does not support what is common. The first is RealVideo (Real's audio section support), because the real video Converter has a copyright issue. In fact VLC 0.9.0 has joined the RealVideo support, but requires an additional decoder (similar to MPlayer). In addition, VLC does not support the 3GP audio format of AMR.

VLC was originally a project of several French university students, and later they took VLC as an open source project, attracting a lot of good programmers from all over the world to co-author and maintain VLC, which became the way it is now.
As for why it is called VideoLAN Client, it is because there is a VideoLAN server project (abbreviated as VLS), and now VLS features have been merged into VLC, so VLC is not only a video player, it can also be used as a small video server, You can also play one side of the transcoding, the video stream sent to the network. VLC is the most prominent is the network stream playback functions, such as MPEG2 UDP TS stream playback and forwarding, almost irreplaceable.
For ordinary users, VLC also has the advantage of not affecting the decoder in Windows. VLC usually does not affect or rely on the system's own decoder (in addition to the RealVideo and QuickTime types), very green and environmentally friendly, not to worry about rogue software, advertising plug-ins and other disgusting things.
The scalability of VLC is very good from the point of view of the program structure. VLC is mostly written in an efficient C code (a small number of C + + and assembler), but fully dynamic modularity is implemented, and all features including the program framework itself are modules that can be loaded at runtime, which allows VLC to easily extend multiple functions and be easy to maintain. Its architecture is a bit similar to DirectShow's technology.
VLC also attaches great importance to the issue of copyright, you can be assured of the freedom of use without needing to worry about copyright issues--VLC only includes free, free libraries. VLC is based on the GPL, so it can also be used in commercial applications, only to retain the GPL and open source code if you modify VLC.
Here are some links related to VLC
VLC Official website: http://www.videolan.org/
VLC download page: http://www.videolan.org/vlc/
VLC download directory (source code and installation package): http://download.videolan.org/pub/videolan/vlc/
VLC Nightly builds:http://nightlies.videolan.org/
VLC Development Wiki:http://wiki.videolan.org/developers_corner
VLC Win32 third-party Libraries precompiled package download directory: http://download.videolan.org/pub/testing/win32/
VLC Official forum: http://forum.videolan.org/
VLC Mailing list: http://www.videolan.org/developers/lists.html

Second, the Windows platform compilation
The first step is to create an environment that compiles VLC. VLC under Windows can be compiled in Msys+mingw or Cygwin way, the two are similar, here is mainly about Cygwin.
Cygwin is something that simulates a Linux environment under Windows. It offers many libraries and applications that allow you to use Windows as you would on Linux. You need to download a Cygwin installer setup.exe in http://www.cygwin.com/. Then choose a Cygwin source to download the required library, domestic words to ftp://ftp.sjtu.edu.cn/cygwin/and http://www.cygwin.cn/pub relatively faster. The first installation, in addition to the default libraries, we also need to add some libraries to support VLC compilation, including
Archive (catalogue)
Unzip
Zip
Devel
Autoconf
Automake
Binutils
Cvs
Expat
Gcc
Gcc-core
gcc-g++
Gcc-mingw
Gcc-mingw-core
gcc-mingw-g++
GDB (if you need to debug)
GetText
Gettext-devel
Git (not necessarily required)
Libiconv
Libtool
Make
Mingw-runtime
Nasm
Patchutils
Pkg-config
Subversion
Editor
Vim (with it handy point)
Libs
Libgcrypt
WEB//These two can not, if you do not want to compile third-party libraries
Curl (optional:for building Extras/contrib)
wget (optional:for building Extras/contrib)

Then download the required version of VLC source code. For release version, you can download from here: http://download.videolan.org/pub/videolan/vlc/, if you need to download the latest real-time library, it will be taken from the VLC source library. Now VLC has switched to git, using the command: Git clone git://git.videolan.org/vlc.git

VLC also needs a lot of third-party libraries, you can get the source code to compile, this part can refer to the Linux VLC compiled article. VLC on Windows has made a compiled Win32 third-party library package that can be downloaded from http://download.videolan.org/pub/testing/win32/. The package needs to be extracted to the root directory '/', in fact these libraries are located in '/usr/win32-branch ' inside.

Enter VLC's home directory in Cygwin, run Bootstrap, './bootstrap '. Before we wait for it to end, let's take a look at how to configure VLC compilation. Run './configure-h >cfg_opt.txt ' to output the configured option information to Cfg_opt.txt, and then slowly study it. Most of it is to enable, disable certain features and function modules, or to configure some of the modules require the path of the library and other information. For the convenience of writing a simple script to do this, of course this is not necessary.
Path=/usr/win32-branch/bin: $PATH \
Pkg_config_path=/usr/win32-branch/lib/pkgconfig \
cppflags= "-I/USR/WIN32-BRANCH/INCLUDE-I/USR/WIN32-BRANCH/INCLUDE/EBML" \
Ldflags=-l/usr/win32-branch/lib \
Cc= "Gcc-mno-cygwin" cxx= "g++-mno-cygwin" \
./configure \
–HOST=I686-PC-MINGW32 \
–DISABLE-GTK \
–enable-nls–enable-sdl–with-sdl-config-path=/usr/win32-branch/bin \
–ENABLE-FFMPEG–WITH-FFMPEG-MP3LAME–WITH-FFMPEG-FAAC \
–with-ffmpeg-zlib–enable-faad–enable-flac–enable-theora \
–with-wx-config-path=/usr/win32-branch/bin \
–with-freetype-config-path=/usr/win32-branch/bin \
–with-fribidi-config-path=/usr/win32-branch/bin \
–enable-live555–with-live555-tree=/usr/win32-branch/live.com \
–enable-caca–with-caca-config-path=/usr/win32-branch/bin \
–with-xml2-config-path=/usr/win32-branch/bin \
–with-dvdnav-config-path=/usr/win32-branch/bin \
–disable-cddax–disable-vcdx–enable-goom \
–enable-twolame–enable-dvdread \
–ENABLE-RELEASE–ENABLE-DCA \
–ENABLE-MKV \
–enable-quicktime–enable-mozilla \
–WITH-MOZILLA-SDK-PATH=/USR/WIN32-BRANCH/GECKO-SDK \
–enable-mostly-builtin \
&& make

For example, save this file as ' Mybuild ', and after BOOTSTRP run, we just need to run the Mybuild to start configuring and compiling. This usually takes a long time, and if the luck is good, after a long wait for make to run successfully, VLC compiles. Simply double-click on the vlc.exe inside the home directory should be ready to run.
For the convenience of packaging it, the simplest is ' make package-win32-base ', which will create a subdirectory to hold all the things needed to run, this directory is a green version of VLC.
Of course, if you're unlucky, you may encounter all sorts of errors, such as errors in boottrap or configure, usually because you don't have a