git.sesse.net Git - vlc/blob - modules/video_output/androidsurface.c

   1 /*****************************************************************************
   2  * androidsurface.c: android video output using Surface Flinger
   3  *****************************************************************************
   4  * Copyright © 2011 VideoLAN
   5  *
   6  * Authors: Ming Hu <tewilove@gmail.com>
   7  *          Ludovic Fauvet <etix@l0cal.com>
   8  *          Sébastien Toque <xilasz@gmail.com>
   9  *
  10  * This program is free software; you can redistribute it and/or modify it
  11  * under the terms of the GNU Lesser General Public License as published by
  12  * the Free Software Foundation; either version 2.1 of the License, or
  13  * (at your option) any later version.
  14  *
  15  * This program is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  18  * GNU Lesser General Public License for more details.
  19  *
  20  * You should have received a copy of the GNU Lesser General Public License
  21  * along with this program; if not, write to the Free Software Foundation,
  22  * Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
  23  *****************************************************************************/
  24
  25 #ifdef HAVE_CONFIG_H
  26 # include "config.h"
  27 #endif
  28
  29 #include <vlc_common.h>
  30 #include <vlc_plugin.h>
  31 #include <vlc_vout_display.h>
  32 #include <vlc_picture_pool.h>
  33
  34 #include <dlfcn.h>
  35
  36 #ifndef ANDROID_SYM_S_LOCK
  37 # define ANDROID_SYM_S_LOCK "_ZN7android7Surface4lockEPNS0_11SurfaceInfoEb"
  38 #endif
  39 #ifndef ANDROID_SYM_S_LOCK2
  40 # define ANDROID_SYM_S_LOCK2 "_ZN7android7Surface4lockEPNS0_11SurfaceInfoEPNS_6RegionE"
  41 #endif
  42 #ifndef ANDROID_SYM_S_UNLOCK
  43 # define ANDROID_SYM_S_UNLOCK "_ZN7android7Surface13unlockAndPostEv"
  44 #endif
  45
  46 /*****************************************************************************
  47  * Module descriptor
  48  *****************************************************************************/
  49 #define CHROMA_TEXT N_("Chroma used")
  50 #define CHROMA_LONGTEXT N_(\
  51     "Force use of a specific chroma for output. Default is RGB32.")
  52
  53 #define CFG_PREFIX "androidsurface-"
  54
  55 static int  Open (vlc_object_t *);
  56 static void Close(vlc_object_t *);
  57
  58 vlc_module_begin()
  59     set_category(CAT_VIDEO)
  60     set_subcategory(SUBCAT_VIDEO_VOUT)
  61     set_shortname("AndroidSurface")
  62     set_description(N_("Android Surface video output"))
  63     set_capability("vout display", 155)
  64     add_shortcut("androidsurface", "android")
  65     add_string(CFG_PREFIX "chroma", NULL, CHROMA_TEXT, CHROMA_LONGTEXT, true)
  66     set_callbacks(Open, Close)
  67 vlc_module_end()
  68
  69 /*****************************************************************************
  70  * JNI prototypes
  71  *****************************************************************************/
  72
  73 extern void *jni_LockAndGetAndroidSurface();
  74 extern void  jni_UnlockAndroidSurface();
  75 extern void  jni_SetAndroidSurfaceSize(int width, int height, int sar_num, int sar_den);
  76
  77 // _ZN7android7Surface4lockEPNS0_11SurfaceInfoEb
  78 typedef void (*Surface_lock)(void *, void *, int);
  79 // _ZN7android7Surface4lockEPNS0_11SurfaceInfoEPNS_6RegionE
  80 typedef void (*Surface_lock2)(void *, void *, void *);
  81 // _ZN7android7Surface13unlockAndPostEv
  82 typedef void (*Surface_unlockAndPost)(void *);
  83
  84 /*****************************************************************************
  85  * Local prototypes
  86  *****************************************************************************/
  87
  88 static picture_pool_t   *Pool  (vout_display_t *, unsigned);
  89 static void             Display(vout_display_t *, picture_t *, subpicture_t *);
  90 static int              Control(vout_display_t *, int, va_list);
  91
  92 /* */
  93 typedef struct _SurfaceInfo {
  94     uint32_t    w;
  95     uint32_t    h;
  96     uint32_t    s;
  97     uint32_t    usage;
  98     uint32_t    format;
  99     uint32_t*   bits;
 100     uint32_t    reserved[2];
 101 } SurfaceInfo;
 102
 103 /* */
 104 struct vout_display_sys_t {
 105     picture_pool_t *pool;
 106     void *p_library;
 107     Surface_lock s_lock;
 108     Surface_lock2 s_lock2;
 109     Surface_unlockAndPost s_unlockAndPost;
 110
 111     picture_resource_t resource;
 112
 113     /* density */
 114     int i_sar_num;
 115     int i_sar_den;
 116 };
 117
 118 struct picture_sys_t
 119 {
 120     void *surf;
 121     SurfaceInfo info;
 122     vout_display_sys_t *sys;
 123 };
 124
 125 static int  AndroidLockSurface(picture_t *);
 126 static void AndroidUnlockSurface(picture_t *);
 127
 128 static vlc_mutex_t single_instance = VLC_STATIC_MUTEX;
 129
 130 static inline void *LoadSurface(const char *psz_lib, vout_display_sys_t *sys) {
 131     void *p_library = dlopen(psz_lib, RTLD_NOW);
 132     if (p_library) {
 133         sys->s_lock = (Surface_lock)(dlsym(p_library, ANDROID_SYM_S_LOCK));
 134         sys->s_lock2 = (Surface_lock2)(dlsym(p_library, ANDROID_SYM_S_LOCK2));
 135         sys->s_unlockAndPost =
 136             (Surface_unlockAndPost)(dlsym(p_library, ANDROID_SYM_S_UNLOCK));
 137         if ((sys->s_lock || sys->s_lock2) && sys->s_unlockAndPost) {
 138             return p_library;
 139         }
 140         dlclose(p_library);
 141     }
 142     return NULL;
 143 }
 144
 145 static void *InitLibrary(vout_display_sys_t *sys) {
 146     void *p_library;
 147     if ((p_library = LoadSurface("libsurfaceflinger_client.so", sys)))
 148         return p_library;
 149     if ((p_library = LoadSurface("libgui.so", sys)))
 150         return p_library;
 151     return LoadSurface("libui.so", sys);
 152 }
 153
 154 static int Open(vlc_object_t *p_this) {
 155     vout_display_t *vd = (vout_display_t *)p_this;
 156     vout_display_sys_t *sys;
 157     void *p_library;
 158
 159     /* */
 160     if (vlc_mutex_trylock(&single_instance) != 0) {
 161         msg_Err(vd, "Can't start more than one instance at a time");
 162         return VLC_EGENERIC;
 163     }
 164
 165     /* Allocate structure */
 166     sys = (struct vout_display_sys_t*) calloc(1, sizeof(*sys));
 167     if (!sys) {
 168         vlc_mutex_unlock(&single_instance);
 169         return VLC_ENOMEM;
 170     }
 171
 172     /* */
 173     sys->p_library = p_library = InitLibrary(sys);
 174     if (!p_library) {
 175         free(sys);
 176         msg_Err(vd, "Could not initialize libui.so/libgui.so/libsurfaceflinger_client.so!");
 177         vlc_mutex_unlock(&single_instance);
 178         return VLC_EGENERIC;
 179     }
 180
 181     /* Setup chroma */
 182     video_format_t fmt = vd->fmt;
 183
 184     char *psz_fcc = var_InheritString(vd, CFG_PREFIX "chroma");
 185     if( psz_fcc ) {
 186         fmt.i_chroma = vlc_fourcc_GetCodecFromString(VIDEO_ES, psz_fcc);
 187         free(psz_fcc);
 188     } else
 189         fmt.i_chroma = VLC_CODEC_RGB32;
 190
 191     switch(fmt.i_chroma) {
 192         case VLC_CODEC_YV12:
 193             /* avoid swscale usage by asking for I420 instead since the
 194              * vout already has code to swap the buffers */
 195             fmt.i_chroma = VLC_CODEC_I420;
 196         case VLC_CODEC_I420:
 197             break;
 198
 199         case VLC_CODEC_RGB16:
 200             fmt.i_bmask = 0x0000001f;
 201             fmt.i_gmask = 0x000007e0;
 202             fmt.i_rmask = 0x0000f800;
 203             break;
 204
 205         case VLC_CODEC_RGB32:
 206             fmt.i_rmask  = 0x000000ff;
 207             fmt.i_gmask  = 0x0000ff00;
 208             fmt.i_bmask  = 0x00ff0000;
 209             break;
 210
 211         default:
 212             return VLC_EGENERIC;
 213     }
 214     video_format_FixRgb(&fmt);
 215
 216     msg_Dbg(vd, "Pixel format %4.4s", (char*)&fmt.i_chroma);
 217
 218     /* Create the associated picture */
 219     picture_resource_t *rsc = &sys->resource;
 220     rsc->p_sys = malloc(sizeof(*rsc->p_sys));
 221     if (!rsc->p_sys)
 222         goto enomem;
 223     rsc->p_sys->sys = sys;
 224
 225     for (int i = 0; i < PICTURE_PLANE_MAX; i++) {
 226         rsc->p[i].p_pixels = NULL;
 227         rsc->p[i].i_pitch = 0;
 228         rsc->p[i].i_lines = 0;
 229     }
 230     picture_t *picture = picture_NewFromResource(&fmt, rsc);
 231     if (!picture)
 232         goto enomem;
 233
 234     /* Wrap it into a picture pool */
 235     picture_pool_configuration_t pool_cfg;
 236     memset(&pool_cfg, 0, sizeof(pool_cfg));
 237     pool_cfg.picture_count = 1;
 238     pool_cfg.picture       = &picture;
 239     pool_cfg.lock          = AndroidLockSurface;
 240     pool_cfg.unlock        = AndroidUnlockSurface;
 241
 242     sys->pool = picture_pool_NewExtended(&pool_cfg);
 243     if (!sys->pool) {
 244         picture_Release(picture);
 245         goto enomem;
 246     }
 247
 248     /* Setup vout_display */
 249     vd->sys     = sys;
 250     vd->fmt     = fmt;
 251     vd->pool    = Pool;
 252     vd->display = Display;
 253     vd->control = Control;
 254     vd->prepare = NULL;
 255     vd->manage  = NULL;
 256
 257     /* Fix initial state */
 258     vout_display_SendEventFullscreen(vd, false);
 259
 260     sys->i_sar_num = vd->source.i_sar_num;
 261     sys->i_sar_den = vd->source.i_sar_den;
 262
 263     return VLC_SUCCESS;
 264
 265 enomem:
 266     free(rsc->p_sys);
 267     free(sys);
 268     dlclose(p_library);
 269     vlc_mutex_unlock(&single_instance);
 270     return VLC_ENOMEM;
 271 }
 272
 273 static void Close(vlc_object_t *p_this) {
 274     vout_display_t *vd = (vout_display_t *)p_this;
 275     vout_display_sys_t *sys = vd->sys;
 276
 277     picture_pool_Delete(sys->pool);
 278     dlclose(sys->p_library);
 279     free(sys);
 280     vlc_mutex_unlock(&single_instance);
 281 }
 282
 283 static picture_pool_t *Pool(vout_display_t *vd, unsigned count) {
 284     vout_display_sys_t *sys = vd->sys;
 285     VLC_UNUSED(count);
 286     return sys->pool;
 287 }
 288
 289 #define ALIGN_16_PIXELS( x ) ( ( ( x ) + 15 ) / 16 * 16 )
 290 static void SetupPictureYV12( SurfaceInfo* p_surfaceInfo, picture_t *p_picture )
 291 {
 292     /* according to document of android.graphics.ImageFormat.YV12 */
 293     int i_stride = ALIGN_16_PIXELS( p_surfaceInfo->s );
 294     int i_c_stride = ALIGN_16_PIXELS( i_stride / 2 );
 295
 296     p_picture->p->i_pitch = i_stride;
 297
 298     /* Fill chroma planes for planar YUV */
 299     for( int n = 1; n < p_picture->i_planes; n++ )
 300     {
 301         const plane_t *o = &p_picture->p[n-1];
 302         plane_t *p = &p_picture->p[n];
 303
 304         p->p_pixels = o->p_pixels + o->i_lines * o->i_pitch;
 305         p->i_pitch  = i_c_stride;
 306         p->i_lines  = p_picture->format.i_height / 2;
 307     }
 308
 309     if( vlc_fourcc_AreUVPlanesSwapped( p_picture->format.i_chroma,
 310                                        VLC_CODEC_YV12 ) ) {
 311         uint8_t *p_tmp = p_picture->p[1].p_pixels;
 312         p_picture->p[1].p_pixels = p_picture->p[2].p_pixels;
 313         p_picture->p[2].p_pixels = p_tmp;
 314     }
 315 }
 316
 317 static int  AndroidLockSurface(picture_t *picture) {
 318     picture_sys_t *picsys = picture->p_sys;
 319     vout_display_sys_t *sys = picsys->sys;
 320     SurfaceInfo *info;
 321     uint32_t sw, sh;
 322     void *surf;
 323
 324     sw = picture->p[0].i_visible_pitch / picture->p[0].i_pixel_pitch;
 325     sh = picture->p[0].i_visible_lines;
 326
 327     picsys->surf = surf = jni_LockAndGetAndroidSurface();
 328     info = &(picsys->info);
 329
 330     if (unlikely(!surf)) {
 331         jni_UnlockAndroidSurface();
 332         return VLC_EGENERIC;
 333     }
 334
 335     if (sys->s_lock)
 336         sys->s_lock(surf, info, 1);
 337     else
 338         sys->s_lock2(surf, info, NULL);
 339
 340     // input size doesn't match the surface size,
 341     // request a resize
 342     if (info->w != sw || info->h != sh) {
 343         jni_SetAndroidSurfaceSize(sw, sh, sys->i_sar_num, sys->i_sar_den);
 344         sys->s_unlockAndPost(surf);
 345         jni_UnlockAndroidSurface();
 346         return VLC_EGENERIC;
 347     }
 348
 349     picture->p[0].p_pixels = (uint8_t*)info->bits;
 350     picture->p[0].i_lines = info->h;
 351     picture->p[0].i_pitch = picture->p[0].i_pixel_pitch * info->s;
 352
 353     if (info->format == 0x32315659 /*ANDROID_IMAGE_FORMAT_YV12*/)
 354         SetupPictureYV12(info, picture);
 355
 356     return VLC_SUCCESS;
 357 }
 358
 359 static void AndroidUnlockSurface(picture_t *picture) {
 360     picture_sys_t *picsys = picture->p_sys;
 361     vout_display_sys_t *sys = picsys->sys;
 362
 363     if (likely(picsys->surf))
 364         sys->s_unlockAndPost(picsys->surf);
 365     jni_UnlockAndroidSurface();
 366 }
 367
 368 static void Display(vout_display_t *vd, picture_t *picture, subpicture_t *subpicture) {
 369     VLC_UNUSED(vd);
 370     VLC_UNUSED(subpicture);
 371     picture_Release(picture);
 372 }
 373
 374 static int Control(vout_display_t *vd, int query, va_list args) {
 375     VLC_UNUSED(args);
 376
 377     switch (query) {
 378         case VOUT_DISPLAY_CHANGE_FULLSCREEN:
 379         case VOUT_DISPLAY_CHANGE_WINDOW_STATE:
 380         case VOUT_DISPLAY_CHANGE_DISPLAY_SIZE:
 381         case VOUT_DISPLAY_CHANGE_DISPLAY_FILLED:
 382         case VOUT_DISPLAY_CHANGE_ZOOM:
 383         case VOUT_DISPLAY_CHANGE_SOURCE_ASPECT:
 384         case VOUT_DISPLAY_CHANGE_SOURCE_CROP:
 385         case VOUT_DISPLAY_GET_OPENGL:
 386             return VLC_EGENERIC;
 387         case VOUT_DISPLAY_HIDE_MOUSE:
 388             return VLC_SUCCESS;
 389         default:
 390             msg_Err(vd, "Unknown request in android vout display");
 391             return VLC_EGENERIC;
 392     }
 393 }