FFmpeg
msmpeg4.c
Go to the documentation of this file.
1 /*
2  * MSMPEG4 backend for encoder and decoder
3  * Copyright (c) 2001 Fabrice Bellard
4  * Copyright (c) 2002-2004 Michael Niedermayer <michaelni@gmx.at>
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  */
24 
25 /**
26  * @file
27  * MSMPEG4 backend for encoder and decoder
28  */
29 
30 #include "avcodec.h"
31 #include "idctdsp.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 "mpegvideodata.h"
39 #include "vc1data.h"
40 #include "libavutil/imgutils.h"
41 
42 /*
43  * You can also call this codec: MPEG-4 with a twist!
44  *
45  * TODO:
46  * - (encoding) select best mv table (two choices)
47  * - (encoding) select best vlc/dc table
48  */
49 
50 /* This table is practically identical to the one from H.263
51  * except that it is inverted. */
53 {
54  int level, uni_code, uni_len;
55 
56  if(ff_v2_dc_chroma_table[255 + 256][1])
57  return;
58 
59  for(level=-256; level<256; level++){
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  }
68 
69  if (level < 0)
70  l= (-level) ^ ((1 << size) - 1);
71  else
72  l= level;
73 
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
78 
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;
89 
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
94 
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 
110 {
111  switch(s->msmpeg4_version){
112  case 1:
113  case 2:
114  s->y_dc_scale_table=
115  s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
116  break;
117  case 3:
118  if(s->workaround_bugs){
119  s->y_dc_scale_table= ff_old_ff_y_dc_scale_table;
120  s->c_dc_scale_table= ff_wmv1_c_dc_scale_table;
121  } else{
122  s->y_dc_scale_table= ff_mpeg4_y_dc_scale_table;
123  s->c_dc_scale_table= ff_mpeg4_c_dc_scale_table;
124  }
125  break;
126  case 4:
127  case 5:
128  s->y_dc_scale_table= ff_wmv1_y_dc_scale_table;
129  s->c_dc_scale_table= ff_wmv1_c_dc_scale_table;
130  break;
131 #if CONFIG_VC1_DECODER
132  case 6:
133  s->y_dc_scale_table= ff_wmv3_dc_scale_table;
134  s->c_dc_scale_table= ff_wmv3_dc_scale_table;
135  break;
136 #endif
137 
138  }
139 
140 
141  if(s->msmpeg4_version>=4){
142  ff_init_scantable(s->idsp.idct_permutation, &s->intra_scantable, ff_wmv1_scantable[1]);
143  ff_init_scantable(s->idsp.idct_permutation, &s->intra_h_scantable, ff_wmv1_scantable[2]);
144  ff_init_scantable(s->idsp.idct_permutation, &s->intra_v_scantable, ff_wmv1_scantable[3]);
145  ff_init_scantable(s->idsp.idct_permutation, &s->inter_scantable, ff_wmv1_scantable[0]);
146  }
147  //Note the default tables are set in common_init in mpegvideo.c
148 
150 }
151 
152 /* predict coded block */
153 int ff_msmpeg4_coded_block_pred(MpegEncContext * s, int n, uint8_t **coded_block_ptr)
154 {
155  int xy, wrap, pred, a, b, c;
156 
157  xy = s->block_index[n];
158  wrap = s->b8_stride;
159 
160  /* B C
161  * A X
162  */
163  a = s->coded_block[xy - 1 ];
164  b = s->coded_block[xy - 1 - wrap];
165  c = s->coded_block[xy - wrap];
166 
167  if (b == c) {
168  pred = a;
169  } else {
170  pred = c;
171  }
172 
173  /* store value */
174  *coded_block_ptr = &s->coded_block[xy];
175 
176  return pred;
177 }
178 
179 static int get_dc(uint8_t *src, int stride, int scale, int block_size)
180 {
181  int y;
182  int sum=0;
183  for(y=0; y<block_size; y++){
184  int x;
185  for(x=0; x<block_size; x++){
186  sum+=src[x + y*stride];
187  }
188  }
189  return FASTDIV((sum + (scale>>1)), scale);
190 }
191 
192 /* dir = 0: left, dir = 1: top prediction */
194  int16_t **dc_val_ptr, int *dir_ptr)
195 {
196  int a, b, c, wrap, pred, scale;
197  int16_t *dc_val;
198 
199  /* find prediction */
200  if (n < 4) {
201  scale = s->y_dc_scale;
202  } else {
203  scale = s->c_dc_scale;
204  }
205 
206  wrap = s->block_wrap[n];
207  dc_val= s->dc_val[0] + s->block_index[n];
208 
209  /* B C
210  * A X
211  */
212  a = dc_val[ - 1];
213  b = dc_val[ - 1 - wrap];
214  c = dc_val[ - wrap];
215 
216  if(s->first_slice_line && (n&2)==0 && s->msmpeg4_version<4){
217  b=c=1024;
218  }
219 
220  /* XXX: the following solution consumes divisions, but it does not
221  necessitate to modify mpegvideo.c. The problem comes from the
222  fact they decided to store the quantized DC (which would lead
223  to problems if Q could vary !) */
224 #if ARCH_X86 && HAVE_7REGS && HAVE_EBX_AVAILABLE
225  __asm__ volatile(
226  "movl %3, %%eax \n\t"
227  "shrl $1, %%eax \n\t"
228  "addl %%eax, %2 \n\t"
229  "addl %%eax, %1 \n\t"
230  "addl %0, %%eax \n\t"
231  "imull %4 \n\t"
232  "movl %%edx, %0 \n\t"
233  "movl %1, %%eax \n\t"
234  "imull %4 \n\t"
235  "movl %%edx, %1 \n\t"
236  "movl %2, %%eax \n\t"
237  "imull %4 \n\t"
238  "movl %%edx, %2 \n\t"
239  : "+b" (a), "+c" (b), "+D" (c)
240  : "g" (scale), "S" (ff_inverse[scale])
241  : "%eax", "%edx"
242  );
243 #else
244  /* Divisions are costly everywhere; optimize the most common case. */
245  if (scale == 8) {
246  a = (a + (8 >> 1)) / 8;
247  b = (b + (8 >> 1)) / 8;
248  c = (c + (8 >> 1)) / 8;
249  } else {
250  a = FASTDIV((a + (scale >> 1)), scale);
251  b = FASTDIV((b + (scale >> 1)), scale);
252  c = FASTDIV((c + (scale >> 1)), scale);
253  }
254 #endif
255  /* XXX: WARNING: they did not choose the same test as MPEG-4. This
256  is very important ! */
257  if(s->msmpeg4_version>3){
258  if(s->inter_intra_pred){
259  uint8_t *dest;
260  int wrap;
261 
262  if(n==1){
263  pred=a;
264  *dir_ptr = 0;
265  }else if(n==2){
266  pred=c;
267  *dir_ptr = 1;
268  }else if(n==3){
269  if (abs(a - b) < abs(b - c)) {
270  pred = c;
271  *dir_ptr = 1;
272  } else {
273  pred = a;
274  *dir_ptr = 0;
275  }
276  }else{
277  int bs = 8 >> s->avctx->lowres;
278  if(n<4){
279  wrap= s->linesize;
280  dest= s->current_picture.f->data[0] + (((n >> 1) + 2*s->mb_y) * bs* wrap ) + ((n & 1) + 2*s->mb_x) * bs;
281  }else{
282  wrap= s->uvlinesize;
283  dest= s->current_picture.f->data[n - 3] + (s->mb_y * bs * wrap) + s->mb_x * bs;
284  }
285  if(s->mb_x==0) a= (1024 + (scale>>1))/scale;
286  else a= get_dc(dest-bs, wrap, scale*8>>(2*s->avctx->lowres), bs);
287  if(s->mb_y==0) c= (1024 + (scale>>1))/scale;
288  else c= get_dc(dest-bs*wrap, wrap, scale*8>>(2*s->avctx->lowres), bs);
289 
290  if (s->h263_aic_dir==0) {
291  pred= a;
292  *dir_ptr = 0;
293  }else if (s->h263_aic_dir==1) {
294  if(n==0){
295  pred= c;
296  *dir_ptr = 1;
297  }else{
298  pred= a;
299  *dir_ptr = 0;
300  }
301  }else if (s->h263_aic_dir==2) {
302  if(n==0){
303  pred= a;
304  *dir_ptr = 0;
305  }else{
306  pred= c;
307  *dir_ptr = 1;
308  }
309  } else {
310  pred= c;
311  *dir_ptr = 1;
312  }
313  }
314  }else{
315  if (abs(a - b) < abs(b - c)) {
316  pred = c;
317  *dir_ptr = 1;
318  } else {
319  pred = a;
320  *dir_ptr = 0;
321  }
322  }
323  }else{
324  if (abs(a - b) <= abs(b - c)) {
325  pred = c;
326  *dir_ptr = 1;
327  } else {
328  pred = a;
329  *dir_ptr = 0;
330  }
331  }
332 
333  /* update predictor */
334  *dc_val_ptr = &dc_val[0];
335  return pred;
336 }
337 
stride
int stride
Definition: mace.c:144
ff_init_scantable
av_cold void ff_init_scantable(uint8_t *permutation, ScanTable *st, const uint8_t *src_scantable)
Definition: idctdsp.c:29
level
uint8_t level
Definition: svq3.c:204
ff_mpeg1_dc_scale_table
const uint8_t ff_mpeg1_dc_scale_table[128]
Definition: mpegvideodata.c:33
ff_wmv1_scantable
const uint8_t ff_wmv1_scantable[WMV1_SCANTABLE_COUNT][64]
Definition: msmpeg4data.c:1807
ff_msmpeg4_common_init
av_cold void ff_msmpeg4_common_init(MpegEncContext *s)
Definition: msmpeg4.c:109
b
#define b
Definition: input.c:41
mpegvideo.h
ff_inverse
const uint32_t ff_inverse[257]
Definition: mathtables.c:27
ff_mpeg4_DCtab_chrom
const uint8_t ff_mpeg4_DCtab_chrom[13][2]
Definition: mpeg4data.h:41
wrap
#define wrap(func)
Definition: neontest.h:65
ff_wmv3_dc_scale_table
const uint8_t ff_wmv3_dc_scale_table[32]
Definition: vc1data.c:648
av_cold
#define av_cold
Definition: attributes.h:90
msmpeg4data.h
s
#define s(width, name)
Definition: cbs_vp9.c:257
ff_mpeg4_DCtab_lum
const uint8_t ff_mpeg4_DCtab_lum[13][2]
Definition: mpeg4data.h:35
ff_v2_dc_lum_table
uint32_t ff_v2_dc_lum_table[512][2]
Definition: msmpeg4data.c:34
src
#define src
Definition: vp8dsp.c:255
get_dc
static int get_dc(uint8_t *src, int stride, int scale, int block_size)
Definition: msmpeg4.c:179
ff_v2_dc_chroma_table
uint32_t ff_v2_dc_chroma_table[512][2]
Definition: msmpeg4data.c:35
abs
#define abs(x)
Definition: cuda_runtime.h:35
FASTDIV
#define FASTDIV(a, b)
Definition: mathops.h:202
c
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
ff_mpeg4_y_dc_scale_table
const uint8_t ff_mpeg4_y_dc_scale_table[32]
Definition: mpeg4data.h:357
size
int size
Definition: twinvq_data.h:10344
asm.h
a
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
vc1data.h
ff_msmpeg4_pred_dc
int ff_msmpeg4_pred_dc(MpegEncContext *s, int n, int16_t **dc_val_ptr, int *dir_ptr)
Definition: msmpeg4.c:193
mpegvideodata.h
uint8_t
uint8_t
Definition: audio_convert.c:194
idctdsp.h
avcodec.h
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:1802
mpeg4video.h
ff_mpeg4_c_dc_scale_table
const uint8_t ff_mpeg4_c_dc_scale_table[32]
Definition: mpeg4data.h:361
ff_wmv1_y_dc_scale_table
const uint8_t ff_wmv1_y_dc_scale_table[32]
Definition: msmpeg4data.c:1793
init_h263_dc_for_msmpeg4
static av_cold void init_h263_dc_for_msmpeg4(void)
Definition: msmpeg4.c:52
ff_wmv1_c_dc_scale_table
const uint8_t ff_wmv1_c_dc_scale_table[32]
Definition: msmpeg4data.c:1797
imgutils.h
MpegEncContext
MpegEncContext.
Definition: mpegvideo.h:81
ff_msmpeg4_coded_block_pred
int ff_msmpeg4_coded_block_pred(MpegEncContext *s, int n, uint8_t **coded_block_ptr)
Definition: msmpeg4.c:153
h263.h