Bump dates to 2011
[x262.git] / filters / video / depth.c
1 /*****************************************************************************
2  * depth.c: bit-depth conversion video filter
3  *****************************************************************************
4  * Copyright (C) 2010-2011 x264 project
5  *
6  * Authors: Oskar Arvidsson <oskar@irock.se>
7  *
8  * This program is free software; you can redistribute it and/or modify
9  * it under the terms of the GNU General Public License as published by
10  * the Free Software Foundation; either version 2 of the License, or
11  * (at your option) any later version.
12  *
13  * This program is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16  * GNU General Public License for more details.
17  *
18  * You should have received a copy of the GNU General Public License
19  * along with this program; if not, write to the Free Software
20  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02111, USA.
21  *
22  * This program is also available under a commercial proprietary license.
23  * For more information, contact us at licensing@x264.com.
24  *****************************************************************************/
25
26 #include "video.h"
27 #define NAME "depth"
28 #define FAIL_IF_ERROR( cond, ... ) FAIL_IF_ERR( cond, NAME, __VA_ARGS__ )
29
30 cli_vid_filter_t depth_filter;
31
32 typedef struct
33 {
34     hnd_t prev_hnd;
35     cli_vid_filter_t prev_filter;
36
37     int bit_depth;
38     int dst_csp;
39     cli_pic_t buffer;
40     int16_t *error_buf;
41 } depth_hnd_t;
42
43 static int depth_filter_csp_is_supported( int csp )
44 {
45     int csp_mask = csp & X264_CSP_MASK;
46     return csp_mask == X264_CSP_I420 ||
47            csp_mask == X264_CSP_I422 ||
48            csp_mask == X264_CSP_I444 ||
49            csp_mask == X264_CSP_YV12 ||
50            csp_mask == X264_CSP_NV12;
51 }
52
53 static int csp_num_interleaved( int csp, int plane )
54 {
55     int csp_mask = csp & X264_CSP_MASK;
56     return ( csp_mask == X264_CSP_NV12 && plane == 1 ) ? 2 : 1;
57 }
58
59 /* The dithering algorithm is based on Sierra-2-4A error diffusion. It has been
60  * written in such a way so that if the source has been upconverted using the
61  * same algorithm as used in scale_image, dithering down to the source bit
62  * depth again is lossless. */
63 #define DITHER_PLANE( pitch ) \
64 static void dither_plane_##pitch( pixel *dst, int dst_stride, uint16_t *src, int src_stride, \
65                                         int width, int height, int16_t *errors ) \
66 { \
67     const int lshift = 16-BIT_DEPTH; \
68     const int rshift = 2*BIT_DEPTH-16; \
69     const int pixel_max = (1 << BIT_DEPTH)-1; \
70     const int half = 1 << (16-BIT_DEPTH); \
71     memset( errors, 0, (width+1) * sizeof(int16_t) ); \
72     for( int y = 0; y < height; y++, src += src_stride, dst += dst_stride ) \
73     { \
74         int err = 0; \
75         for( int x = 0; x < width; x++ ) \
76         { \
77             err = err*2 + errors[x] + errors[x+1]; \
78             dst[x*pitch] = x264_clip3( (((src[x*pitch]+half)<<2)+err)*pixel_max >> 18, 0, pixel_max ); \
79             errors[x] = err = src[x*pitch] - (dst[x*pitch] << lshift) - (dst[x*pitch] >> rshift); \
80         } \
81     } \
82 }
83
84 DITHER_PLANE( 1 )
85 DITHER_PLANE( 2 )
86
87 static void dither_image( cli_image_t *out, cli_image_t *img, int16_t *error_buf )
88 {
89     int csp_mask = img->csp & X264_CSP_MASK;
90     for( int i = 0; i < img->planes; i++ )
91     {
92         int num_interleaved = csp_num_interleaved( img->csp, i );
93         int height = x264_cli_csps[csp_mask].height[i] * img->height;
94         int width = x264_cli_csps[csp_mask].width[i] * img->width / num_interleaved;
95
96 #define CALL_DITHER_PLANE( pitch, off ) \
97         dither_plane_##pitch( ((pixel*)out->plane[i])+off, out->stride[i]/sizeof(pixel), \
98                 ((uint16_t*)img->plane[i])+off, img->stride[i]/2, width, height, error_buf )
99
100         if( num_interleaved == 1 )
101         {
102             CALL_DITHER_PLANE( 1, 0 );
103         }
104         else
105         {
106             CALL_DITHER_PLANE( 2, 0 );
107             CALL_DITHER_PLANE( 2, 1 );
108         }
109     }
110 }
111
112 static void scale_image( cli_image_t *output, cli_image_t *img )
113 {
114     /* this function mimics how swscale does upconversion. 8-bit is converted
115      * to 16-bit through left shifting the orginal value with 8 and then adding
116      * the original value to that. This effectively keeps the full color range
117      * while also being fast. for n-bit we basically do the same thing, but we
118      * discard the lower 16-n bits. */
119     int csp_mask = img->csp & X264_CSP_MASK;
120     const int shift = 16-BIT_DEPTH;
121     for( int i = 0; i < img->planes; i++ )
122     {
123         uint8_t *src = img->plane[i];
124         uint16_t *dst = (uint16_t*)output->plane[i];
125         int height = x264_cli_csps[csp_mask].height[i] * img->height;
126         int width = x264_cli_csps[csp_mask].width[i] * img->width;
127
128         for( int j = 0; j < height; j++ )
129         {
130             for( int k = 0; k < width; k++ )
131                 dst[k] = ((src[k] << 8) + src[k]) >> shift;
132
133             src += img->stride[i];
134             dst += output->stride[i]/2;
135         }
136     }
137 }
138
139 static int get_frame( hnd_t handle, cli_pic_t *output, int frame )
140 {
141     depth_hnd_t *h = handle;
142
143     if( h->prev_filter.get_frame( h->prev_hnd, output, frame ) )
144         return -1;
145
146     if( h->bit_depth < 16 && output->img.csp & X264_CSP_HIGH_DEPTH )
147     {
148         dither_image( &h->buffer.img, &output->img, h->error_buf );
149         output->img = h->buffer.img;
150     }
151     else if( h->bit_depth > 8 && !(output->img.csp & X264_CSP_HIGH_DEPTH) )
152     {
153         scale_image( &h->buffer.img, &output->img );
154         output->img = h->buffer.img;
155     }
156     return 0;
157 }
158
159 static int release_frame( hnd_t handle, cli_pic_t *pic, int frame )
160 {
161     depth_hnd_t *h = handle;
162     return h->prev_filter.release_frame( h->prev_hnd, pic, frame );
163 }
164
165 static void free_filter( hnd_t handle )
166 {
167     depth_hnd_t *h = handle;
168     h->prev_filter.free( h->prev_hnd );
169     x264_cli_pic_clean( &h->buffer );
170     x264_free( h );
171 }
172
173 static int init( hnd_t *handle, cli_vid_filter_t *filter, video_info_t *info,
174                  x264_param_t *param, char *opt_string )
175 {
176     int ret = 0;
177     int change_fmt = (info->csp ^ param->i_csp) & X264_CSP_HIGH_DEPTH;
178     int csp = ~(~info->csp ^ change_fmt);
179     int bit_depth = 8*x264_cli_csp_depth_factor( csp );
180
181     if( opt_string )
182     {
183         static const char *optlist[] = { "bit_depth", NULL };
184         char **opts = x264_split_options( opt_string, optlist );
185
186         if( opts )
187         {
188             char *str_bit_depth = x264_get_option( "bit_depth", opts );
189             bit_depth = x264_otoi( str_bit_depth, -1 );
190
191             ret = bit_depth < 8 || bit_depth > 16;
192             csp = bit_depth > 8 ? csp | X264_CSP_HIGH_DEPTH : csp & ~X264_CSP_HIGH_DEPTH;
193             change_fmt = (info->csp ^ csp) & X264_CSP_HIGH_DEPTH;
194             x264_free_string_array( opts );
195         }
196         else
197             ret = 1;
198     }
199
200     FAIL_IF_ERROR( bit_depth != BIT_DEPTH, "this build supports only bit depth %d\n", BIT_DEPTH )
201     FAIL_IF_ERROR( ret, "unsupported bit depth conversion.\n" )
202
203     /* only add the filter to the chain if it's needed */
204     if( change_fmt || bit_depth != 8 * x264_cli_csp_depth_factor( csp ) )
205     {
206         FAIL_IF_ERROR( !depth_filter_csp_is_supported(csp), "unsupported colorspace.\n" )
207         depth_hnd_t *h = x264_malloc( sizeof(depth_hnd_t) + (info->width+1)*sizeof(int16_t) );
208
209         if( !h )
210             return -1;
211
212         h->error_buf = (int16_t*)(h + 1);
213         h->dst_csp = csp;
214         h->bit_depth = bit_depth;
215         h->prev_hnd = *handle;
216         h->prev_filter = *filter;
217
218         if( x264_cli_pic_alloc( &h->buffer, h->dst_csp, info->width, info->height ) )
219         {
220             x264_free( h );
221             return -1;
222         }
223
224         *handle = h;
225         *filter = depth_filter;
226         info->csp = h->dst_csp;
227     }
228
229     return 0;
230 }
231
232 cli_vid_filter_t depth_filter = { NAME, NULL, init, get_frame, release_frame, free_filter, NULL };