picture_pool: remove unnecessary special case

[vlc] / src / misc / es_format.c

diff --git a/src/misc/es_format.c b/src/misc/es_format.c
index 8936414c0716775c4c48fb074483ac103bb12c37..27622bcb742992bfa9baa706e1e88c28ff49f6e3 100644 (file)
--- a/src/misc/es_format.c
+++ b/src/misc/es_format.c
@@ -190,6 +190,7 @@ void video_format_Setup( video_format_t *p_fmt, vlc_fourcc_t i_chroma,
     case VLC_CODEC_RGB32:
     case VLC_CODEC_RGBA:
     case VLC_CODEC_ARGB:
+    case VLC_CODEC_BGRA:
         p_fmt->i_bits_per_pixel = 32;
         break;
     case VLC_CODEC_RGB24:
@@ -244,6 +245,134 @@ void video_format_ScaleCropAr( video_format_t *p_dst, const video_format_t *p_sr
                 p_dst->i_sar_num, p_dst->i_sar_den, 65536);
 }
 
+//Simplify transforms to have something more managable. Order: angle, hflip.
+static void transform_GetBasicOps( video_transform_t transform,
+                                   unsigned *restrict angle,
+                                   bool *restrict hflip )
+{
+    *hflip = ORIENT_IS_MIRROR(transform);
+
+    switch ( transform )
+    {
+        case TRANSFORM_R90:
+        case TRANSFORM_TRANSPOSE:
+            *angle = 90;
+            break;
+        case TRANSFORM_R180:
+        case TRANSFORM_VFLIP:
+            *angle = 180;
+            break;
+        case TRANSFORM_R270:
+        case TRANSFORM_ANTI_TRANSPOSE:
+            *angle = 270;
+            break;
+        case TRANSFORM_HFLIP:
+        case TRANSFORM_IDENTITY:
+            *angle = 0;
+            break;
+    }
+}
+
+static video_transform_t transform_FromBasicOps( unsigned angle, bool hflip )
+{
+    switch ( angle )
+    {
+        case 90:
+            return hflip ? TRANSFORM_TRANSPOSE : TRANSFORM_R90;
+        case 180:
+            return hflip ? TRANSFORM_VFLIP : TRANSFORM_R180;
+        case 270:
+            return hflip ? TRANSFORM_ANTI_TRANSPOSE : TRANSFORM_R270;
+        default:
+            return hflip ? TRANSFORM_HFLIP : TRANSFORM_IDENTITY;
+    }
+}
+
+video_transform_t video_format_GetTransform( video_orientation_t src,
+                                             video_orientation_t dst )
+{
+    unsigned angle1, angle2;
+    bool hflip1, hflip2;
+
+    transform_GetBasicOps(  (video_transform_t)src, &angle1, &hflip1 );
+    transform_GetBasicOps( transform_Inverse( (video_transform_t)dst ),
+                           &angle2, &hflip2 );
+
+    int angle = (angle1 + angle2) % 360;
+    bool hflip = hflip1 ^ hflip2;
+
+    return transform_FromBasicOps(angle, hflip);
+}
+
+void video_format_TransformBy( video_format_t *fmt, video_transform_t transform )
+{
+    /* Get destination orientation */
+    unsigned angle1, angle2;
+    bool hflip1, hflip2;
+
+    transform_GetBasicOps( transform, &angle1, &hflip1 );
+    transform_GetBasicOps( (video_transform_t)fmt->orientation, &angle2, &hflip2 );
+
+    unsigned angle = (angle2 - angle1 + 360) % 360;
+    bool hflip = hflip2 ^ hflip1;
+
+    video_orientation_t dst_orient = ORIENT_NORMAL;
+
+    if( hflip ) {
+
+        if( angle == 0 )
+            dst_orient = ORIENT_HFLIPPED;
+        else if( angle == 90 )
+            dst_orient = ORIENT_ANTI_TRANSPOSED;
+        else if( angle == 180 )
+            dst_orient = ORIENT_VFLIPPED;
+        else if( angle == 270 )
+            dst_orient = ORIENT_TRANSPOSED;
+    }
+    else {
+
+        if( angle == 90 )
+            dst_orient = ORIENT_ROTATED_90;
+        else if( angle == 180 )
+            dst_orient = ORIENT_ROTATED_180;
+        else if( angle == 270 )
+            dst_orient = ORIENT_ROTATED_270;
+    }
+
+    /* Apply transform */
+    if( ORIENT_IS_SWAP( fmt->orientation ) != ORIENT_IS_SWAP( dst_orient ) )
+    {
+        video_format_t scratch = *fmt;
+
+        fmt->i_width = scratch.i_height;
+        fmt->i_visible_width = scratch.i_visible_height;
+        fmt->i_height = scratch.i_width;
+        fmt->i_visible_height = scratch.i_visible_width;
+        fmt->i_x_offset = scratch.i_y_offset;
+        fmt->i_y_offset = scratch.i_x_offset;
+        fmt->i_sar_num = scratch.i_sar_den;
+        fmt->i_sar_den = scratch.i_sar_num;
+    }
+
+    fmt->orientation = dst_orient;
+}
+
+void video_format_TransformTo( video_format_t *restrict fmt,
+                               video_orientation_t dst_orientation )
+{
+    video_transform_t transform = video_format_GetTransform(fmt->orientation,
+                                                            dst_orientation);
+    video_format_TransformBy(fmt, transform);
+}
+
+void video_format_ApplyRotation( video_format_t *restrict out,
+                                 const video_format_t *restrict in )
+{
+    *out = *in;
+
+    video_format_TransformTo(out, ORIENT_NORMAL);
+}
+
 bool video_format_IsSimilar( const video_format_t *p_fmt1, const video_format_t *p_fmt2 )
 {
     video_format_t v1 = *p_fmt1;
@@ -347,6 +476,7 @@ int es_format_Copy( es_format_t *dst, const es_format_t *src )
     }
 
     dst->subs.psz_encoding = dst->subs.psz_encoding ? strdup( src->subs.psz_encoding ) : NULL;
+    dst->subs.p_style = src->subs.p_style ? text_style_Duplicate( src->subs.p_style ) : NULL;
 
     if( src->video.p_palette )
     {
@@ -395,6 +525,8 @@ void es_format_Clean( es_format_t *fmt )
     free( fmt->video.p_palette );
     free( fmt->subs.psz_encoding );
 
+    if ( fmt->subs.p_style ) text_style_Delete( fmt->subs.p_style );
+
     if( fmt->i_extra_languages > 0 && fmt->p_extra_languages )
     {
         int i;