Cosmetics (K&R of picture_pool).

include/vlc_picture_pool.h

@@ -69,14 +69,14 @@ VLC_EXPORT( picture_pool_t *, picture_pool_NewExtended, ( const picture_pool_con
  *
  * It is provided as convenience.
  */
-VLC_EXPORT( picture_pool_t *, picture_pool_New, ( int i_picture, picture_t *pp_picture[] ) );
+VLC_EXPORT( picture_pool_t *, picture_pool_New, ( int picture_count, picture_t *picture[] ) );
 
 /**
  * It creates a picture_pool_t creating images using the given format.
  *
  * Provided for convenience.
  */
-VLC_EXPORT( picture_pool_t *, picture_pool_NewFromFormat, ( const video_format_t *, int i_picture ) );
+VLC_EXPORT( picture_pool_t *, picture_pool_NewFromFormat, ( const video_format_t *, int picture_count ) );
 
 /**
  * It destroys a pool created by picture_pool_New.
@@ -104,7 +104,7 @@ VLC_EXPORT( picture_t *, picture_pool_Get, ( picture_pool_t * ) );
  * XXX it should be used with great care, the only reason you may need
  * it is to workaround a bug.
  */
-VLC_EXPORT( void, picture_pool_NonEmpty, ( picture_pool_t *, bool b_reset ) );
+VLC_EXPORT( void, picture_pool_NonEmpty, ( picture_pool_t *, bool reset ) );
 
 #endif /* VLC_PICTURE_POOL_H */
 

src/misc/picture_pool.c

@@ -37,182 +37,177 @@
 /*****************************************************************************
  *
  *****************************************************************************/
-struct picture_release_sys_t
-{
+struct picture_release_sys_t {
     /* Saved release */
-    void (*pf_release)( picture_t * );
-    picture_release_sys_t *p_release_sys;
+    void (*release)(picture_t *);
+    picture_release_sys_t *release_sys;
 
     /* */
-    int  (*pf_lock)( picture_t * );
-    void (*pf_unlock)( picture_t * );
+    int  (*lock)(picture_t *);
+    void (*unlock)(picture_t *);
 
     /* */
-    int64_t i_tick;
+    int64_t tick;
 };
 
-struct picture_pool_t
-{
-    int64_t i_tick;
-
-    int i_picture;
-    picture_t **pp_picture;
+struct picture_pool_t {
+    /* */
+    int64_t   tick;
+    /* */
+    int       picture_count;
+    picture_t **picture;
 };
 
-static void PicturePoolPictureRelease( picture_t * );
+static void PicturePoolPictureRelease(picture_t *);
 
-picture_pool_t *picture_pool_NewExtended( const picture_pool_configuration_t *cfg )
+picture_pool_t *picture_pool_NewExtended(const picture_pool_configuration_t *cfg)
 {
-    picture_pool_t *p_pool = calloc( 1, sizeof(*p_pool) );
-    if( !p_pool )
+    picture_pool_t *pool = calloc(1, sizeof(*pool));
+    if (!pool)
         return NULL;
 
-    p_pool->i_tick = 1;
-    p_pool->i_picture = cfg->picture_count;
-    p_pool->pp_picture = calloc( p_pool->i_picture, sizeof(*p_pool->pp_picture) );
-    if( !p_pool->pp_picture )
-    {
-        free( p_pool );
+    pool->tick = 1;
+    pool->picture_count = cfg->picture_count;
+    pool->picture = calloc(pool->picture_count, sizeof(*pool->picture));
+    if (!pool->picture) {
+        free(pool);
         return NULL;
     }
 
-    for( int i = 0; i < cfg->picture_count; i++ )
-    {
-        picture_t *p_picture = cfg->picture[i];
+    for (int i = 0; i < cfg->picture_count; i++) {
+        picture_t *picture = cfg->picture[i];
 
         /* The pool must be the only owner of the picture */
-        assert( p_picture->i_refcount == 1 );
+        assert(picture->i_refcount == 1);
 
         /* Install the new release callback */
-        picture_release_sys_t *p_release_sys = malloc( sizeof(*p_release_sys) );
-        if( !p_release_sys )
+        picture_release_sys_t *release_sys = malloc(sizeof(*release_sys));
+        if (!release_sys)
             abort();
-        p_release_sys->pf_release    = p_picture->pf_release;
-        p_release_sys->p_release_sys = p_picture->p_release_sys;
-        p_release_sys->pf_lock       = cfg->lock;
-        p_release_sys->pf_unlock     = cfg->unlock;
-        p_release_sys->i_tick        = 0;
+        release_sys->release     = picture->pf_release;
+        release_sys->release_sys = picture->p_release_sys;
+        release_sys->lock        = cfg->lock;
+        release_sys->unlock      = cfg->unlock;
+        release_sys->tick        = 0;
 
-        p_picture->i_refcount = 0;
-        p_picture->pf_release = PicturePoolPictureRelease;
-        p_picture->p_release_sys = p_release_sys;
+        /* */
+        picture->i_refcount    = 0;
+        picture->pf_release    = PicturePoolPictureRelease;
+        picture->p_release_sys = release_sys;
 
         /* */
-        p_pool->pp_picture[i] = p_picture;
+        pool->picture[i] = picture;
     }
-    return p_pool;
+    return pool;
 
 }
 
-picture_pool_t *picture_pool_New( int i_picture, picture_t *pp_picture[] )
+picture_pool_t *picture_pool_New(int picture_count, picture_t *picture[])
 {
     picture_pool_configuration_t cfg;
 
-    memset( &cfg, 0, sizeof(cfg) );
-    cfg.picture_count = i_picture;
-    cfg.picture       = pp_picture;
+    memset(&cfg, 0, sizeof(cfg));
+    cfg.picture_count = picture_count;
+    cfg.picture       = picture;
 
-    return picture_pool_NewExtended( &cfg );
+    return picture_pool_NewExtended(&cfg);
 }
 
-picture_pool_t *picture_pool_NewFromFormat( const video_format_t *p_fmt, int i_picture )
+picture_pool_t *picture_pool_NewFromFormat(const video_format_t *fmt, int picture_count)
 {
-    picture_t *pp_picture[i_picture];
-
-    for( int i = 0; i < i_picture; i++ )
-    {
-        pp_picture[i] = picture_New( p_fmt->i_chroma,
-                                     p_fmt->i_width, p_fmt->i_height,
-                                     p_fmt->i_aspect );
-        if( !pp_picture[i] )
+    picture_t *picture[picture_count];
+
+    for (int i = 0; i < picture_count; i++) {
+        picture[i] = picture_NewFromFormat(fmt);
+        if (!picture[i])
             goto error;
     }
-    picture_pool_t *p_pool = picture_pool_New( i_picture, pp_picture );
-    if( !p_pool )
+    picture_pool_t *pool = picture_pool_New(picture_count, picture);
+    if (!pool)
         goto error;
 
-    return p_pool;
+    return pool;
 
 error:
-    for( int i = 0; i < i_picture; i++ )
-    {
-        if( !pp_picture[i] )
+    for (int i = 0; i < picture_count; i++) {
+        if (!picture[i])
             break;
-        picture_Release( pp_picture[i] );
+        picture_Release(picture[i]);
     }
     return NULL;
 }
 
-void picture_pool_Delete( picture_pool_t *p_pool )
+void picture_pool_Delete(picture_pool_t *pool)
 {
-    for( int i = 0; i < p_pool->i_picture; i++ )
-    {
-        picture_t *p_picture = p_pool->pp_picture[i];
-        picture_release_sys_t *p_release_sys = p_picture->p_release_sys;
+    for (int i = 0; i < pool->picture_count; i++) {
+        picture_t *picture = pool->picture[i];
+        picture_release_sys_t *release_sys = picture->p_release_sys;
 
-        assert( p_picture->i_refcount == 0 );
+        assert(picture->i_refcount == 0);
 
         /* Restore old release callback */
-        p_picture->i_refcount = 1;
-        p_picture->pf_release = p_release_sys->pf_release;
-        p_picture->p_release_sys = p_release_sys->p_release_sys;
+        picture->i_refcount    = 1;
+        picture->pf_release    = release_sys->release;
+        picture->p_release_sys = release_sys->release_sys;
 
-        picture_Release( p_picture );
+        picture_Release(picture);
 
-        free( p_release_sys );
+        free(release_sys);
     }
-    free( p_pool->pp_picture );
-    free( p_pool );
+    free(pool->picture);
+    free(pool);
 }
 
-picture_t *picture_pool_Get( picture_pool_t *p_pool )
+picture_t *picture_pool_Get(picture_pool_t *pool)
 {
-    for( int i = 0; i < p_pool->i_picture; i++ )
-    {
-        picture_t *p_picture = p_pool->pp_picture[i];
-        if( p_picture->i_refcount > 0 )
+    for (int i = 0; i < pool->picture_count; i++) {
+        picture_t *picture = pool->picture[i];
+        if (picture->i_refcount > 0)
             continue;
 
-        picture_release_sys_t *p_release_sys = p_picture->p_release_sys;
-        if( p_release_sys->pf_lock && p_release_sys->pf_lock(p_picture) )
+        picture_release_sys_t *release_sys = picture->p_release_sys;
+        if (release_sys->lock && release_sys->lock(picture))
             continue;
 
         /* */
-        p_picture->p_release_sys->i_tick = p_pool->i_tick++;
-        picture_Hold( p_picture );
-        return p_picture;
+        picture->p_release_sys->tick = pool->tick++;
+        picture_Hold(picture);
+        return picture;
     }
     return NULL;
 }
 
-void picture_pool_NonEmpty( picture_pool_t *p_pool, bool b_reset )
+void picture_pool_NonEmpty(picture_pool_t *pool, bool reset)
 {
-    picture_t *p_old = NULL;
+    picture_t *old = NULL;
 
-    for( int i = 0; i < p_pool->i_picture; i++ )
-    {
-        picture_t *p_picture = p_pool->pp_picture[i];
+    for (int i = 0; i < pool->picture_count; i++) {
+        picture_t *picture = pool->picture[i];
 
-        if( b_reset )
-            p_picture->i_refcount = 0;
-        else if( p_picture->i_refcount == 0 )
+        if (reset) {
+            /* TODO pf_unlock */
+            picture->i_refcount = 0;
+        } else if (picture->i_refcount == 0) {
             return;
-        else if( !p_old || p_picture->p_release_sys->i_tick < p_old->p_release_sys->i_tick )
-            p_old = p_picture;
+        } else if (!old || picture->p_release_sys->tick < old->p_release_sys->tick) {
+            old = picture;
+        }
+    }
+    if (!reset && old) {
+        /* TODO pf_unlock */
+        old->i_refcount = 0;
     }
-    if( !b_reset && p_old )
-        p_old->i_refcount = 0;
 }
 
-static void PicturePoolPictureRelease( picture_t *p_picture )
+static void PicturePoolPictureRelease(picture_t *picture)
 {
-    assert( p_picture->i_refcount > 0 );
+    assert(picture->i_refcount > 0);
 
-    if( --p_picture->i_refcount > 0 )
+    if (--picture->i_refcount > 0)
         return;
 
-    picture_release_sys_t *p_release_sys = p_picture->p_release_sys;
-    if( p_release_sys->pf_unlock )
-        p_release_sys->pf_unlock( p_picture );
+    picture_release_sys_t *release_sys = picture->p_release_sys;
+    if (release_sys->unlock)
+        release_sys->unlock(picture);
 }