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 "config.h"

32 #include "libavutil/thread.h"

33 #if ARCH_X86

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

35 #endif

37 #include "avcodec.h"

38 #include "idctdsp.h"

39 #include "mpegvideo.h"

40 #include "msmpeg4.h"

41 #include "mpeg4videodata.h"

42 #include "msmpeg4data.h"

43 #include "msmpeg4_vc1_data.h"

45 /*

46 * You can also call this codec: MPEG-4 with a twist!

47 *

48 * TODO:

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

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

51 */

53 /* This table is practically identical to the one from H.263

54 * except that it is inverted. */

55 static av_cold void init_h263_dc_for_msmpeg4(void)

56 {

57 for (int level = -256; level < 256; level++) {

58 int uni_code, uni_len;

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 H.263 */

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 H.263 */

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 static av_cold void msmpeg4_common_init_static(void)

108 {

109 static uint8_t rl_table_store[NB_RL_TABLES][2][2 * MAX_RUN + MAX_LEVEL + 3];

110

111 for (int i = 0; i < NB_RL_TABLES; i++)

112 ff_rl_init(&ff_rl_table[i], rl_table_store[i]);

113

114 init_h263_dc_for_msmpeg4();

115 }

116

117 av_cold void ff_msmpeg4_common_init(MpegEncContext *s)

118 {

119 static AVOnce init_static_once = AV_ONCE_INIT;

120

121 switch(s->msmpeg4_version){

122 case MSMP4_V1:

123 case MSMP4_V2:

124 // Correct *_dc_scale_tables (ff_mpeg1_dc_scale_table) is the default

125 break;

126 case MSMP4_V3:

127 if(s->workaround_bugs){

128 s->y_dc_scale_table= ff_old_ff_y_dc_scale_table;

129 s->c_dc_scale_table= ff_wmv1_c_dc_scale_table;

130 } else{

131 s->y_dc_scale_table= ff_mpeg4_y_dc_scale_table;

132 s->c_dc_scale_table= ff_mpeg4_c_dc_scale_table;

133 }

134 break;

135 case MSMP4_WMV1:

136 case MSMP4_WMV2:

137 s->y_dc_scale_table= ff_wmv1_y_dc_scale_table;

138 s->c_dc_scale_table= ff_wmv1_c_dc_scale_table;

139 break;

140 }

141

142 if (s->msmpeg4_version >= MSMP4_WMV1) {

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

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

145 ff_permute_scantable(s->permutated_intra_h_scantable, ff_wmv1_scantable[2],

146 s->idsp.idct_permutation);

147 ff_permute_scantable(s->permutated_intra_v_scantable, ff_wmv1_scantable[3],

148 s->idsp.idct_permutation);

149 }

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

151

152 ff_thread_once(&init_static_once, msmpeg4_common_init_static);

153 }

154

155 /* predict coded block */

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

157 {

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

159

160 xy = s->block_index[n];

161 wrap = s->b8_stride;

162

163 /* B C

164 * A X

165 */

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

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

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

169

170 if (b == c) {

171 pred = a;

172 } else {

173 pred = c;

174 }

175

176 /* store value */

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

178

179 return pred;

180 }

181

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

183 {

184 int y;

185 int sum=0;

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

187 int x;

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

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

190 }

191 }

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

193 }

194

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

196 int ff_msmpeg4_pred_dc(MpegEncContext *s, int n,

197 int16_t **dc_val_ptr, int *dir_ptr)

198 {

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

200 int16_t *dc_val;

201

202 /* find prediction */

203 if (n < 4) {

204 scale = s->y_dc_scale;

205 } else {

206 scale = s->c_dc_scale;

207 }

208

209 wrap = s->block_wrap[n];

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

211

212 /* B C

213 * A X

214 */

215 a = dc_val[ - 1];

216 b = dc_val[ - 1 - wrap];

217 c = dc_val[ - wrap];

218

219 if (s->first_slice_line && !(n & 2) && s->msmpeg4_version < MSMP4_WMV1)

220 b=c=1024;

221

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

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

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

225 to problems if Q could vary !) */

226 #if ARCH_X86 && HAVE_7REGS && HAVE_EBX_AVAILABLE

227 __asm__ volatile(

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

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

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

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

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

233 "imull %4 \n\t"

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

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

236 "imull %4 \n\t"

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

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

239 "imull %4 \n\t"

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

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

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

243 : "%eax", "%edx"

244 );

245 #else

246 /* Divisions are costly everywhere; optimize the most common case. */

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 MPEG-4. This

258 is very important ! */

259 if (s->msmpeg4_version > MSMP4_V3) {

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->cur_pic.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->cur_pic.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

level

uint8_t level

Definition: svq3.c:205

thread.h

MAX_RUN

#define MAX_RUN

Definition: rl.h:35

ff_msmpeg4_common_init

av_cold void ff_msmpeg4_common_init(MpegEncContext *s)

Definition: msmpeg4.c:117

#define b

Definition: input.c:41

mpegvideo.h

ff_rl_table

RLTable ff_rl_table[NB_RL_TABLES]

Definition: msmpeg4data.c:441

ff_inverse

const uint32_t ff_inverse[257]

Definition: mathtables.c:27

ff_permute_scantable

av_cold void ff_permute_scantable(uint8_t dst[64], const uint8_t src[64], const uint8_t permutation[64])

Definition: idctdsp.c:30

ff_mpeg4_DCtab_chrom

const uint8_t ff_mpeg4_DCtab_chrom[13][2]

Definition: mpeg4data.h:40

wrap

#define wrap(func)

Definition: neontest.h:65

NB_RL_TABLES

#define NB_RL_TABLES

Definition: msmpeg4data.h:51

ff_thread_once

static int ff_thread_once(char *control, void(*routine)(void))

Definition: thread.h:205

av_cold

#define av_cold

Definition: attributes.h:90

msmpeg4data.h

#define s(width, name)

Definition: cbs_vp9.c:198

ff_rl_init

av_cold void ff_rl_init(RLTable *rl, uint8_t static_store[2][2 *MAX_RUN+MAX_LEVEL+3])

Initialize index_run, max_level and max_run from n, last, table_vlc, table_run and table_level.

Definition: rl.c:44

ff_mpeg4_DCtab_lum

const uint8_t ff_mpeg4_DCtab_lum[13][2]

Definition: mpeg4data.h:34

AV_ONCE_INIT

#define AV_ONCE_INIT

Definition: thread.h:203

asm.h

ff_v2_dc_lum_table

uint32_t ff_v2_dc_lum_table[512][2]

Definition: msmpeg4data.c:35

get_dc

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

Definition: msmpeg4.c:182

ff_v2_dc_chroma_table

uint32_t ff_v2_dc_chroma_table[512][2]

Definition: msmpeg4data.c:36

abs

#define abs(x)

Definition: cuda_runtime.h:35

FASTDIV

#define FASTDIV(a, b)

Definition: mathops.h:212

AVOnce

#define AVOnce

Definition: thread.h:202

Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C it is not safe even if the output of undefined operations is unused The unsafety may seem nit picking but Optimizing compilers have in fact optimized code on the assumption that no undefined Behavior occurs Optimizing code based on wrong assumptions can and has in some cases lead to effects beyond the output of computations The signed integer overflow problem in speed critical code Code which is highly optimized and works with signed integers sometimes has the problem that often the output of the computation does not c

Definition: undefined.txt:32

MAX_LEVEL

#define MAX_LEVEL

Definition: rl.h:36

ff_mpeg4_y_dc_scale_table

const uint8_t ff_mpeg4_y_dc_scale_table[32]

Definition: mpeg4data.h:356

size

int size

Definition: twinvq_data.h:10344

The reader does not expect b to be semantically here and if the code is changed by maybe adding a a division or other the signedness will almost certainly be mistaken To avoid this confusion a new type was SUINT is the C unsigned type but it holds a signed int to use the same example SUINT a

Definition: undefined.txt:41

ff_msmpeg4_pred_dc

int ff_msmpeg4_pred_dc(MpegEncContext *s, int n, int16_t **dc_val_ptr, int *dir_ptr)

Definition: msmpeg4.c:196

ff_init_scantable

av_cold void ff_init_scantable(const uint8_t *permutation, ScanTable *st, const uint8_t *src_scantable)

Definition: mpegvideo.c:293

#define i(width, name, range_min, range_max)

Definition: cbs_h2645.c:256

msmpeg4_common_init_static

static av_cold void msmpeg4_common_init_static(void)

Definition: msmpeg4.c:107

idctdsp.h

avcodec.h

stride

#define stride

Definition: h264pred_template.c:537

msmpeg4.h

__asm__

__asm__(".macro parse_r var r\n\t" "\\var = -1\n\t" _IFC_REG(0) _IFC_REG(1) _IFC_REG(2) _IFC_REG(3) _IFC_REG(4) _IFC_REG(5) _IFC_REG(6) _IFC_REG(7) _IFC_REG(8) _IFC_REG(9) _IFC_REG(10) _IFC_REG(11) _IFC_REG(12) _IFC_REG(13) _IFC_REG(14) _IFC_REG(15) _IFC_REG(16) _IFC_REG(17) _IFC_REG(18) _IFC_REG(19) _IFC_REG(20) _IFC_REG(21) _IFC_REG(22) _IFC_REG(23) _IFC_REG(24) _IFC_REG(25) _IFC_REG(26) _IFC_REG(27) _IFC_REG(28) _IFC_REG(29) _IFC_REG(30) _IFC_REG(31) ".iflt \\var\n\t" ".error \"Unable to parse register name \\r\"\n\t" ".endif\n\t" ".endm")

pred

static const float pred[4]

Definition: siprdata.h:259

ff_old_ff_y_dc_scale_table

const uint8_t ff_old_ff_y_dc_scale_table[32]

Definition: msmpeg4data.c:1642

msmpeg4_vc1_data.h

ff_mpeg4_c_dc_scale_table

const uint8_t ff_mpeg4_c_dc_scale_table[32]

Definition: mpeg4data.h:360

ff_wmv1_y_dc_scale_table

const uint8_t ff_wmv1_y_dc_scale_table[32]