FFmpeg: libavcodec/msmpeg4.c Source File

FFmpeg

[フレーム]

libavcodec

msmpeg4.c

Go to the documentation of this file.

1 /*

2 * MSMPEG4 backend for encoder and decoder

5 *

6 * msmpeg4v1 & v2 stuff by Michael Niedermayer <michaelni@gmx.at>

7 *

8 * This file is part of FFmpeg.

9 *

10 * FFmpeg is free software; you can redistribute it and/or

11 * modify it under the terms of the GNU Lesser General Public

12 * License as published by the Free Software Foundation; either

13 * version 2.1 of the License, or (at your option) any later version.

14 *

15 * FFmpeg is distributed in the hope that it will be useful,

16 * but WITHOUT ANY WARRANTY; without even the implied warranty of

17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

18 * Lesser General Public License for more details.

19 *

20 * You should have received a copy of the GNU Lesser General Public

21 * License along with FFmpeg; if not, write to the Free Software

22 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

23 */

25 /**

26 * @file

27 * MSMPEG4 backend for encoder and decoder

28 */

30 #include "avcodec.h"

31 #include "dsputil.h"

32 #include "mpegvideo.h"

33 #include "msmpeg4.h"

34 #include "libavutil/x86/asm.h"

35 #include "h263.h"

36 #include "mpeg4video.h"

37 #include "msmpeg4data.h"

38 #include "vc1data.h"

39 #include "libavutil/imgutils.h"

41 /*

42 * You can also call this codec : MPEG4 with a twist !

43 *

44 * TODO:

45 * - (encoding) select best mv table (two choices)

46 * - (encoding) select best vlc/dc table

47 */

49 /* This table is practically identical to the one from h263

50 * except that it is inverted. */

51 static av_cold void init_h263_dc_for_msmpeg4(void)

52 {

53 int level, uni_code, uni_len;

55 if(ff_v2_dc_chroma_table[255 + 256][1])

56 return;

58 for(level=-256; level<256; level++){

59 int size, v, l;

60 /* find number of bits */

61 size = 0;

62 v = abs(level);

63 while (v) {

64 v >>= 1;

65 size++;

66 }

68 if (level < 0)

69 l= (-level) ^ ((1 << size) - 1);

70 else

71 l= level;

73 /* luminance h263 */

74 uni_code= ff_mpeg4_DCtab_lum[size][0];

75 uni_len = ff_mpeg4_DCtab_lum[size][1];

76 uni_code ^= (1<<uni_len)-1; //M$ does not like compatibility

78 if (size > 0) {

79 uni_code<<=size; uni_code|=l;

80 uni_len+=size;

81 if (size > 8){

82 uni_code<<=1; uni_code|=1;

83 uni_len++;

84 }

85 }

86 ff_v2_dc_lum_table[level + 256][0] = uni_code;

87 ff_v2_dc_lum_table[level + 256][1] = uni_len;

89 /* chrominance h263 */

90 uni_code= ff_mpeg4_DCtab_chrom[size][0];

91 uni_len = ff_mpeg4_DCtab_chrom[size][1];

92 uni_code ^= (1<<uni_len)-1; //M$ does not like compatibility

94 if (size > 0) {

95 uni_code<<=size; uni_code|=l;

96 uni_len+=size;

97 if (size > 8){

98 uni_code<<=1; uni_code|=1;

99 uni_len++;

100 }

101 }

102 ff_v2_dc_chroma_table[level + 256][0] = uni_code;

103 ff_v2_dc_chroma_table[level + 256][1] = uni_len;

104

105 }

106 }

107

108 av_cold void ff_msmpeg4_common_init(MpegEncContext *s)

109 {

110 switch(s->msmpeg4_version){

111 case 1:

112 case 2:

113 s->y_dc_scale_table=

114 s->c_dc_scale_table= ff_mpeg1_dc_scale_table;

115 break;

116 case 3:

117 if(s->workaround_bugs){

118 s->y_dc_scale_table= ff_old_ff_y_dc_scale_table;

119 s->c_dc_scale_table= ff_wmv1_c_dc_scale_table;

120 } else{

121 s->y_dc_scale_table= ff_mpeg4_y_dc_scale_table;

122 s->c_dc_scale_table= ff_mpeg4_c_dc_scale_table;

123 }

124 break;

125 case 4:

126 case 5:

127 s->y_dc_scale_table= ff_wmv1_y_dc_scale_table;

128 s->c_dc_scale_table= ff_wmv1_c_dc_scale_table;

129 break;

130 #if CONFIG_VC1_DECODER

131 case 6:

132 s->y_dc_scale_table= ff_wmv3_dc_scale_table;

133 s->c_dc_scale_table= ff_wmv3_dc_scale_table;

134 break;

135 #endif

136

137 }

138

139

140 if(s->msmpeg4_version>=4){

141 ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable , ff_wmv1_scantable[1]);

142 ff_init_scantable(s->dsp.idct_permutation, &s->intra_h_scantable, ff_wmv1_scantable[2]);

143 ff_init_scantable(s->dsp.idct_permutation, &s->intra_v_scantable, ff_wmv1_scantable[3]);

144 ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable , ff_wmv1_scantable[0]);

145 }

146 //Note the default tables are set in common_init in mpegvideo.c

147

148 init_h263_dc_for_msmpeg4();

149 }

150

151 /* predict coded block */

152 int ff_msmpeg4_coded_block_pred(MpegEncContext * s, int n, uint8_t **coded_block_ptr)

153 {

154 int xy, wrap, pred, a, b, c;

155

156 xy = s->block_index[n];

157 wrap = s->b8_stride;

158

159 /* B C

160 * A X

161 */

162 a = s->coded_block[xy - 1 ];

163 b = s->coded_block[xy - 1 - wrap];

164 c = s->coded_block[xy - wrap];

165

166 if (b == c) {

167 pred = a;

168 } else {

169 pred = c;

170 }

171

172 /* store value */

173 *coded_block_ptr = &s->coded_block[xy];

174

175 return pred;

176 }

177

178 static int get_dc(uint8_t *src, int stride, int scale, int block_size)

179 {

180 int y;

181 int sum=0;

182 for(y=0; y<block_size; y++){

183 int x;

184 for(x=0; x<block_size; x++){

185 sum+=src[x + y*stride];

186 }

187 }

188 return FASTDIV((sum + (scale>>1)), scale);

189 }

190

191 /* dir = 0: left, dir = 1: top prediction */

192 int ff_msmpeg4_pred_dc(MpegEncContext *s, int n,

193 int16_t **dc_val_ptr, int *dir_ptr)

194 {

195 int a, b, c, wrap, pred, scale;

196 int16_t *dc_val;

197

198 /* find prediction */

199 if (n < 4) {

200 scale = s->y_dc_scale;

201 } else {

202 scale = s->c_dc_scale;

203 }

204

205 wrap = s->block_wrap[n];

206 dc_val= s->dc_val[0] + s->block_index[n];

207

208 /* B C

209 * A X

210 */

211 a = dc_val[ - 1];

212 b = dc_val[ - 1 - wrap];

213 c = dc_val[ - wrap];

214

215 if(s->first_slice_line && (n&2)==0 && s->msmpeg4_version<4){

216 b=c=1024;

217 }

218

219 /* XXX: the following solution consumes divisions, but it does not

220 necessitate to modify mpegvideo.c. The problem comes from the

221 fact they decided to store the quantized DC (which would lead

222 to problems if Q could vary !) */

223 #if ARCH_X86 && HAVE_7REGS && HAVE_EBX_AVAILABLE

224 __asm__ volatile(

225 "movl %3, %%eax \n\t"

226 "shrl 1,ドル %%eax \n\t"

227 "addl %%eax, %2 \n\t"

228 "addl %%eax, %1 \n\t"

229 "addl %0, %%eax \n\t"

230 "imull %4 \n\t"

231 "movl %%edx, %0 \n\t"

232 "movl %1, %%eax \n\t"

233 "imull %4 \n\t"

234 "movl %%edx, %1 \n\t"

235 "movl %2, %%eax \n\t"

236 "imull %4 \n\t"

237 "movl %%edx, %2 \n\t"

238 : "+b" (a), "+c" (b), "+D" (c)

239 : "g" (scale), "S" (ff_inverse[scale])

240 : "%eax", "%edx"

241 );

242 #else

243 /* #elif ARCH_ALPHA */

244 /* Divisions are extremely costly on Alpha; optimize the most

245 common case. But they are costly everywhere...

246 */

247 if (scale == 8) {

248 a = (a + (8 >> 1)) / 8;

249 b = (b + (8 >> 1)) / 8;

250 c = (c + (8 >> 1)) / 8;

251 } else {

252 a = FASTDIV((a + (scale >> 1)), scale);

253 b = FASTDIV((b + (scale >> 1)), scale);

254 c = FASTDIV((c + (scale >> 1)), scale);

255 }

256 #endif

257 /* XXX: WARNING: they did not choose the same test as MPEG4. This

258 is very important ! */

259 if(s->msmpeg4_version>3){

260 if(s->inter_intra_pred){

261 uint8_t *dest;

262 int wrap;

263

264 if(n==1){

265 pred=a;

266 *dir_ptr = 0;

267 }else if(n==2){

268 pred=c;

269 *dir_ptr = 1;

270 }else if(n==3){

271 if (abs(a - b) < abs(b - c)) {

272 pred = c;

273 *dir_ptr = 1;

274 } else {

275 pred = a;

276 *dir_ptr = 0;

277 }

278 }else{

279 int bs = 8 >> s->avctx->lowres;

280 if(n<4){

281 wrap= s->linesize;

282 dest= s->current_picture.f.data[0] + (((n >> 1) + 2*s->mb_y) * bs* wrap ) + ((n & 1) + 2*s->mb_x) * bs;

283 }else{

284 wrap= s->uvlinesize;

285 dest= s->current_picture.f.data[n - 3] + (s->mb_y * bs * wrap) + s->mb_x * bs;

286 }

287 if(s->mb_x==0) a= (1024 + (scale>>1))/scale;

288 else a= get_dc(dest-bs, wrap, scale*8>>(2*s->avctx->lowres), bs);

289 if(s->mb_y==0) c= (1024 + (scale>>1))/scale;

290 else c= get_dc(dest-bs*wrap, wrap, scale*8>>(2*s->avctx->lowres), bs);

291

292 if (s->h263_aic_dir==0) {

293 pred= a;

294 *dir_ptr = 0;

295 }else if (s->h263_aic_dir==1) {

296 if(n==0){

297 pred= c;

298 *dir_ptr = 1;

299 }else{

300 pred= a;

301 *dir_ptr = 0;

302 }

303 }else if (s->h263_aic_dir==2) {

304 if(n==0){

305 pred= a;

306 *dir_ptr = 0;

307 }else{

308 pred= c;

309 *dir_ptr = 1;

310 }

311 } else {

312 pred= c;

313 *dir_ptr = 1;

314 }

315 }

316 }else{

317 if (abs(a - b) < abs(b - c)) {

318 pred = c;

319 *dir_ptr = 1;

320 } else {

321 pred = a;

322 *dir_ptr = 0;

323 }

324 }

325 }else{

326 if (abs(a - b) <= abs(b - c)) {

327 pred = c;

328 *dir_ptr = 1;

329 } else {

330 pred = a;

331 *dir_ptr = 0;

332 }

333 }

334

335 /* update predictor */

336 *dc_val_ptr = &dc_val[0];

337 return pred;

338 }

339

Generated on Wed Jul 10 2013 23:48:02 for FFmpeg by doxygen 1.8.2