Fixed and simplify a bit puzzle filter.

Pitch of input and output pictures can be differents...
BP.

modules/video_filter/puzzle.c

@@ -223,65 +223,53 @@ static picture_t *Filter( filter_t *p_filter, picture_t *p_pic )
     for( int i_plane = 0; i_plane < p_outpic->i_planes; i_plane++ )
     {
         const plane_t *p_in = &p_pic->p[i_plane];
-        const int i_pitch = p_in->i_pitch;
         plane_t *p_out = &p_outpic->p[i_plane];
 
         for( int i = 0; i < i_cols * i_rows; i++ )
         {
-            int i_col = i % i_cols;
-            int i_row = i / i_cols;
-            int i_ocol = p_sys->pi_order[i] % i_cols;
-            int i_orow = p_sys->pi_order[i] / i_cols;
-            int i_last_row = i_row + 1;
-            i_orow *= p_in->i_lines / i_rows;
-            i_row *= p_in->i_lines / i_rows;
-            i_last_row *= p_in->i_lines / i_rows;
+            int i_piece_height = p_out->i_visible_lines / i_rows;
+            int i_piece_width  = p_out->i_visible_pitch / i_cols;
+
+            int i_col = (i % i_cols) * i_piece_width;
+            int i_row = (i / i_cols) * i_piece_height;
+            int i_last_row = i_row + i_piece_height;
+
+            int i_ocol = (p_sys->pi_order[i] % i_cols) * i_piece_width;
+            int i_orow = (p_sys->pi_order[i] / i_cols) * i_piece_height;
 
             if( p_sys->b_blackslot && !p_sys->b_finished && i == p_sys->i_selected )
             {
                 uint8_t color = ( i_plane == Y_PLANE ? 0x0 : 0x80 );
-                for( ; i_row < i_last_row; i_row++, i_orow++ )
+                for( int r = i_row; r < i_last_row; r++ )
                 {
-                    memset( p_out->p_pixels + i_row * i_pitch + i_col * i_pitch / i_cols,
-                            color, i_pitch / i_cols );
+                    memset( p_out->p_pixels + r * p_out->i_pitch + i_col,
+                            color, i_piece_width );
                 }
             }
             else
             {
-                for( ; i_row < i_last_row; i_row++, i_orow++ )
+                for( int r = i_row, or = i_orow; r < i_last_row; r++, or++ )
                 {
-                    memcpy( p_out->p_pixels + i_row * i_pitch + i_col * i_pitch / i_cols,
-                            p_in->p_pixels + i_orow * i_pitch + i_ocol * i_pitch / i_cols,
-                            i_pitch / i_cols );
+                    memcpy( p_out->p_pixels + r * p_out->i_pitch + i_col,
+                            p_in->p_pixels + or * p_in->i_pitch  + i_ocol,
+                            i_piece_width );
                 }
             }
-        }
-    }
-
-    /* Draw the borders of the selected slot */
-    if( p_sys->i_selected != -1 && !p_sys->b_blackslot )
-    {
-        const plane_t *p_in = &p_pic->p[Y_PLANE];
-        const int i_pitch = p_in->i_pitch;
-        plane_t *p_out = &p_outpic->p[Y_PLANE];
 
-        int i_col = p_sys->i_selected % i_cols;
-        int i_row = p_sys->i_selected / i_cols;
-        int i_last_row = i_row + 1;
-        i_row *= p_in->i_lines / i_rows;
-        i_last_row *= p_in->i_lines / i_rows;
-        memset( p_out->p_pixels + i_row * i_pitch + i_col * i_pitch / i_cols,
-                0xff, i_pitch / i_cols );
-        for( ; i_row < i_last_row; i_row++ )
-        {
-            p_out->p_pixels[   i_row * i_pitch
-                             + i_col * i_pitch / i_cols ] = 0xff;
-            p_out->p_pixels[ i_row * i_pitch
-                             + (i_col+1) * i_pitch / i_cols - 1 ] = 0xff;
+            /* Draw the borders of the selected slot */
+            if( i_plane == 0 && !p_sys->b_blackslot && p_sys->i_selected == i )
+            {
+                memset( p_out->p_pixels + i_row * p_out->i_pitch + i_col,
+                        0xff, i_piece_width );
+                for( int r = i_row; r < i_last_row; r++ )
+                {
+                    p_out->p_pixels[r * p_out->i_pitch + i_col + 0             + 0 ] = 0xff;
+                    p_out->p_pixels[r * p_out->i_pitch + i_col + i_piece_width - 1 ] = 0xff;
+                }
+                memset( p_out->p_pixels + (i_last_row - 1) * p_out->i_pitch + i_col,
+                        0xff, i_piece_width );
+            }
         }
-        i_row--;
-        memset( p_out->p_pixels + i_row * i_pitch + i_col * i_pitch / i_cols,
-                0xff, i_pitch / i_cols );
     }
 
     /* Draw the 'Shuffle' button if the puzzle is finished */