• Main Page
  • Related Pages
  • Modules
  • Data Structures
  • Files
  • Examples
  • File List
  • Globals

libavcodec/snow.c

Go to the documentation of this file.
00001 /*
00002  * Copyright (C) 2004 Michael Niedermayer <michaelni@gmx.at>
00003  *
00004  * This file is part of FFmpeg.
00005  *
00006  * FFmpeg is free software; you can redistribute it and/or
00007  * modify it under the terms of the GNU Lesser General Public
00008  * License as published by the Free Software Foundation; either
00009  * version 2.1 of the License, or (at your option) any later version.
00010  *
00011  * FFmpeg is distributed in the hope that it will be useful,
00012  * but WITHOUT ANY WARRANTY; without even the implied warranty of
00013  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
00014  * Lesser General Public License for more details.
00015  *
00016  * You should have received a copy of the GNU Lesser General Public
00017  * License along with FFmpeg; if not, write to the Free Software
00018  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
00019  */
00020 
00021 #include "libavutil/intmath.h"
00022 #include "avcodec.h"
00023 #include "dsputil.h"
00024 #include "dwt.h"
00025 #include "snow.h"
00026 
00027 #include "rangecoder.h"
00028 #include "mathops.h"
00029 
00030 #include "mpegvideo.h"
00031 #include "h263.h"
00032 
00033 #undef NDEBUG
00034 #include <assert.h>
00035 
00036 static const int8_t quant3[256]={
00037  0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
00038  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
00039  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
00040  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
00041  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
00042  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
00043  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
00044  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
00045 -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
00046 -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
00047 -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
00048 -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
00049 -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
00050 -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
00051 -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
00052 -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1, 0,
00053 };
00054 static const int8_t quant3b[256]={
00055  0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
00056  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
00057  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
00058  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
00059  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
00060  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
00061  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
00062  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
00063 -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
00064 -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
00065 -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
00066 -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
00067 -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
00068 -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
00069 -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
00070 -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
00071 };
00072 static const int8_t quant3bA[256]={
00073  0, 0, 1,-1, 1,-1, 1,-1, 1,-1, 1,-1, 1,-1, 1,-1,
00074  1,-1, 1,-1, 1,-1, 1,-1, 1,-1, 1,-1, 1,-1, 1,-1,
00075  1,-1, 1,-1, 1,-1, 1,-1, 1,-1, 1,-1, 1,-1, 1,-1,
00076  1,-1, 1,-1, 1,-1, 1,-1, 1,-1, 1,-1, 1,-1, 1,-1,
00077  1,-1, 1,-1, 1,-1, 1,-1, 1,-1, 1,-1, 1,-1, 1,-1,
00078  1,-1, 1,-1, 1,-1, 1,-1, 1,-1, 1,-1, 1,-1, 1,-1,
00079  1,-1, 1,-1, 1,-1, 1,-1, 1,-1, 1,-1, 1,-1, 1,-1,
00080  1,-1, 1,-1, 1,-1, 1,-1, 1,-1, 1,-1, 1,-1, 1,-1,
00081  1,-1, 1,-1, 1,-1, 1,-1, 1,-1, 1,-1, 1,-1, 1,-1,
00082  1,-1, 1,-1, 1,-1, 1,-1, 1,-1, 1,-1, 1,-1, 1,-1,
00083  1,-1, 1,-1, 1,-1, 1,-1, 1,-1, 1,-1, 1,-1, 1,-1,
00084  1,-1, 1,-1, 1,-1, 1,-1, 1,-1, 1,-1, 1,-1, 1,-1,
00085  1,-1, 1,-1, 1,-1, 1,-1, 1,-1, 1,-1, 1,-1, 1,-1,
00086  1,-1, 1,-1, 1,-1, 1,-1, 1,-1, 1,-1, 1,-1, 1,-1,
00087  1,-1, 1,-1, 1,-1, 1,-1, 1,-1, 1,-1, 1,-1, 1,-1,
00088  1,-1, 1,-1, 1,-1, 1,-1, 1,-1, 1,-1, 1,-1, 1,-1,
00089 };
00090 static const int8_t quant5[256]={
00091  0, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
00092  2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
00093  2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
00094  2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
00095  2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
00096  2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
00097  2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
00098  2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
00099 -2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,
00100 -2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,
00101 -2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,
00102 -2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,
00103 -2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,
00104 -2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,
00105 -2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,
00106 -2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-1,-1,-1,
00107 };
00108 static const int8_t quant7[256]={
00109  0, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
00110  2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
00111  2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3,
00112  3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
00113  3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
00114  3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
00115  3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
00116  3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
00117 -3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,
00118 -3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,
00119 -3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,
00120 -3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,
00121 -3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,
00122 -3,-3,-3,-3,-3,-3,-3,-3,-3,-2,-2,-2,-2,-2,-2,-2,
00123 -2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,
00124 -2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-1,-1,
00125 };
00126 static const int8_t quant9[256]={
00127  0, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3,
00128  3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
00129  4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
00130  4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
00131  4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
00132  4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
00133  4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
00134  4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
00135 -4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,
00136 -4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,
00137 -4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,
00138 -4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,
00139 -4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,
00140 -4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,
00141 -4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-3,-3,-3,-3,
00142 -3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-2,-2,-2,-2,-1,-1,
00143 };
00144 static const int8_t quant11[256]={
00145  0, 1, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4,
00146  4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
00147  4, 4, 4, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
00148  5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
00149  5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
00150  5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
00151  5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
00152  5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
00153 -5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,
00154 -5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,
00155 -5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,
00156 -5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,
00157 -5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,
00158 -5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-4,-4,
00159 -4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,
00160 -4,-4,-4,-4,-4,-3,-3,-3,-3,-3,-3,-3,-2,-2,-2,-1,
00161 };
00162 static const int8_t quant13[256]={
00163  0, 1, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4,
00164  4, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
00165  5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
00166  5, 5, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
00167  6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
00168  6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
00169  6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
00170  6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
00171 -6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,
00172 -6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,
00173 -6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,
00174 -6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,
00175 -6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-5,
00176 -5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,
00177 -5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,
00178 -4,-4,-4,-4,-4,-4,-4,-4,-4,-3,-3,-3,-3,-2,-2,-1,
00179 };
00180 
00181 #if 0 //64*cubic
00182 static const uint8_t obmc32[1024]={
00183   0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
00184   0,  0,  0,  0,  0,  4,  4,  4,  4,  4,  4,  4,  4,  8,  8,  8,  8,  8,  8,  4,  4,  4,  4,  4,  4,  4,  4,  0,  0,  0,  0,  0,
00185   0,  0,  0,  4,  4,  4,  4,  8,  8, 12, 12, 12, 16, 16, 16, 16, 16, 16, 16, 16, 12, 12, 12,  8,  8,  4,  4,  4,  4,  0,  0,  0,
00186   0,  0,  4,  4,  8,  8, 12, 16, 16, 20, 24, 24, 28, 28, 32, 32, 32, 32, 28, 28, 24, 24, 20, 16, 16, 12,  8,  8,  4,  4,  0,  0,
00187   0,  0,  4,  8,  8, 12, 16, 24, 28, 32, 36, 40, 44, 48, 48, 48, 48, 48, 48, 44, 40, 36, 32, 28, 24, 16, 12,  8,  8,  4,  0,  0,
00188   0,  4,  4,  8, 12, 20, 24, 32, 40, 44, 52, 56, 60, 64, 68, 72, 72, 68, 64, 60, 56, 52, 44, 40, 32, 24, 20, 12,  8,  4,  4,  0,
00189   0,  4,  4, 12, 16, 24, 32, 40, 52, 60, 68, 76, 80, 88, 88, 92, 92, 88, 88, 80, 76, 68, 60, 52, 40, 32, 24, 16, 12,  4,  4,  0,
00190   0,  4,  8, 16, 24, 32, 40, 52, 64, 76, 84, 92,100,108,112,116,116,112,108,100, 92, 84, 76, 64, 52, 40, 32, 24, 16,  8,  4,  0,
00191   0,  4,  8, 16, 28, 40, 52, 64, 76, 88,100,112,124,132,136,140,140,136,132,124,112,100, 88, 76, 64, 52, 40, 28, 16,  8,  4,  0,
00192   0,  4, 12, 20, 32, 44, 60, 76, 88,104,120,132,144,152,160,164,164,160,152,144,132,120,104, 88, 76, 60, 44, 32, 20, 12,  4,  0,
00193   0,  4, 12, 24, 36, 48, 68, 84,100,120,136,152,164,176,180,184,184,180,176,164,152,136,120,100, 84, 68, 48, 36, 24, 12,  4,  0,
00194   0,  4, 12, 24, 40, 56, 76, 92,112,132,152,168,180,192,204,208,208,204,192,180,168,152,132,112, 92, 76, 56, 40, 24, 12,  4,  0,
00195   0,  4, 16, 28, 44, 60, 80,100,124,144,164,180,196,208,220,224,224,220,208,196,180,164,144,124,100, 80, 60, 44, 28, 16,  4,  0,
00196   0,  8, 16, 28, 48, 64, 88,108,132,152,176,192,208,224,232,240,240,232,224,208,192,176,152,132,108, 88, 64, 48, 28, 16,  8,  0,
00197   0,  4, 16, 32, 48, 68, 88,112,136,160,180,204,220,232,244,248,248,244,232,220,204,180,160,136,112, 88, 68, 48, 32, 16,  4,  0,
00198   1,  8, 16, 32, 48, 72, 92,116,140,164,184,208,224,240,248,255,255,248,240,224,208,184,164,140,116, 92, 72, 48, 32, 16,  8,  1,
00199   1,  8, 16, 32, 48, 72, 92,116,140,164,184,208,224,240,248,255,255,248,240,224,208,184,164,140,116, 92, 72, 48, 32, 16,  8,  1,
00200   0,  4, 16, 32, 48, 68, 88,112,136,160,180,204,220,232,244,248,248,244,232,220,204,180,160,136,112, 88, 68, 48, 32, 16,  4,  0,
00201   0,  8, 16, 28, 48, 64, 88,108,132,152,176,192,208,224,232,240,240,232,224,208,192,176,152,132,108, 88, 64, 48, 28, 16,  8,  0,
00202   0,  4, 16, 28, 44, 60, 80,100,124,144,164,180,196,208,220,224,224,220,208,196,180,164,144,124,100, 80, 60, 44, 28, 16,  4,  0,
00203   0,  4, 12, 24, 40, 56, 76, 92,112,132,152,168,180,192,204,208,208,204,192,180,168,152,132,112, 92, 76, 56, 40, 24, 12,  4,  0,
00204   0,  4, 12, 24, 36, 48, 68, 84,100,120,136,152,164,176,180,184,184,180,176,164,152,136,120,100, 84, 68, 48, 36, 24, 12,  4,  0,
00205   0,  4, 12, 20, 32, 44, 60, 76, 88,104,120,132,144,152,160,164,164,160,152,144,132,120,104, 88, 76, 60, 44, 32, 20, 12,  4,  0,
00206   0,  4,  8, 16, 28, 40, 52, 64, 76, 88,100,112,124,132,136,140,140,136,132,124,112,100, 88, 76, 64, 52, 40, 28, 16,  8,  4,  0,
00207   0,  4,  8, 16, 24, 32, 40, 52, 64, 76, 84, 92,100,108,112,116,116,112,108,100, 92, 84, 76, 64, 52, 40, 32, 24, 16,  8,  4,  0,
00208   0,  4,  4, 12, 16, 24, 32, 40, 52, 60, 68, 76, 80, 88, 88, 92, 92, 88, 88, 80, 76, 68, 60, 52, 40, 32, 24, 16, 12,  4,  4,  0,
00209   0,  4,  4,  8, 12, 20, 24, 32, 40, 44, 52, 56, 60, 64, 68, 72, 72, 68, 64, 60, 56, 52, 44, 40, 32, 24, 20, 12,  8,  4,  4,  0,
00210   0,  0,  4,  8,  8, 12, 16, 24, 28, 32, 36, 40, 44, 48, 48, 48, 48, 48, 48, 44, 40, 36, 32, 28, 24, 16, 12,  8,  8,  4,  0,  0,
00211   0,  0,  4,  4,  8,  8, 12, 16, 16, 20, 24, 24, 28, 28, 32, 32, 32, 32, 28, 28, 24, 24, 20, 16, 16, 12,  8,  8,  4,  4,  0,  0,
00212   0,  0,  0,  4,  4,  4,  4,  8,  8, 12, 12, 12, 16, 16, 16, 16, 16, 16, 16, 16, 12, 12, 12,  8,  8,  4,  4,  4,  4,  0,  0,  0,
00213   0,  0,  0,  0,  0,  4,  4,  4,  4,  4,  4,  4,  4,  8,  8,  8,  8,  8,  8,  4,  4,  4,  4,  4,  4,  4,  4,  0,  0,  0,  0,  0,
00214   0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
00215 //error:0.000022
00216 };
00217 static const uint8_t obmc16[256]={
00218   0,  0,  0,  0,  0,  0,  4,  4,  4,  4,  0,  0,  0,  0,  0,  0,
00219   0,  4,  4,  8, 16, 20, 20, 24, 24, 20, 20, 16,  8,  4,  4,  0,
00220   0,  4, 16, 24, 36, 44, 52, 60, 60, 52, 44, 36, 24, 16,  4,  0,
00221   0,  8, 24, 44, 60, 80, 96,104,104, 96, 80, 60, 44, 24,  8,  0,
00222   0, 16, 36, 60, 92,116,136,152,152,136,116, 92, 60, 36, 16,  0,
00223   0, 20, 44, 80,116,152,180,196,196,180,152,116, 80, 44, 20,  0,
00224   4, 20, 52, 96,136,180,212,228,228,212,180,136, 96, 52, 20,  4,
00225   4, 24, 60,104,152,196,228,248,248,228,196,152,104, 60, 24,  4,
00226   4, 24, 60,104,152,196,228,248,248,228,196,152,104, 60, 24,  4,
00227   4, 20, 52, 96,136,180,212,228,228,212,180,136, 96, 52, 20,  4,
00228   0, 20, 44, 80,116,152,180,196,196,180,152,116, 80, 44, 20,  0,
00229   0, 16, 36, 60, 92,116,136,152,152,136,116, 92, 60, 36, 16,  0,
00230   0,  8, 24, 44, 60, 80, 96,104,104, 96, 80, 60, 44, 24,  8,  0,
00231   0,  4, 16, 24, 36, 44, 52, 60, 60, 52, 44, 36, 24, 16,  4,  0,
00232   0,  4,  4,  8, 16, 20, 20, 24, 24, 20, 20, 16,  8,  4,  4,  0,
00233   0,  0,  0,  0,  0,  0,  4,  4,  4,  4,  0,  0,  0,  0,  0,  0,
00234 //error:0.000033
00235 };
00236 #elif 1 // 64*linear
00237 static const uint8_t obmc32[1024]={
00238   0,  0,  0,  0,  4,  4,  4,  4,  4,  4,  4,  4,  8,  8,  8,  8,  8,  8,  8,  8,  4,  4,  4,  4,  4,  4,  4,  4,  0,  0,  0,  0,
00239   0,  4,  4,  4,  8,  8,  8, 12, 12, 16, 16, 16, 20, 20, 20, 24, 24, 20, 20, 20, 16, 16, 16, 12, 12,  8,  8,  8,  4,  4,  4,  0,
00240   0,  4,  8,  8, 12, 12, 16, 20, 20, 24, 28, 28, 32, 32, 36, 40, 40, 36, 32, 32, 28, 28, 24, 20, 20, 16, 12, 12,  8,  8,  4,  0,
00241   0,  4,  8, 12, 16, 20, 24, 28, 28, 32, 36, 40, 44, 48, 52, 56, 56, 52, 48, 44, 40, 36, 32, 28, 28, 24, 20, 16, 12,  8,  4,  0,
00242   4,  8, 12, 16, 20, 24, 28, 32, 40, 44, 48, 52, 56, 60, 64, 68, 68, 64, 60, 56, 52, 48, 44, 40, 32, 28, 24, 20, 16, 12,  8,  4,
00243   4,  8, 12, 20, 24, 32, 36, 40, 48, 52, 56, 64, 68, 76, 80, 84, 84, 80, 76, 68, 64, 56, 52, 48, 40, 36, 32, 24, 20, 12,  8,  4,
00244   4,  8, 16, 24, 28, 36, 44, 48, 56, 60, 68, 76, 80, 88, 96,100,100, 96, 88, 80, 76, 68, 60, 56, 48, 44, 36, 28, 24, 16,  8,  4,
00245   4, 12, 20, 28, 32, 40, 48, 56, 64, 72, 80, 88, 92,100,108,116,116,108,100, 92, 88, 80, 72, 64, 56, 48, 40, 32, 28, 20, 12,  4,
00246   4, 12, 20, 28, 40, 48, 56, 64, 72, 80, 88, 96,108,116,124,132,132,124,116,108, 96, 88, 80, 72, 64, 56, 48, 40, 28, 20, 12,  4,
00247   4, 16, 24, 32, 44, 52, 60, 72, 80, 92,100,108,120,128,136,148,148,136,128,120,108,100, 92, 80, 72, 60, 52, 44, 32, 24, 16,  4,
00248   4, 16, 28, 36, 48, 56, 68, 80, 88,100,112,120,132,140,152,164,164,152,140,132,120,112,100, 88, 80, 68, 56, 48, 36, 28, 16,  4,
00249   4, 16, 28, 40, 52, 64, 76, 88, 96,108,120,132,144,156,168,180,180,168,156,144,132,120,108, 96, 88, 76, 64, 52, 40, 28, 16,  4,
00250   8, 20, 32, 44, 56, 68, 80, 92,108,120,132,144,156,168,180,192,192,180,168,156,144,132,120,108, 92, 80, 68, 56, 44, 32, 20,  8,
00251   8, 20, 32, 48, 60, 76, 88,100,116,128,140,156,168,184,196,208,208,196,184,168,156,140,128,116,100, 88, 76, 60, 48, 32, 20,  8,
00252   8, 20, 36, 52, 64, 80, 96,108,124,136,152,168,180,196,212,224,224,212,196,180,168,152,136,124,108, 96, 80, 64, 52, 36, 20,  8,
00253   8, 24, 40, 56, 68, 84,100,116,132,148,164,180,192,208,224,240,240,224,208,192,180,164,148,132,116,100, 84, 68, 56, 40, 24,  8,
00254   8, 24, 40, 56, 68, 84,100,116,132,148,164,180,192,208,224,240,240,224,208,192,180,164,148,132,116,100, 84, 68, 56, 40, 24,  8,
00255   8, 20, 36, 52, 64, 80, 96,108,124,136,152,168,180,196,212,224,224,212,196,180,168,152,136,124,108, 96, 80, 64, 52, 36, 20,  8,
00256   8, 20, 32, 48, 60, 76, 88,100,116,128,140,156,168,184,196,208,208,196,184,168,156,140,128,116,100, 88, 76, 60, 48, 32, 20,  8,
00257   8, 20, 32, 44, 56, 68, 80, 92,108,120,132,144,156,168,180,192,192,180,168,156,144,132,120,108, 92, 80, 68, 56, 44, 32, 20,  8,
00258   4, 16, 28, 40, 52, 64, 76, 88, 96,108,120,132,144,156,168,180,180,168,156,144,132,120,108, 96, 88, 76, 64, 52, 40, 28, 16,  4,
00259   4, 16, 28, 36, 48, 56, 68, 80, 88,100,112,120,132,140,152,164,164,152,140,132,120,112,100, 88, 80, 68, 56, 48, 36, 28, 16,  4,
00260   4, 16, 24, 32, 44, 52, 60, 72, 80, 92,100,108,120,128,136,148,148,136,128,120,108,100, 92, 80, 72, 60, 52, 44, 32, 24, 16,  4,
00261   4, 12, 20, 28, 40, 48, 56, 64, 72, 80, 88, 96,108,116,124,132,132,124,116,108, 96, 88, 80, 72, 64, 56, 48, 40, 28, 20, 12,  4,
00262   4, 12, 20, 28, 32, 40, 48, 56, 64, 72, 80, 88, 92,100,108,116,116,108,100, 92, 88, 80, 72, 64, 56, 48, 40, 32, 28, 20, 12,  4,
00263   4,  8, 16, 24, 28, 36, 44, 48, 56, 60, 68, 76, 80, 88, 96,100,100, 96, 88, 80, 76, 68, 60, 56, 48, 44, 36, 28, 24, 16,  8,  4,
00264   4,  8, 12, 20, 24, 32, 36, 40, 48, 52, 56, 64, 68, 76, 80, 84, 84, 80, 76, 68, 64, 56, 52, 48, 40, 36, 32, 24, 20, 12,  8,  4,
00265   4,  8, 12, 16, 20, 24, 28, 32, 40, 44, 48, 52, 56, 60, 64, 68, 68, 64, 60, 56, 52, 48, 44, 40, 32, 28, 24, 20, 16, 12,  8,  4,
00266   0,  4,  8, 12, 16, 20, 24, 28, 28, 32, 36, 40, 44, 48, 52, 56, 56, 52, 48, 44, 40, 36, 32, 28, 28, 24, 20, 16, 12,  8,  4,  0,
00267   0,  4,  8,  8, 12, 12, 16, 20, 20, 24, 28, 28, 32, 32, 36, 40, 40, 36, 32, 32, 28, 28, 24, 20, 20, 16, 12, 12,  8,  8,  4,  0,
00268   0,  4,  4,  4,  8,  8,  8, 12, 12, 16, 16, 16, 20, 20, 20, 24, 24, 20, 20, 20, 16, 16, 16, 12, 12,  8,  8,  8,  4,  4,  4,  0,
00269   0,  0,  0,  0,  4,  4,  4,  4,  4,  4,  4,  4,  8,  8,  8,  8,  8,  8,  8,  8,  4,  4,  4,  4,  4,  4,  4,  4,  0,  0,  0,  0,
00270  //error:0.000020
00271 };
00272 static const uint8_t obmc16[256]={
00273   0,  4,  4,  8,  8, 12, 12, 16, 16, 12, 12,  8,  8,  4,  4,  0,
00274   4,  8, 16, 20, 28, 32, 40, 44, 44, 40, 32, 28, 20, 16,  8,  4,
00275   4, 16, 24, 36, 44, 56, 64, 76, 76, 64, 56, 44, 36, 24, 16,  4,
00276   8, 20, 36, 48, 64, 76, 92,104,104, 92, 76, 64, 48, 36, 20,  8,
00277   8, 28, 44, 64, 80,100,116,136,136,116,100, 80, 64, 44, 28,  8,
00278  12, 32, 56, 76,100,120,144,164,164,144,120,100, 76, 56, 32, 12,
00279  12, 40, 64, 92,116,144,168,196,196,168,144,116, 92, 64, 40, 12,
00280  16, 44, 76,104,136,164,196,224,224,196,164,136,104, 76, 44, 16,
00281  16, 44, 76,104,136,164,196,224,224,196,164,136,104, 76, 44, 16,
00282  12, 40, 64, 92,116,144,168,196,196,168,144,116, 92, 64, 40, 12,
00283  12, 32, 56, 76,100,120,144,164,164,144,120,100, 76, 56, 32, 12,
00284   8, 28, 44, 64, 80,100,116,136,136,116,100, 80, 64, 44, 28,  8,
00285   8, 20, 36, 48, 64, 76, 92,104,104, 92, 76, 64, 48, 36, 20,  8,
00286   4, 16, 24, 36, 44, 56, 64, 76, 76, 64, 56, 44, 36, 24, 16,  4,
00287   4,  8, 16, 20, 28, 32, 40, 44, 44, 40, 32, 28, 20, 16,  8,  4,
00288   0,  4,  4,  8,  8, 12, 12, 16, 16, 12, 12,  8,  8,  4,  4,  0,
00289 //error:0.000015
00290 };
00291 #else //64*cos
00292 static const uint8_t obmc32[1024]={
00293   0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
00294   0,  0,  0,  0,  0,  0,  4,  4,  4,  4,  4,  4,  4,  4,  8,  4,  4,  8,  4,  4,  4,  4,  4,  4,  4,  4,  0,  0,  0,  0,  0,  0,
00295   0,  0,  0,  4,  4,  4,  4,  8,  8, 12, 12, 12, 12, 16, 16, 16, 16, 16, 16, 12, 12, 12, 12,  8,  8,  4,  4,  4,  4,  0,  0,  0,
00296   0,  0,  4,  4,  4,  8,  8, 12, 16, 20, 20, 24, 28, 28, 28, 28, 28, 28, 28, 28, 24, 20, 20, 16, 12,  8,  8,  4,  4,  4,  0,  0,
00297   0,  0,  4,  4,  8, 12, 16, 20, 24, 28, 36, 40, 44, 44, 48, 48, 48, 48, 44, 44, 40, 36, 28, 24, 20, 16, 12,  8,  4,  4,  0,  0,
00298   0,  0,  4,  8, 12, 20, 24, 32, 36, 44, 48, 56, 60, 64, 68, 68, 68, 68, 64, 60, 56, 48, 44, 36, 32, 24, 20, 12,  8,  4,  0,  0,
00299   0,  4,  4,  8, 16, 24, 32, 40, 48, 60, 68, 76, 80, 84, 88, 92, 92, 88, 84, 80, 76, 68, 60, 48, 40, 32, 24, 16,  8,  4,  4,  0,
00300   0,  4,  8, 12, 20, 32, 40, 52, 64, 76, 84, 96,104,108,112,116,116,112,108,104, 96, 84, 76, 64, 52, 40, 32, 20, 12,  8,  4,  0,
00301   0,  4,  8, 16, 24, 36, 48, 64, 76, 92,104,116,124,132,136,140,140,136,132,124,116,104, 92, 76, 64, 48, 36, 24, 16,  8,  4,  0,
00302   0,  4, 12, 20, 28, 44, 60, 76, 92,104,120,136,148,156,160,164,164,160,156,148,136,120,104, 92, 76, 60, 44, 28, 20, 12,  4,  0,
00303   0,  4, 12, 20, 36, 48, 68, 84,104,120,140,152,168,176,184,188,188,184,176,168,152,140,120,104, 84, 68, 48, 36, 20, 12,  4,  0,
00304   0,  4, 12, 24, 36, 56, 76, 96,116,136,152,172,184,196,204,208,208,204,196,184,172,152,136,116, 96, 76, 56, 36, 24, 12,  4,  0,
00305   0,  4, 12, 24, 44, 60, 80,104,124,148,168,184,200,212,224,228,228,224,212,200,184,168,148,124,104, 80, 60, 44, 24, 12,  4,  0,
00306   0,  4, 12, 28, 44, 64, 84,108,132,156,176,196,212,228,236,240,240,236,228,212,196,176,156,132,108, 84, 64, 44, 28, 12,  4,  0,
00307   0,  4, 16, 28, 48, 68, 88,112,136,160,184,204,224,236,244,252,252,244,236,224,204,184,160,136,112, 88, 68, 48, 28, 16,  4,  0,
00308   1,  4, 16, 28, 48, 68, 92,116,140,164,188,208,228,240,252,255,255,252,240,228,208,188,164,140,116, 92, 68, 48, 28, 16,  4,  1,
00309   1,  4, 16, 28, 48, 68, 92,116,140,164,188,208,228,240,252,255,255,252,240,228,208,188,164,140,116, 92, 68, 48, 28, 16,  4,  1,
00310   0,  4, 16, 28, 48, 68, 88,112,136,160,184,204,224,236,244,252,252,244,236,224,204,184,160,136,112, 88, 68, 48, 28, 16,  4,  0,
00311   0,  4, 12, 28, 44, 64, 84,108,132,156,176,196,212,228,236,240,240,236,228,212,196,176,156,132,108, 84, 64, 44, 28, 12,  4,  0,
00312   0,  4, 12, 24, 44, 60, 80,104,124,148,168,184,200,212,224,228,228,224,212,200,184,168,148,124,104, 80, 60, 44, 24, 12,  4,  0,
00313   0,  4, 12, 24, 36, 56, 76, 96,116,136,152,172,184,196,204,208,208,204,196,184,172,152,136,116, 96, 76, 56, 36, 24, 12,  4,  0,
00314   0,  4, 12, 20, 36, 48, 68, 84,104,120,140,152,168,176,184,188,188,184,176,168,152,140,120,104, 84, 68, 48, 36, 20, 12,  4,  0,
00315   0,  4, 12, 20, 28, 44, 60, 76, 92,104,120,136,148,156,160,164,164,160,156,148,136,120,104, 92, 76, 60, 44, 28, 20, 12,  4,  0,
00316   0,  4,  8, 16, 24, 36, 48, 64, 76, 92,104,116,124,132,136,140,140,136,132,124,116,104, 92, 76, 64, 48, 36, 24, 16,  8,  4,  0,
00317   0,  4,  8, 12, 20, 32, 40, 52, 64, 76, 84, 96,104,108,112,116,116,112,108,104, 96, 84, 76, 64, 52, 40, 32, 20, 12,  8,  4,  0,
00318   0,  4,  4,  8, 16, 24, 32, 40, 48, 60, 68, 76, 80, 84, 88, 92, 92, 88, 84, 80, 76, 68, 60, 48, 40, 32, 24, 16,  8,  4,  4,  0,
00319   0,  0,  4,  8, 12, 20, 24, 32, 36, 44, 48, 56, 60, 64, 68, 68, 68, 68, 64, 60, 56, 48, 44, 36, 32, 24, 20, 12,  8,  4,  0,  0,
00320   0,  0,  4,  4,  8, 12, 16, 20, 24, 28, 36, 40, 44, 44, 48, 48, 48, 48, 44, 44, 40, 36, 28, 24, 20, 16, 12,  8,  4,  4,  0,  0,
00321   0,  0,  4,  4,  4,  8,  8, 12, 16, 20, 20, 24, 28, 28, 28, 28, 28, 28, 28, 28, 24, 20, 20, 16, 12,  8,  8,  4,  4,  4,  0,  0,
00322   0,  0,  0,  4,  4,  4,  4,  8,  8, 12, 12, 12, 12, 16, 16, 16, 16, 16, 16, 12, 12, 12, 12,  8,  8,  4,  4,  4,  4,  0,  0,  0,
00323   0,  0,  0,  0,  0,  0,  4,  4,  4,  4,  4,  4,  4,  4,  8,  4,  4,  8,  4,  4,  4,  4,  4,  4,  4,  4,  0,  0,  0,  0,  0,  0,
00324   0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
00325 //error:0.000022
00326 };
00327 static const uint8_t obmc16[256]={
00328   0,  0,  0,  0,  0,  4,  4,  4,  4,  4,  4,  0,  0,  0,  0,  0,
00329   0,  0,  4,  8, 12, 16, 20, 20, 20, 20, 16, 12,  8,  4,  0,  0,
00330   0,  4, 12, 24, 32, 44, 52, 56, 56, 52, 44, 32, 24, 12,  4,  0,
00331   0,  8, 24, 40, 60, 80, 96,104,104, 96, 80, 60, 40, 24,  8,  0,
00332   0, 12, 32, 64, 92,120,140,152,152,140,120, 92, 64, 32, 12,  0,
00333   4, 16, 44, 80,120,156,184,196,196,184,156,120, 80, 44, 16,  4,
00334   4, 20, 52, 96,140,184,216,232,232,216,184,140, 96, 52, 20,  4,
00335   0, 20, 56,104,152,196,232,252,252,232,196,152,104, 56, 20,  0,
00336   0, 20, 56,104,152,196,232,252,252,232,196,152,104, 56, 20,  0,
00337   4, 20, 52, 96,140,184,216,232,232,216,184,140, 96, 52, 20,  4,
00338   4, 16, 44, 80,120,156,184,196,196,184,156,120, 80, 44, 16,  4,
00339   0, 12, 32, 64, 92,120,140,152,152,140,120, 92, 64, 32, 12,  0,
00340   0,  8, 24, 40, 60, 80, 96,104,104, 96, 80, 60, 40, 24,  8,  0,
00341   0,  4, 12, 24, 32, 44, 52, 56, 56, 52, 44, 32, 24, 12,  4,  0,
00342   0,  0,  4,  8, 12, 16, 20, 20, 20, 20, 16, 12,  8,  4,  0,  0,
00343   0,  0,  0,  0,  0,  4,  4,  4,  4,  4,  4,  0,  0,  0,  0,  0,
00344 //error:0.000022
00345 };
00346 #endif /* 0 */
00347 
00348 //linear *64
00349 static const uint8_t obmc8[64]={
00350   4, 12, 20, 28, 28, 20, 12,  4,
00351  12, 36, 60, 84, 84, 60, 36, 12,
00352  20, 60,100,140,140,100, 60, 20,
00353  28, 84,140,196,196,140, 84, 28,
00354  28, 84,140,196,196,140, 84, 28,
00355  20, 60,100,140,140,100, 60, 20,
00356  12, 36, 60, 84, 84, 60, 36, 12,
00357   4, 12, 20, 28, 28, 20, 12,  4,
00358 //error:0.000000
00359 };
00360 
00361 //linear *64
00362 static const uint8_t obmc4[16]={
00363  16, 48, 48, 16,
00364  48,144,144, 48,
00365  48,144,144, 48,
00366  16, 48, 48, 16,
00367 //error:0.000000
00368 };
00369 
00370 static const uint8_t * const obmc_tab[4]={
00371     obmc32, obmc16, obmc8, obmc4
00372 };
00373 
00374 static int scale_mv_ref[MAX_REF_FRAMES][MAX_REF_FRAMES];
00375 
00376 typedef struct BlockNode{
00377     int16_t mx;
00378     int16_t my;
00379     uint8_t ref;
00380     uint8_t color[3];
00381     uint8_t type;
00382 //#define TYPE_SPLIT    1
00383 #define BLOCK_INTRA   1
00384 #define BLOCK_OPT     2
00385 //#define TYPE_NOCOLOR  4
00386     uint8_t level; //FIXME merge into type?
00387 }BlockNode;
00388 
00389 static const BlockNode null_block= { //FIXME add border maybe
00390     .color= {128,128,128},
00391     .mx= 0,
00392     .my= 0,
00393     .ref= 0,
00394     .type= 0,
00395     .level= 0,
00396 };
00397 
00398 #define LOG2_MB_SIZE 4
00399 #define MB_SIZE (1<<LOG2_MB_SIZE)
00400 #define ENCODER_EXTRA_BITS 4
00401 #define HTAPS_MAX 8
00402 
00403 typedef struct x_and_coeff{
00404     int16_t x;
00405     uint16_t coeff;
00406 } x_and_coeff;
00407 
00408 typedef struct SubBand{
00409     int level;
00410     int stride;
00411     int width;
00412     int height;
00413     int qlog;        
00414     DWTELEM *buf;
00415     IDWTELEM *ibuf;
00416     int buf_x_offset;
00417     int buf_y_offset;
00418     int stride_line; 
00419     x_and_coeff * x_coeff;
00420     struct SubBand *parent;
00421     uint8_t state[/*7*2*/ 7 + 512][32];
00422 }SubBand;
00423 
00424 typedef struct Plane{
00425     int width;
00426     int height;
00427     SubBand band[MAX_DECOMPOSITIONS][4];
00428 
00429     int htaps;
00430     int8_t hcoeff[HTAPS_MAX/2];
00431     int diag_mc;
00432     int fast_mc;
00433 
00434     int last_htaps;
00435     int8_t last_hcoeff[HTAPS_MAX/2];
00436     int last_diag_mc;
00437 }Plane;
00438 
00439 typedef struct SnowContext{
00440 
00441     AVCodecContext *avctx;
00442     RangeCoder c;
00443     DSPContext dsp;
00444     DWTContext dwt;
00445     AVFrame new_picture;
00446     AVFrame input_picture;              
00447     AVFrame current_picture;
00448     AVFrame last_picture[MAX_REF_FRAMES];
00449     uint8_t *halfpel_plane[MAX_REF_FRAMES][4][4];
00450     AVFrame mconly_picture;
00451 //     uint8_t q_context[16];
00452     uint8_t header_state[32];
00453     uint8_t block_state[128 + 32*128];
00454     int keyframe;
00455     int always_reset;
00456     int version;
00457     int spatial_decomposition_type;
00458     int last_spatial_decomposition_type;
00459     int temporal_decomposition_type;
00460     int spatial_decomposition_count;
00461     int last_spatial_decomposition_count;
00462     int temporal_decomposition_count;
00463     int max_ref_frames;
00464     int ref_frames;
00465     int16_t (*ref_mvs[MAX_REF_FRAMES])[2];
00466     uint32_t *ref_scores[MAX_REF_FRAMES];
00467     DWTELEM *spatial_dwt_buffer;
00468     IDWTELEM *spatial_idwt_buffer;
00469     int colorspace_type;
00470     int chroma_h_shift;
00471     int chroma_v_shift;
00472     int spatial_scalability;
00473     int qlog;
00474     int last_qlog;
00475     int lambda;
00476     int lambda2;
00477     int pass1_rc;
00478     int mv_scale;
00479     int last_mv_scale;
00480     int qbias;
00481     int last_qbias;
00482 #define QBIAS_SHIFT 3
00483     int b_width;
00484     int b_height;
00485     int block_max_depth;
00486     int last_block_max_depth;
00487     Plane plane[MAX_PLANES];
00488     BlockNode *block;
00489 #define ME_CACHE_SIZE 1024
00490     int me_cache[ME_CACHE_SIZE];
00491     int me_cache_generation;
00492     slice_buffer sb;
00493 
00494     MpegEncContext m; // needed for motion estimation, should not be used for anything else, the idea is to eventually make the motion estimation independent of MpegEncContext, so this will be removed then (FIXME/XXX)
00495 
00496     uint8_t *scratchbuf;
00497 }SnowContext;
00498 
00499 #ifdef __sgi
00500 // Avoid a name clash on SGI IRIX
00501 #undef qexp
00502 #endif
00503 #define QEXPSHIFT (7-FRAC_BITS+8) //FIXME try to change this to 0
00504 static uint8_t qexp[QROOT];
00505 
00506 static inline void put_symbol(RangeCoder *c, uint8_t *state, int v, int is_signed){
00507     int i;
00508 
00509     if(v){
00510         const int a= FFABS(v);
00511         const int e= av_log2(a);
00512 #if 1
00513         const int el= FFMIN(e, 10);
00514         put_rac(c, state+0, 0);
00515 
00516         for(i=0; i<el; i++){
00517             put_rac(c, state+1+i, 1);  //1..10
00518         }
00519         for(; i<e; i++){
00520             put_rac(c, state+1+9, 1);  //1..10
00521         }
00522         put_rac(c, state+1+FFMIN(i,9), 0);
00523 
00524         for(i=e-1; i>=el; i--){
00525             put_rac(c, state+22+9, (a>>i)&1); //22..31
00526         }
00527         for(; i>=0; i--){
00528             put_rac(c, state+22+i, (a>>i)&1); //22..31
00529         }
00530 
00531         if(is_signed)
00532             put_rac(c, state+11 + el, v < 0); //11..21
00533 #else
00534 
00535         put_rac(c, state+0, 0);
00536         if(e<=9){
00537             for(i=0; i<e; i++){
00538                 put_rac(c, state+1+i, 1);  //1..10
00539             }
00540             put_rac(c, state+1+i, 0);
00541 
00542             for(i=e-1; i>=0; i--){
00543                 put_rac(c, state+22+i, (a>>i)&1); //22..31
00544             }
00545 
00546             if(is_signed)
00547                 put_rac(c, state+11 + e, v < 0); //11..21
00548         }else{
00549             for(i=0; i<e; i++){
00550                 put_rac(c, state+1+FFMIN(i,9), 1);  //1..10
00551             }
00552             put_rac(c, state+1+9, 0);
00553 
00554             for(i=e-1; i>=0; i--){
00555                 put_rac(c, state+22+FFMIN(i,9), (a>>i)&1); //22..31
00556             }
00557 
00558             if(is_signed)
00559                 put_rac(c, state+11 + 10, v < 0); //11..21
00560         }
00561 #endif /* 1 */
00562     }else{
00563         put_rac(c, state+0, 1);
00564     }
00565 }
00566 
00567 static inline int get_symbol(RangeCoder *c, uint8_t *state, int is_signed){
00568     if(get_rac(c, state+0))
00569         return 0;
00570     else{
00571         int i, e, a;
00572         e= 0;
00573         while(get_rac(c, state+1 + FFMIN(e,9))){ //1..10
00574             e++;
00575         }
00576 
00577         a= 1;
00578         for(i=e-1; i>=0; i--){
00579             a += a + get_rac(c, state+22 + FFMIN(i,9)); //22..31
00580         }
00581 
00582         e= -(is_signed && get_rac(c, state+11 + FFMIN(e,10))); //11..21
00583         return (a^e)-e;
00584     }
00585 }
00586 
00587 static inline void put_symbol2(RangeCoder *c, uint8_t *state, int v, int log2){
00588     int i;
00589     int r= log2>=0 ? 1<<log2 : 1;
00590 
00591     assert(v>=0);
00592     assert(log2>=-4);
00593 
00594     while(v >= r){
00595         put_rac(c, state+4+log2, 1);
00596         v -= r;
00597         log2++;
00598         if(log2>0) r+=r;
00599     }
00600     put_rac(c, state+4+log2, 0);
00601 
00602     for(i=log2-1; i>=0; i--){
00603         put_rac(c, state+31-i, (v>>i)&1);
00604     }
00605 }
00606 
00607 static inline int get_symbol2(RangeCoder *c, uint8_t *state, int log2){
00608     int i;
00609     int r= log2>=0 ? 1<<log2 : 1;
00610     int v=0;
00611 
00612     assert(log2>=-4);
00613 
00614     while(get_rac(c, state+4+log2)){
00615         v+= r;
00616         log2++;
00617         if(log2>0) r+=r;
00618     }
00619 
00620     for(i=log2-1; i>=0; i--){
00621         v+= get_rac(c, state+31-i)<<i;
00622     }
00623 
00624     return v;
00625 }
00626 
00627 static inline void unpack_coeffs(SnowContext *s, SubBand *b, SubBand * parent, int orientation){
00628     const int w= b->width;
00629     const int h= b->height;
00630     int x,y;
00631 
00632     int run, runs;
00633     x_and_coeff *xc= b->x_coeff;
00634     x_and_coeff *prev_xc= NULL;
00635     x_and_coeff *prev2_xc= xc;
00636     x_and_coeff *parent_xc= parent ? parent->x_coeff : NULL;
00637     x_and_coeff *prev_parent_xc= parent_xc;
00638 
00639     runs= get_symbol2(&s->c, b->state[30], 0);
00640     if(runs-- > 0) run= get_symbol2(&s->c, b->state[1], 3);
00641     else           run= INT_MAX;
00642 
00643     for(y=0; y<h; y++){
00644         int v=0;
00645         int lt=0, t=0, rt=0;
00646 
00647         if(y && prev_xc->x == 0){
00648             rt= prev_xc->coeff;
00649         }
00650         for(x=0; x<w; x++){
00651             int p=0;
00652             const int l= v;
00653 
00654             lt= t; t= rt;
00655 
00656             if(y){
00657                 if(prev_xc->x <= x)
00658                     prev_xc++;
00659                 if(prev_xc->x == x + 1)
00660                     rt= prev_xc->coeff;
00661                 else
00662                     rt=0;
00663             }
00664             if(parent_xc){
00665                 if(x>>1 > parent_xc->x){
00666                     parent_xc++;
00667                 }
00668                 if(x>>1 == parent_xc->x){
00669                     p= parent_xc->coeff;
00670                 }
00671             }
00672             if(/*ll|*/l|lt|t|rt|p){
00673                 int context= av_log2(/*FFABS(ll) + */3*(l>>1) + (lt>>1) + (t&~1) + (rt>>1) + (p>>1));
00674 
00675                 v=get_rac(&s->c, &b->state[0][context]);
00676                 if(v){
00677                     v= 2*(get_symbol2(&s->c, b->state[context + 2], context-4) + 1);
00678                     v+=get_rac(&s->c, &b->state[0][16 + 1 + 3 + quant3bA[l&0xFF] + 3*quant3bA[t&0xFF]]);
00679 
00680                     xc->x=x;
00681                     (xc++)->coeff= v;
00682                 }
00683             }else{
00684                 if(!run){
00685                     if(runs-- > 0) run= get_symbol2(&s->c, b->state[1], 3);
00686                     else           run= INT_MAX;
00687                     v= 2*(get_symbol2(&s->c, b->state[0 + 2], 0-4) + 1);
00688                     v+=get_rac(&s->c, &b->state[0][16 + 1 + 3]);
00689 
00690                     xc->x=x;
00691                     (xc++)->coeff= v;
00692                 }else{
00693                     int max_run;
00694                     run--;
00695                     v=0;
00696 
00697                     if(y) max_run= FFMIN(run, prev_xc->x - x - 2);
00698                     else  max_run= FFMIN(run, w-x-1);
00699                     if(parent_xc)
00700                         max_run= FFMIN(max_run, 2*parent_xc->x - x - 1);
00701                     x+= max_run;
00702                     run-= max_run;
00703                 }
00704             }
00705         }
00706         (xc++)->x= w+1; //end marker
00707         prev_xc= prev2_xc;
00708         prev2_xc= xc;
00709 
00710         if(parent_xc){
00711             if(y&1){
00712                 while(parent_xc->x != parent->width+1)
00713                     parent_xc++;
00714                 parent_xc++;
00715                 prev_parent_xc= parent_xc;
00716             }else{
00717                 parent_xc= prev_parent_xc;
00718             }
00719         }
00720     }
00721 
00722     (xc++)->x= w+1; //end marker
00723 }
00724 
00725 static inline void decode_subband_slice_buffered(SnowContext *s, SubBand *b, slice_buffer * sb, int start_y, int h, int save_state[1]){
00726     const int w= b->width;
00727     int y;
00728     const int qlog= av_clip(s->qlog + b->qlog, 0, QROOT*16);
00729     int qmul= qexp[qlog&(QROOT-1)]<<(qlog>>QSHIFT);
00730     int qadd= (s->qbias*qmul)>>QBIAS_SHIFT;
00731     int new_index = 0;
00732 
00733     if(b->ibuf == s->spatial_idwt_buffer || s->qlog == LOSSLESS_QLOG){
00734         qadd= 0;
00735         qmul= 1<<QEXPSHIFT;
00736     }
00737 
00738     /* If we are on the second or later slice, restore our index. */
00739     if (start_y != 0)
00740         new_index = save_state[0];
00741 
00742 
00743     for(y=start_y; y<h; y++){
00744         int x = 0;
00745         int v;
00746         IDWTELEM * line = slice_buffer_get_line(sb, y * b->stride_line + b->buf_y_offset) + b->buf_x_offset;
00747         memset(line, 0, b->width*sizeof(IDWTELEM));
00748         v = b->x_coeff[new_index].coeff;
00749         x = b->x_coeff[new_index++].x;
00750         while(x < w){
00751             register int t= ( (v>>1)*qmul + qadd)>>QEXPSHIFT;
00752             register int u= -(v&1);
00753             line[x] = (t^u) - u;
00754 
00755             v = b->x_coeff[new_index].coeff;
00756             x = b->x_coeff[new_index++].x;
00757         }
00758     }
00759 
00760     /* Save our variables for the next slice. */
00761     save_state[0] = new_index;
00762 
00763     return;
00764 }
00765 
00766 static void reset_contexts(SnowContext *s){ //FIXME better initial contexts
00767     int plane_index, level, orientation;
00768 
00769     for(plane_index=0; plane_index<3; plane_index++){
00770         for(level=0; level<MAX_DECOMPOSITIONS; level++){
00771             for(orientation=level ? 1:0; orientation<4; orientation++){
00772                 memset(s->plane[plane_index].band[level][orientation].state, MID_STATE, sizeof(s->plane[plane_index].band[level][orientation].state));
00773             }
00774         }
00775     }
00776     memset(s->header_state, MID_STATE, sizeof(s->header_state));
00777     memset(s->block_state, MID_STATE, sizeof(s->block_state));
00778 }
00779 
00780 static int alloc_blocks(SnowContext *s){
00781     int w= -((-s->avctx->width )>>LOG2_MB_SIZE);
00782     int h= -((-s->avctx->height)>>LOG2_MB_SIZE);
00783 
00784     s->b_width = w;
00785     s->b_height= h;
00786 
00787     av_free(s->block);
00788     s->block= av_mallocz(w * h * sizeof(BlockNode) << (s->block_max_depth*2));
00789     return 0;
00790 }
00791 
00792 static inline void copy_rac_state(RangeCoder *d, RangeCoder *s){
00793     uint8_t *bytestream= d->bytestream;
00794     uint8_t *bytestream_start= d->bytestream_start;
00795     *d= *s;
00796     d->bytestream= bytestream;
00797     d->bytestream_start= bytestream_start;
00798 }
00799 
00800 static inline void set_blocks(SnowContext *s, int level, int x, int y, int l, int cb, int cr, int mx, int my, int ref, int type){
00801     const int w= s->b_width << s->block_max_depth;
00802     const int rem_depth= s->block_max_depth - level;
00803     const int index= (x + y*w) << rem_depth;
00804     const int block_w= 1<<rem_depth;
00805     BlockNode block;
00806     int i,j;
00807 
00808     block.color[0]= l;
00809     block.color[1]= cb;
00810     block.color[2]= cr;
00811     block.mx= mx;
00812     block.my= my;
00813     block.ref= ref;
00814     block.type= type;
00815     block.level= level;
00816 
00817     for(j=0; j<block_w; j++){
00818         for(i=0; i<block_w; i++){
00819             s->block[index + i + j*w]= block;
00820         }
00821     }
00822 }
00823 
00824 static inline void init_ref(MotionEstContext *c, uint8_t *src[3], uint8_t *ref[3], uint8_t *ref2[3], int x, int y, int ref_index){
00825     const int offset[3]= {
00826           y*c->  stride + x,
00827         ((y*c->uvstride + x)>>1),
00828         ((y*c->uvstride + x)>>1),
00829     };
00830     int i;
00831     for(i=0; i<3; i++){
00832         c->src[0][i]= src [i];
00833         c->ref[0][i]= ref [i] + offset[i];
00834     }
00835     assert(!ref_index);
00836 }
00837 
00838 static inline void pred_mv(SnowContext *s, int *mx, int *my, int ref,
00839                            const BlockNode *left, const BlockNode *top, const BlockNode *tr){
00840     if(s->ref_frames == 1){
00841         *mx = mid_pred(left->mx, top->mx, tr->mx);
00842         *my = mid_pred(left->my, top->my, tr->my);
00843     }else{
00844         const int *scale = scale_mv_ref[ref];
00845         *mx = mid_pred((left->mx * scale[left->ref] + 128) >>8,
00846                        (top ->mx * scale[top ->ref] + 128) >>8,
00847                        (tr  ->mx * scale[tr  ->ref] + 128) >>8);
00848         *my = mid_pred((left->my * scale[left->ref] + 128) >>8,
00849                        (top ->my * scale[top ->ref] + 128) >>8,
00850                        (tr  ->my * scale[tr  ->ref] + 128) >>8);
00851     }
00852 }
00853 
00854 static av_always_inline int same_block(BlockNode *a, BlockNode *b){
00855     if((a->type&BLOCK_INTRA) && (b->type&BLOCK_INTRA)){
00856         return !((a->color[0] - b->color[0]) | (a->color[1] - b->color[1]) | (a->color[2] - b->color[2]));
00857     }else{
00858         return !((a->mx - b->mx) | (a->my - b->my) | (a->ref - b->ref) | ((a->type ^ b->type)&BLOCK_INTRA));
00859     }
00860 }
00861 
00862 static void decode_q_branch(SnowContext *s, int level, int x, int y){
00863     const int w= s->b_width << s->block_max_depth;
00864     const int rem_depth= s->block_max_depth - level;
00865     const int index= (x + y*w) << rem_depth;
00866     int trx= (x+1)<<rem_depth;
00867     const BlockNode *left  = x ? &s->block[index-1] : &null_block;
00868     const BlockNode *top   = y ? &s->block[index-w] : &null_block;
00869     const BlockNode *tl    = y && x ? &s->block[index-w-1] : left;
00870     const BlockNode *tr    = y && trx<w && ((x&1)==0 || level==0) ? &s->block[index-w+(1<<rem_depth)] : tl; //FIXME use lt
00871     int s_context= 2*left->level + 2*top->level + tl->level + tr->level;
00872 
00873     if(s->keyframe){
00874         set_blocks(s, level, x, y, null_block.color[0], null_block.color[1], null_block.color[2], null_block.mx, null_block.my, null_block.ref, BLOCK_INTRA);
00875         return;
00876     }
00877 
00878     if(level==s->block_max_depth || get_rac(&s->c, &s->block_state[4 + s_context])){
00879         int type, mx, my;
00880         int l = left->color[0];
00881         int cb= left->color[1];
00882         int cr= left->color[2];
00883         int ref = 0;
00884         int ref_context= av_log2(2*left->ref) + av_log2(2*top->ref);
00885         int mx_context= av_log2(2*FFABS(left->mx - top->mx)) + 0*av_log2(2*FFABS(tr->mx - top->mx));
00886         int my_context= av_log2(2*FFABS(left->my - top->my)) + 0*av_log2(2*FFABS(tr->my - top->my));
00887 
00888         type= get_rac(&s->c, &s->block_state[1 + left->type + top->type]) ? BLOCK_INTRA : 0;
00889 
00890         if(type){
00891             pred_mv(s, &mx, &my, 0, left, top, tr);
00892             l += get_symbol(&s->c, &s->block_state[32], 1);
00893             cb+= get_symbol(&s->c, &s->block_state[64], 1);
00894             cr+= get_symbol(&s->c, &s->block_state[96], 1);
00895         }else{
00896             if(s->ref_frames > 1)
00897                 ref= get_symbol(&s->c, &s->block_state[128 + 1024 + 32*ref_context], 0);
00898             pred_mv(s, &mx, &my, ref, left, top, tr);
00899             mx+= get_symbol(&s->c, &s->block_state[128 + 32*(mx_context + 16*!!ref)], 1);
00900             my+= get_symbol(&s->c, &s->block_state[128 + 32*(my_context + 16*!!ref)], 1);
00901         }
00902         set_blocks(s, level, x, y, l, cb, cr, mx, my, ref, type);
00903     }else{
00904         decode_q_branch(s, level+1, 2*x+0, 2*y+0);
00905         decode_q_branch(s, level+1, 2*x+1, 2*y+0);
00906         decode_q_branch(s, level+1, 2*x+0, 2*y+1);
00907         decode_q_branch(s, level+1, 2*x+1, 2*y+1);
00908     }
00909 }
00910 
00911 static void decode_blocks(SnowContext *s){
00912     int x, y;
00913     int w= s->b_width;
00914     int h= s->b_height;
00915 
00916     for(y=0; y<h; y++){
00917         for(x=0; x<w; x++){
00918             decode_q_branch(s, 0, x, y);
00919         }
00920     }
00921 }
00922 
00923 static void mc_block(Plane *p, uint8_t *dst, const uint8_t *src, int stride, int b_w, int b_h, int dx, int dy){
00924     static const uint8_t weight[64]={
00925     8,7,6,5,4,3,2,1,
00926     7,7,0,0,0,0,0,1,
00927     6,0,6,0,0,0,2,0,
00928     5,0,0,5,0,3,0,0,
00929     4,0,0,0,4,0,0,0,
00930     3,0,0,5,0,3,0,0,
00931     2,0,6,0,0,0,2,0,
00932     1,7,0,0,0,0,0,1,
00933     };
00934 
00935     static const uint8_t brane[256]={
00936     0x00,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x11,0x12,0x12,0x12,0x12,0x12,0x12,0x12,
00937     0x04,0x05,0xcc,0xcc,0xcc,0xcc,0xcc,0x41,0x15,0x16,0xcc,0xcc,0xcc,0xcc,0xcc,0x52,
00938     0x04,0xcc,0x05,0xcc,0xcc,0xcc,0x41,0xcc,0x15,0xcc,0x16,0xcc,0xcc,0xcc,0x52,0xcc,
00939     0x04,0xcc,0xcc,0x05,0xcc,0x41,0xcc,0xcc,0x15,0xcc,0xcc,0x16,0xcc,0x52,0xcc,0xcc,
00940     0x04,0xcc,0xcc,0xcc,0x41,0xcc,0xcc,0xcc,0x15,0xcc,0xcc,0xcc,0x16,0xcc,0xcc,0xcc,
00941     0x04,0xcc,0xcc,0x41,0xcc,0x05,0xcc,0xcc,0x15,0xcc,0xcc,0x52,0xcc,0x16,0xcc,0xcc,
00942     0x04,0xcc,0x41,0xcc,0xcc,0xcc,0x05,0xcc,0x15,0xcc,0x52,0xcc,0xcc,0xcc,0x16,0xcc,
00943     0x04,0x41,0xcc,0xcc,0xcc,0xcc,0xcc,0x05,0x15,0x52,0xcc,0xcc,0xcc,0xcc,0xcc,0x16,
00944     0x44,0x45,0x45,0x45,0x45,0x45,0x45,0x45,0x55,0x56,0x56,0x56,0x56,0x56,0x56,0x56,
00945     0x48,0x49,0xcc,0xcc,0xcc,0xcc,0xcc,0x85,0x59,0x5A,0xcc,0xcc,0xcc,0xcc,0xcc,0x96,
00946     0x48,0xcc,0x49,0xcc,0xcc,0xcc,0x85,0xcc,0x59,0xcc,0x5A,0xcc,0xcc,0xcc,0x96,0xcc,
00947     0x48,0xcc,0xcc,0x49,0xcc,0x85,0xcc,0xcc,0x59,0xcc,0xcc,0x5A,0xcc,0x96,0xcc,0xcc,
00948     0x48,0xcc,0xcc,0xcc,0x49,0xcc,0xcc,0xcc,0x59,0xcc,0xcc,0xcc,0x96,0xcc,0xcc,0xcc,
00949     0x48,0xcc,0xcc,0x85,0xcc,0x49,0xcc,0xcc,0x59,0xcc,0xcc,0x96,0xcc,0x5A,0xcc,0xcc,
00950     0x48,0xcc,0x85,0xcc,0xcc,0xcc,0x49,0xcc,0x59,0xcc,0x96,0xcc,0xcc,0xcc,0x5A,0xcc,
00951     0x48,0x85,0xcc,0xcc,0xcc,0xcc,0xcc,0x49,0x59,0x96,0xcc,0xcc,0xcc,0xcc,0xcc,0x5A,
00952     };
00953 
00954     static const uint8_t needs[16]={
00955     0,1,0,0,
00956     2,4,2,0,
00957     0,1,0,0,
00958     15
00959     };
00960 
00961     int x, y, b, r, l;
00962     int16_t tmpIt   [64*(32+HTAPS_MAX)];
00963     uint8_t tmp2t[3][stride*(32+HTAPS_MAX)];
00964     int16_t *tmpI= tmpIt;
00965     uint8_t *tmp2= tmp2t[0];
00966     const uint8_t *hpel[11];
00967     assert(dx<16 && dy<16);
00968     r= brane[dx + 16*dy]&15;
00969     l= brane[dx + 16*dy]>>4;
00970 
00971     b= needs[l] | needs[r];
00972     if(p && !p->diag_mc)
00973         b= 15;
00974 
00975     if(b&5){
00976         for(y=0; y < b_h+HTAPS_MAX-1; y++){
00977             for(x=0; x < b_w; x++){
00978                 int a_1=src[x + HTAPS_MAX/2-4];
00979                 int a0= src[x + HTAPS_MAX/2-3];
00980                 int a1= src[x + HTAPS_MAX/2-2];
00981                 int a2= src[x + HTAPS_MAX/2-1];
00982                 int a3= src[x + HTAPS_MAX/2+0];
00983                 int a4= src[x + HTAPS_MAX/2+1];
00984                 int a5= src[x + HTAPS_MAX/2+2];
00985                 int a6= src[x + HTAPS_MAX/2+3];
00986                 int am=0;
00987                 if(!p || p->fast_mc){
00988                     am= 20*(a2+a3) - 5*(a1+a4) + (a0+a5);
00989                     tmpI[x]= am;
00990                     am= (am+16)>>5;
00991                 }else{
00992                     am= p->hcoeff[0]*(a2+a3) + p->hcoeff[1]*(a1+a4) + p->hcoeff[2]*(a0+a5) + p->hcoeff[3]*(a_1+a6);
00993                     tmpI[x]= am;
00994                     am= (am+32)>>6;
00995                 }
00996 
00997                 if(am&(~255)) am= ~(am>>31);
00998                 tmp2[x]= am;
00999             }
01000             tmpI+= 64;
01001             tmp2+= stride;
01002             src += stride;
01003         }
01004         src -= stride*y;
01005     }
01006     src += HTAPS_MAX/2 - 1;
01007     tmp2= tmp2t[1];
01008 
01009     if(b&2){
01010         for(y=0; y < b_h; y++){
01011             for(x=0; x < b_w+1; x++){
01012                 int a_1=src[x + (HTAPS_MAX/2-4)*stride];
01013                 int a0= src[x + (HTAPS_MAX/2-3)*stride];
01014                 int a1= src[x + (HTAPS_MAX/2-2)*stride];
01015                 int a2= src[x + (HTAPS_MAX/2-1)*stride];
01016                 int a3= src[x + (HTAPS_MAX/2+0)*stride];
01017                 int a4= src[x + (HTAPS_MAX/2+1)*stride];
01018                 int a5= src[x + (HTAPS_MAX/2+2)*stride];
01019                 int a6= src[x + (HTAPS_MAX/2+3)*stride];
01020                 int am=0;
01021                 if(!p || p->fast_mc)
01022                     am= (20*(a2+a3) - 5*(a1+a4) + (a0+a5) + 16)>>5;
01023                 else
01024                     am= (p->hcoeff[0]*(a2+a3) + p->hcoeff[1]*(a1+a4) + p->hcoeff[2]*(a0+a5) + p->hcoeff[3]*(a_1+a6) + 32)>>6;
01025 
01026                 if(am&(~255)) am= ~(am>>31);
01027                 tmp2[x]= am;
01028             }
01029             src += stride;
01030             tmp2+= stride;
01031         }
01032         src -= stride*y;
01033     }
01034     src += stride*(HTAPS_MAX/2 - 1);
01035     tmp2= tmp2t[2];
01036     tmpI= tmpIt;
01037     if(b&4){
01038         for(y=0; y < b_h; y++){
01039             for(x=0; x < b_w; x++){
01040                 int a_1=tmpI[x + (HTAPS_MAX/2-4)*64];
01041                 int a0= tmpI[x + (HTAPS_MAX/2-3)*64];
01042                 int a1= tmpI[x + (HTAPS_MAX/2-2)*64];
01043                 int a2= tmpI[x + (HTAPS_MAX/2-1)*64];
01044                 int a3= tmpI[x + (HTAPS_MAX/2+0)*64];
01045                 int a4= tmpI[x + (HTAPS_MAX/2+1)*64];
01046                 int a5= tmpI[x + (HTAPS_MAX/2+2)*64];
01047                 int a6= tmpI[x + (HTAPS_MAX/2+3)*64];
01048                 int am=0;
01049                 if(!p || p->fast_mc)
01050                     am= (20*(a2+a3) - 5*(a1+a4) + (a0+a5) + 512)>>10;
01051                 else
01052                     am= (p->hcoeff[0]*(a2+a3) + p->hcoeff[1]*(a1+a4) + p->hcoeff[2]*(a0+a5) + p->hcoeff[3]*(a_1+a6) + 2048)>>12;
01053                 if(am&(~255)) am= ~(am>>31);
01054                 tmp2[x]= am;
01055             }
01056             tmpI+= 64;
01057             tmp2+= stride;
01058         }
01059     }
01060 
01061     hpel[ 0]= src;
01062     hpel[ 1]= tmp2t[0] + stride*(HTAPS_MAX/2-1);
01063     hpel[ 2]= src + 1;
01064 
01065     hpel[ 4]= tmp2t[1];
01066     hpel[ 5]= tmp2t[2];
01067     hpel[ 6]= tmp2t[1] + 1;
01068 
01069     hpel[ 8]= src + stride;
01070     hpel[ 9]= hpel[1] + stride;
01071     hpel[10]= hpel[8] + 1;
01072 
01073     if(b==15){
01074         const uint8_t *src1= hpel[dx/8 + dy/8*4  ];
01075         const uint8_t *src2= hpel[dx/8 + dy/8*4+1];
01076         const uint8_t *src3= hpel[dx/8 + dy/8*4+4];
01077         const uint8_t *src4= hpel[dx/8 + dy/8*4+5];
01078         dx&=7;
01079         dy&=7;
01080         for(y=0; y < b_h; y++){
01081             for(x=0; x < b_w; x++){
01082                 dst[x]= ((8-dx)*(8-dy)*src1[x] + dx*(8-dy)*src2[x]+
01083                          (8-dx)*   dy *src3[x] + dx*   dy *src4[x]+32)>>6;
01084             }
01085             src1+=stride;
01086             src2+=stride;
01087             src3+=stride;
01088             src4+=stride;
01089             dst +=stride;
01090         }
01091     }else{
01092         const uint8_t *src1= hpel[l];
01093         const uint8_t *src2= hpel[r];
01094         int a= weight[((dx&7) + (8*(dy&7)))];
01095         int b= 8-a;
01096         for(y=0; y < b_h; y++){
01097             for(x=0; x < b_w; x++){
01098                 dst[x]= (a*src1[x] + b*src2[x] + 4)>>3;
01099             }
01100             src1+=stride;
01101             src2+=stride;
01102             dst +=stride;
01103         }
01104     }
01105 }
01106 
01107 #define mca(dx,dy,b_w)\
01108 static void mc_block_hpel ## dx ## dy ## b_w(uint8_t *dst, const uint8_t *src, int stride, int h){\
01109     assert(h==b_w);\
01110     mc_block(NULL, dst, src-(HTAPS_MAX/2-1)-(HTAPS_MAX/2-1)*stride, stride, b_w, b_w, dx, dy);\
01111 }
01112 
01113 mca( 0, 0,16)
01114 mca( 8, 0,16)
01115 mca( 0, 8,16)
01116 mca( 8, 8,16)
01117 mca( 0, 0,8)
01118 mca( 8, 0,8)
01119 mca( 0, 8,8)
01120 mca( 8, 8,8)
01121 
01122 static void pred_block(SnowContext *s, uint8_t *dst, uint8_t *tmp, int stride, int sx, int sy, int b_w, int b_h, BlockNode *block, int plane_index, int w, int h){
01123     if(block->type & BLOCK_INTRA){
01124         int x, y;
01125         const int color = block->color[plane_index];
01126         const int color4= color*0x01010101;
01127         if(b_w==32){
01128             for(y=0; y < b_h; y++){
01129                 *(uint32_t*)&dst[0 + y*stride]= color4;
01130                 *(uint32_t*)&dst[4 + y*stride]= color4;
01131                 *(uint32_t*)&dst[8 + y*stride]= color4;
01132                 *(uint32_t*)&dst[12+ y*stride]= color4;
01133                 *(uint32_t*)&dst[16+ y*stride]= color4;
01134                 *(uint32_t*)&dst[20+ y*stride]= color4;
01135                 *(uint32_t*)&dst[24+ y*stride]= color4;
01136                 *(uint32_t*)&dst[28+ y*stride]= color4;
01137             }
01138         }else if(b_w==16){
01139             for(y=0; y < b_h; y++){
01140                 *(uint32_t*)&dst[0 + y*stride]= color4;
01141                 *(uint32_t*)&dst[4 + y*stride]= color4;
01142                 *(uint32_t*)&dst[8 + y*stride]= color4;
01143                 *(uint32_t*)&dst[12+ y*stride]= color4;
01144             }
01145         }else if(b_w==8){
01146             for(y=0; y < b_h; y++){
01147                 *(uint32_t*)&dst[0 + y*stride]= color4;
01148                 *(uint32_t*)&dst[4 + y*stride]= color4;
01149             }
01150         }else if(b_w==4){
01151             for(y=0; y < b_h; y++){
01152                 *(uint32_t*)&dst[0 + y*stride]= color4;
01153             }
01154         }else{
01155             for(y=0; y < b_h; y++){
01156                 for(x=0; x < b_w; x++){
01157                     dst[x + y*stride]= color;
01158                 }
01159             }
01160         }
01161     }else{
01162         uint8_t *src= s->last_picture[block->ref].data[plane_index];
01163         const int scale= plane_index ?  s->mv_scale : 2*s->mv_scale;
01164         int mx= block->mx*scale;
01165         int my= block->my*scale;
01166         const int dx= mx&15;
01167         const int dy= my&15;
01168         const int tab_index= 3 - (b_w>>2) + (b_w>>4);
01169         sx += (mx>>4) - (HTAPS_MAX/2-1);
01170         sy += (my>>4) - (HTAPS_MAX/2-1);
01171         src += sx + sy*stride;
01172         if(   (unsigned)sx >= w - b_w - (HTAPS_MAX-2)
01173            || (unsigned)sy >= h - b_h - (HTAPS_MAX-2)){
01174             s->dsp.emulated_edge_mc(tmp + MB_SIZE, src, stride, b_w+HTAPS_MAX-1, b_h+HTAPS_MAX-1, sx, sy, w, h);
01175             src= tmp + MB_SIZE;
01176         }
01177 //        assert(b_w == b_h || 2*b_w == b_h || b_w == 2*b_h);
01178 //        assert(!(b_w&(b_w-1)));
01179         assert(b_w>1 && b_h>1);
01180         assert((tab_index>=0 && tab_index<4) || b_w==32);
01181         if((dx&3) || (dy&3) || !(b_w == b_h || 2*b_w == b_h || b_w == 2*b_h) || (b_w&(b_w-1)) || !s->plane[plane_index].fast_mc )
01182             mc_block(&s->plane[plane_index], dst, src, stride, b_w, b_h, dx, dy);
01183         else if(b_w==32){
01184             int y;
01185             for(y=0; y<b_h; y+=16){
01186                 s->dsp.put_h264_qpel_pixels_tab[0][dy+(dx>>2)](dst + y*stride, src + 3 + (y+3)*stride,stride);
01187                 s->dsp.put_h264_qpel_pixels_tab[0][dy+(dx>>2)](dst + 16 + y*stride, src + 19 + (y+3)*stride,stride);
01188             }
01189         }else if(b_w==b_h)
01190             s->dsp.put_h264_qpel_pixels_tab[tab_index  ][dy+(dx>>2)](dst,src + 3 + 3*stride,stride);
01191         else if(b_w==2*b_h){
01192             s->dsp.put_h264_qpel_pixels_tab[tab_index+1][dy+(dx>>2)](dst    ,src + 3       + 3*stride,stride);
01193             s->dsp.put_h264_qpel_pixels_tab[tab_index+1][dy+(dx>>2)](dst+b_h,src + 3 + b_h + 3*stride,stride);
01194         }else{
01195             assert(2*b_w==b_h);
01196             s->dsp.put_h264_qpel_pixels_tab[tab_index  ][dy+(dx>>2)](dst           ,src + 3 + 3*stride           ,stride);
01197             s->dsp.put_h264_qpel_pixels_tab[tab_index  ][dy+(dx>>2)](dst+b_w*stride,src + 3 + 3*stride+b_w*stride,stride);
01198         }
01199     }
01200 }
01201 
01202 void ff_snow_inner_add_yblock(const uint8_t *obmc, const int obmc_stride, uint8_t * * block, int b_w, int b_h,
01203                               int src_x, int src_y, int src_stride, slice_buffer * sb, int add, uint8_t * dst8){
01204     int y, x;
01205     IDWTELEM * dst;
01206     for(y=0; y<b_h; y++){
01207         //FIXME ugly misuse of obmc_stride
01208         const uint8_t *obmc1= obmc + y*obmc_stride;
01209         const uint8_t *obmc2= obmc1+ (obmc_stride>>1);
01210         const uint8_t *obmc3= obmc1+ obmc_stride*(obmc_stride>>1);
01211         const uint8_t *obmc4= obmc3+ (obmc_stride>>1);
01212         dst = slice_buffer_get_line(sb, src_y + y);
01213         for(x=0; x<b_w; x++){
01214             int v=   obmc1[x] * block[3][x + y*src_stride]
01215                     +obmc2[x] * block[2][x + y*src_stride]
01216                     +obmc3[x] * block[1][x + y*src_stride]
01217                     +obmc4[x] * block[0][x + y*src_stride];
01218 
01219             v <<= 8 - LOG2_OBMC_MAX;
01220             if(FRAC_BITS != 8){
01221                 v >>= 8 - FRAC_BITS;
01222             }
01223             if(add){
01224                 v += dst[x + src_x];
01225                 v = (v + (1<<(FRAC_BITS-1))) >> FRAC_BITS;
01226                 if(v&(~255)) v= ~(v>>31);
01227                 dst8[x + y*src_stride] = v;
01228             }else{
01229                 dst[x + src_x] -= v;
01230             }
01231         }
01232     }
01233 }
01234 
01235 //FIXME name cleanup (b_w, block_w, b_width stuff)
01236 static av_always_inline void add_yblock(SnowContext *s, int sliced, slice_buffer *sb, IDWTELEM *dst, uint8_t *dst8, const uint8_t *obmc, int src_x, int src_y, int b_w, int b_h, int w, int h, int dst_stride, int src_stride, int obmc_stride, int b_x, int b_y, int add, int offset_dst, int plane_index){
01237     const int b_width = s->b_width  << s->block_max_depth;
01238     const int b_height= s->b_height << s->block_max_depth;
01239     const int b_stride= b_width;
01240     BlockNode *lt= &s->block[b_x + b_y*b_stride];
01241     BlockNode *rt= lt+1;
01242     BlockNode *lb= lt+b_stride;
01243     BlockNode *rb= lb+1;
01244     uint8_t *block[4];
01245     int tmp_step= src_stride >= 7*MB_SIZE ? MB_SIZE : MB_SIZE*src_stride;
01246     uint8_t *tmp = s->scratchbuf;
01247     uint8_t *ptmp;
01248     int x,y;
01249 
01250     if(b_x<0){
01251         lt= rt;
01252         lb= rb;
01253     }else if(b_x + 1 >= b_width){
01254         rt= lt;
01255         rb= lb;
01256     }
01257     if(b_y<0){
01258         lt= lb;
01259         rt= rb;
01260     }else if(b_y + 1 >= b_height){
01261         lb= lt;
01262         rb= rt;
01263     }
01264 
01265     if(src_x<0){ //FIXME merge with prev & always round internal width up to *16
01266         obmc -= src_x;
01267         b_w += src_x;
01268         if(!sliced && !offset_dst)
01269             dst -= src_x;
01270         src_x=0;
01271     }else if(src_x + b_w > w){
01272         b_w = w - src_x;
01273     }
01274     if(src_y<0){
01275         obmc -= src_y*obmc_stride;
01276         b_h += src_y;
01277         if(!sliced && !offset_dst)
01278             dst -= src_y*dst_stride;
01279         src_y=0;
01280     }else if(src_y + b_h> h){
01281         b_h = h - src_y;
01282     }
01283 
01284     if(b_w<=0 || b_h<=0) return;
01285 
01286     assert(src_stride > 2*MB_SIZE + 5);
01287 
01288     if(!sliced && offset_dst)
01289         dst += src_x + src_y*dst_stride;
01290     dst8+= src_x + src_y*src_stride;
01291 //    src += src_x + src_y*src_stride;
01292 
01293     ptmp= tmp + 3*tmp_step;
01294     block[0]= ptmp;
01295     ptmp+=tmp_step;
01296     pred_block(s, block[0], tmp, src_stride, src_x, src_y, b_w, b_h, lt, plane_index, w, h);
01297 
01298     if(same_block(lt, rt)){
01299         block[1]= block[0];
01300     }else{
01301         block[1]= ptmp;
01302         ptmp+=tmp_step;
01303         pred_block(s, block[1], tmp, src_stride, src_x, src_y, b_w, b_h, rt, plane_index, w, h);
01304     }
01305 
01306     if(same_block(lt, lb)){
01307         block[2]= block[0];
01308     }else if(same_block(rt, lb)){
01309         block[2]= block[1];
01310     }else{
01311         block[2]= ptmp;
01312         ptmp+=tmp_step;
01313         pred_block(s, block[2], tmp, src_stride, src_x, src_y, b_w, b_h, lb, plane_index, w, h);
01314     }
01315 
01316     if(same_block(lt, rb) ){
01317         block[3]= block[0];
01318     }else if(same_block(rt, rb)){
01319         block[3]= block[1];
01320     }else if(same_block(lb, rb)){
01321         block[3]= block[2];
01322     }else{
01323         block[3]= ptmp;
01324         pred_block(s, block[3], tmp, src_stride, src_x, src_y, b_w, b_h, rb, plane_index, w, h);
01325     }
01326 #if 0
01327     for(y=0; y<b_h; y++){
01328         for(x=0; x<b_w; x++){
01329             int v=   obmc [x + y*obmc_stride] * block[3][x + y*src_stride] * (256/OBMC_MAX);
01330             if(add) dst[x + y*dst_stride] += v;
01331             else    dst[x + y*dst_stride] -= v;
01332         }
01333     }
01334     for(y=0; y<b_h; y++){
01335         uint8_t *obmc2= obmc + (obmc_stride>>1);
01336         for(x=0; x<b_w; x++){
01337             int v=   obmc2[x + y*obmc_stride] * block[2][x + y*src_stride] * (256/OBMC_MAX);
01338             if(add) dst[x + y*dst_stride] += v;
01339             else    dst[x + y*dst_stride] -= v;
01340         }
01341     }
01342     for(y=0; y<b_h; y++){
01343         uint8_t *obmc3= obmc + obmc_stride*(obmc_stride>>1);
01344         for(x=0; x<b_w; x++){
01345             int v=   obmc3[x + y*obmc_stride] * block[1][x + y*src_stride] * (256/OBMC_MAX);
01346             if(add) dst[x + y*dst_stride] += v;
01347             else    dst[x + y*dst_stride] -= v;
01348         }
01349     }
01350     for(y=0; y<b_h; y++){
01351         uint8_t *obmc3= obmc + obmc_stride*(obmc_stride>>1);
01352         uint8_t *obmc4= obmc3+ (obmc_stride>>1);
01353         for(x=0; x<b_w; x++){
01354             int v=   obmc4[x + y*obmc_stride] * block[0][x + y*src_stride] * (256/OBMC_MAX);
01355             if(add) dst[x + y*dst_stride] += v;
01356             else    dst[x + y*dst_stride] -= v;
01357         }
01358     }
01359 #else
01360     if(sliced){
01361         s->dwt.inner_add_yblock(obmc, obmc_stride, block, b_w, b_h, src_x,src_y, src_stride, sb, add, dst8);
01362     }else{
01363         for(y=0; y<b_h; y++){
01364             //FIXME ugly misuse of obmc_stride
01365             const uint8_t *obmc1= obmc + y*obmc_stride;
01366             const uint8_t *obmc2= obmc1+ (obmc_stride>>1);
01367             const uint8_t *obmc3= obmc1+ obmc_stride*(obmc_stride>>1);
01368             const uint8_t *obmc4= obmc3+ (obmc_stride>>1);
01369             for(x=0; x<b_w; x++){
01370                 int v=   obmc1[x] * block[3][x + y*src_stride]
01371                         +obmc2[x] * block[2][x + y*src_stride]
01372                         +obmc3[x] * block[1][x + y*src_stride]
01373                         +obmc4[x] * block[0][x + y*src_stride];
01374 
01375                 v <<= 8 - LOG2_OBMC_MAX;
01376                 if(FRAC_BITS != 8){
01377                     v >>= 8 - FRAC_BITS;
01378                 }
01379                 if(add){
01380                     v += dst[x + y*dst_stride];
01381                     v = (v + (1<<(FRAC_BITS-1))) >> FRAC_BITS;
01382                     if(v&(~255)) v= ~(v>>31);
01383                     dst8[x + y*src_stride] = v;
01384                 }else{
01385                     dst[x + y*dst_stride] -= v;
01386                 }
01387             }
01388         }
01389     }
01390 #endif /* 0 */
01391 }
01392 
01393 static av_always_inline void predict_slice_buffered(SnowContext *s, slice_buffer * sb, IDWTELEM * old_buffer, int plane_index, int add, int mb_y){
01394     Plane *p= &s->plane[plane_index];
01395     const int mb_w= s->b_width  << s->block_max_depth;
01396     const int mb_h= s->b_height << s->block_max_depth;
01397     int x, y, mb_x;
01398     int block_size = MB_SIZE >> s->block_max_depth;
01399     int block_w    = plane_index ? block_size/2 : block_size;
01400     const uint8_t *obmc  = plane_index ? obmc_tab[s->block_max_depth+1] : obmc_tab[s->block_max_depth];
01401     int obmc_stride= plane_index ? block_size : 2*block_size;
01402     int ref_stride= s->current_picture.linesize[plane_index];
01403     uint8_t *dst8= s->current_picture.data[plane_index];
01404     int w= p->width;
01405     int h= p->height;
01406 
01407     if(s->keyframe || (s->avctx->debug&512)){
01408         if(mb_y==mb_h)
01409             return;
01410 
01411         if(add){
01412             for(y=block_w*mb_y; y<FFMIN(h,block_w*(mb_y+1)); y++){
01413 //                DWTELEM * line = slice_buffer_get_line(sb, y);
01414                 IDWTELEM * line = sb->line[y];
01415                 for(x=0; x<w; x++){
01416 //                    int v= buf[x + y*w] + (128<<FRAC_BITS) + (1<<(FRAC_BITS-1));
01417                     int v= line[x] + (128<<FRAC_BITS) + (1<<(FRAC_BITS-1));
01418                     v >>= FRAC_BITS;
01419                     if(v&(~255)) v= ~(v>>31);
01420                     dst8[x + y*ref_stride]= v;
01421                 }
01422             }
01423         }else{
01424             for(y=block_w*mb_y; y<FFMIN(h,block_w*(mb_y+1)); y++){
01425 //                DWTELEM * line = slice_buffer_get_line(sb, y);
01426                 IDWTELEM * line = sb->line[y];
01427                 for(x=0; x<w; x++){
01428                     line[x] -= 128 << FRAC_BITS;
01429 //                    buf[x + y*w]-= 128<<FRAC_BITS;
01430                 }
01431             }
01432         }
01433 
01434         return;
01435     }
01436 
01437     for(mb_x=0; mb_x<=mb_w; mb_x++){
01438         add_yblock(s, 1, sb, old_buffer, dst8, obmc,
01439                    block_w*mb_x - block_w/2,
01440                    block_w*mb_y - block_w/2,
01441                    block_w, block_w,
01442                    w, h,
01443                    w, ref_stride, obmc_stride,
01444                    mb_x - 1, mb_y - 1,
01445                    add, 0, plane_index);
01446     }
01447 }
01448 
01449 static av_always_inline void predict_slice(SnowContext *s, IDWTELEM *buf, int plane_index, int add, int mb_y){
01450     Plane *p= &s->plane[plane_index];
01451     const int mb_w= s->b_width  << s->block_max_depth;
01452     const int mb_h= s->b_height << s->block_max_depth;
01453     int x, y, mb_x;
01454     int block_size = MB_SIZE >> s->block_max_depth;
01455     int block_w    = plane_index ? block_size/2 : block_size;
01456     const uint8_t *obmc  = plane_index ? obmc_tab[s->block_max_depth+1] : obmc_tab[s->block_max_depth];
01457     const int obmc_stride= plane_index ? block_size : 2*block_size;
01458     int ref_stride= s->current_picture.linesize[plane_index];
01459     uint8_t *dst8= s->current_picture.data[plane_index];
01460     int w= p->width;
01461     int h= p->height;
01462 
01463     if(s->keyframe || (s->avctx->debug&512)){
01464         if(mb_y==mb_h)
01465             return;
01466 
01467         if(add){
01468             for(y=block_w*mb_y; y<FFMIN(h,block_w*(mb_y+1)); y++){
01469                 for(x=0; x<w; x++){
01470                     int v= buf[x + y*w] + (128<<FRAC_BITS) + (1<<(FRAC_BITS-1));
01471                     v >>= FRAC_BITS;
01472                     if(v&(~255)) v= ~(v>>31);
01473                     dst8[x + y*ref_stride]= v;
01474                 }
01475             }
01476         }else{
01477             for(y=block_w*mb_y; y<FFMIN(h,block_w*(mb_y+1)); y++){
01478                 for(x=0; x<w; x++){
01479                     buf[x + y*w]-= 128<<FRAC_BITS;
01480                 }
01481             }
01482         }
01483 
01484         return;
01485     }
01486 
01487     for(mb_x=0; mb_x<=mb_w; mb_x++){
01488         add_yblock(s, 0, NULL, buf, dst8, obmc,
01489                    block_w*mb_x - block_w/2,
01490                    block_w*mb_y - block_w/2,
01491                    block_w, block_w,
01492                    w, h,
01493                    w, ref_stride, obmc_stride,
01494                    mb_x - 1, mb_y - 1,
01495                    add, 1, plane_index);
01496     }
01497 }
01498 
01499 static av_always_inline void predict_plane(SnowContext *s, IDWTELEM *buf, int plane_index, int add){
01500     const int mb_h= s->b_height << s->block_max_depth;
01501     int mb_y;
01502     for(mb_y=0; mb_y<=mb_h; mb_y++)
01503         predict_slice(s, buf, plane_index, add, mb_y);
01504 }
01505 
01506 static void dequantize_slice_buffered(SnowContext *s, slice_buffer * sb, SubBand *b, IDWTELEM *src, int stride, int start_y, int end_y){
01507     const int w= b->width;
01508     const int qlog= av_clip(s->qlog + b->qlog, 0, QROOT*16);
01509     const int qmul= qexp[qlog&(QROOT-1)]<<(qlog>>QSHIFT);
01510     const int qadd= (s->qbias*qmul)>>QBIAS_SHIFT;
01511     int x,y;
01512 
01513     if(s->qlog == LOSSLESS_QLOG) return;
01514 
01515     for(y=start_y; y<end_y; y++){
01516 //        DWTELEM * line = slice_buffer_get_line_from_address(sb, src + (y * stride));
01517         IDWTELEM * line = slice_buffer_get_line(sb, (y * b->stride_line) + b->buf_y_offset) + b->buf_x_offset;
01518         for(x=0; x<w; x++){
01519             int i= line[x];
01520             if(i<0){
01521                 line[x]= -((-i*qmul + qadd)>>(QEXPSHIFT)); //FIXME try different bias
01522             }else if(i>0){
01523                 line[x]=  (( i*qmul + qadd)>>(QEXPSHIFT));
01524             }
01525         }
01526     }
01527 }
01528 
01529 static void correlate_slice_buffered(SnowContext *s, slice_buffer * sb, SubBand *b, IDWTELEM *src, int stride, int inverse, int use_median, int start_y, int end_y){
01530     const int w= b->width;
01531     int x,y;
01532 
01533     IDWTELEM * line=0; // silence silly "could be used without having been initialized" warning
01534     IDWTELEM * prev;
01535 
01536     if (start_y != 0)
01537         line = slice_buffer_get_line(sb, ((start_y - 1) * b->stride_line) + b->buf_y_offset) + b->buf_x_offset;
01538 
01539     for(y=start_y; y<end_y; y++){
01540         prev = line;
01541 //        line = slice_buffer_get_line_from_address(sb, src + (y * stride));
01542         line = slice_buffer_get_line(sb, (y * b->stride_line) + b->buf_y_offset) + b->buf_x_offset;
01543         for(x=0; x<w; x++){
01544             if(x){
01545                 if(use_median){
01546                     if(y && x+1<w) line[x] += mid_pred(line[x - 1], prev[x], prev[x + 1]);
01547                     else  line[x] += line[x - 1];
01548                 }else{
01549                     if(y) line[x] += mid_pred(line[x - 1], prev[x], line[x - 1] + prev[x] - prev[x - 1]);
01550                     else  line[x] += line[x - 1];
01551                 }
01552             }else{
01553                 if(y) line[x] += prev[x];
01554             }
01555         }
01556     }
01557 }
01558 
01559 static void decode_qlogs(SnowContext *s){
01560     int plane_index, level, orientation;
01561 
01562     for(plane_index=0; plane_index<3; plane_index++){
01563         for(level=0; level<s->spatial_decomposition_count; level++){
01564             for(orientation=level ? 1:0; orientation<4; orientation++){
01565                 int q;
01566                 if     (plane_index==2) q= s->plane[1].band[level][orientation].qlog;
01567                 else if(orientation==2) q= s->plane[plane_index].band[level][1].qlog;
01568                 else                    q= get_symbol(&s->c, s->header_state, 1);
01569                 s->plane[plane_index].band[level][orientation].qlog= q;
01570             }
01571         }
01572     }
01573 }
01574 
01575 #define GET_S(dst, check) \
01576     tmp= get_symbol(&s->c, s->header_state, 0);\
01577     if(!(check)){\
01578         av_log(s->avctx, AV_LOG_ERROR, "Error " #dst " is %d\n", tmp);\
01579         return -1;\
01580     }\
01581     dst= tmp;
01582 
01583 static int decode_header(SnowContext *s){
01584     int plane_index, tmp;
01585     uint8_t kstate[32];
01586 
01587     memset(kstate, MID_STATE, sizeof(kstate));
01588 
01589     s->keyframe= get_rac(&s->c, kstate);
01590     if(s->keyframe || s->always_reset){
01591         reset_contexts(s);
01592         s->spatial_decomposition_type=
01593         s->qlog=
01594         s->qbias=
01595         s->mv_scale=
01596         s->block_max_depth= 0;
01597     }
01598     if(s->keyframe){
01599         GET_S(s->version, tmp <= 0U)
01600         s->always_reset= get_rac(&s->c, s->header_state);
01601         s->temporal_decomposition_type= get_symbol(&s->c, s->header_state, 0);
01602         s->temporal_decomposition_count= get_symbol(&s->c, s->header_state, 0);
01603         GET_S(s->spatial_decomposition_count, 0 < tmp && tmp <= MAX_DECOMPOSITIONS)
01604         s->colorspace_type= get_symbol(&s->c, s->header_state, 0);
01605         s->chroma_h_shift= get_symbol(&s->c, s->header_state, 0);
01606         s->chroma_v_shift= get_symbol(&s->c, s->header_state, 0);
01607         s->spatial_scalability= get_rac(&s->c, s->header_state);
01608 //        s->rate_scalability= get_rac(&s->c, s->header_state);
01609         GET_S(s->max_ref_frames, tmp < (unsigned)MAX_REF_FRAMES)
01610         s->max_ref_frames++;
01611 
01612         decode_qlogs(s);
01613     }
01614 
01615     if(!s->keyframe){
01616         if(get_rac(&s->c, s->header_state)){
01617             for(plane_index=0; plane_index<2; plane_index++){
01618                 int htaps, i, sum=0;
01619                 Plane *p= &s->plane[plane_index];
01620                 p->diag_mc= get_rac(&s->c, s->header_state);
01621                 htaps= get_symbol(&s->c, s->header_state, 0)*2 + 2;
01622                 if((unsigned)htaps > HTAPS_MAX || htaps==0)
01623                     return -1;
01624                 p->htaps= htaps;
01625                 for(i= htaps/2; i; i--){
01626                     p->hcoeff[i]= get_symbol(&s->c, s->header_state, 0) * (1-2*(i&1));
01627                     sum += p->hcoeff[i];
01628                 }
01629                 p->hcoeff[0]= 32-sum;
01630             }
01631             s->plane[2].diag_mc= s->plane[1].diag_mc;
01632             s->plane[2].htaps  = s->plane[1].htaps;
01633             memcpy(s->plane[2].hcoeff, s->plane[1].hcoeff, sizeof(s->plane[1].hcoeff));
01634         }
01635         if(get_rac(&s->c, s->header_state)){
01636             GET_S(s->spatial_decomposition_count, 0 < tmp && tmp <= MAX_DECOMPOSITIONS)
01637             decode_qlogs(s);
01638         }
01639     }
01640 
01641     s->spatial_decomposition_type+= get_symbol(&s->c, s->header_state, 1);
01642     if(s->spatial_decomposition_type > 1U){
01643         av_log(s->avctx, AV_LOG_ERROR, "spatial_decomposition_type %d not supported", s->spatial_decomposition_type);
01644         return -1;
01645     }
01646     if(FFMIN(s->avctx-> width>>s->chroma_h_shift,
01647              s->avctx->height>>s->chroma_v_shift) >> (s->spatial_decomposition_count-1) <= 0){
01648         av_log(s->avctx, AV_LOG_ERROR, "spatial_decomposition_count %d too large for size", s->spatial_decomposition_count);
01649         return -1;
01650     }
01651 
01652     s->qlog           += get_symbol(&s->c, s->header_state, 1);
01653     s->mv_scale       += get_symbol(&s->c, s->header_state, 1);
01654     s->qbias          += get_symbol(&s->c, s->header_state, 1);
01655     s->block_max_depth+= get_symbol(&s->c, s->header_state, 1);
01656     if(s->block_max_depth > 1 || s->block_max_depth < 0){
01657         av_log(s->avctx, AV_LOG_ERROR, "block_max_depth= %d is too large", s->block_max_depth);
01658         s->block_max_depth= 0;
01659         return -1;
01660     }
01661 
01662     return 0;
01663 }
01664 
01665 static void init_qexp(void){
01666     int i;
01667     double v=128;
01668 
01669     for(i=0; i<QROOT; i++){
01670         qexp[i]= lrintf(v);
01671         v *= pow(2, 1.0 / QROOT);
01672     }
01673 }
01674 
01675 static av_cold int common_init(AVCodecContext *avctx){
01676     SnowContext *s = avctx->priv_data;
01677     int width, height;
01678     int i, j;
01679 
01680     s->avctx= avctx;
01681     s->max_ref_frames=1; //just make sure its not an invalid value in case of no initial keyframe
01682 
01683     dsputil_init(&s->dsp, avctx);
01684     ff_dwt_init(&s->dwt);
01685 
01686 #define mcf(dx,dy)\
01687     s->dsp.put_qpel_pixels_tab       [0][dy+dx/4]=\
01688     s->dsp.put_no_rnd_qpel_pixels_tab[0][dy+dx/4]=\
01689         s->dsp.put_h264_qpel_pixels_tab[0][dy+dx/4];\
01690     s->dsp.put_qpel_pixels_tab       [1][dy+dx/4]=\
01691     s->dsp.put_no_rnd_qpel_pixels_tab[1][dy+dx/4]=\
01692         s->dsp.put_h264_qpel_pixels_tab[1][dy+dx/4];
01693 
01694     mcf( 0, 0)
01695     mcf( 4, 0)
01696     mcf( 8, 0)
01697     mcf(12, 0)
01698     mcf( 0, 4)
01699     mcf( 4, 4)
01700     mcf( 8, 4)
01701     mcf(12, 4)
01702     mcf( 0, 8)
01703     mcf( 4, 8)
01704     mcf( 8, 8)
01705     mcf(12, 8)
01706     mcf( 0,12)
01707     mcf( 4,12)
01708     mcf( 8,12)
01709     mcf(12,12)
01710 
01711 #define mcfh(dx,dy)\
01712     s->dsp.put_pixels_tab       [0][dy/4+dx/8]=\
01713     s->dsp.put_no_rnd_pixels_tab[0][dy/4+dx/8]=\
01714         mc_block_hpel ## dx ## dy ## 16;\
01715     s->dsp.put_pixels_tab       [1][dy/4+dx/8]=\
01716     s->dsp.put_no_rnd_pixels_tab[1][dy/4+dx/8]=\
01717         mc_block_hpel ## dx ## dy ## 8;
01718 
01719     mcfh(0, 0)
01720     mcfh(8, 0)
01721     mcfh(0, 8)
01722     mcfh(8, 8)
01723 
01724     if(!qexp[0])
01725         init_qexp();
01726 
01727 //    dec += FFMAX(s->chroma_h_shift, s->chroma_v_shift);
01728 
01729     width= s->avctx->width;
01730     height= s->avctx->height;
01731 
01732     s->spatial_idwt_buffer= av_mallocz(width*height*sizeof(IDWTELEM));
01733     s->spatial_dwt_buffer= av_mallocz(width*height*sizeof(DWTELEM)); //FIXME this does not belong here
01734 
01735     for(i=0; i<MAX_REF_FRAMES; i++)
01736         for(j=0; j<MAX_REF_FRAMES; j++)
01737             scale_mv_ref[i][j] = 256*(i+1)/(j+1);
01738 
01739     s->avctx->get_buffer(s->avctx, &s->mconly_picture);
01740     s->scratchbuf = av_malloc(s->mconly_picture.linesize[0]*7*MB_SIZE);
01741 
01742     return 0;
01743 }
01744 
01745 static int common_init_after_header(AVCodecContext *avctx){
01746     SnowContext *s = avctx->priv_data;
01747     int plane_index, level, orientation;
01748 
01749     for(plane_index=0; plane_index<3; plane_index++){
01750         int w= s->avctx->width;
01751         int h= s->avctx->height;
01752 
01753         if(plane_index){
01754             w>>= s->chroma_h_shift;
01755             h>>= s->chroma_v_shift;
01756         }
01757         s->plane[plane_index].width = w;
01758         s->plane[plane_index].height= h;
01759 
01760         for(level=s->spatial_decomposition_count-1; level>=0; level--){
01761             for(orientation=level ? 1 : 0; orientation<4; orientation++){
01762                 SubBand *b= &s->plane[plane_index].band[level][orientation];
01763 
01764                 b->buf= s->spatial_dwt_buffer;
01765                 b->level= level;
01766                 b->stride= s->plane[plane_index].width << (s->spatial_decomposition_count - level);
01767                 b->width = (w + !(orientation&1))>>1;
01768                 b->height= (h + !(orientation>1))>>1;
01769 
01770                 b->stride_line = 1 << (s->spatial_decomposition_count - level);
01771                 b->buf_x_offset = 0;
01772                 b->buf_y_offset = 0;
01773 
01774                 if(orientation&1){
01775                     b->buf += (w+1)>>1;
01776                     b->buf_x_offset = (w+1)>>1;
01777                 }
01778                 if(orientation>1){
01779                     b->buf += b->stride>>1;
01780                     b->buf_y_offset = b->stride_line >> 1;
01781                 }
01782                 b->ibuf= s->spatial_idwt_buffer + (b->buf - s->spatial_dwt_buffer);
01783 
01784                 if(level)
01785                     b->parent= &s->plane[plane_index].band[level-1][orientation];
01786                 //FIXME avoid this realloc
01787                 av_freep(&b->x_coeff);
01788                 b->x_coeff=av_mallocz(((b->width+1) * b->height+1)*sizeof(x_and_coeff));
01789             }
01790             w= (w+1)>>1;
01791             h= (h+1)>>1;
01792         }
01793     }
01794 
01795     return 0;
01796 }
01797 
01798 #define QUANTIZE2 0
01799 
01800 #if QUANTIZE2==1
01801 #define Q2_STEP 8
01802 
01803 static void find_sse(SnowContext *s, Plane *p, int *score, int score_stride, IDWTELEM *r0, IDWTELEM *r1, int level, int orientation){
01804     SubBand *b= &p->band[level][orientation];
01805     int x, y;
01806     int xo=0;
01807     int yo=0;
01808     int step= 1 << (s->spatial_decomposition_count - level);
01809 
01810     if(orientation&1)
01811         xo= step>>1;
01812     if(orientation&2)
01813         yo= step>>1;
01814 
01815     //FIXME bias for nonzero ?
01816     //FIXME optimize
01817     memset(score, 0, sizeof(*score)*score_stride*((p->height + Q2_STEP-1)/Q2_STEP));
01818     for(y=0; y<p->height; y++){
01819         for(x=0; x<p->width; x++){
01820             int sx= (x-xo + step/2) / step / Q2_STEP;
01821             int sy= (y-yo + step/2) / step / Q2_STEP;
01822             int v= r0[x + y*p->width] - r1[x + y*p->width];
01823             assert(sx>=0 && sy>=0 && sx < score_stride);
01824             v= ((v+8)>>4)<<4;
01825             score[sx + sy*score_stride] += v*v;
01826             assert(score[sx + sy*score_stride] >= 0);
01827         }
01828     }
01829 }
01830 
01831 static void dequantize_all(SnowContext *s, Plane *p, IDWTELEM *buffer, int width, int height){
01832     int level, orientation;
01833 
01834     for(level=0; level<s->spatial_decomposition_count; level++){
01835         for(orientation=level ? 1 : 0; orientation<4; orientation++){
01836             SubBand *b= &p->band[level][orientation];
01837             IDWTELEM *dst= buffer + (b->ibuf - s->spatial_idwt_buffer);
01838 
01839             dequantize(s, b, dst, b->stride);
01840         }
01841     }
01842 }
01843 
01844 static void dwt_quantize(SnowContext *s, Plane *p, DWTELEM *buffer, int width, int height, int stride, int type){
01845     int level, orientation, ys, xs, x, y, pass;
01846     IDWTELEM best_dequant[height * stride];
01847     IDWTELEM idwt2_buffer[height * stride];
01848     const int score_stride= (width + 10)/Q2_STEP;
01849     int best_score[(width + 10)/Q2_STEP * (height + 10)/Q2_STEP]; //FIXME size
01850     int score[(width + 10)/Q2_STEP * (height + 10)/Q2_STEP]; //FIXME size
01851     int threshold= (s->m.lambda * s->m.lambda) >> 6;
01852 
01853     //FIXME pass the copy cleanly ?
01854 
01855 //    memcpy(dwt_buffer, buffer, height * stride * sizeof(DWTELEM));
01856     ff_spatial_dwt(buffer, width, height, stride, type, s->spatial_decomposition_count);
01857 
01858     for(level=0; level<s->spatial_decomposition_count; level++){
01859         for(orientation=level ? 1 : 0; orientation<4; orientation++){
01860             SubBand *b= &p->band[level][orientation];
01861             IDWTELEM *dst= best_dequant + (b->ibuf - s->spatial_idwt_buffer);
01862              DWTELEM *src=       buffer + (b-> buf - s->spatial_dwt_buffer);
01863             assert(src == b->buf); // code does not depend on this but it is true currently
01864 
01865             quantize(s, b, dst, src, b->stride, s->qbias);
01866         }
01867     }
01868     for(pass=0; pass<1; pass++){
01869         if(s->qbias == 0) //keyframe
01870             continue;
01871         for(level=0; level<s->spatial_decomposition_count; level++){
01872             for(orientation=level ? 1 : 0; orientation<4; orientation++){
01873                 SubBand *b= &p->band[level][orientation];
01874                 IDWTELEM *dst= idwt2_buffer + (b->ibuf - s->spatial_idwt_buffer);
01875                 IDWTELEM *best_dst= best_dequant + (b->ibuf - s->spatial_idwt_buffer);
01876 
01877                 for(ys= 0; ys<Q2_STEP; ys++){
01878                     for(xs= 0; xs<Q2_STEP; xs++){
01879                         memcpy(idwt2_buffer, best_dequant, height * stride * sizeof(IDWTELEM));
01880                         dequantize_all(s, p, idwt2_buffer, width, height);
01881                         ff_spatial_idwt(idwt2_buffer, width, height, stride, type, s->spatial_decomposition_count);
01882                         find_sse(s, p, best_score, score_stride, idwt2_buffer, s->spatial_idwt_buffer, level, orientation);
01883                         memcpy(idwt2_buffer, best_dequant, height * stride * sizeof(IDWTELEM));
01884                         for(y=ys; y<b->height; y+= Q2_STEP){
01885                             for(x=xs; x<b->width; x+= Q2_STEP){
01886                                 if(dst[x + y*b->stride]<0) dst[x + y*b->stride]++;
01887                                 if(dst[x + y*b->stride]>0) dst[x + y*b->stride]--;
01888                                 //FIXME try more than just --
01889                             }
01890                         }
01891                         dequantize_all(s, p, idwt2_buffer, width, height);
01892                         ff_spatial_idwt(idwt2_buffer, width, height, stride, type, s->spatial_decomposition_count);
01893                         find_sse(s, p, score, score_stride, idwt2_buffer, s->spatial_idwt_buffer, level, orientation);
01894                         for(y=ys; y<b->height; y+= Q2_STEP){
01895                             for(x=xs; x<b->width; x+= Q2_STEP){
01896                                 int score_idx= x/Q2_STEP + (y/Q2_STEP)*score_stride;
01897                                 if(score[score_idx] <= best_score[score_idx] + threshold){
01898                                     best_score[score_idx]= score[score_idx];
01899                                     if(best_dst[x + y*b->stride]<0) best_dst[x + y*b->stride]++;
01900                                     if(best_dst[x + y*b->stride]>0) best_dst[x + y*b->stride]--;
01901                                     //FIXME copy instead
01902                                 }
01903                             }
01904                         }
01905                     }
01906                 }
01907             }
01908         }
01909     }
01910     memcpy(s->spatial_idwt_buffer, best_dequant, height * stride * sizeof(IDWTELEM)); //FIXME work with that directly instead of copy at the end
01911 }
01912 
01913 #endif /* QUANTIZE2==1 */
01914 
01915 #define USE_HALFPEL_PLANE 0
01916 
01917 static void halfpel_interpol(SnowContext *s, uint8_t *halfpel[4][4], AVFrame *frame){
01918     int p,x,y;
01919 
01920     for(p=0; p<3; p++){
01921         int is_chroma= !!p;
01922         int w= s->avctx->width  >>is_chroma;
01923         int h= s->avctx->height >>is_chroma;
01924         int ls= frame->linesize[p];
01925         uint8_t *src= frame->data[p];
01926 
01927         halfpel[1][p]= (uint8_t*)av_malloc(ls * (h+2*EDGE_WIDTH)) + EDGE_WIDTH*(1+ls);
01928         halfpel[2][p]= (uint8_t*)av_malloc(ls * (h+2*EDGE_WIDTH)) + EDGE_WIDTH*(1+ls);
01929         halfpel[3][p]= (uint8_t*)av_malloc(ls * (h+2*EDGE_WIDTH)) + EDGE_WIDTH*(1+ls);
01930 
01931         halfpel[0][p]= src;
01932         for(y=0; y<h; y++){
01933             for(x=0; x<w; x++){
01934                 int i= y*ls + x;
01935 
01936                 halfpel[1][p][i]= (20*(src[i] + src[i+1]) - 5*(src[i-1] + src[i+2]) + (src[i-2] + src[i+3]) + 16 )>>5;
01937             }
01938         }
01939         for(y=0; y<h; y++){
01940             for(x=0; x<w; x++){
01941                 int i= y*ls + x;
01942 
01943                 halfpel[2][p][i]= (20*(src[i] + src[i+ls]) - 5*(src[i-ls] + src[i+2*ls]) + (src[i-2*ls] + src[i+3*ls]) + 16 )>>5;
01944             }
01945         }
01946         src= halfpel[1][p];
01947         for(y=0; y<h; y++){
01948             for(x=0; x<w; x++){
01949                 int i= y*ls + x;
01950 
01951                 halfpel[3][p][i]= (20*(src[i] + src[i+ls]) - 5*(src[i-ls] + src[i+2*ls]) + (src[i-2*ls] + src[i+3*ls]) + 16 )>>5;
01952             }
01953         }
01954 
01955 //FIXME border!
01956     }
01957 }
01958 
01959 static void release_buffer(AVCodecContext *avctx){
01960     SnowContext *s = avctx->priv_data;
01961     int i;
01962 
01963     if(s->last_picture[s->max_ref_frames-1].data[0]){
01964         avctx->release_buffer(avctx, &s->last_picture[s->max_ref_frames-1]);
01965         for(i=0; i<9; i++)
01966             if(s->halfpel_plane[s->max_ref_frames-1][1+i/3][i%3])
01967                 av_free(s->halfpel_plane[s->max_ref_frames-1][1+i/3][i%3] - EDGE_WIDTH*(1+s->current_picture.linesize[i%3]));
01968     }
01969 }
01970 
01971 static int frame_start(SnowContext *s){
01972    AVFrame tmp;
01973    int w= s->avctx->width; //FIXME round up to x16 ?
01974    int h= s->avctx->height;
01975 
01976     if(s->current_picture.data[0] && !(s->avctx->flags&CODEC_FLAG_EMU_EDGE)){
01977         s->dsp.draw_edges(s->current_picture.data[0],
01978                           s->current_picture.linesize[0], w   , h   ,
01979                           EDGE_WIDTH  , EDGE_WIDTH  , EDGE_TOP | EDGE_BOTTOM);
01980         s->dsp.draw_edges(s->current_picture.data[1],
01981                           s->current_picture.linesize[1], w>>1, h>>1,
01982                           EDGE_WIDTH/2, EDGE_WIDTH/2, EDGE_TOP | EDGE_BOTTOM);
01983         s->dsp.draw_edges(s->current_picture.data[2],
01984                           s->current_picture.linesize[2], w>>1, h>>1,
01985                           EDGE_WIDTH/2, EDGE_WIDTH/2, EDGE_TOP | EDGE_BOTTOM);
01986     }
01987 
01988     release_buffer(s->avctx);
01989 
01990     tmp= s->last_picture[s->max_ref_frames-1];
01991     memmove(s->last_picture+1, s->last_picture, (s->max_ref_frames-1)*sizeof(AVFrame));
01992     memmove(s->halfpel_plane+1, s->halfpel_plane, (s->max_ref_frames-1)*sizeof(void*)*4*4);
01993     if(USE_HALFPEL_PLANE && s->current_picture.data[0])
01994         halfpel_interpol(s, s->halfpel_plane[0], &s->current_picture);
01995     s->last_picture[0]= s->current_picture;
01996     s->current_picture= tmp;
01997 
01998     if(s->keyframe){
01999         s->ref_frames= 0;
02000     }else{
02001         int i;
02002         for(i=0; i<s->max_ref_frames && s->last_picture[i].data[0]; i++)
02003             if(i && s->last_picture[i-1].key_frame)
02004                 break;
02005         s->ref_frames= i;
02006         if(s->ref_frames==0){
02007             av_log(s->avctx,AV_LOG_ERROR, "No reference frames\n");
02008             return -1;
02009         }
02010     }
02011 
02012     s->current_picture.reference= 1;
02013     if(s->avctx->get_buffer(s->avctx, &s->current_picture) < 0){
02014         av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed\n");
02015         return -1;
02016     }
02017 
02018     s->current_picture.key_frame= s->keyframe;
02019 
02020     return 0;
02021 }
02022 
02023 static av_cold void common_end(SnowContext *s){
02024     int plane_index, level, orientation, i;
02025 
02026     av_freep(&s->spatial_dwt_buffer);
02027     av_freep(&s->spatial_idwt_buffer);
02028 
02029     s->m.me.temp= NULL;
02030     av_freep(&s->m.me.scratchpad);
02031     av_freep(&s->m.me.map);
02032     av_freep(&s->m.me.score_map);
02033     av_freep(&s->m.obmc_scratchpad);
02034 
02035     av_freep(&s->block);
02036     av_freep(&s->scratchbuf);
02037 
02038     for(i=0; i<MAX_REF_FRAMES; i++){
02039         av_freep(&s->ref_mvs[i]);
02040         av_freep(&s->ref_scores[i]);
02041         if(s->last_picture[i].data[0])
02042             s->avctx->release_buffer(s->avctx, &s->last_picture[i]);
02043     }
02044 
02045     for(plane_index=0; plane_index<3; plane_index++){
02046         for(level=s->spatial_decomposition_count-1; level>=0; level--){
02047             for(orientation=level ? 1 : 0; orientation<4; orientation++){
02048                 SubBand *b= &s->plane[plane_index].band[level][orientation];
02049 
02050                 av_freep(&b->x_coeff);
02051             }
02052         }
02053     }
02054     if (s->mconly_picture.data[0])
02055         s->avctx->release_buffer(s->avctx, &s->mconly_picture);
02056     if (s->current_picture.data[0])
02057         s->avctx->release_buffer(s->avctx, &s->current_picture);
02058 }
02059 
02060 static av_cold int decode_init(AVCodecContext *avctx)
02061 {
02062     avctx->pix_fmt= PIX_FMT_YUV420P;
02063 
02064     common_init(avctx);
02065 
02066     return 0;
02067 }
02068 
02069 static int decode_frame(AVCodecContext *avctx, void *data, int *data_size, AVPacket *avpkt){
02070     const uint8_t *buf = avpkt->data;
02071     int buf_size = avpkt->size;
02072     SnowContext *s = avctx->priv_data;
02073     RangeCoder * const c= &s->c;
02074     int bytes_read;
02075     AVFrame *picture = data;
02076     int level, orientation, plane_index;
02077 
02078     ff_init_range_decoder(c, buf, buf_size);
02079     ff_build_rac_states(c, 0.05*(1LL<<32), 256-8);
02080 
02081     s->current_picture.pict_type= AV_PICTURE_TYPE_I; //FIXME I vs. P
02082     if(decode_header(s)<0)
02083         return -1;
02084     common_init_after_header(avctx);
02085 
02086     // realloc slice buffer for the case that spatial_decomposition_count changed
02087     ff_slice_buffer_destroy(&s->sb);
02088     ff_slice_buffer_init(&s->sb, s->plane[0].height, (MB_SIZE >> s->block_max_depth) + s->spatial_decomposition_count * 8 + 1, s->plane[0].width, s->spatial_idwt_buffer);
02089 
02090     for(plane_index=0; plane_index<3; plane_index++){
02091         Plane *p= &s->plane[plane_index];
02092         p->fast_mc= p->diag_mc && p->htaps==6 && p->hcoeff[0]==40
02093                                               && p->hcoeff[1]==-10
02094                                               && p->hcoeff[2]==2;
02095     }
02096 
02097     alloc_blocks(s);
02098 
02099     if(frame_start(s) < 0)
02100         return -1;
02101     //keyframe flag duplication mess FIXME
02102     if(avctx->debug&FF_DEBUG_PICT_INFO)
02103         av_log(avctx, AV_LOG_ERROR, "keyframe:%d qlog:%d\n", s->keyframe, s->qlog);
02104 
02105     decode_blocks(s);
02106 
02107     for(plane_index=0; plane_index<3; plane_index++){
02108         Plane *p= &s->plane[plane_index];
02109         int w= p->width;
02110         int h= p->height;
02111         int x, y;
02112         int decode_state[MAX_DECOMPOSITIONS][4][1]; /* Stored state info for unpack_coeffs. 1 variable per instance. */
02113 
02114         if(s->avctx->debug&2048){
02115             memset(s->spatial_dwt_buffer, 0, sizeof(DWTELEM)*w*h);
02116             predict_plane(s, s->spatial_idwt_buffer, plane_index, 1);
02117 
02118             for(y=0; y<h; y++){
02119                 for(x=0; x<w; x++){
02120                     int v= s->current_picture.data[plane_index][y*s->current_picture.linesize[plane_index] + x];
02121                     s->mconly_picture.data[plane_index][y*s->mconly_picture.linesize[plane_index] + x]= v;
02122                 }
02123             }
02124         }
02125 
02126         {
02127         for(level=0; level<s->spatial_decomposition_count; level++){
02128             for(orientation=level ? 1 : 0; orientation<4; orientation++){
02129                 SubBand *b= &p->band[level][orientation];
02130                 unpack_coeffs(s, b, b->parent, orientation);
02131             }
02132         }
02133         }
02134 
02135         {
02136         const int mb_h= s->b_height << s->block_max_depth;
02137         const int block_size = MB_SIZE >> s->block_max_depth;
02138         const int block_w    = plane_index ? block_size/2 : block_size;
02139         int mb_y;
02140         DWTCompose cs[MAX_DECOMPOSITIONS];
02141         int yd=0, yq=0;
02142         int y;
02143         int end_y;
02144 
02145         ff_spatial_idwt_buffered_init(cs, &s->sb, w, h, 1, s->spatial_decomposition_type, s->spatial_decomposition_count);
02146         for(mb_y=0; mb_y<=mb_h; mb_y++){
02147 
02148             int slice_starty = block_w*mb_y;
02149             int slice_h = block_w*(mb_y+1);
02150             if (!(s->keyframe || s->avctx->debug&512)){
02151                 slice_starty = FFMAX(0, slice_starty - (block_w >> 1));
02152                 slice_h -= (block_w >> 1);
02153             }
02154 
02155             for(level=0; level<s->spatial_decomposition_count; level++){
02156                 for(orientation=level ? 1 : 0; orientation<4; orientation++){
02157                     SubBand *b= &p->band[level][orientation];
02158                     int start_y;
02159                     int end_y;
02160                     int our_mb_start = mb_y;
02161                     int our_mb_end = (mb_y + 1);
02162                     const int extra= 3;
02163                     start_y = (mb_y ? ((block_w * our_mb_start) >> (s->spatial_decomposition_count - level)) + s->spatial_decomposition_count - level + extra: 0);
02164                     end_y = (((block_w * our_mb_end) >> (s->spatial_decomposition_count - level)) + s->spatial_decomposition_count - level + extra);
02165                     if (!(s->keyframe || s->avctx->debug&512)){
02166                         start_y = FFMAX(0, start_y - (block_w >> (1+s->spatial_decomposition_count - level)));
02167                         end_y = FFMAX(0, end_y - (block_w >> (1+s->spatial_decomposition_count - level)));
02168                     }
02169                     start_y = FFMIN(b->height, start_y);
02170                     end_y = FFMIN(b->height, end_y);
02171 
02172                     if (start_y != end_y){
02173                         if (orientation == 0){
02174                             SubBand * correlate_band = &p->band[0][0];
02175                             int correlate_end_y = FFMIN(b->height, end_y + 1);
02176                             int correlate_start_y = FFMIN(b->height, (start_y ? start_y + 1 : 0));
02177                             decode_subband_slice_buffered(s, correlate_band, &s->sb, correlate_start_y, correlate_end_y, decode_state[0][0]);
02178                             correlate_slice_buffered(s, &s->sb, correlate_band, correlate_band->ibuf, correlate_band->stride, 1, 0, correlate_start_y, correlate_end_y);
02179                             dequantize_slice_buffered(s, &s->sb, correlate_band, correlate_band->ibuf, correlate_band->stride, start_y, end_y);
02180                         }
02181                         else
02182                             decode_subband_slice_buffered(s, b, &s->sb, start_y, end_y, decode_state[level][orientation]);
02183                     }
02184                 }
02185             }
02186 
02187             for(; yd<slice_h; yd+=4){
02188                 ff_spatial_idwt_buffered_slice(&s->dwt, cs, &s->sb, w, h, 1, s->spatial_decomposition_type, s->spatial_decomposition_count, yd);
02189             }
02190 
02191             if(s->qlog == LOSSLESS_QLOG){
02192                 for(; yq<slice_h && yq<h; yq++){
02193                     IDWTELEM * line = slice_buffer_get_line(&s->sb, yq);
02194                     for(x=0; x<w; x++){
02195                         line[x] <<= FRAC_BITS;
02196                     }
02197                 }
02198             }
02199 
02200             predict_slice_buffered(s, &s->sb, s->spatial_idwt_buffer, plane_index, 1, mb_y);
02201 
02202             y = FFMIN(p->height, slice_starty);
02203             end_y = FFMIN(p->height, slice_h);
02204             while(y < end_y)
02205                 ff_slice_buffer_release(&s->sb, y++);
02206         }
02207 
02208         ff_slice_buffer_flush(&s->sb);
02209         }
02210 
02211     }
02212 
02213     emms_c();
02214 
02215     release_buffer(avctx);
02216 
02217     if(!(s->avctx->debug&2048))
02218         *picture= s->current_picture;
02219     else
02220         *picture= s->mconly_picture;
02221 
02222     *data_size = sizeof(AVFrame);
02223 
02224     bytes_read= c->bytestream - c->bytestream_start;
02225     if(bytes_read ==0) av_log(s->avctx, AV_LOG_ERROR, "error at end of frame\n"); //FIXME
02226 
02227     return bytes_read;
02228 }
02229 
02230 static av_cold int decode_end(AVCodecContext *avctx)
02231 {
02232     SnowContext *s = avctx->priv_data;
02233 
02234     ff_slice_buffer_destroy(&s->sb);
02235 
02236     common_end(s);
02237 
02238     return 0;
02239 }
02240 
02241 AVCodec ff_snow_decoder = {
02242     "snow",
02243     AVMEDIA_TYPE_VIDEO,
02244     CODEC_ID_SNOW,
02245     sizeof(SnowContext),
02246     decode_init,
02247     NULL,
02248     decode_end,
02249     decode_frame,
02250     CODEC_CAP_DR1 /*| CODEC_CAP_DRAW_HORIZ_BAND*/,
02251     NULL,
02252     .long_name = NULL_IF_CONFIG_SMALL("Snow"),
02253 };
02254 
02255 #if CONFIG_SNOW_ENCODER
02256 static av_cold int encode_init(AVCodecContext *avctx)
02257 {
02258     SnowContext *s = avctx->priv_data;
02259     int plane_index;
02260 
02261     if(avctx->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL){
02262         av_log(avctx, AV_LOG_ERROR, "This codec is under development, files encoded with it may not be decodable with future versions!!!\n"
02263                "Use vstrict=-2 / -strict -2 to use it anyway.\n");
02264         return -1;
02265     }
02266 
02267     if(avctx->prediction_method == DWT_97
02268        && (avctx->flags & CODEC_FLAG_QSCALE)
02269        && avctx->global_quality == 0){
02270         av_log(avctx, AV_LOG_ERROR, "The 9/7 wavelet is incompatible with lossless mode.\n");
02271         return -1;
02272     }
02273 
02274     s->spatial_decomposition_type= avctx->prediction_method; //FIXME add decorrelator type r transform_type
02275 
02276     s->mv_scale       = (avctx->flags & CODEC_FLAG_QPEL) ? 2 : 4;
02277     s->block_max_depth= (avctx->flags & CODEC_FLAG_4MV ) ? 1 : 0;
02278 
02279     for(plane_index=0; plane_index<3; plane_index++){
02280         s->plane[plane_index].diag_mc= 1;
02281         s->plane[plane_index].htaps= 6;
02282         s->plane[plane_index].hcoeff[0]=  40;
02283         s->plane[plane_index].hcoeff[1]= -10;
02284         s->plane[plane_index].hcoeff[2]=   2;
02285         s->plane[plane_index].fast_mc= 1;
02286     }
02287 
02288     common_init(avctx);
02289     alloc_blocks(s);
02290 
02291     s->version=0;
02292 
02293     s->m.avctx   = avctx;
02294     s->m.flags   = avctx->flags;
02295     s->m.bit_rate= avctx->bit_rate;
02296 
02297     s->m.me.temp      =
02298     s->m.me.scratchpad= av_mallocz((avctx->width+64)*2*16*2*sizeof(uint8_t));
02299     s->m.me.map       = av_mallocz(ME_MAP_SIZE*sizeof(uint32_t));
02300     s->m.me.score_map = av_mallocz(ME_MAP_SIZE*sizeof(uint32_t));
02301     s->m.obmc_scratchpad= av_mallocz(MB_SIZE*MB_SIZE*12*sizeof(uint32_t));
02302     ff_h263_encode_init(&s->m); //mv_penalty
02303 
02304     s->max_ref_frames = FFMAX(FFMIN(avctx->refs, MAX_REF_FRAMES), 1);
02305 
02306     if(avctx->flags&CODEC_FLAG_PASS1){
02307         if(!avctx->stats_out)
02308             avctx->stats_out = av_mallocz(256);
02309     }
02310     if((avctx->flags&CODEC_FLAG_PASS2) || !(avctx->flags&CODEC_FLAG_QSCALE)){
02311         if(ff_rate_control_init(&s->m) < 0)
02312             return -1;
02313     }
02314     s->pass1_rc= !(avctx->flags & (CODEC_FLAG_QSCALE|CODEC_FLAG_PASS2));
02315 
02316     avctx->coded_frame= &s->current_picture;
02317     switch(avctx->pix_fmt){
02318 //    case PIX_FMT_YUV444P:
02319 //    case PIX_FMT_YUV422P:
02320     case PIX_FMT_YUV420P:
02321     case PIX_FMT_GRAY8:
02322 //    case PIX_FMT_YUV411P:
02323 //    case PIX_FMT_YUV410P:
02324         s->colorspace_type= 0;
02325         break;
02326 /*    case PIX_FMT_RGB32:
02327         s->colorspace= 1;
02328         break;*/
02329     default:
02330         av_log(avctx, AV_LOG_ERROR, "pixel format not supported\n");
02331         return -1;
02332     }
02333 //    avcodec_get_chroma_sub_sample(avctx->pix_fmt, &s->chroma_h_shift, &s->chroma_v_shift);
02334     s->chroma_h_shift= 1;
02335     s->chroma_v_shift= 1;
02336 
02337     ff_set_cmp(&s->dsp, s->dsp.me_cmp, s->avctx->me_cmp);
02338     ff_set_cmp(&s->dsp, s->dsp.me_sub_cmp, s->avctx->me_sub_cmp);
02339 
02340     s->avctx->get_buffer(s->avctx, &s->input_picture);
02341 
02342     if(s->avctx->me_method == ME_ITER){
02343         int i;
02344         int size= s->b_width * s->b_height << 2*s->block_max_depth;
02345         for(i=0; i<s->max_ref_frames; i++){
02346             s->ref_mvs[i]= av_mallocz(size*sizeof(int16_t[2]));
02347             s->ref_scores[i]= av_mallocz(size*sizeof(uint32_t));
02348         }
02349     }
02350 
02351     return 0;
02352 }
02353 
02354 //near copy & paste from dsputil, FIXME
02355 static int pix_sum(uint8_t * pix, int line_size, int w)
02356 {
02357     int s, i, j;
02358 
02359     s = 0;
02360     for (i = 0; i < w; i++) {
02361         for (j = 0; j < w; j++) {
02362             s += pix[0];
02363             pix ++;
02364         }
02365         pix += line_size - w;
02366     }
02367     return s;
02368 }
02369 
02370 //near copy & paste from dsputil, FIXME
02371 static int pix_norm1(uint8_t * pix, int line_size, int w)
02372 {
02373     int s, i, j;
02374     uint32_t *sq = ff_squareTbl + 256;
02375 
02376     s = 0;
02377     for (i = 0; i < w; i++) {
02378         for (j = 0; j < w; j ++) {
02379             s += sq[pix[0]];
02380             pix ++;
02381         }
02382         pix += line_size - w;
02383     }
02384     return s;
02385 }
02386 
02387 //FIXME copy&paste
02388 #define P_LEFT P[1]
02389 #define P_TOP P[2]
02390 #define P_TOPRIGHT P[3]
02391 #define P_MEDIAN P[4]
02392 #define P_MV1 P[9]
02393 #define FLAG_QPEL   1 //must be 1
02394 
02395 static int encode_q_branch(SnowContext *s, int level, int x, int y){
02396     uint8_t p_buffer[1024];
02397     uint8_t i_buffer[1024];
02398     uint8_t p_state[sizeof(s->block_state)];
02399     uint8_t i_state[sizeof(s->block_state)];
02400     RangeCoder pc, ic;
02401     uint8_t *pbbak= s->c.bytestream;
02402     uint8_t *pbbak_start= s->c.bytestream_start;
02403     int score, score2, iscore, i_len, p_len, block_s, sum, base_bits;
02404     const int w= s->b_width  << s->block_max_depth;
02405     const int h= s->b_height << s->block_max_depth;
02406     const int rem_depth= s->block_max_depth - level;
02407     const int index= (x + y*w) << rem_depth;
02408     const int block_w= 1<<(LOG2_MB_SIZE - level);
02409     int trx= (x+1)<<rem_depth;
02410     int try= (y+1)<<rem_depth;
02411     const BlockNode *left  = x ? &s->block[index-1] : &null_block;
02412     const BlockNode *top   = y ? &s->block[index-w] : &null_block;
02413     const BlockNode *right = trx<w ? &s->block[index+1] : &null_block;
02414     const BlockNode *bottom= try<h ? &s->block[index+w] : &null_block;
02415     const BlockNode *tl    = y && x ? &s->block[index-w-1] : left;
02416     const BlockNode *tr    = y && trx<w && ((x&1)==0 || level==0) ? &s->block[index-w+(1<<rem_depth)] : tl; //FIXME use lt
02417     int pl = left->color[0];
02418     int pcb= left->color[1];
02419     int pcr= left->color[2];
02420     int pmx, pmy;
02421     int mx=0, my=0;
02422     int l,cr,cb;
02423     const int stride= s->current_picture.linesize[0];
02424     const int uvstride= s->current_picture.linesize[1];
02425     uint8_t *current_data[3]= { s->input_picture.data[0] + (x + y*  stride)*block_w,
02426                                 s->input_picture.data[1] + (x + y*uvstride)*block_w/2,
02427                                 s->input_picture.data[2] + (x + y*uvstride)*block_w/2};
02428     int P[10][2];
02429     int16_t last_mv[3][2];
02430     int qpel= !!(s->avctx->flags & CODEC_FLAG_QPEL); //unused
02431     const int shift= 1+qpel;
02432     MotionEstContext *c= &s->m.me;
02433     int ref_context= av_log2(2*left->ref) + av_log2(2*top->ref);
02434     int mx_context= av_log2(2*FFABS(left->mx - top->mx));
02435     int my_context= av_log2(2*FFABS(left->my - top->my));
02436     int s_context= 2*left->level + 2*top->level + tl->level + tr->level;
02437     int ref, best_ref, ref_score, ref_mx, ref_my;
02438 
02439     assert(sizeof(s->block_state) >= 256);
02440     if(s->keyframe){
02441         set_blocks(s, level, x, y, pl, pcb, pcr, 0, 0, 0, BLOCK_INTRA);
02442         return 0;
02443     }
02444 
02445 //    clip predictors / edge ?
02446 
02447     P_LEFT[0]= left->mx;
02448     P_LEFT[1]= left->my;
02449     P_TOP [0]= top->mx;
02450     P_TOP [1]= top->my;
02451     P_TOPRIGHT[0]= tr->mx;
02452     P_TOPRIGHT[1]= tr->my;
02453 
02454     last_mv[0][0]= s->block[index].mx;
02455     last_mv[0][1]= s->block[index].my;
02456     last_mv[1][0]= right->mx;
02457     last_mv[1][1]= right->my;
02458     last_mv[2][0]= bottom->mx;
02459     last_mv[2][1]= bottom->my;
02460 
02461     s->m.mb_stride=2;
02462     s->m.mb_x=
02463     s->m.mb_y= 0;
02464     c->skip= 0;
02465 
02466     assert(c->  stride ==   stride);
02467     assert(c->uvstride == uvstride);
02468 
02469     c->penalty_factor    = get_penalty_factor(s->lambda, s->lambda2, c->avctx->me_cmp);
02470     c->sub_penalty_factor= get_penalty_factor(s->lambda, s->lambda2, c->avctx->me_sub_cmp);
02471     c->mb_penalty_factor = get_penalty_factor(s->lambda, s->lambda2, c->avctx->mb_cmp);
02472     c->current_mv_penalty= c->mv_penalty[s->m.f_code=1] + MAX_MV;
02473 
02474     c->xmin = - x*block_w - 16+3;
02475     c->ymin = - y*block_w - 16+3;
02476     c->xmax = - (x+1)*block_w + (w<<(LOG2_MB_SIZE - s->block_max_depth)) + 16-3;
02477     c->ymax = - (y+1)*block_w + (h<<(LOG2_MB_SIZE - s->block_max_depth)) + 16-3;
02478 
02479     if(P_LEFT[0]     > (c->xmax<<shift)) P_LEFT[0]    = (c->xmax<<shift);
02480     if(P_LEFT[1]     > (c->ymax<<shift)) P_LEFT[1]    = (c->ymax<<shift);
02481     if(P_TOP[0]      > (c->xmax<<shift)) P_TOP[0]     = (c->xmax<<shift);
02482     if(P_TOP[1]      > (c->ymax<<shift)) P_TOP[1]     = (c->ymax<<shift);
02483     if(P_TOPRIGHT[0] < (c->xmin<<shift)) P_TOPRIGHT[0]= (c->xmin<<shift);
02484     if(P_TOPRIGHT[0] > (c->xmax<<shift)) P_TOPRIGHT[0]= (c->xmax<<shift); //due to pmx no clip
02485     if(P_TOPRIGHT[1] > (c->ymax<<shift)) P_TOPRIGHT[1]= (c->ymax<<shift);
02486 
02487     P_MEDIAN[0]= mid_pred(P_LEFT[0], P_TOP[0], P_TOPRIGHT[0]);
02488     P_MEDIAN[1]= mid_pred(P_LEFT[1], P_TOP[1], P_TOPRIGHT[1]);
02489 
02490     if (!y) {
02491         c->pred_x= P_LEFT[0];
02492         c->pred_y= P_LEFT[1];
02493     } else {
02494         c->pred_x = P_MEDIAN[0];
02495         c->pred_y = P_MEDIAN[1];
02496     }
02497 
02498     score= INT_MAX;
02499     best_ref= 0;
02500     for(ref=0; ref<s->ref_frames; ref++){
02501         init_ref(c, current_data, s->last_picture[ref].data, NULL, block_w*x, block_w*y, 0);
02502 
02503         ref_score= ff_epzs_motion_search(&s->m, &ref_mx, &ref_my, P, 0, /*ref_index*/ 0, last_mv,
02504                                          (1<<16)>>shift, level-LOG2_MB_SIZE+4, block_w);
02505 
02506         assert(ref_mx >= c->xmin);
02507         assert(ref_mx <= c->xmax);
02508         assert(ref_my >= c->ymin);
02509         assert(ref_my <= c->ymax);
02510 
02511         ref_score= c->sub_motion_search(&s->m, &ref_mx, &ref_my, ref_score, 0, 0, level-LOG2_MB_SIZE+4, block_w);
02512         ref_score= ff_get_mb_score(&s->m, ref_mx, ref_my, 0, 0, level-LOG2_MB_SIZE+4, block_w, 0);
02513         ref_score+= 2*av_log2(2*ref)*c->penalty_factor;
02514         if(s->ref_mvs[ref]){
02515             s->ref_mvs[ref][index][0]= ref_mx;
02516             s->ref_mvs[ref][index][1]= ref_my;
02517             s->ref_scores[ref][index]= ref_score;
02518         }
02519         if(score > ref_score){
02520             score= ref_score;
02521             best_ref= ref;
02522             mx= ref_mx;
02523             my= ref_my;
02524         }
02525     }
02526     //FIXME if mb_cmp != SSE then intra cannot be compared currently and mb_penalty vs. lambda2
02527 
02528   //  subpel search
02529     base_bits= get_rac_count(&s->c) - 8*(s->c.bytestream - s->c.bytestream_start);
02530     pc= s->c;
02531     pc.bytestream_start=
02532     pc.bytestream= p_buffer; //FIXME end/start? and at the other stoo
02533     memcpy(p_state, s->block_state, sizeof(s->block_state));
02534 
02535     if(level!=s->block_max_depth)
02536         put_rac(&pc, &p_state[4 + s_context], 1);
02537     put_rac(&pc, &p_state[1 + left->type + top->type], 0);
02538     if(s->ref_frames > 1)
02539         put_symbol(&pc, &p_state[128 + 1024 + 32*ref_context], best_ref, 0);
02540     pred_mv(s, &pmx, &pmy, best_ref, left, top, tr);
02541     put_symbol(&pc, &p_state[128 + 32*(mx_context + 16*!!best_ref)], mx - pmx, 1);
02542     put_symbol(&pc, &p_state[128 + 32*(my_context + 16*!!best_ref)], my - pmy, 1);
02543     p_len= pc.bytestream - pc.bytestream_start;
02544     score += (s->lambda2*(get_rac_count(&pc)-base_bits))>>FF_LAMBDA_SHIFT;
02545 
02546     block_s= block_w*block_w;
02547     sum = pix_sum(current_data[0], stride, block_w);
02548     l= (sum + block_s/2)/block_s;
02549     iscore = pix_norm1(current_data[0], stride, block_w) - 2*l*sum + l*l*block_s;
02550 
02551     block_s= block_w*block_w>>2;
02552     sum = pix_sum(current_data[1], uvstride, block_w>>1);
02553     cb= (sum + block_s/2)/block_s;
02554 //    iscore += pix_norm1(&current_mb[1][0], uvstride, block_w>>1) - 2*cb*sum + cb*cb*block_s;
02555     sum = pix_sum(current_data[2], uvstride, block_w>>1);
02556     cr= (sum + block_s/2)/block_s;
02557 //    iscore += pix_norm1(&current_mb[2][0], uvstride, block_w>>1) - 2*cr*sum + cr*cr*block_s;
02558 
02559     ic= s->c;
02560     ic.bytestream_start=
02561     ic.bytestream= i_buffer; //FIXME end/start? and at the other stoo
02562     memcpy(i_state, s->block_state, sizeof(s->block_state));
02563     if(level!=s->block_max_depth)
02564         put_rac(&ic, &i_state[4 + s_context], 1);
02565     put_rac(&ic, &i_state[1 + left->type + top->type], 1);
02566     put_symbol(&ic, &i_state[32],  l-pl , 1);
02567     put_symbol(&ic, &i_state[64], cb-pcb, 1);
02568     put_symbol(&ic, &i_state[96], cr-pcr, 1);
02569     i_len= ic.bytestream - ic.bytestream_start;
02570     iscore += (s->lambda2*(get_rac_count(&ic)-base_bits))>>FF_LAMBDA_SHIFT;
02571 
02572 //    assert(score==256*256*256*64-1);
02573     assert(iscore < 255*255*256 + s->lambda2*10);
02574     assert(iscore >= 0);
02575     assert(l>=0 && l<=255);
02576     assert(pl>=0 && pl<=255);
02577 
02578     if(level==0){
02579         int varc= iscore >> 8;
02580         int vard= score >> 8;
02581         if (vard <= 64 || vard < varc)
02582             c->scene_change_score+= ff_sqrt(vard) - ff_sqrt(varc);
02583         else
02584             c->scene_change_score+= s->m.qscale;
02585     }
02586 
02587     if(level!=s->block_max_depth){
02588         put_rac(&s->c, &s->block_state[4 + s_context], 0);
02589         score2 = encode_q_branch(s, level+1, 2*x+0, 2*y+0);
02590         score2+= encode_q_branch(s, level+1, 2*x+1, 2*y+0);
02591         score2+= encode_q_branch(s, level+1, 2*x+0, 2*y+1);
02592         score2+= encode_q_branch(s, level+1, 2*x+1, 2*y+1);
02593         score2+= s->lambda2>>FF_LAMBDA_SHIFT; //FIXME exact split overhead
02594 
02595         if(score2 < score && score2 < iscore)
02596             return score2;
02597     }
02598 
02599     if(iscore < score){
02600         pred_mv(s, &pmx, &pmy, 0, left, top, tr);
02601         memcpy(pbbak, i_buffer, i_len);
02602         s->c= ic;
02603         s->c.bytestream_start= pbbak_start;
02604         s->c.bytestream= pbbak + i_len;
02605         set_blocks(s, level, x, y, l, cb, cr, pmx, pmy, 0, BLOCK_INTRA);
02606         memcpy(s->block_state, i_state, sizeof(s->block_state));
02607         return iscore;
02608     }else{
02609         memcpy(pbbak, p_buffer, p_len);
02610         s->c= pc;
02611         s->c.bytestream_start= pbbak_start;
02612         s->c.bytestream= pbbak + p_len;
02613         set_blocks(s, level, x, y, pl, pcb, pcr, mx, my, best_ref, 0);
02614         memcpy(s->block_state, p_state, sizeof(s->block_state));
02615         return score;
02616     }
02617 }
02618 
02619 static void encode_q_branch2(SnowContext *s, int level, int x, int y){
02620     const int w= s->b_width  << s->block_max_depth;
02621     const int rem_depth= s->block_max_depth - level;
02622     const int index= (x + y*w) << rem_depth;
02623     int trx= (x+1)<<rem_depth;
02624     BlockNode *b= &s->block[index];
02625     const BlockNode *left  = x ? &s->block[index-1] : &null_block;
02626     const BlockNode *top   = y ? &s->block[index-w] : &null_block;
02627     const BlockNode *tl    = y && x ? &s->block[index-w-1] : left;
02628     const BlockNode *tr    = y && trx<w && ((x&1)==0 || level==0) ? &s->block[index-w+(1<<rem_depth)] : tl; //FIXME use lt
02629     int pl = left->color[0];
02630     int pcb= left->color[1];
02631     int pcr= left->color[2];
02632     int pmx, pmy;
02633     int ref_context= av_log2(2*left->ref) + av_log2(2*top->ref);
02634     int mx_context= av_log2(2*FFABS(left->mx - top->mx)) + 16*!!b->ref;
02635     int my_context= av_log2(2*FFABS(left->my - top->my)) + 16*!!b->ref;
02636     int s_context= 2*left->level + 2*top->level + tl->level + tr->level;
02637 
02638     if(s->keyframe){
02639         set_blocks(s, level, x, y, pl, pcb, pcr, 0, 0, 0, BLOCK_INTRA);
02640         return;
02641     }
02642 
02643     if(level!=s->block_max_depth){
02644         if(same_block(b,b+1) && same_block(b,b+w) && same_block(b,b+w+1)){
02645             put_rac(&s->c, &s->block_state[4 + s_context], 1);
02646         }else{
02647             put_rac(&s->c, &s->block_state[4 + s_context], 0);
02648             encode_q_branch2(s, level+1, 2*x+0, 2*y+0);
02649             encode_q_branch2(s, level+1, 2*x+1, 2*y+0);
02650             encode_q_branch2(s, level+1, 2*x+0, 2*y+1);
02651             encode_q_branch2(s, level+1, 2*x+1, 2*y+1);
02652             return;
02653         }
02654     }
02655     if(b->type & BLOCK_INTRA){
02656         pred_mv(s, &pmx, &pmy, 0, left, top, tr);
02657         put_rac(&s->c, &s->block_state[1 + (left->type&1) + (top->type&1)], 1);
02658         put_symbol(&s->c, &s->block_state[32], b->color[0]-pl , 1);
02659         put_symbol(&s->c, &s->block_state[64], b->color[1]-pcb, 1);
02660         put_symbol(&s->c, &s->block_state[96], b->color[2]-pcr, 1);
02661         set_blocks(s, level, x, y, b->color[0], b->color[1], b->color[2], pmx, pmy, 0, BLOCK_INTRA);
02662     }else{
02663         pred_mv(s, &pmx, &pmy, b->ref, left, top, tr);
02664         put_rac(&s->c, &s->block_state[1 + (left->type&1) + (top->type&1)], 0);
02665         if(s->ref_frames > 1)
02666             put_symbol(&s->c, &s->block_state[128 + 1024 + 32*ref_context], b->ref, 0);
02667         put_symbol(&s->c, &s->block_state[128 + 32*mx_context], b->mx - pmx, 1);
02668         put_symbol(&s->c, &s->block_state[128 + 32*my_context], b->my - pmy, 1);
02669         set_blocks(s, level, x, y, pl, pcb, pcr, b->mx, b->my, b->ref, 0);
02670     }
02671 }
02672 
02673 static int get_dc(SnowContext *s, int mb_x, int mb_y, int plane_index){
02674     int i, x2, y2;
02675     Plane *p= &s->plane[plane_index];
02676     const int block_size = MB_SIZE >> s->block_max_depth;
02677     const int block_w    = plane_index ? block_size/2 : block_size;
02678     const uint8_t *obmc  = plane_index ? obmc_tab[s->block_max_depth+1] : obmc_tab[s->block_max_depth];
02679     const int obmc_stride= plane_index ? block_size : 2*block_size;
02680     const int ref_stride= s->current_picture.linesize[plane_index];
02681     uint8_t *src= s-> input_picture.data[plane_index];
02682     IDWTELEM *dst= (IDWTELEM*)s->m.obmc_scratchpad + plane_index*block_size*block_size*4; //FIXME change to unsigned
02683     const int b_stride = s->b_width << s->block_max_depth;
02684     const int w= p->width;
02685     const int h= p->height;
02686     int index= mb_x + mb_y*b_stride;
02687     BlockNode *b= &s->block[index];
02688     BlockNode backup= *b;
02689     int ab=0;
02690     int aa=0;
02691 
02692     b->type|= BLOCK_INTRA;
02693     b->color[plane_index]= 0;
02694     memset(dst, 0, obmc_stride*obmc_stride*sizeof(IDWTELEM));
02695 
02696     for(i=0; i<4; i++){
02697         int mb_x2= mb_x + (i &1) - 1;
02698         int mb_y2= mb_y + (i>>1) - 1;
02699         int x= block_w*mb_x2 + block_w/2;
02700         int y= block_w*mb_y2 + block_w/2;
02701 
02702         add_yblock(s, 0, NULL, dst + ((i&1)+(i>>1)*obmc_stride)*block_w, NULL, obmc,
02703                     x, y, block_w, block_w, w, h, obmc_stride, ref_stride, obmc_stride, mb_x2, mb_y2, 0, 0, plane_index);
02704 
02705         for(y2= FFMAX(y, 0); y2<FFMIN(h, y+block_w); y2++){
02706             for(x2= FFMAX(x, 0); x2<FFMIN(w, x+block_w); x2++){
02707                 int index= x2-(block_w*mb_x - block_w/2) + (y2-(block_w*mb_y - block_w/2))*obmc_stride;
02708                 int obmc_v= obmc[index];
02709                 int d;
02710                 if(y<0) obmc_v += obmc[index + block_w*obmc_stride];
02711                 if(x<0) obmc_v += obmc[index + block_w];
02712                 if(y+block_w>h) obmc_v += obmc[index - block_w*obmc_stride];
02713                 if(x+block_w>w) obmc_v += obmc[index - block_w];
02714                 //FIXME precalculate this or simplify it somehow else
02715 
02716                 d = -dst[index] + (1<<(FRAC_BITS-1));
02717                 dst[index] = d;
02718                 ab += (src[x2 + y2*ref_stride] - (d>>FRAC_BITS)) * obmc_v;
02719                 aa += obmc_v * obmc_v; //FIXME precalculate this
02720             }
02721         }
02722     }
02723     *b= backup;
02724 
02725     return av_clip(((ab<<LOG2_OBMC_MAX) + aa/2)/aa, 0, 255); //FIXME we should not need clipping
02726 }
02727 
02728 static inline int get_block_bits(SnowContext *s, int x, int y, int w){
02729     const int b_stride = s->b_width << s->block_max_depth;
02730     const int b_height = s->b_height<< s->block_max_depth;
02731     int index= x + y*b_stride;
02732     const BlockNode *b     = &s->block[index];
02733     const BlockNode *left  = x ? &s->block[index-1] : &null_block;
02734     const BlockNode *top   = y ? &s->block[index-b_stride] : &null_block;
02735     const BlockNode *tl    = y && x ? &s->block[index-b_stride-1] : left;
02736     const BlockNode *tr    = y && x+w<b_stride ? &s->block[index-b_stride+w] : tl;
02737     int dmx, dmy;
02738 //  int mx_context= av_log2(2*FFABS(left->mx - top->mx));
02739 //  int my_context= av_log2(2*FFABS(left->my - top->my));
02740 
02741     if(x<0 || x>=b_stride || y>=b_height)
02742         return 0;
02743 /*
02744 1            0      0
02745 01X          1-2    1
02746 001XX        3-6    2-3
02747 0001XXX      7-14   4-7
02748 00001XXXX   15-30   8-15
02749 */
02750 //FIXME try accurate rate
02751 //FIXME intra and inter predictors if surrounding blocks are not the same type
02752     if(b->type & BLOCK_INTRA){
02753         return 3+2*( av_log2(2*FFABS(left->color[0] - b->color[0]))
02754                    + av_log2(2*FFABS(left->color[1] - b->color[1]))
02755                    + av_log2(2*FFABS(left->color[2] - b->color[2])));
02756     }else{
02757         pred_mv(s, &dmx, &dmy, b->ref, left, top, tr);
02758         dmx-= b->mx;
02759         dmy-= b->my;
02760         return 2*(1 + av_log2(2*FFABS(dmx)) //FIXME kill the 2* can be merged in lambda
02761                     + av_log2(2*FFABS(dmy))
02762                     + av_log2(2*b->ref));
02763     }
02764 }
02765 
02766 static int get_block_rd(SnowContext *s, int mb_x, int mb_y, int plane_index, const uint8_t *obmc_edged){
02767     Plane *p= &s->plane[plane_index];
02768     const int block_size = MB_SIZE >> s->block_max_depth;
02769     const int block_w    = plane_index ? block_size/2 : block_size;
02770     const int obmc_stride= plane_index ? block_size : 2*block_size;
02771     const int ref_stride= s->current_picture.linesize[plane_index];
02772     uint8_t *dst= s->current_picture.data[plane_index];
02773     uint8_t *src= s->  input_picture.data[plane_index];
02774     IDWTELEM *pred= (IDWTELEM*)s->m.obmc_scratchpad + plane_index*block_size*block_size*4;
02775     uint8_t *cur = s->scratchbuf;
02776     uint8_t tmp[ref_stride*(2*MB_SIZE+HTAPS_MAX-1)];
02777     const int b_stride = s->b_width << s->block_max_depth;
02778     const int b_height = s->b_height<< s->block_max_depth;
02779     const int w= p->width;
02780     const int h= p->height;
02781     int distortion;
02782     int rate= 0;
02783     const int penalty_factor= get_penalty_factor(s->lambda, s->lambda2, s->avctx->me_cmp);
02784     int sx= block_w*mb_x - block_w/2;
02785     int sy= block_w*mb_y - block_w/2;
02786     int x0= FFMAX(0,-sx);
02787     int y0= FFMAX(0,-sy);
02788     int x1= FFMIN(block_w*2, w-sx);
02789     int y1= FFMIN(block_w*2, h-sy);
02790     int i,x,y;
02791 
02792     pred_block(s, cur, tmp, ref_stride, sx, sy, block_w*2, block_w*2, &s->block[mb_x + mb_y*b_stride], plane_index, w, h);
02793 
02794     for(y=y0; y<y1; y++){
02795         const uint8_t *obmc1= obmc_edged + y*obmc_stride;
02796         const IDWTELEM *pred1 = pred + y*obmc_stride;
02797         uint8_t *cur1 = cur + y*ref_stride;
02798         uint8_t *dst1 = dst + sx + (sy+y)*ref_stride;
02799         for(x=x0; x<x1; x++){
02800 #if FRAC_BITS >= LOG2_OBMC_MAX
02801             int v = (cur1[x] * obmc1[x]) << (FRAC_BITS - LOG2_OBMC_MAX);
02802 #else
02803             int v = (cur1[x] * obmc1[x] + (1<<(LOG2_OBMC_MAX - FRAC_BITS-1))) >> (LOG2_OBMC_MAX - FRAC_BITS);
02804 #endif
02805             v = (v + pred1[x]) >> FRAC_BITS;
02806             if(v&(~255)) v= ~(v>>31);
02807             dst1[x] = v;
02808         }
02809     }
02810 
02811     /* copy the regions where obmc[] = (uint8_t)256 */
02812     if(LOG2_OBMC_MAX == 8
02813         && (mb_x == 0 || mb_x == b_stride-1)
02814         && (mb_y == 0 || mb_y == b_height-1)){
02815         if(mb_x == 0)
02816             x1 = block_w;
02817         else
02818             x0 = block_w;
02819         if(mb_y == 0)
02820             y1 = block_w;
02821         else
02822             y0 = block_w;
02823         for(y=y0; y<y1; y++)
02824             memcpy(dst + sx+x0 + (sy+y)*ref_stride, cur + x0 + y*ref_stride, x1-x0);
02825     }
02826 
02827     if(block_w==16){
02828         /* FIXME rearrange dsputil to fit 32x32 cmp functions */
02829         /* FIXME check alignment of the cmp wavelet vs the encoding wavelet */
02830         /* FIXME cmps overlap but do not cover the wavelet's whole support.
02831          * So improving the score of one block is not strictly guaranteed
02832          * to improve the score of the whole frame, thus iterative motion
02833          * estimation does not always converge. */
02834         if(s->avctx->me_cmp == FF_CMP_W97)
02835             distortion = ff_w97_32_c(&s->m, src + sx + sy*ref_stride, dst + sx + sy*ref_stride, ref_stride, 32);
02836         else if(s->avctx->me_cmp == FF_CMP_W53)
02837             distortion = ff_w53_32_c(&s->m, src + sx + sy*ref_stride, dst + sx + sy*ref_stride, ref_stride, 32);
02838         else{
02839             distortion = 0;
02840             for(i=0; i<4; i++){
02841                 int off = sx+16*(i&1) + (sy+16*(i>>1))*ref_stride;
02842                 distortion += s->dsp.me_cmp[0](&s->m, src + off, dst + off, ref_stride, 16);
02843             }
02844         }
02845     }else{
02846         assert(block_w==8);
02847         distortion = s->dsp.me_cmp[0](&s->m, src + sx + sy*ref_stride, dst + sx + sy*ref_stride, ref_stride, block_w*2);
02848     }
02849 
02850     if(plane_index==0){
02851         for(i=0; i<4; i++){
02852 /* ..RRr
02853  * .RXx.
02854  * rxx..
02855  */
02856             rate += get_block_bits(s, mb_x + (i&1) - (i>>1), mb_y + (i>>1), 1);
02857         }
02858         if(mb_x == b_stride-2)
02859             rate += get_block_bits(s, mb_x + 1, mb_y + 1, 1);
02860     }
02861     return distortion + rate*penalty_factor;
02862 }
02863 
02864 static int get_4block_rd(SnowContext *s, int mb_x, int mb_y, int plane_index){
02865     int i, y2;
02866     Plane *p= &s->plane[plane_index];
02867     const int block_size = MB_SIZE >> s->block_max_depth;
02868     const int block_w    = plane_index ? block_size/2 : block_size;
02869     const uint8_t *obmc  = plane_index ? obmc_tab[s->block_max_depth+1] : obmc_tab[s->block_max_depth];
02870     const int obmc_stride= plane_index ? block_size : 2*block_size;
02871     const int ref_stride= s->current_picture.linesize[plane_index];
02872     uint8_t *dst= s->current_picture.data[plane_index];
02873     uint8_t *src= s-> input_picture.data[plane_index];
02874     //FIXME zero_dst is const but add_yblock changes dst if add is 0 (this is never the case for dst=zero_dst
02875     // const has only been removed from zero_dst to suppress a warning
02876     static IDWTELEM zero_dst[4096]; //FIXME
02877     const int b_stride = s->b_width << s->block_max_depth;
02878     const int w= p->width;
02879     const int h= p->height;
02880     int distortion= 0;
02881     int rate= 0;
02882     const int penalty_factor= get_penalty_factor(s->lambda, s->lambda2, s->avctx->me_cmp);
02883 
02884     for(i=0; i<9; i++){
02885         int mb_x2= mb_x + (i%3) - 1;
02886         int mb_y2= mb_y + (i/3) - 1;
02887         int x= block_w*mb_x2 + block_w/2;
02888         int y= block_w*mb_y2 + block_w/2;
02889 
02890         add_yblock(s, 0, NULL, zero_dst, dst, obmc,
02891                    x, y, block_w, block_w, w, h, /*dst_stride*/0, ref_stride, obmc_stride, mb_x2, mb_y2, 1, 1, plane_index);
02892 
02893         //FIXME find a cleaner/simpler way to skip the outside stuff
02894         for(y2= y; y2<0; y2++)
02895             memcpy(dst + x + y2*ref_stride, src + x + y2*ref_stride, block_w);
02896         for(y2= h; y2<y+block_w; y2++)
02897             memcpy(dst + x + y2*ref_stride, src + x + y2*ref_stride, block_w);
02898         if(x<0){
02899             for(y2= y; y2<y+block_w; y2++)
02900                 memcpy(dst + x + y2*ref_stride, src + x + y2*ref_stride, -x);
02901         }
02902         if(x+block_w > w){
02903             for(y2= y; y2<y+block_w; y2++)
02904                 memcpy(dst + w + y2*ref_stride, src + w + y2*ref_stride, x+block_w - w);
02905         }
02906 
02907         assert(block_w== 8 || block_w==16);
02908         distortion += s->dsp.me_cmp[block_w==8](&s->m, src + x + y*ref_stride, dst + x + y*ref_stride, ref_stride, block_w);
02909     }
02910 
02911     if(plane_index==0){
02912         BlockNode *b= &s->block[mb_x+mb_y*b_stride];
02913         int merged= same_block(b,b+1) && same_block(b,b+b_stride) && same_block(b,b+b_stride+1);
02914 
02915 /* ..RRRr
02916  * .RXXx.
02917  * .RXXx.
02918  * rxxx.
02919  */
02920         if(merged)
02921             rate = get_block_bits(s, mb_x, mb_y, 2);
02922         for(i=merged?4:0; i<9; i++){
02923             static const int dxy[9][2] = {{0,0},{1,0},{0,1},{1,1},{2,0},{2,1},{-1,2},{0,2},{1,2}};
02924             rate += get_block_bits(s, mb_x + dxy[i][0], mb_y + dxy[i][1], 1);
02925         }
02926     }
02927     return distortion + rate*penalty_factor;
02928 }
02929 
02930 static int encode_subband_c0run(SnowContext *s, SubBand *b, IDWTELEM *src, IDWTELEM *parent, int stride, int orientation){
02931     const int w= b->width;
02932     const int h= b->height;
02933     int x, y;
02934 
02935     if(1){
02936         int run=0;
02937         int runs[w*h];
02938         int run_index=0;
02939         int max_index;
02940 
02941         for(y=0; y<h; y++){
02942             for(x=0; x<w; x++){
02943                 int v, p=0;
02944                 int /*ll=0, */l=0, lt=0, t=0, rt=0;
02945                 v= src[x + y*stride];
02946 
02947                 if(y){
02948                     t= src[x + (y-1)*stride];
02949                     if(x){
02950                         lt= src[x - 1 + (y-1)*stride];
02951                     }
02952                     if(x + 1 < w){
02953                         rt= src[x + 1 + (y-1)*stride];
02954                     }
02955                 }
02956                 if(x){
02957                     l= src[x - 1 + y*stride];
02958                     /*if(x > 1){
02959                         if(orientation==1) ll= src[y + (x-2)*stride];
02960                         else               ll= src[x - 2 + y*stride];
02961                     }*/
02962                 }
02963                 if(parent){
02964                     int px= x>>1;
02965                     int py= y>>1;
02966                     if(px<b->parent->width && py<b->parent->height)
02967                         p= parent[px + py*2*stride];
02968                 }
02969                 if(!(/*ll|*/l|lt|t|rt|p)){
02970                     if(v){
02971                         runs[run_index++]= run;
02972                         run=0;
02973                     }else{
02974                         run++;
02975                     }
02976                 }
02977             }
02978         }
02979         max_index= run_index;
02980         runs[run_index++]= run;
02981         run_index=0;
02982         run= runs[run_index++];
02983 
02984         put_symbol2(&s->c, b->state[30], max_index, 0);
02985         if(run_index <= max_index)
02986             put_symbol2(&s->c, b->state[1], run, 3);
02987 
02988         for(y=0; y<h; y++){
02989             if(s->c.bytestream_end - s->c.bytestream < w*40){
02990                 av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
02991                 return -1;
02992             }
02993             for(x=0; x<w; x++){
02994                 int v, p=0;
02995                 int /*ll=0, */l=0, lt=0, t=0, rt=0;
02996                 v= src[x + y*stride];
02997 
02998                 if(y){
02999                     t= src[x + (y-1)*stride];
03000                     if(x){
03001                         lt= src[x - 1 + (y-1)*stride];
03002                     }
03003                     if(x + 1 < w){
03004                         rt= src[x + 1 + (y-1)*stride];
03005                     }
03006                 }
03007                 if(x){
03008                     l= src[x - 1 + y*stride];
03009                     /*if(x > 1){
03010                         if(orientation==1) ll= src[y + (x-2)*stride];
03011                         else               ll= src[x - 2 + y*stride];
03012                     }*/
03013                 }
03014                 if(parent){
03015                     int px= x>>1;
03016                     int py= y>>1;
03017                     if(px<b->parent->width && py<b->parent->height)
03018                         p= parent[px + py*2*stride];
03019                 }
03020                 if(/*ll|*/l|lt|t|rt|p){
03021                     int context= av_log2(/*FFABS(ll) + */3*FFABS(l) + FFABS(lt) + 2*FFABS(t) + FFABS(rt) + FFABS(p));
03022 
03023                     put_rac(&s->c, &b->state[0][context], !!v);
03024                 }else{
03025                     if(!run){
03026                         run= runs[run_index++];
03027 
03028                         if(run_index <= max_index)
03029                             put_symbol2(&s->c, b->state[1], run, 3);
03030                         assert(v);
03031                     }else{
03032                         run--;
03033                         assert(!v);
03034                     }
03035                 }
03036                 if(v){
03037                     int context= av_log2(/*FFABS(ll) + */3*FFABS(l) + FFABS(lt) + 2*FFABS(t) + FFABS(rt) + FFABS(p));
03038                     int l2= 2*FFABS(l) + (l<0);
03039                     int t2= 2*FFABS(t) + (t<0);
03040 
03041                     put_symbol2(&s->c, b->state[context + 2], FFABS(v)-1, context-4);
03042                     put_rac(&s->c, &b->state[0][16 + 1 + 3 + quant3bA[l2&0xFF] + 3*quant3bA[t2&0xFF]], v<0);
03043                 }
03044             }
03045         }
03046     }
03047     return 0;
03048 }
03049 
03050 static int encode_subband(SnowContext *s, SubBand *b, IDWTELEM *src, IDWTELEM *parent, int stride, int orientation){
03051 //    encode_subband_qtree(s, b, src, parent, stride, orientation);
03052 //    encode_subband_z0run(s, b, src, parent, stride, orientation);
03053     return encode_subband_c0run(s, b, src, parent, stride, orientation);
03054 //    encode_subband_dzr(s, b, src, parent, stride, orientation);
03055 }
03056 
03057 static av_always_inline int check_block(SnowContext *s, int mb_x, int mb_y, int p[3], int intra, const uint8_t *obmc_edged, int *best_rd){
03058     const int b_stride= s->b_width << s->block_max_depth;
03059     BlockNode *block= &s->block[mb_x + mb_y * b_stride];
03060     BlockNode backup= *block;
03061     int rd, index, value;
03062 
03063     assert(mb_x>=0 && mb_y>=0);
03064     assert(mb_x<b_stride);
03065 
03066     if(intra){
03067         block->color[0] = p[0];
03068         block->color[1] = p[1];
03069         block->color[2] = p[2];
03070         block->type |= BLOCK_INTRA;
03071     }else{
03072         index= (p[0] + 31*p[1]) & (ME_CACHE_SIZE-1);
03073         value= s->me_cache_generation + (p[0]>>10) + (p[1]<<6) + (block->ref<<12);
03074         if(s->me_cache[index] == value)
03075             return 0;
03076         s->me_cache[index]= value;
03077 
03078         block->mx= p[0];
03079         block->my= p[1];
03080         block->type &= ~BLOCK_INTRA;
03081     }
03082 
03083     rd= get_block_rd(s, mb_x, mb_y, 0, obmc_edged);
03084 
03085 //FIXME chroma
03086     if(rd < *best_rd){
03087         *best_rd= rd;
03088         return 1;
03089     }else{
03090         *block= backup;
03091         return 0;
03092     }
03093 }
03094 
03095 /* special case for int[2] args we discard afterwards,
03096  * fixes compilation problem with gcc 2.95 */
03097 static av_always_inline int check_block_inter(SnowContext *s, int mb_x, int mb_y, int p0, int p1, const uint8_t *obmc_edged, int *best_rd){
03098     int p[2] = {p0, p1};
03099     return check_block(s, mb_x, mb_y, p, 0, obmc_edged, best_rd);
03100 }
03101 
03102 static av_always_inline int check_4block_inter(SnowContext *s, int mb_x, int mb_y, int p0, int p1, int ref, int *best_rd){
03103     const int b_stride= s->b_width << s->block_max_depth;
03104     BlockNode *block= &s->block[mb_x + mb_y * b_stride];
03105     BlockNode backup[4]= {block[0], block[1], block[b_stride], block[b_stride+1]};
03106     int rd, index, value;
03107 
03108     assert(mb_x>=0 && mb_y>=0);
03109     assert(mb_x<b_stride);
03110     assert(((mb_x|mb_y)&1) == 0);
03111 
03112     index= (p0 + 31*p1) & (ME_CACHE_SIZE-1);
03113     value= s->me_cache_generation + (p0>>10) + (p1<<6) + (block->ref<<12);
03114     if(s->me_cache[index] == value)
03115         return 0;
03116     s->me_cache[index]= value;
03117 
03118     block->mx= p0;
03119     block->my= p1;
03120     block->ref= ref;
03121     block->type &= ~BLOCK_INTRA;
03122     block[1]= block[b_stride]= block[b_stride+1]= *block;
03123 
03124     rd= get_4block_rd(s, mb_x, mb_y, 0);
03125 
03126 //FIXME chroma
03127     if(rd < *best_rd){
03128         *best_rd= rd;
03129         return 1;
03130     }else{
03131         block[0]= backup[0];
03132         block[1]= backup[1];
03133         block[b_stride]= backup[2];
03134         block[b_stride+1]= backup[3];
03135         return 0;
03136     }
03137 }
03138 
03139 static void iterative_me(SnowContext *s){
03140     int pass, mb_x, mb_y;
03141     const int b_width = s->b_width  << s->block_max_depth;
03142     const int b_height= s->b_height << s->block_max_depth;
03143     const int b_stride= b_width;
03144     int color[3];
03145 
03146     {
03147         RangeCoder r = s->c;
03148         uint8_t state[sizeof(s->block_state)];
03149         memcpy(state, s->block_state, sizeof(s->block_state));
03150         for(mb_y= 0; mb_y<s->b_height; mb_y++)
03151             for(mb_x= 0; mb_x<s->b_width; mb_x++)
03152                 encode_q_branch(s, 0, mb_x, mb_y);
03153         s->c = r;
03154         memcpy(s->block_state, state, sizeof(s->block_state));
03155     }
03156 
03157     for(pass=0; pass<25; pass++){
03158         int change= 0;
03159 
03160         for(mb_y= 0; mb_y<b_height; mb_y++){
03161             for(mb_x= 0; mb_x<b_width; mb_x++){
03162                 int dia_change, i, j, ref;
03163                 int best_rd= INT_MAX, ref_rd;
03164                 BlockNode backup, ref_b;
03165                 const int index= mb_x + mb_y * b_stride;
03166                 BlockNode *block= &s->block[index];
03167                 BlockNode *tb =                   mb_y            ? &s->block[index-b_stride  ] : NULL;
03168                 BlockNode *lb = mb_x                              ? &s->block[index         -1] : NULL;
03169                 BlockNode *rb = mb_x+1<b_width                    ? &s->block[index         +1] : NULL;
03170                 BlockNode *bb =                   mb_y+1<b_height ? &s->block[index+b_stride  ] : NULL;
03171                 BlockNode *tlb= mb_x           && mb_y            ? &s->block[index-b_stride-1] : NULL;
03172                 BlockNode *trb= mb_x+1<b_width && mb_y            ? &s->block[index-b_stride+1] : NULL;
03173                 BlockNode *blb= mb_x           && mb_y+1<b_height ? &s->block[index+b_stride-1] : NULL;
03174                 BlockNode *brb= mb_x+1<b_width && mb_y+1<b_height ? &s->block[index+b_stride+1] : NULL;
03175                 const int b_w= (MB_SIZE >> s->block_max_depth);
03176                 uint8_t obmc_edged[b_w*2][b_w*2];
03177 
03178                 if(pass && (block->type & BLOCK_OPT))
03179                     continue;
03180                 block->type |= BLOCK_OPT;
03181 
03182                 backup= *block;
03183 
03184                 if(!s->me_cache_generation)
03185                     memset(s->me_cache, 0, sizeof(s->me_cache));
03186                 s->me_cache_generation += 1<<22;
03187 
03188                 //FIXME precalculate
03189                 {
03190                     int x, y;
03191                     memcpy(obmc_edged, obmc_tab[s->block_max_depth], b_w*b_w*4);
03192                     if(mb_x==0)
03193                         for(y=0; y<b_w*2; y++)
03194                             memset(obmc_edged[y], obmc_edged[y][0] + obmc_edged[y][b_w-1], b_w);
03195                     if(mb_x==b_stride-1)
03196                         for(y=0; y<b_w*2; y++)
03197                             memset(obmc_edged[y]+b_w, obmc_edged[y][b_w] + obmc_edged[y][b_w*2-1], b_w);
03198                     if(mb_y==0){
03199                         for(x=0; x<b_w*2; x++)
03200                             obmc_edged[0][x] += obmc_edged[b_w-1][x];
03201                         for(y=1; y<b_w; y++)
03202                             memcpy(obmc_edged[y], obmc_edged[0], b_w*2);
03203                     }
03204                     if(mb_y==b_height-1){
03205                         for(x=0; x<b_w*2; x++)
03206                             obmc_edged[b_w*2-1][x] += obmc_edged[b_w][x];
03207                         for(y=b_w; y<b_w*2-1; y++)
03208                             memcpy(obmc_edged[y], obmc_edged[b_w*2-1], b_w*2);
03209                     }
03210                 }
03211 
03212                 //skip stuff outside the picture
03213                 if(mb_x==0 || mb_y==0 || mb_x==b_width-1 || mb_y==b_height-1){
03214                     uint8_t *src= s->  input_picture.data[0];
03215                     uint8_t *dst= s->current_picture.data[0];
03216                     const int stride= s->current_picture.linesize[0];
03217                     const int block_w= MB_SIZE >> s->block_max_depth;
03218                     const int sx= block_w*mb_x - block_w/2;
03219                     const int sy= block_w*mb_y - block_w/2;
03220                     const int w= s->plane[0].width;
03221                     const int h= s->plane[0].height;
03222                     int y;
03223 
03224                     for(y=sy; y<0; y++)
03225                         memcpy(dst + sx + y*stride, src + sx + y*stride, block_w*2);
03226                     for(y=h; y<sy+block_w*2; y++)
03227                         memcpy(dst + sx + y*stride, src + sx + y*stride, block_w*2);
03228                     if(sx<0){
03229                         for(y=sy; y<sy+block_w*2; y++)
03230                             memcpy(dst + sx + y*stride, src + sx + y*stride, -sx);
03231                     }
03232                     if(sx+block_w*2 > w){
03233                         for(y=sy; y<sy+block_w*2; y++)
03234                             memcpy(dst + w + y*stride, src + w + y*stride, sx+block_w*2 - w);
03235                     }
03236                 }
03237 
03238                 // intra(black) = neighbors' contribution to the current block
03239                 for(i=0; i<3; i++)
03240                     color[i]= get_dc(s, mb_x, mb_y, i);
03241 
03242                 // get previous score (cannot be cached due to OBMC)
03243                 if(pass > 0 && (block->type&BLOCK_INTRA)){
03244                     int color0[3]= {block->color[0], block->color[1], block->color[2]};
03245                     check_block(s, mb_x, mb_y, color0, 1, *obmc_edged, &best_rd);
03246                 }else
03247                     check_block_inter(s, mb_x, mb_y, block->mx, block->my, *obmc_edged, &best_rd);
03248 
03249                 ref_b= *block;
03250                 ref_rd= best_rd;
03251                 for(ref=0; ref < s->ref_frames; ref++){
03252                     int16_t (*mvr)[2]= &s->ref_mvs[ref][index];
03253                     if(s->ref_scores[ref][index] > s->ref_scores[ref_b.ref][index]*3/2) //FIXME tune threshold
03254                         continue;
03255                     block->ref= ref;
03256                     best_rd= INT_MAX;
03257 
03258                     check_block_inter(s, mb_x, mb_y, mvr[0][0], mvr[0][1], *obmc_edged, &best_rd);
03259                     check_block_inter(s, mb_x, mb_y, 0, 0, *obmc_edged, &best_rd);
03260                     if(tb)
03261                         check_block_inter(s, mb_x, mb_y, mvr[-b_stride][0], mvr[-b_stride][1], *obmc_edged, &best_rd);
03262                     if(lb)
03263                         check_block_inter(s, mb_x, mb_y, mvr[-1][0], mvr[-1][1], *obmc_edged, &best_rd);
03264                     if(rb)
03265                         check_block_inter(s, mb_x, mb_y, mvr[1][0], mvr[1][1], *obmc_edged, &best_rd);
03266                     if(bb)
03267                         check_block_inter(s, mb_x, mb_y, mvr[b_stride][0], mvr[b_stride][1], *obmc_edged, &best_rd);
03268 
03269                     /* fullpel ME */
03270                     //FIXME avoid subpel interpolation / round to nearest integer
03271                     do{
03272                         dia_change=0;
03273                         for(i=0; i<FFMAX(s->avctx->dia_size, 1); i++){
03274                             for(j=0; j<i; j++){
03275                                 dia_change |= check_block_inter(s, mb_x, mb_y, block->mx+4*(i-j), block->my+(4*j), *obmc_edged, &best_rd);
03276                                 dia_change |= check_block_inter(s, mb_x, mb_y, block->mx-4*(i-j), block->my-(4*j), *obmc_edged, &best_rd);
03277                                 dia_change |= check_block_inter(s, mb_x, mb_y, block->mx+4*(i-j), block->my-(4*j), *obmc_edged, &best_rd);
03278                                 dia_change |= check_block_inter(s, mb_x, mb_y, block->mx-4*(i-j), block->my+(4*j), *obmc_edged, &best_rd);
03279                             }
03280                         }
03281                     }while(dia_change);
03282                     /* subpel ME */
03283                     do{
03284                         static const int square[8][2]= {{+1, 0},{-1, 0},{ 0,+1},{ 0,-1},{+1,+1},{-1,-1},{+1,-1},{-1,+1},};
03285                         dia_change=0;
03286                         for(i=0; i<8; i++)
03287                             dia_change |= check_block_inter(s, mb_x, mb_y, block->mx+square[i][0], block->my+square[i][1], *obmc_edged, &best_rd);
03288                     }while(dia_change);
03289                     //FIXME or try the standard 2 pass qpel or similar
03290 
03291                     mvr[0][0]= block->mx;
03292                     mvr[0][1]= block->my;
03293                     if(ref_rd > best_rd){
03294                         ref_rd= best_rd;
03295                         ref_b= *block;
03296                     }
03297                 }
03298                 best_rd= ref_rd;
03299                 *block= ref_b;
03300                 check_block(s, mb_x, mb_y, color, 1, *obmc_edged, &best_rd);
03301                 //FIXME RD style color selection
03302                 if(!same_block(block, &backup)){
03303                     if(tb ) tb ->type &= ~BLOCK_OPT;
03304                     if(lb ) lb ->type &= ~BLOCK_OPT;
03305                     if(rb ) rb ->type &= ~BLOCK_OPT;
03306                     if(bb ) bb ->type &= ~BLOCK_OPT;
03307                     if(tlb) tlb->type &= ~BLOCK_OPT;
03308                     if(trb) trb->type &= ~BLOCK_OPT;
03309                     if(blb) blb->type &= ~BLOCK_OPT;
03310                     if(brb) brb->type &= ~BLOCK_OPT;
03311                     change ++;
03312                 }
03313             }
03314         }
03315         av_log(s->avctx, AV_LOG_ERROR, "pass:%d changed:%d\n", pass, change);
03316         if(!change)
03317             break;
03318     }
03319 
03320     if(s->block_max_depth == 1){
03321         int change= 0;
03322         for(mb_y= 0; mb_y<b_height; mb_y+=2){
03323             for(mb_x= 0; mb_x<b_width; mb_x+=2){
03324                 int i;
03325                 int best_rd, init_rd;
03326                 const int index= mb_x + mb_y * b_stride;
03327                 BlockNode *b[4];
03328 
03329                 b[0]= &s->block[index];
03330                 b[1]= b[0]+1;
03331                 b[2]= b[0]+b_stride;
03332                 b[3]= b[2]+1;
03333                 if(same_block(b[0], b[1]) &&
03334                    same_block(b[0], b[2]) &&
03335                    same_block(b[0], b[3]))
03336                     continue;
03337 
03338                 if(!s->me_cache_generation)
03339                     memset(s->me_cache, 0, sizeof(s->me_cache));
03340                 s->me_cache_generation += 1<<22;
03341 
03342                 init_rd= best_rd= get_4block_rd(s, mb_x, mb_y, 0);
03343 
03344                 //FIXME more multiref search?
03345                 check_4block_inter(s, mb_x, mb_y,
03346                                    (b[0]->mx + b[1]->mx + b[2]->mx + b[3]->mx + 2) >> 2,
03347                                    (b[0]->my + b[1]->my + b[2]->my + b[3]->my + 2) >> 2, 0, &best_rd);
03348 
03349                 for(i=0; i<4; i++)
03350                     if(!(b[i]->type&BLOCK_INTRA))
03351                         check_4block_inter(s, mb_x, mb_y, b[i]->mx, b[i]->my, b[i]->ref, &best_rd);
03352 
03353                 if(init_rd != best_rd)
03354                     change++;
03355             }
03356         }
03357         av_log(s->avctx, AV_LOG_ERROR, "pass:4mv changed:%d\n", change*4);
03358     }
03359 }
03360 
03361 static void encode_blocks(SnowContext *s, int search){
03362     int x, y;
03363     int w= s->b_width;
03364     int h= s->b_height;
03365 
03366     if(s->avctx->me_method == ME_ITER && !s->keyframe && search)
03367         iterative_me(s);
03368 
03369     for(y=0; y<h; y++){
03370         if(s->c.bytestream_end - s->c.bytestream < w*MB_SIZE*MB_SIZE*3){ //FIXME nicer limit
03371             av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
03372             return;
03373         }
03374         for(x=0; x<w; x++){
03375             if(s->avctx->me_method == ME_ITER || !search)
03376                 encode_q_branch2(s, 0, x, y);
03377             else
03378                 encode_q_branch (s, 0, x, y);
03379         }
03380     }
03381 }
03382 
03383 static void quantize(SnowContext *s, SubBand *b, IDWTELEM *dst, DWTELEM *src, int stride, int bias){
03384     const int w= b->width;
03385     const int h= b->height;
03386     const int qlog= av_clip(s->qlog + b->qlog, 0, QROOT*16);
03387     const int qmul= qexp[qlog&(QROOT-1)]<<((qlog>>QSHIFT) + ENCODER_EXTRA_BITS);
03388     int x,y, thres1, thres2;
03389 
03390     if(s->qlog == LOSSLESS_QLOG){
03391         for(y=0; y<h; y++)
03392             for(x=0; x<w; x++)
03393                 dst[x + y*stride]= src[x + y*stride];
03394         return;
03395     }
03396 
03397     bias= bias ? 0 : (3*qmul)>>3;
03398     thres1= ((qmul - bias)>>QEXPSHIFT) - 1;
03399     thres2= 2*thres1;
03400 
03401     if(!bias){
03402         for(y=0; y<h; y++){
03403             for(x=0; x<w; x++){
03404                 int i= src[x + y*stride];
03405 
03406                 if((unsigned)(i+thres1) > thres2){
03407                     if(i>=0){
03408                         i<<= QEXPSHIFT;
03409                         i/= qmul; //FIXME optimize
03410                         dst[x + y*stride]=  i;
03411                     }else{
03412                         i= -i;
03413                         i<<= QEXPSHIFT;
03414                         i/= qmul; //FIXME optimize
03415                         dst[x + y*stride]= -i;
03416                     }
03417                 }else
03418                     dst[x + y*stride]= 0;
03419             }
03420         }
03421     }else{
03422         for(y=0; y<h; y++){
03423             for(x=0; x<w; x++){
03424                 int i= src[x + y*stride];
03425 
03426                 if((unsigned)(i+thres1) > thres2){
03427                     if(i>=0){
03428                         i<<= QEXPSHIFT;
03429                         i= (i + bias) / qmul; //FIXME optimize
03430                         dst[x + y*stride]=  i;
03431                     }else{
03432                         i= -i;
03433                         i<<= QEXPSHIFT;
03434                         i= (i + bias) / qmul; //FIXME optimize
03435                         dst[x + y*stride]= -i;
03436                     }
03437                 }else
03438                     dst[x + y*stride]= 0;
03439             }
03440         }
03441     }
03442 }
03443 
03444 static void dequantize(SnowContext *s, SubBand *b, IDWTELEM *src, int stride){
03445     const int w= b->width;
03446     const int h= b->height;
03447     const int qlog= av_clip(s->qlog + b->qlog, 0, QROOT*16);
03448     const int qmul= qexp[qlog&(QROOT-1)]<<(qlog>>QSHIFT);
03449     const int qadd= (s->qbias*qmul)>>QBIAS_SHIFT;
03450     int x,y;
03451 
03452     if(s->qlog == LOSSLESS_QLOG) return;
03453 
03454     for(y=0; y<h; y++){
03455         for(x=0; x<w; x++){
03456             int i= src[x + y*stride];
03457             if(i<0){
03458                 src[x + y*stride]= -((-i*qmul + qadd)>>(QEXPSHIFT)); //FIXME try different bias
03459             }else if(i>0){
03460                 src[x + y*stride]=  (( i*qmul + qadd)>>(QEXPSHIFT));
03461             }
03462         }
03463     }
03464 }
03465 
03466 static void decorrelate(SnowContext *s, SubBand *b, IDWTELEM *src, int stride, int inverse, int use_median){
03467     const int w= b->width;
03468     const int h= b->height;
03469     int x,y;
03470 
03471     for(y=h-1; y>=0; y--){
03472         for(x=w-1; x>=0; x--){
03473             int i= x + y*stride;
03474 
03475             if(x){
03476                 if(use_median){
03477                     if(y && x+1<w) src[i] -= mid_pred(src[i - 1], src[i - stride], src[i - stride + 1]);
03478                     else  src[i] -= src[i - 1];
03479                 }else{
03480                     if(y) src[i] -= mid_pred(src[i - 1], src[i - stride], src[i - 1] + src[i - stride] - src[i - 1 - stride]);
03481                     else  src[i] -= src[i - 1];
03482                 }
03483             }else{
03484                 if(y) src[i] -= src[i - stride];
03485             }
03486         }
03487     }
03488 }
03489 
03490 static void correlate(SnowContext *s, SubBand *b, IDWTELEM *src, int stride, int inverse, int use_median){
03491     const int w= b->width;
03492     const int h= b->height;
03493     int x,y;
03494 
03495     for(y=0; y<h; y++){
03496         for(x=0; x<w; x++){
03497             int i= x + y*stride;
03498 
03499             if(x){
03500                 if(use_median){
03501                     if(y && x+1<w) src[i] += mid_pred(src[i - 1], src[i - stride], src[i - stride + 1]);
03502                     else  src[i] += src[i - 1];
03503                 }else{
03504                     if(y) src[i] += mid_pred(src[i - 1], src[i - stride], src[i - 1] + src[i - stride] - src[i - 1 - stride]);
03505                     else  src[i] += src[i - 1];
03506                 }
03507             }else{
03508                 if(y) src[i] += src[i - stride];
03509             }
03510         }
03511     }
03512 }
03513 
03514 static void encode_qlogs(SnowContext *s){
03515     int plane_index, level, orientation;
03516 
03517     for(plane_index=0; plane_index<2; plane_index++){
03518         for(level=0; level<s->spatial_decomposition_count; level++){
03519             for(orientation=level ? 1:0; orientation<4; orientation++){
03520                 if(orientation==2) continue;
03521                 put_symbol(&s->c, s->header_state, s->plane[plane_index].band[level][orientation].qlog, 1);
03522             }
03523         }
03524     }
03525 }
03526 
03527 static void encode_header(SnowContext *s){
03528     int plane_index, i;
03529     uint8_t kstate[32];
03530 
03531     memset(kstate, MID_STATE, sizeof(kstate));
03532 
03533     put_rac(&s->c, kstate, s->keyframe);
03534     if(s->keyframe || s->always_reset){
03535         reset_contexts(s);
03536         s->last_spatial_decomposition_type=
03537         s->last_qlog=
03538         s->last_qbias=
03539         s->last_mv_scale=
03540         s->last_block_max_depth= 0;
03541         for(plane_index=0; plane_index<2; plane_index++){
03542             Plane *p= &s->plane[plane_index];
03543             p->last_htaps=0;
03544             p->last_diag_mc=0;
03545             memset(p->last_hcoeff, 0, sizeof(p->last_hcoeff));
03546         }
03547     }
03548     if(s->keyframe){
03549         put_symbol(&s->c, s->header_state, s->version, 0);
03550         put_rac(&s->c, s->header_state, s->always_reset);
03551         put_symbol(&s->c, s->header_state, s->temporal_decomposition_type, 0);
03552         put_symbol(&s->c, s->header_state, s->temporal_decomposition_count, 0);
03553         put_symbol(&s->c, s->header_state, s->spatial_decomposition_count, 0);
03554         put_symbol(&s->c, s->header_state, s->colorspace_type, 0);
03555         put_symbol(&s->c, s->header_state, s->chroma_h_shift, 0);
03556         put_symbol(&s->c, s->header_state, s->chroma_v_shift, 0);
03557         put_rac(&s->c, s->header_state, s->spatial_scalability);
03558 //        put_rac(&s->c, s->header_state, s->rate_scalability);
03559         put_symbol(&s->c, s->header_state, s->max_ref_frames-1, 0);
03560 
03561         encode_qlogs(s);
03562     }
03563 
03564     if(!s->keyframe){
03565         int update_mc=0;
03566         for(plane_index=0; plane_index<2; plane_index++){
03567             Plane *p= &s->plane[plane_index];
03568             update_mc |= p->last_htaps   != p->htaps;
03569             update_mc |= p->last_diag_mc != p->diag_mc;
03570             update_mc |= !!memcmp(p->last_hcoeff, p->hcoeff, sizeof(p->hcoeff));
03571         }
03572         put_rac(&s->c, s->header_state, update_mc);
03573         if(update_mc){
03574             for(plane_index=0; plane_index<2; plane_index++){
03575                 Plane *p= &s->plane[plane_index];
03576                 put_rac(&s->c, s->header_state, p->diag_mc);
03577                 put_symbol(&s->c, s->header_state, p->htaps/2-1, 0);
03578                 for(i= p->htaps/2; i; i--)
03579                     put_symbol(&s->c, s->header_state, FFABS(p->hcoeff[i]), 0);
03580             }
03581         }
03582         if(s->last_spatial_decomposition_count != s->spatial_decomposition_count){
03583             put_rac(&s->c, s->header_state, 1);
03584             put_symbol(&s->c, s->header_state, s->spatial_decomposition_count, 0);
03585             encode_qlogs(s);
03586         }else
03587             put_rac(&s->c, s->header_state, 0);
03588     }
03589 
03590     put_symbol(&s->c, s->header_state, s->spatial_decomposition_type - s->last_spatial_decomposition_type, 1);
03591     put_symbol(&s->c, s->header_state, s->qlog            - s->last_qlog    , 1);
03592     put_symbol(&s->c, s->header_state, s->mv_scale        - s->last_mv_scale, 1);
03593     put_symbol(&s->c, s->header_state, s->qbias           - s->last_qbias   , 1);
03594     put_symbol(&s->c, s->header_state, s->block_max_depth - s->last_block_max_depth, 1);
03595 
03596 }
03597 
03598 static void update_last_header_values(SnowContext *s){
03599     int plane_index;
03600 
03601     if(!s->keyframe){
03602         for(plane_index=0; plane_index<2; plane_index++){
03603             Plane *p= &s->plane[plane_index];
03604             p->last_diag_mc= p->diag_mc;
03605             p->last_htaps  = p->htaps;
03606             memcpy(p->last_hcoeff, p->hcoeff, sizeof(p->hcoeff));
03607         }
03608     }
03609 
03610     s->last_spatial_decomposition_type  = s->spatial_decomposition_type;
03611     s->last_qlog                        = s->qlog;
03612     s->last_qbias                       = s->qbias;
03613     s->last_mv_scale                    = s->mv_scale;
03614     s->last_block_max_depth             = s->block_max_depth;
03615     s->last_spatial_decomposition_count = s->spatial_decomposition_count;
03616 }
03617 
03618 static int qscale2qlog(int qscale){
03619     return rint(QROOT*log(qscale / (float)FF_QP2LAMBDA)/log(2))
03620            + 61*QROOT/8; //<64 >60
03621 }
03622 
03623 static int ratecontrol_1pass(SnowContext *s, AVFrame *pict)
03624 {
03625     /* Estimate the frame's complexity as a sum of weighted dwt coefficients.
03626      * FIXME we know exact mv bits at this point,
03627      * but ratecontrol isn't set up to include them. */
03628     uint32_t coef_sum= 0;
03629     int level, orientation, delta_qlog;
03630 
03631     for(level=0; level<s->spatial_decomposition_count; level++){
03632         for(orientation=level ? 1 : 0; orientation<4; orientation++){
03633             SubBand *b= &s->plane[0].band[level][orientation];
03634             IDWTELEM *buf= b->ibuf;
03635             const int w= b->width;
03636             const int h= b->height;
03637             const int stride= b->stride;
03638             const int qlog= av_clip(2*QROOT + b->qlog, 0, QROOT*16);
03639             const int qmul= qexp[qlog&(QROOT-1)]<<(qlog>>QSHIFT);
03640             const int qdiv= (1<<16)/qmul;
03641             int x, y;
03642             //FIXME this is ugly
03643             for(y=0; y<h; y++)
03644                 for(x=0; x<w; x++)
03645                     buf[x+y*stride]= b->buf[x+y*stride];
03646             if(orientation==0)
03647                 decorrelate(s, b, buf, stride, 1, 0);
03648             for(y=0; y<h; y++)
03649                 for(x=0; x<w; x++)
03650                     coef_sum+= abs(buf[x+y*stride]) * qdiv >> 16;
03651         }
03652     }
03653 
03654     /* ugly, ratecontrol just takes a sqrt again */
03655     coef_sum = (uint64_t)coef_sum * coef_sum >> 16;
03656     assert(coef_sum < INT_MAX);
03657 
03658     if(pict->pict_type == AV_PICTURE_TYPE_I){
03659         s->m.current_picture.mb_var_sum= coef_sum;
03660         s->m.current_picture.mc_mb_var_sum= 0;
03661     }else{
03662         s->m.current_picture.mc_mb_var_sum= coef_sum;
03663         s->m.current_picture.mb_var_sum= 0;
03664     }
03665 
03666     pict->quality= ff_rate_estimate_qscale(&s->m, 1);
03667     if (pict->quality < 0)
03668         return INT_MIN;
03669     s->lambda= pict->quality * 3/2;
03670     delta_qlog= qscale2qlog(pict->quality) - s->qlog;
03671     s->qlog+= delta_qlog;
03672     return delta_qlog;
03673 }
03674 
03675 static void calculate_visual_weight(SnowContext *s, Plane *p){
03676     int width = p->width;
03677     int height= p->height;
03678     int level, orientation, x, y;
03679 
03680     for(level=0; level<s->spatial_decomposition_count; level++){
03681         for(orientation=level ? 1 : 0; orientation<4; orientation++){
03682             SubBand *b= &p->band[level][orientation];
03683             IDWTELEM *ibuf= b->ibuf;
03684             int64_t error=0;
03685 
03686             memset(s->spatial_idwt_buffer, 0, sizeof(*s->spatial_idwt_buffer)*width*height);
03687             ibuf[b->width/2 + b->height/2*b->stride]= 256*16;
03688             ff_spatial_idwt(s->spatial_idwt_buffer, width, height, width, s->spatial_decomposition_type, s->spatial_decomposition_count);
03689             for(y=0; y<height; y++){
03690                 for(x=0; x<width; x++){
03691                     int64_t d= s->spatial_idwt_buffer[x + y*width]*16;
03692                     error += d*d;
03693                 }
03694             }
03695 
03696             b->qlog= (int)(log(352256.0/sqrt(error)) / log(pow(2.0, 1.0/QROOT))+0.5);
03697         }
03698     }
03699 }
03700 
03701 static int encode_frame(AVCodecContext *avctx, unsigned char *buf, int buf_size, void *data){
03702     SnowContext *s = avctx->priv_data;
03703     RangeCoder * const c= &s->c;
03704     AVFrame *pict = data;
03705     const int width= s->avctx->width;
03706     const int height= s->avctx->height;
03707     int level, orientation, plane_index, i, y;
03708     uint8_t rc_header_bak[sizeof(s->header_state)];
03709     uint8_t rc_block_bak[sizeof(s->block_state)];
03710 
03711     ff_init_range_encoder(c, buf, buf_size);
03712     ff_build_rac_states(c, 0.05*(1LL<<32), 256-8);
03713 
03714     for(i=0; i<3; i++){
03715         int shift= !!i;
03716         for(y=0; y<(height>>shift); y++)
03717             memcpy(&s->input_picture.data[i][y * s->input_picture.linesize[i]],
03718                    &pict->data[i][y * pict->linesize[i]],
03719                    width>>shift);
03720     }
03721     s->new_picture = *pict;
03722 
03723     s->m.picture_number= avctx->frame_number;
03724     if(avctx->flags&CODEC_FLAG_PASS2){
03725         s->m.pict_type =
03726         pict->pict_type= s->m.rc_context.entry[avctx->frame_number].new_pict_type;
03727         s->keyframe= pict->pict_type==AV_PICTURE_TYPE_I;
03728         if(!(avctx->flags&CODEC_FLAG_QSCALE)) {
03729             pict->quality= ff_rate_estimate_qscale(&s->m, 0);
03730             if (pict->quality < 0)
03731                 return -1;
03732         }
03733     }else{
03734         s->keyframe= avctx->gop_size==0 || avctx->frame_number % avctx->gop_size == 0;
03735         s->m.pict_type=
03736         pict->pict_type= s->keyframe ? AV_PICTURE_TYPE_I : AV_PICTURE_TYPE_P;
03737     }
03738 
03739     if(s->pass1_rc && avctx->frame_number == 0)
03740         pict->quality= 2*FF_QP2LAMBDA;
03741     if(pict->quality){
03742         s->qlog= qscale2qlog(pict->quality);
03743         s->lambda = pict->quality * 3/2;
03744     }
03745     if(s->qlog < 0 || (!pict->quality && (avctx->flags & CODEC_FLAG_QSCALE))){
03746         s->qlog= LOSSLESS_QLOG;
03747         s->lambda = 0;
03748     }//else keep previous frame's qlog until after motion estimation
03749 
03750     frame_start(s);
03751 
03752     s->m.current_picture_ptr= &s->m.current_picture;
03753     s->m.last_picture.pts= s->m.current_picture.pts;
03754     s->m.current_picture.pts= pict->pts;
03755     if(pict->pict_type == AV_PICTURE_TYPE_P){
03756         int block_width = (width +15)>>4;
03757         int block_height= (height+15)>>4;
03758         int stride= s->current_picture.linesize[0];
03759 
03760         assert(s->current_picture.data[0]);
03761         assert(s->last_picture[0].data[0]);
03762 
03763         s->m.avctx= s->avctx;
03764         s->m.current_picture.data[0]= s->current_picture.data[0];
03765         s->m.   last_picture.data[0]= s->last_picture[0].data[0];
03766         s->m.    new_picture.data[0]= s->  input_picture.data[0];
03767         s->m.   last_picture_ptr= &s->m.   last_picture;
03768         s->m.linesize=
03769         s->m.   last_picture.linesize[0]=
03770         s->m.    new_picture.linesize[0]=
03771         s->m.current_picture.linesize[0]= stride;
03772         s->m.uvlinesize= s->current_picture.linesize[1];
03773         s->m.width = width;
03774         s->m.height= height;
03775         s->m.mb_width = block_width;
03776         s->m.mb_height= block_height;
03777         s->m.mb_stride=   s->m.mb_width+1;
03778         s->m.b8_stride= 2*s->m.mb_width+1;
03779         s->m.f_code=1;
03780         s->m.pict_type= pict->pict_type;
03781         s->m.me_method= s->avctx->me_method;
03782         s->m.me.scene_change_score=0;
03783         s->m.flags= s->avctx->flags;
03784         s->m.quarter_sample= (s->avctx->flags & CODEC_FLAG_QPEL)!=0;
03785         s->m.out_format= FMT_H263;
03786         s->m.unrestricted_mv= 1;
03787 
03788         s->m.lambda = s->lambda;
03789         s->m.qscale= (s->m.lambda*139 + FF_LAMBDA_SCALE*64) >> (FF_LAMBDA_SHIFT + 7);
03790         s->lambda2= s->m.lambda2= (s->m.lambda*s->m.lambda + FF_LAMBDA_SCALE/2) >> FF_LAMBDA_SHIFT;
03791 
03792         s->m.dsp= s->dsp; //move
03793         ff_init_me(&s->m);
03794         s->dsp= s->m.dsp;
03795     }
03796 
03797     if(s->pass1_rc){
03798         memcpy(rc_header_bak, s->header_state, sizeof(s->header_state));
03799         memcpy(rc_block_bak, s->block_state, sizeof(s->block_state));
03800     }
03801 
03802 redo_frame:
03803 
03804     if(pict->pict_type == AV_PICTURE_TYPE_I)
03805         s->spatial_decomposition_count= 5;
03806     else
03807         s->spatial_decomposition_count= 5;
03808 
03809     s->m.pict_type = pict->pict_type;
03810     s->qbias= pict->pict_type == AV_PICTURE_TYPE_P ? 2 : 0;
03811 
03812     common_init_after_header(avctx);
03813 
03814     if(s->last_spatial_decomposition_count != s->spatial_decomposition_count){
03815         for(plane_index=0; plane_index<3; plane_index++){
03816             calculate_visual_weight(s, &s->plane[plane_index]);
03817         }
03818     }
03819 
03820     encode_header(s);
03821     s->m.misc_bits = 8*(s->c.bytestream - s->c.bytestream_start);
03822     encode_blocks(s, 1);
03823     s->m.mv_bits = 8*(s->c.bytestream - s->c.bytestream_start) - s->m.misc_bits;
03824 
03825     for(plane_index=0; plane_index<3; plane_index++){
03826         Plane *p= &s->plane[plane_index];
03827         int w= p->width;
03828         int h= p->height;
03829         int x, y;
03830 //        int bits= put_bits_count(&s->c.pb);
03831 
03832         if(!(avctx->flags2 & CODEC_FLAG2_MEMC_ONLY)){
03833             //FIXME optimize
03834             if(pict->data[plane_index]) //FIXME gray hack
03835                 for(y=0; y<h; y++){
03836                     for(x=0; x<w; x++){
03837                         s->spatial_idwt_buffer[y*w + x]= pict->data[plane_index][y*pict->linesize[plane_index] + x]<<FRAC_BITS;
03838                     }
03839                 }
03840             predict_plane(s, s->spatial_idwt_buffer, plane_index, 0);
03841 
03842             if(   plane_index==0
03843                && pict->pict_type == AV_PICTURE_TYPE_P
03844                && !(avctx->flags&CODEC_FLAG_PASS2)
03845                && s->m.me.scene_change_score > s->avctx->scenechange_threshold){
03846                 ff_init_range_encoder(c, buf, buf_size);
03847                 ff_build_rac_states(c, 0.05*(1LL<<32), 256-8);
03848                 pict->pict_type= AV_PICTURE_TYPE_I;
03849                 s->keyframe=1;
03850                 s->current_picture.key_frame=1;
03851                 goto redo_frame;
03852             }
03853 
03854             if(s->qlog == LOSSLESS_QLOG){
03855                 for(y=0; y<h; y++){
03856                     for(x=0; x<w; x++){
03857                         s->spatial_dwt_buffer[y*w + x]= (s->spatial_idwt_buffer[y*w + x] + (1<<(FRAC_BITS-1))-1)>>FRAC_BITS;
03858                     }
03859                 }
03860             }else{
03861                 for(y=0; y<h; y++){
03862                     for(x=0; x<w; x++){
03863                         s->spatial_dwt_buffer[y*w + x]=s->spatial_idwt_buffer[y*w + x]<<ENCODER_EXTRA_BITS;
03864                     }
03865                 }
03866             }
03867 
03868             /*  if(QUANTIZE2)
03869                 dwt_quantize(s, p, s->spatial_dwt_buffer, w, h, w, s->spatial_decomposition_type);
03870             else*/
03871                 ff_spatial_dwt(s->spatial_dwt_buffer, w, h, w, s->spatial_decomposition_type, s->spatial_decomposition_count);
03872 
03873             if(s->pass1_rc && plane_index==0){
03874                 int delta_qlog = ratecontrol_1pass(s, pict);
03875                 if (delta_qlog <= INT_MIN)
03876                     return -1;
03877                 if(delta_qlog){
03878                     //reordering qlog in the bitstream would eliminate this reset
03879                     ff_init_range_encoder(c, buf, buf_size);
03880                     memcpy(s->header_state, rc_header_bak, sizeof(s->header_state));
03881                     memcpy(s->block_state, rc_block_bak, sizeof(s->block_state));
03882                     encode_header(s);
03883                     encode_blocks(s, 0);
03884                 }
03885             }
03886 
03887             for(level=0; level<s->spatial_decomposition_count; level++){
03888                 for(orientation=level ? 1 : 0; orientation<4; orientation++){
03889                     SubBand *b= &p->band[level][orientation];
03890 
03891                     if(!QUANTIZE2)
03892                         quantize(s, b, b->ibuf, b->buf, b->stride, s->qbias);
03893                     if(orientation==0)
03894                         decorrelate(s, b, b->ibuf, b->stride, pict->pict_type == AV_PICTURE_TYPE_P, 0);
03895                     encode_subband(s, b, b->ibuf, b->parent ? b->parent->ibuf : NULL, b->stride, orientation);
03896                     assert(b->parent==NULL || b->parent->stride == b->stride*2);
03897                     if(orientation==0)
03898                         correlate(s, b, b->ibuf, b->stride, 1, 0);
03899                 }
03900             }
03901 
03902             for(level=0; level<s->spatial_decomposition_count; level++){
03903                 for(orientation=level ? 1 : 0; orientation<4; orientation++){
03904                     SubBand *b= &p->band[level][orientation];
03905 
03906                     dequantize(s, b, b->ibuf, b->stride);
03907                 }
03908             }
03909 
03910             ff_spatial_idwt(s->spatial_idwt_buffer, w, h, w, s->spatial_decomposition_type, s->spatial_decomposition_count);
03911             if(s->qlog == LOSSLESS_QLOG){
03912                 for(y=0; y<h; y++){
03913                     for(x=0; x<w; x++){
03914                         s->spatial_idwt_buffer[y*w + x]<<=FRAC_BITS;
03915                     }
03916                 }
03917             }
03918             predict_plane(s, s->spatial_idwt_buffer, plane_index, 1);
03919         }else{
03920             //ME/MC only
03921             if(pict->pict_type == AV_PICTURE_TYPE_I){
03922                 for(y=0; y<h; y++){
03923                     for(x=0; x<w; x++){
03924                         s->current_picture.data[plane_index][y*s->current_picture.linesize[plane_index] + x]=
03925                             pict->data[plane_index][y*pict->linesize[plane_index] + x];
03926                     }
03927                 }
03928             }else{
03929                 memset(s->spatial_idwt_buffer, 0, sizeof(IDWTELEM)*w*h);
03930                 predict_plane(s, s->spatial_idwt_buffer, plane_index, 1);
03931             }
03932         }
03933         if(s->avctx->flags&CODEC_FLAG_PSNR){
03934             int64_t error= 0;
03935 
03936             if(pict->data[plane_index]) //FIXME gray hack
03937                 for(y=0; y<h; y++){
03938                     for(x=0; x<w; x++){
03939                         int d= s->current_picture.data[plane_index][y*s->current_picture.linesize[plane_index] + x] - pict->data[plane_index][y*pict->linesize[plane_index] + x];
03940                         error += d*d;
03941                     }
03942                 }
03943             s->avctx->error[plane_index] += error;
03944             s->current_picture.error[plane_index] = error;
03945         }
03946 
03947     }
03948 
03949     update_last_header_values(s);
03950 
03951     release_buffer(avctx);
03952 
03953     s->current_picture.coded_picture_number = avctx->frame_number;
03954     s->current_picture.pict_type = pict->pict_type;
03955     s->current_picture.quality = pict->quality;
03956     s->m.frame_bits = 8*(s->c.bytestream - s->c.bytestream_start);
03957     s->m.p_tex_bits = s->m.frame_bits - s->m.misc_bits - s->m.mv_bits;
03958     s->m.current_picture.display_picture_number =
03959     s->m.current_picture.coded_picture_number = avctx->frame_number;
03960     s->m.current_picture.quality = pict->quality;
03961     s->m.total_bits += 8*(s->c.bytestream - s->c.bytestream_start);
03962     if(s->pass1_rc)
03963         if (ff_rate_estimate_qscale(&s->m, 0) < 0)
03964             return -1;
03965     if(avctx->flags&CODEC_FLAG_PASS1)
03966         ff_write_pass1_stats(&s->m);
03967     s->m.last_pict_type = s->m.pict_type;
03968     avctx->frame_bits = s->m.frame_bits;
03969     avctx->mv_bits = s->m.mv_bits;
03970     avctx->misc_bits = s->m.misc_bits;
03971     avctx->p_tex_bits = s->m.p_tex_bits;
03972 
03973     emms_c();
03974 
03975     return ff_rac_terminate(c);
03976 }
03977 
03978 static av_cold int encode_end(AVCodecContext *avctx)
03979 {
03980     SnowContext *s = avctx->priv_data;
03981 
03982     common_end(s);
03983     if (s->input_picture.data[0])
03984         avctx->release_buffer(avctx, &s->input_picture);
03985     av_free(avctx->stats_out);
03986 
03987     return 0;
03988 }
03989 
03990 AVCodec ff_snow_encoder = {
03991     "snow",
03992     AVMEDIA_TYPE_VIDEO,
03993     CODEC_ID_SNOW,
03994     sizeof(SnowContext),
03995     encode_init,
03996     encode_frame,
03997     encode_end,
03998     .long_name = NULL_IF_CONFIG_SMALL("Snow"),
03999 };
04000 #endif
04001 
04002 
04003 #ifdef TEST
04004 #undef malloc
04005 #undef free
04006 #undef printf
04007 
04008 #include "libavutil/lfg.h"
04009 
04010 int main(void){
04011     int width=256;
04012     int height=256;
04013     int buffer[2][width*height];
04014     SnowContext s;
04015     int i;
04016     AVLFG prng;
04017     s.spatial_decomposition_count=6;
04018     s.spatial_decomposition_type=1;
04019 
04020     av_lfg_init(&prng, 1);
04021 
04022     printf("testing 5/3 DWT\n");
04023     for(i=0; i<width*height; i++)
04024         buffer[0][i] = buffer[1][i] = av_lfg_get(&prng) % 54321 - 12345;
04025 
04026     ff_spatial_dwt(buffer[0], width, height, width, s.spatial_decomposition_type, s.spatial_decomposition_count);
04027     ff_spatial_idwt(buffer[0], width, height, width, s.spatial_decomposition_type, s.spatial_decomposition_count);
04028 
04029     for(i=0; i<width*height; i++)
04030         if(buffer[0][i]!= buffer[1][i]) printf("fsck: %6d %12d %7d\n",i, buffer[0][i], buffer[1][i]);
04031 
04032     printf("testing 9/7 DWT\n");
04033     s.spatial_decomposition_type=0;
04034     for(i=0; i<width*height; i++)
04035         buffer[0][i] = buffer[1][i] = av_lfg_get(&prng) % 54321 - 12345;
04036 
04037     ff_spatial_dwt(buffer[0], width, height, width, s.spatial_decomposition_type, s.spatial_decomposition_count);
04038     ff_spatial_idwt(buffer[0], width, height, width, s.spatial_decomposition_type, s.spatial_decomposition_count);
04039 
04040     for(i=0; i<width*height; i++)
04041         if(FFABS(buffer[0][i] - buffer[1][i])>20) printf("fsck: %6d %12d %7d\n",i, buffer[0][i], buffer[1][i]);
04042 
04043 #if 0
04044     printf("testing AC coder\n");
04045     memset(s.header_state, 0, sizeof(s.header_state));
04046     ff_init_range_encoder(&s.c, buffer[0], 256*256);
04047     ff_init_cabac_states(&s.c, ff_h264_lps_range, ff_h264_mps_state, ff_h264_lps_state, 64);
04048 
04049     for(i=-256; i<256; i++){
04050         put_symbol(&s.c, s.header_state, i*i*i/3*FFABS(i), 1);
04051     }
04052     ff_rac_terminate(&s.c);
04053 
04054     memset(s.header_state, 0, sizeof(s.header_state));
04055     ff_init_range_decoder(&s.c, buffer[0], 256*256);
04056     ff_init_cabac_states(&s.c, ff_h264_lps_range, ff_h264_mps_state, ff_h264_lps_state, 64);
04057 
04058     for(i=-256; i<256; i++){
04059         int j;
04060         j= get_symbol(&s.c, s.header_state, 1);
04061         if(j!=i*i*i/3*FFABS(i)) printf("fsck: %d != %d\n", i, j);
04062     }
04063 #endif
04064     {
04065     int level, orientation, x, y;
04066     int64_t errors[8][4];
04067     int64_t g=0;
04068 
04069         memset(errors, 0, sizeof(errors));
04070         s.spatial_decomposition_count=3;
04071         s.spatial_decomposition_type=0;
04072         for(level=0; level<s.spatial_decomposition_count; level++){
04073             for(orientation=level ? 1 : 0; orientation<4; orientation++){
04074                 int w= width  >> (s.spatial_decomposition_count-level);
04075                 int h= height >> (s.spatial_decomposition_count-level);
04076                 int stride= width  << (s.spatial_decomposition_count-level);
04077                 DWTELEM *buf= buffer[0];
04078                 int64_t error=0;
04079 
04080                 if(orientation&1) buf+=w;
04081                 if(orientation>1) buf+=stride>>1;
04082 
04083                 memset(buffer[0], 0, sizeof(int)*width*height);
04084                 buf[w/2 + h/2*stride]= 256*256;
04085                 ff_spatial_idwt(buffer[0], width, height, width, s.spatial_decomposition_type, s.spatial_decomposition_count);
04086                 for(y=0; y<height; y++){
04087                     for(x=0; x<width; x++){
04088                         int64_t d= buffer[0][x + y*width];
04089                         error += d*d;
04090                         if(FFABS(width/2-x)<9 && FFABS(height/2-y)<9 && level==2) printf("%8"PRId64" ", d);
04091                     }
04092                     if(FFABS(height/2-y)<9 && level==2) printf("\n");
04093                 }
04094                 error= (int)(sqrt(error)+0.5);
04095                 errors[level][orientation]= error;
04096                 if(g) g=av_gcd(g, error);
04097                 else g= error;
04098             }
04099         }
04100         printf("static int const visual_weight[][4]={\n");
04101         for(level=0; level<s.spatial_decomposition_count; level++){
04102             printf("  {");
04103             for(orientation=0; orientation<4; orientation++){
04104                 printf("%8"PRId64",", errors[level][orientation]/g);
04105             }
04106             printf("},\n");
04107         }
04108         printf("};\n");
04109         {
04110             int level=2;
04111             int w= width  >> (s.spatial_decomposition_count-level);
04112             //int h= height >> (s.spatial_decomposition_count-level);
04113             int stride= width  << (s.spatial_decomposition_count-level);
04114             DWTELEM *buf= buffer[0];
04115             int64_t error=0;
04116 
04117             buf+=w;
04118             buf+=stride>>1;
04119 
04120             memset(buffer[0], 0, sizeof(int)*width*height);
04121 #if 1
04122             for(y=0; y<height; y++){
04123                 for(x=0; x<width; x++){
04124                     int tab[4]={0,2,3,1};
04125                     buffer[0][x+width*y]= 256*256*tab[(x&1) + 2*(y&1)];
04126                 }
04127             }
04128             ff_spatial_dwt(buffer[0], width, height, width, s.spatial_decomposition_type, s.spatial_decomposition_count);
04129 #else
04130             for(y=0; y<h; y++){
04131                 for(x=0; x<w; x++){
04132                     buf[x + y*stride  ]=169;
04133                     buf[x + y*stride-w]=64;
04134                 }
04135             }
04136             ff_spatial_idwt(buffer[0], width, height, width, s.spatial_decomposition_type, s.spatial_decomposition_count);
04137 #endif
04138             for(y=0; y<height; y++){
04139                 for(x=0; x<width; x++){
04140                     int64_t d= buffer[0][x + y*width];
04141                     error += d*d;
04142                     if(FFABS(width/2-x)<9 && FFABS(height/2-y)<9) printf("%8"PRId64" ", d);
04143                 }
04144                 if(FFABS(height/2-y)<9) printf("\n");
04145             }
04146         }
04147 
04148     }
04149     return 0;
04150 }
04151 #endif /* TEST */

Generated on Fri Feb 22 2013 07:24:28 for FFmpeg by  doxygen 1.7.1