research.m1stereo.tv/gitweb/ - melted/blob - src/modules/avformat/filter_avcolour_space.c

   1 /*
   2  * filter_avcolour_space.c -- Colour space filter
   3  * Copyright (C) 2004-2005 Ushodaya Enterprises Limited
   4  * Author: Charles Yates <charles.yates@pandora.be>
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation; either version 2 of the License, or
   9  * (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with this program; if not, write to the Free Software Foundation,
  18  * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  19  */
  20
  21 #include "filter_avcolour_space.h"
  22
  23 #include <framework/mlt_frame.h>
  24
  25 // ffmpeg Header files
  26 #include <avformat.h>
  27
  28 #include <stdio.h>
  29 #include <stdlib.h>
  30
  31 static inline int convert_mlt_to_av_cs( mlt_image_format format )
  32 {
  33         int value = 0;
  34
  35         switch( format )
  36         {
  37                 case mlt_image_rgb24:
  38                         value = PIX_FMT_RGB24;
  39                         break;
  40                 case mlt_image_rgb24a:
  41                         value = PIX_FMT_RGBA32;
  42                         break;
  43                 case mlt_image_yuv422:
  44                         value = PIX_FMT_YUV422;
  45                         break;
  46                 case mlt_image_yuv420p:
  47                         value = PIX_FMT_YUV420P;
  48                         break;
  49                 case mlt_image_none:
  50                         fprintf( stderr, "Invalid format...\n" );
  51                         break;
  52         }
  53
  54         return value;
  55 }
  56
  57 static inline void convert_image( uint8_t *out, uint8_t *in, int out_fmt, int in_fmt, int width, int height )
  58 {
  59         if ( in_fmt == PIX_FMT_YUV420P && out_fmt == PIX_FMT_YUV422 )
  60         {
  61                 register int i, j;
  62                 register int half = width >> 1;
  63                 register uint8_t *Y = in;
  64                 register uint8_t *U = Y + width * height;
  65                 register uint8_t *V = U + width * height / 2;
  66                 register uint8_t *d = out;
  67                 register uint8_t *y, *u, *v;
  68
  69                 i = height >> 1;
  70                 while ( i -- )
  71                 {
  72                         y = Y;
  73                         u = U;
  74                         v = V;
  75                         j = half;
  76                         while ( j -- )
  77                         {
  78                                 *d ++ = *y ++;
  79                                 *d ++ = *u ++;
  80                                 *d ++ = *y ++;
  81                                 *d ++ = *v ++;
  82                         }
  83
  84                         Y += width;
  85                         y = Y;
  86                         u = U;
  87                         v = V;
  88                         j = half;
  89                         while ( j -- )
  90                         {
  91                                 *d ++ = *y ++;
  92                                 *d ++ = *u ++;
  93                                 *d ++ = *y ++;
  94                                 *d ++ = *v ++;
  95                         }
  96
  97                         Y += width;
  98                         U += width / 2;
  99                         V += width / 2;
 100                 }
 101         }
 102         else
 103         {
 104                 AVPicture input;
 105                 AVPicture output;
 106                 avpicture_fill( &output, out, out_fmt, width, height );
 107                 avpicture_fill( &input, in, in_fmt, width, height );
 108                 img_convert( &output, out_fmt, &input, in_fmt, width, height );
 109         }
 110 }
 111
 112 /** Do it :-).
 113 */
 114
 115 static int filter_get_image( mlt_frame this, uint8_t **image, mlt_image_format *format, int *width, int *height, int writable )
 116 {
 117         mlt_filter filter = mlt_frame_pop_service( this );
 118         mlt_properties properties = mlt_frame_properties( this );
 119         int output_format = *format;
 120         mlt_image_format forced = mlt_properties_get_int( mlt_filter_properties( filter ), "forced" );
 121         int error = 0;
 122
 123         // Allow this filter to force processing in a colour space other than requested
 124         *format = forced != 0 ? forced : *format;
 125
 126         error = mlt_frame_get_image( this, image, format, width, height, 0 );
 127
 128         if ( error == 0 && *format != output_format )
 129         {
 130                 int in_fmt = convert_mlt_to_av_cs( *format );
 131                 int out_fmt = convert_mlt_to_av_cs( output_format );
 132                 int size = avpicture_get_size( out_fmt, *width, *height );
 133                 uint8_t *output = mlt_pool_alloc( size );
 134                 convert_image( output, *image, out_fmt, in_fmt, *width, *height );
 135                 *image = output;
 136                 *format = output_format;
 137                 mlt_properties_set_data( properties, "image", output, size, mlt_pool_release, NULL );
 138                 mlt_properties_set_int( properties, "format", output_format );
 139         }
 140         return error;
 141 }
 142
 143 /** Filter processing.
 144 */
 145
 146 static mlt_frame filter_process( mlt_filter this, mlt_frame frame )
 147 {
 148         mlt_frame_push_service( frame, this );
 149         mlt_frame_push_get_image( frame, filter_get_image );
 150         return frame;
 151 }
 152
 153 /** Constructor for the filter.
 154 */
 155
 156 mlt_filter filter_avcolour_space_init( void *arg )
 157 {
 158         mlt_filter this = mlt_filter_new( );
 159         if ( this != NULL )
 160                 this->process = filter_process;
 161         return this;
 162 }
 163