vaapi: cosmetic

modules/codec/avcodec/vaapi.c

@@ -95,10 +95,10 @@ struct vlc_va_sys_t
 };
 
 /* */
-static int Open( vlc_va_t *p_external, int i_codec_id )
+static int Open( vlc_va_t *va, int i_codec_id )
 {
-    vlc_va_sys_t *p_va = calloc( 1, sizeof(*p_va) );
-    if ( unlikely(p_va == NULL) )
+    vlc_va_sys_t *sys = calloc( 1, sizeof(*sys) );
+    if ( unlikely(sys == NULL) )
        return VLC_ENOMEM;
 
     VAProfile i_profile, *p_profiles_list;
@@ -135,38 +135,38 @@ static int Open( vlc_va_t *p_external, int i_codec_id )
     }
 
     /* */
-    p_va->i_config_id  = VA_INVALID_ID;
-    p_va->i_context_id = VA_INVALID_ID;
-    p_va->image.image_id = VA_INVALID_ID;
+    sys->i_config_id  = VA_INVALID_ID;
+    sys->i_context_id = VA_INVALID_ID;
+    sys->image.image_id = VA_INVALID_ID;
 
     /* Create a VA display */
-    p_va->p_display_x11 = XOpenDisplay(NULL);
-    if( !p_va->p_display_x11 )
+    sys->p_display_x11 = XOpenDisplay(NULL);
+    if( !sys->p_display_x11 )
     {
-        msg_Err( p_external, "Could not connect to X server" );
+        msg_Err( va, "Could not connect to X server" );
         goto error;
     }
 
-    p_va->p_display = vaGetDisplay( p_va->p_display_x11 );
-    if( !p_va->p_display )
+    sys->p_display = vaGetDisplay( sys->p_display_x11 );
+    if( !sys->p_display )
     {
-        msg_Err( p_external, "Could not get a VAAPI device" );
+        msg_Err( va, "Could not get a VAAPI device" );
         goto error;
     }
 
-    if( vaInitialize( p_va->p_display, &p_va->i_version_major, &p_va->i_version_minor ) )
+    if( vaInitialize( sys->p_display, &sys->i_version_major, &sys->i_version_minor ) )
     {
-        msg_Err( p_external, "Failed to initialize the VAAPI device" );
+        msg_Err( va, "Failed to initialize the VAAPI device" );
         goto error;
     }
 
     /* Check if the selected profile is supported */
-    i_profiles_nb = vaMaxNumProfiles( p_va->p_display );
+    i_profiles_nb = vaMaxNumProfiles( sys->p_display );
     p_profiles_list = calloc( i_profiles_nb, sizeof( VAProfile ) );
     if( !p_profiles_list )
         goto error;
 
-    VAStatus i_status = vaQueryConfigProfiles( p_va->p_display, p_profiles_list, &i_profiles_nb );
+    VAStatus i_status = vaQueryConfigProfiles( sys->p_display, p_profiles_list, &i_profiles_nb );
     if ( i_status == VA_STATUS_SUCCESS )
     {
         for( int i = 0; i < i_profiles_nb; i++ )
@@ -181,7 +181,7 @@ static int Open( vlc_va_t *p_external, int i_codec_id )
     free( p_profiles_list );
     if ( !b_supported_profile )
     {
-        msg_Dbg( p_external, "Codec and profile not supported by the hardware" );
+        msg_Dbg( va, "Codec and profile not supported by the hardware" );
         goto error;
     }
 
@@ -189,91 +189,91 @@ static int Open( vlc_va_t *p_external, int i_codec_id )
     VAConfigAttrib attrib;
     memset( &attrib, 0, sizeof(attrib) );
     attrib.type = VAConfigAttribRTFormat;
-    if( vaGetConfigAttributes( p_va->p_display,
+    if( vaGetConfigAttributes( sys->p_display,
                                i_profile, VAEntrypointVLD, &attrib, 1 ) )
         goto error;
 
     /* Not sure what to do if not, I don't have a way to test */
     if( (attrib.value & VA_RT_FORMAT_YUV420) == 0 )
         goto error;
-    if( vaCreateConfig( p_va->p_display,
-                        i_profile, VAEntrypointVLD, &attrib, 1, &p_va->i_config_id ) )
+    if( vaCreateConfig( sys->p_display,
+                        i_profile, VAEntrypointVLD, &attrib, 1, &sys->i_config_id ) )
     {
-        p_va->i_config_id = VA_INVALID_ID;
+        sys->i_config_id = VA_INVALID_ID;
         goto error;
     }
 
-    p_va->i_surface_count = i_surface_count;
+    sys->i_surface_count = i_surface_count;
 
-    p_va->b_supports_derive = false;
+    sys->b_supports_derive = false;
 
-    if( asprintf( &p_external->description, "VA API version %d.%d",
-                  p_va->i_version_major, p_va->i_version_minor ) < 0 )
-        p_external->description = NULL;
+    if( asprintf( &va->description, "VA API version %d.%d",
+                  sys->i_version_major, sys->i_version_minor ) < 0 )
+        va->description = NULL;
 
-    p_external->sys = p_va;
+    va->sys = sys;
     return VLC_SUCCESS;
 
 error:
     return VLC_EGENERIC;
 }
 
-static void DestroySurfaces( vlc_va_sys_t *p_va )
+static void DestroySurfaces( vlc_va_sys_t *sys )
 {
-    if( p_va->image.image_id != VA_INVALID_ID )
+    if( sys->image.image_id != VA_INVALID_ID )
     {
-        CopyCleanCache( &p_va->image_cache );
-        vaDestroyImage( p_va->p_display, p_va->image.image_id );
+        CopyCleanCache( &sys->image_cache );
+        vaDestroyImage( sys->p_display, sys->image.image_id );
     }
-    else if(p_va->b_supports_derive)
+    else if(sys->b_supports_derive)
     {
-        CopyCleanCache( &p_va->image_cache );
+        CopyCleanCache( &sys->image_cache );
     }
 
-    if( p_va->i_context_id != VA_INVALID_ID )
-        vaDestroyContext( p_va->p_display, p_va->i_context_id );
+    if( sys->i_context_id != VA_INVALID_ID )
+        vaDestroyContext( sys->p_display, sys->i_context_id );
 
-    for( int i = 0; i < p_va->i_surface_count && p_va->p_surface; i++ )
+    for( int i = 0; i < sys->i_surface_count && sys->p_surface; i++ )
     {
-        vlc_va_surface_t *p_surface = &p_va->p_surface[i];
+        vlc_va_surface_t *p_surface = &sys->p_surface[i];
 
         if( p_surface->i_id != VA_INVALID_SURFACE )
-            vaDestroySurfaces( p_va->p_display, &p_surface->i_id, 1 );
+            vaDestroySurfaces( sys->p_display, &p_surface->i_id, 1 );
     }
-    free( p_va->p_surface );
+    free( sys->p_surface );
 
     /* */
-    p_va->image.image_id = VA_INVALID_ID;
-    p_va->i_context_id = VA_INVALID_ID;
-    p_va->p_surface = NULL;
-    p_va->i_surface_width = 0;
-    p_va->i_surface_height = 0;
+    sys->image.image_id = VA_INVALID_ID;
+    sys->i_context_id = VA_INVALID_ID;
+    sys->p_surface = NULL;
+    sys->i_surface_width = 0;
+    sys->i_surface_height = 0;
 }
-static int CreateSurfaces( vlc_va_sys_t *p_va, void **pp_hw_ctx, vlc_fourcc_t *pi_chroma,
+static int CreateSurfaces( vlc_va_sys_t *sys, void **pp_hw_ctx, vlc_fourcc_t *pi_chroma,
                            int i_width, int i_height )
 {
     assert( i_width > 0 && i_height > 0 );
 
     /* */
-    p_va->p_surface = calloc( p_va->i_surface_count, sizeof(*p_va->p_surface) );
-    if( !p_va->p_surface )
+    sys->p_surface = calloc( sys->i_surface_count, sizeof(*sys->p_surface) );
+    if( !sys->p_surface )
         return VLC_EGENERIC;
-    p_va->image.image_id = VA_INVALID_ID;
-    p_va->i_context_id   = VA_INVALID_ID;
+    sys->image.image_id = VA_INVALID_ID;
+    sys->i_context_id   = VA_INVALID_ID;
 
     /* Create surfaces */
-    VASurfaceID pi_surface_id[p_va->i_surface_count];
-    if( vaCreateSurfaces( p_va->p_display, VA_RT_FORMAT_YUV420, i_width, i_height,
-                          pi_surface_id, p_va->i_surface_count, NULL, 0 ) )
+    VASurfaceID pi_surface_id[sys->i_surface_count];
+    if( vaCreateSurfaces( sys->p_display, VA_RT_FORMAT_YUV420, i_width, i_height,
+                          pi_surface_id, sys->i_surface_count, NULL, 0 ) )
     {
-        for( int i = 0; i < p_va->i_surface_count; i++ )
-            p_va->p_surface[i].i_id = VA_INVALID_SURFACE;
+        for( int i = 0; i < sys->i_surface_count; i++ )
+            sys->p_surface[i].i_id = VA_INVALID_SURFACE;
         goto error;
     }
 
-    for( int i = 0; i < p_va->i_surface_count; i++ )
+    for( int i = 0; i < sys->i_surface_count; i++ )
     {
-        vlc_va_surface_t *p_surface = &p_va->p_surface[i];
+        vlc_va_surface_t *p_surface = &sys->p_surface[i];
 
         p_surface->i_id = pi_surface_id[i];
         p_surface->i_refcount = 0;
@@ -281,31 +281,31 @@ static int CreateSurfaces( vlc_va_sys_t *p_va, void **pp_hw_ctx, vlc_fourcc_t *p
     }
 
     /* Create a context */
-    if( vaCreateContext( p_va->p_display, p_va->i_config_id,
+    if( vaCreateContext( sys->p_display, sys->i_config_id,
                          i_width, i_height, VA_PROGRESSIVE,
-                         pi_surface_id, p_va->i_surface_count, &p_va->i_context_id ) )
+                         pi_surface_id, sys->i_surface_count, &sys->i_context_id ) )
     {
-        p_va->i_context_id = VA_INVALID_ID;
+        sys->i_context_id = VA_INVALID_ID;
         goto error;
     }
 
     /* Find and create a supported image chroma */
-    int i_fmt_count = vaMaxNumImageFormats( p_va->p_display );
+    int i_fmt_count = vaMaxNumImageFormats( sys->p_display );
     VAImageFormat *p_fmt = calloc( i_fmt_count, sizeof(*p_fmt) );
     if( !p_fmt )
         goto error;
 
-    if( vaQueryImageFormats( p_va->p_display, p_fmt, &i_fmt_count ) )
+    if( vaQueryImageFormats( sys->p_display, p_fmt, &i_fmt_count ) )
     {
         free( p_fmt );
         goto error;
     }
 
     VAImage test_image;
-    if(vaDeriveImage(p_va->p_display, pi_surface_id[0], &test_image) == VA_STATUS_SUCCESS)
+    if(vaDeriveImage(sys->p_display, pi_surface_id[0], &test_image) == VA_STATUS_SUCCESS)
     {
-        p_va->b_supports_derive = true;
-        vaDestroyImage(p_va->p_display, test_image.image_id);
+        sys->b_supports_derive = true;
+        vaDestroyImage(sys->p_display, test_image.image_id);
     }
 
     vlc_fourcc_t  i_chroma = 0;
@@ -316,18 +316,18 @@ static int CreateSurfaces( vlc_va_sys_t *p_va, void **pp_hw_ctx, vlc_fourcc_t *p
             p_fmt[i].fourcc == VA_FOURCC( 'I', '4', '2', '0' ) ||
             p_fmt[i].fourcc == VA_FOURCC( 'N', 'V', '1', '2' ) )
         {
-            if( vaCreateImage(  p_va->p_display, &p_fmt[i], i_width, i_height, &p_va->image ) )
+            if( vaCreateImage(  sys->p_display, &p_fmt[i], i_width, i_height, &sys->image ) )
             {
-                p_va->image.image_id = VA_INVALID_ID;
+                sys->image.image_id = VA_INVALID_ID;
                 continue;
             }
             /* Validate that vaGetImage works with this format */
-            if( vaGetImage( p_va->p_display, pi_surface_id[0],
+            if( vaGetImage( sys->p_display, pi_surface_id[0],
                             0, 0, i_width, i_height,
-                            p_va->image.image_id) )
+                            sys->image.image_id) )
             {
-                vaDestroyImage( p_va->p_display, p_va->image.image_id );
-                p_va->image.image_id = VA_INVALID_ID;
+                vaDestroyImage( sys->p_display, sys->image.image_id );
+                sys->image.image_id = VA_INVALID_ID;
                 continue;
             }
 
@@ -341,88 +341,88 @@ static int CreateSurfaces( vlc_va_sys_t *p_va, void **pp_hw_ctx, vlc_fourcc_t *p
         goto error;
     *pi_chroma = i_chroma;
 
-    if(p_va->b_supports_derive)
+    if(sys->b_supports_derive)
     {
-        vaDestroyImage( p_va->p_display, p_va->image.image_id );
-        p_va->image.image_id = VA_INVALID_ID;
+        vaDestroyImage( sys->p_display, sys->image.image_id );
+        sys->image.image_id = VA_INVALID_ID;
     }
 
-    if( unlikely(CopyInitCache( &p_va->image_cache, i_width )) )
+    if( unlikely(CopyInitCache( &sys->image_cache, i_width )) )
         goto error;
 
     /* Setup the ffmpeg hardware context */
-    *pp_hw_ctx = &p_va->hw_ctx;
+    *pp_hw_ctx = &sys->hw_ctx;
 
-    memset( &p_va->hw_ctx, 0, sizeof(p_va->hw_ctx) );
-    p_va->hw_ctx.display    = p_va->p_display;
-    p_va->hw_ctx.config_id  = p_va->i_config_id;
-    p_va->hw_ctx.context_id = p_va->i_context_id;
+    memset( &sys->hw_ctx, 0, sizeof(sys->hw_ctx) );
+    sys->hw_ctx.display    = sys->p_display;
+    sys->hw_ctx.config_id  = sys->i_config_id;
+    sys->hw_ctx.context_id = sys->i_context_id;
 
     /* */
-    p_va->i_surface_chroma = i_chroma;
-    p_va->i_surface_width = i_width;
-    p_va->i_surface_height = i_height;
+    sys->i_surface_chroma = i_chroma;
+    sys->i_surface_width = i_width;
+    sys->i_surface_height = i_height;
     return VLC_SUCCESS;
 
 error:
-    DestroySurfaces( p_va );
+    DestroySurfaces( sys );
     return VLC_EGENERIC;
 }
 
-static int Setup( vlc_va_t *p_external, void **pp_hw_ctx, vlc_fourcc_t *pi_chroma,
+static int Setup( vlc_va_t *va, void **pp_hw_ctx, vlc_fourcc_t *pi_chroma,
                   int i_width, int i_height )
 {
-    vlc_va_sys_t *p_va = p_external->sys;
+    vlc_va_sys_t *sys = va->sys;
 
-    if( p_va->i_surface_width == i_width &&
-        p_va->i_surface_height == i_height )
+    if( sys->i_surface_width == i_width &&
+        sys->i_surface_height == i_height )
     {
-        *pp_hw_ctx = &p_va->hw_ctx;
-        *pi_chroma = p_va->i_surface_chroma;
+        *pp_hw_ctx = &sys->hw_ctx;
+        *pi_chroma = sys->i_surface_chroma;
         return VLC_SUCCESS;
     }
 
     *pp_hw_ctx = NULL;
     *pi_chroma = 0;
-    if( p_va->i_surface_width || p_va->i_surface_height )
-        DestroySurfaces( p_va );
+    if( sys->i_surface_width || sys->i_surface_height )
+        DestroySurfaces( sys );
 
     if( i_width > 0 && i_height > 0 )
-        return CreateSurfaces( p_va, pp_hw_ctx, pi_chroma, i_width, i_height );
+        return CreateSurfaces( sys, pp_hw_ctx, pi_chroma, i_width, i_height );
 
     return VLC_EGENERIC;
 }
-static int Extract( vlc_va_t *p_external, picture_t *p_picture, AVFrame *p_ff )
+static int Extract( vlc_va_t *va, picture_t *p_picture, AVFrame *p_ff )
 {
-    vlc_va_sys_t *p_va = p_external->sys;
+    vlc_va_sys_t *sys = va->sys;
 
     VASurfaceID i_surface_id = (VASurfaceID)(uintptr_t)p_ff->data[3];
 
 #if VA_CHECK_VERSION(0,31,0)
-    if( vaSyncSurface( p_va->p_display, i_surface_id ) )
+    if( vaSyncSurface( sys->p_display, i_surface_id ) )
 #else
-    if( vaSyncSurface( p_va->p_display, p_va->i_context_id, i_surface_id ) )
+    if( vaSyncSurface( sys->p_display, sys->i_context_id, i_surface_id ) )
 #endif
         return VLC_EGENERIC;
 
-    if(p_va->b_supports_derive)
+    if(sys->b_supports_derive)
     {
-        if(vaDeriveImage(p_va->p_display, i_surface_id, &(p_va->image)) != VA_STATUS_SUCCESS)
+        if(vaDeriveImage(sys->p_display, i_surface_id, &(sys->image)) != VA_STATUS_SUCCESS)
             return VLC_EGENERIC;
     }
     else
     {
-        if( vaGetImage( p_va->p_display, i_surface_id,
-                        0, 0, p_va->i_surface_width, p_va->i_surface_height,
-                        p_va->image.image_id) )
+        if( vaGetImage( sys->p_display, i_surface_id,
+                        0, 0, sys->i_surface_width, sys->i_surface_height,
+                        sys->image.image_id) )
             return VLC_EGENERIC;
     }
 
     void *p_base;
-    if( vaMapBuffer( p_va->p_display, p_va->image.buf, &p_base ) )
+    if( vaMapBuffer( sys->p_display, sys->image.buf, &p_base ) )
         return VLC_EGENERIC;
 
-    const uint32_t i_fourcc = p_va->image.format.fourcc;
+    const uint32_t i_fourcc = sys->image.format.fourcc;
     if( i_fourcc == VA_FOURCC('Y','V','1','2') ||
         i_fourcc == VA_FOURCC('I','4','2','0') )
     {
@@ -433,13 +433,13 @@ static int Extract( vlc_va_t *p_external, picture_t *p_picture, AVFrame *p_ff )
         for( int i = 0; i < 3; i++ )
         {
             const int i_src_plane = (b_swap_uv && i != 0) ?  (3 - i) : i;
-            pp_plane[i] = (uint8_t*)p_base + p_va->image.offsets[i_src_plane];
-            pi_pitch[i] = p_va->image.pitches[i_src_plane];
+            pp_plane[i] = (uint8_t*)p_base + sys->image.offsets[i_src_plane];
+            pi_pitch[i] = sys->image.pitches[i_src_plane];
         }
         CopyFromYv12( p_picture, pp_plane, pi_pitch,
-                      p_va->i_surface_width,
-                      p_va->i_surface_height,
-                      &p_va->image_cache );
+                      sys->i_surface_width,
+                      sys->i_surface_height,
+                      &sys->image_cache );
     }
     else
     {
@@ -449,51 +449,51 @@ static int Extract( vlc_va_t *p_external, picture_t *p_picture, AVFrame *p_ff )
 
         for( int i = 0; i < 2; i++ )
         {
-            pp_plane[i] = (uint8_t*)p_base + p_va->image.offsets[i];
-            pi_pitch[i] = p_va->image.pitches[i];
+            pp_plane[i] = (uint8_t*)p_base + sys->image.offsets[i];
+            pi_pitch[i] = sys->image.pitches[i];
         }
         CopyFromNv12( p_picture, pp_plane, pi_pitch,
-                      p_va->i_surface_width,
-                      p_va->i_surface_height,
-                      &p_va->image_cache );
+                      sys->i_surface_width,
+                      sys->i_surface_height,
+                      &sys->image_cache );
     }
 
-    if( vaUnmapBuffer( p_va->p_display, p_va->image.buf ) )
+    if( vaUnmapBuffer( sys->p_display, sys->image.buf ) )
         return VLC_EGENERIC;
 
-    if(p_va->b_supports_derive)
+    if(sys->b_supports_derive)
     {
-        vaDestroyImage( p_va->p_display, p_va->image.image_id );
-        p_va->image.image_id = VA_INVALID_ID;
+        vaDestroyImage( sys->p_display, sys->image.image_id );
+        sys->image.image_id = VA_INVALID_ID;
     }
 
     return VLC_SUCCESS;
 }
-static int Get( vlc_va_t *p_external, AVFrame *p_ff )
+static int Get( vlc_va_t *va, AVFrame *p_ff )
 {
-    vlc_va_sys_t *p_va = p_external->sys;
+    vlc_va_sys_t *sys = va->sys;
     int i_old;
     int i;
 
     /* Grab an unused surface, in case none are, try the oldest
      * XXX using the oldest is a workaround in case a problem happens with ffmpeg */
-    for( i = 0, i_old = 0; i < p_va->i_surface_count; i++ )
+    for( i = 0, i_old = 0; i < sys->i_surface_count; i++ )
     {
-        vlc_va_surface_t *p_surface = &p_va->p_surface[i];
+        vlc_va_surface_t *p_surface = &sys->p_surface[i];
 
         if( !p_surface->i_refcount )
             break;
 
-        if( p_surface->i_order < p_va->p_surface[i_old].i_order )
+        if( p_surface->i_order < sys->p_surface[i_old].i_order )
             i_old = i;
     }
-    if( i >= p_va->i_surface_count )
+    if( i >= sys->i_surface_count )
         i = i_old;
 
-    vlc_va_surface_t *p_surface = &p_va->p_surface[i];
+    vlc_va_surface_t *p_surface = &sys->p_surface[i];
 
     p_surface->i_refcount = 1;
-    p_surface->i_order = p_va->i_surface_order++;
+    p_surface->i_order = sys->i_surface_order++;
 
     /* */
     for( int i = 0; i < 4; i++ )
@@ -506,40 +506,40 @@ static int Get( vlc_va_t *p_external, AVFrame *p_ff )
     }
     return VLC_SUCCESS;
 }
-static void Release( vlc_va_t *p_external, AVFrame *p_ff )
+static void Release( vlc_va_t *va, AVFrame *p_ff )
 {
-    vlc_va_sys_t *p_va = p_external->sys;
+    vlc_va_sys_t *sys = va->sys;
 
     VASurfaceID i_surface_id = (VASurfaceID)(uintptr_t)p_ff->data[3];
 
-    for( int i = 0; i < p_va->i_surface_count; i++ )
+    for( int i = 0; i < sys->i_surface_count; i++ )
     {
-        vlc_va_surface_t *p_surface = &p_va->p_surface[i];
+        vlc_va_surface_t *p_surface = &sys->p_surface[i];
 
         if( p_surface->i_id == i_surface_id )
             p_surface->i_refcount--;
     }
 }
 
-static void Close( vlc_va_sys_t *p_va )
+static void Close( vlc_va_sys_t *sys )
 {
-    if( p_va->i_surface_width || p_va->i_surface_height )
-        DestroySurfaces( p_va );
-
-    if( p_va->i_config_id != VA_INVALID_ID )
-        vaDestroyConfig( p_va->p_display, p_va->i_config_id );
-    if( p_va->p_display )
-        vaTerminate( p_va->p_display );
-    if( p_va->p_display_x11 )
-        XCloseDisplay( p_va->p_display_x11 );
+    if( sys->i_surface_width || sys->i_surface_height )
+        DestroySurfaces( sys );
+
+    if( sys->i_config_id != VA_INVALID_ID )
+        vaDestroyConfig( sys->p_display, sys->i_config_id );
+    if( sys->p_display )
+        vaTerminate( sys->p_display );
+    if( sys->p_display_x11 )
+        XCloseDisplay( sys->p_display_x11 );
 }
 
-static void Delete( vlc_va_t *p_external )
+static void Delete( vlc_va_t *va )
 {
-    vlc_va_sys_t *p_va = p_external->sys;
-    Close( p_va );
-    free( p_external->description );
-    free( p_va );
+    vlc_va_sys_t *sys = va->sys;
+    Close( sys );
+    free( va->description );
+    free( sys );
 }
 
 static int Create( vlc_va_t *p_va, int i_codec_id, const es_format_t *fmt )