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

40 #include "mpegvideo.h"

41 #include "msmpeg4.h"

42 #include "mpeg4videodata.h"

43 #include "msmpeg4data.h"

44 #include "msmpeg4_vc1_data.h"

46 /*

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

48 *

49 * TODO:

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

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

52 */

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

55 * except that it is inverted. */

56 static av_cold void init_h263_dc_for_msmpeg4(void)

57 {

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

59 int uni_code, uni_len;

60 int size, v, l;

61 /* find number of bits */

62 size = 0;

63 v = abs(level);

64 while (v) {

65 v >>= 1;

66 size++;

67 }

69 if (level < 0)

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

71 else

72 l = level;

74 /* luminance H.263 */

75 uni_code = ff_mpeg4_DCtab_lum[size][0];

76 uni_len = ff_mpeg4_DCtab_lum[size][1];

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

79 if (size > 0) {

80 uni_code <<= size; uni_code |= l;

81 uni_len += size;

82 if (size > 8) {

83 uni_code <<= 1; uni_code |= 1;

84 uni_len++;

85 }

86 }

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

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

90 /* chrominance H.263 */

91 uni_code = ff_mpeg4_DCtab_chrom[size][0];

92 uni_len = ff_mpeg4_DCtab_chrom[size][1];

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

95 if (size > 0) {

96 uni_code <<= size; uni_code |= l;

97 uni_len +=size;

98 if (size > 8) {

99 uni_code <<= 1; uni_code |= 1;

100 uni_len++;

101 }

102 }

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

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

105 }

106 }

107

108 static av_cold void msmpeg4_common_init_static(void)

109 {

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

111

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

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

114

115 init_h263_dc_for_msmpeg4();

116 }

117

118 av_cold void ff_msmpeg4_common_init(MpegEncContext *s)

119 {

120 static AVOnce init_static_once = AV_ONCE_INIT;

121

122 switch(s->msmpeg4_version){

123 case MSMP4_V1:

124 case MSMP4_V2:

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

126 break;

127 case MSMP4_V3:

128 if(s->workaround_bugs){

129 s->y_dc_scale_table= ff_old_ff_y_dc_scale_table;

130 s->c_dc_scale_table= ff_wmv1_c_dc_scale_table;

131 } else{

132 s->y_dc_scale_table= ff_mpeg4_y_dc_scale_table;

133 s->c_dc_scale_table= ff_mpeg4_c_dc_scale_table;

134 }

135 break;

136 case MSMP4_WMV1:

137 case MSMP4_WMV2:

138 s->y_dc_scale_table= ff_wmv1_y_dc_scale_table;

139 s->c_dc_scale_table= ff_wmv1_c_dc_scale_table;

140 break;

141 }

142

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

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

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

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

147 s->idsp.idct_permutation);

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

149 s->idsp.idct_permutation);

150 }

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

152

153 ff_thread_once(&init_static_once, msmpeg4_common_init_static);

154 }

155

156 /* predict coded block */

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

158 {

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

160

161 xy = s->block_index[n];

162 wrap = s->b8_stride;

163

164 /* B C

165 * A X

166 */

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

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

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

170

171 if (b == c) {

172 pred = a;

173 } else {

174 pred = c;

175 }

176

177 /* store value */

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

179

180 return pred;

181 }

182

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

184 {

185 int y;

186 int sum=0;

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

188 int x;

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

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

191 }

192 }

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

194 }

195

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

197 int ff_msmpeg4_pred_dc(MpegEncContext *s, int n,

198 int16_t **dc_val_ptr, int *dir_ptr)

199 {

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

201 int16_t *const dc_val = s->dc_val + s->block_index[n];

202

203 /* find prediction */

204 if (n < 4) {

205 scale = s->y_dc_scale;

206 } else {

207 scale = s->c_dc_scale;

208 }

209

210 wrap = s->block_wrap[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 }

level

uint8_t level

Definition: svq3.c:208

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:118

#define b

Definition: input.c:42

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:66

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:40

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:106

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:43

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

mathops.h

get_dc

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

Definition: msmpeg4.c:183

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:213

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:197

ff_init_scantable

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

Definition: mpegvideo.c:82

#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:108

__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:1011

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]