vlc sdl2.0 播放示例

?

#include <stdio.h>

#include <stdint.h>

#include <math.h>

#include <stdlib.h>

#include <assert.h>

 

#include <SDL2/SDL.h>

#include <SDL2/SDL_mutex.h>

 

#include <vlc/vlc.h>

 

struct context {

    SDL_Renderer *renderer;

    SDL_Texture *texture;

    SDL_mutex *mutex;

    int n;

 

    uint32_t *pixels;

 

    int window_w;

    int window_h;

};

 

// VLC prepares to render a video frame.

static void *lock(void *data, void **p_pixels) {

 

    struct context *c = (struct context *) data;

 

    int pitch;

    SDL_LockMutex(c->mutex);

    SDL_LockTexture(c->texture, NULL, p_pixels, &pitch);

 

    c->pixels = (uint16_t *) *p_pixels;

 

    return NULL; // Picture identifier, not needed here.

}

 

// VLC just rendered a video frame.

static void unlock(void *data, void *id, void * const *p_pixels) {

 

    struct context *c = (struct context *) data;

 

    SDL_UnlockTexture(c->texture);

    SDL_UnlockMutex(c->mutex);

}

 

// VLC wants to display a video frame.

static void display(void *data, void *id) {

 

    struct context *ctx = (struct context *) data;

 

    SDL_Rect displayrect;

 

    uint32_t *pixels = ctx->pixels;

 

    // We can also render stuff.

    int x, y;

    for (y = 10; y < 40; y++) {

        for (x = 10; x < 40; x++) {

            if (x < 13 || y < 13 || x > 36 || y > 36) {

                pixels[y * ctx->window_w + x] = 0xffffffff;

            } else {

                // RV16 = 5+6+5 pixels per color, BGR.

                pixels[y * ctx->window_w + x] = 0x02ff02ff;

            }

        }

    }

 

    displayrect.x = 0;

    displayrect.y = 0;

    displayrect.w = ctx->window_w;

    displayrect.h = ctx->window_h;

//  printf("----%d, %d\n", displayrect.w, displayrect.h);

 

    SDL_SetRenderDrawColor(ctx->renderer, 0, 0, 0, 128);

    SDL_RenderClear(ctx->renderer);

    SDL_RenderCopy(ctx->renderer, ctx->texture, NULL, &displayrect);

    SDL_RenderPresent(ctx->renderer);

}

 

static void quit(int c) {

    SDL_Quit();

    exit(c);

}

 

int main_video(int argc, char *argv[]) {

 

    struct context ctx;

 

    libvlc_instance_t *libvlc;

    libvlc_media_t *m;

    libvlc_media_player_t *mp;

 

    char const *vlc_argv[] = { "--no-audio", // Don't play audio.

            "-vvv",

//          "--no-xlib", // Don't use Xlib.

 

            // Apply a video filter.

            //"--video-filter", "sepia",

            //"--sepia-intensity=200"

 

            };

    int vlc_argc = sizeof(vlc_argv) / sizeof(*vlc_argv);

 

    SDL_Event event;

    int done = 0, action = 0, pause = 0, n = 0;

    unsigned video_w = 0, video_h = 0;

 

//    if(argc < 2) {

//        printf("Usage: %s <filename>\n", argv[0]);

//        return EXIT_FAILURE;

//    }

 

    // Initialise libSDL.

    if (SDL_Init(SDL_INIT_VIDEO) < 0) {

        printf("Could not initialize SDL: %s.\n", SDL_GetError());

        return EXIT_FAILURE;

    }

 

    int nRenderDrivers = SDL_GetNumRenderDrivers();

    int i = 0;

    for (; i < nRenderDrivers; i++) {

        SDL_RendererInfo info;

        SDL_GetRenderDriverInfo(i, &info);    //d3d

        printf("====info name %d: %s =====\n", i, info.name);

        printf("====max_texture_height %d  =====\n", i, info.max_texture_height);

        printf("====max_texture_width %d  =====\n", i, info.max_texture_width);

 

    }

 

    SDL_SetHint(SDL_HINT_RENDER_SCALE_QUALITY, "linear");

    SDL_SetHint(SDL_HINT_RENDER_VSYNC, "1");

 

    ctx.mutex = SDL_CreateMutex();

 

    // If you don't have this variable set you must have plugins directory

    // with the executable or libvlc_new() will not work!

    printf("VLC_PLUGIN_PATH=%s\n", getenv("VLC_PLUGIN_PATH"));

 

    // Initialise libVLC.

    libvlc = libvlc_new(vlc_argc, vlc_argv);

    if (NULL == libvlc) {

        printf("LibVLC initialization failure.\n");

        return EXIT_FAILURE;

    }

 

    m = libvlc_media_new_path(libvlc, "./test5.mp4");

    mp = libvlc_media_player_new_from_media(m);

    libvlc_media_parse(m); //get file information

    libvlc_video_get_size(mp, 0, &video_w, &video_h);

    printf("----%d, %d\n", video_w, video_h);

    if (video_w == 0) {

        printf("cannot get video size\n");

        exit(-1);

    }

    //init w,h

    ctx.window_w = video_w;

    ctx.window_h = video_h;

 

    libvlc_media_release(m);

 

    //initialize window and render

    // Create SDL graphics objects.

    SDL_Window * window = SDL_CreateWindow("Fartplayer", SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED, video_w, video_h,

            SDL_WINDOW_SHOWN | SDL_WINDOW_RESIZABLE);

 

    if (!window) {

        fprintf(stderr, "Couldn't create window: %s\n", SDL_GetError());

        quit(3);

    }

 

    ctx.renderer = SDL_CreateRenderer(window, 1, 0);

    if (!ctx.renderer) {

        fprintf(stderr, "Couldn't create renderer: %s\n", SDL_GetError());

        quit(4);

    }

 

    //init texture

    ctx.texture = SDL_CreateTexture(ctx.renderer, SDL_PIXELFORMAT_ARGB8888, SDL_TEXTUREACCESS_STREAMING, video_w, video_h);

    if (!ctx.texture) {

        fprintf(stderr, "Couldn't create texture: %s\n", SDL_GetError());

        quit(5);

    }

 

    libvlc_video_set_callbacks(mp, lock, unlock, display, &ctx);

    libvlc_video_set_format(mp, "RV32", video_w, video_h, video_w * 4);

//  libvlc_video_set_format(mp, "UYVY", VIDEOWIDTH, VIDEOHEIGHT, VIDEOWIDTH * 4);

    libvlc_media_player_play(mp);

 

    // Main loop.

    while (!done) {

 

        action = 0;

 

        // Keys: enter (fullscreen), space (pause), escape (quit).

        while (SDL_PollEvent(&event)) {

 

            switch (event.type) {

            case SDL_WINDOWEVENT:

                if (event.window.event == SDL_WINDOWEVENT_RESIZED) {

                    SDL_RenderSetViewport(ctx.renderer, NULL);

                    ctx.window_w = event.window.data1;

                    ctx.window_h = event.window.data2;

                }

                break;

            case SDL_QUIT:

                done = 1;

                break;

            case SDL_KEYDOWN:

                action = event.key.keysym.sym;

                break;

            }

        }

 

        switch (action) {

        case SDLK_ESCAPE:

        case SDLK_q:

            done = 1;

            break;

        case ' ':

            printf("Pause toggle.\n");

            pause = !pause;

            break;

        }

        if (!pause) {

            ctx.n++;

        }

 

        SDL_Delay(100);

    }

 

    // Stop stream and clean up libVLC.

    libvlc_media_player_stop(mp);

    libvlc_media_player_release(mp);

    libvlc_release(libvlc);

 

    // Close window and clean up libSDL.

    SDL_DestroyMutex(ctx.mutex);

    SDL_DestroyRenderer(ctx.renderer);

 

    quit(0);

 

    return 0;

}