FFmpeg  2.1.1
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 "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"
40 
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  */
48 
49 /* This table is practically identical to the one from h263
50  * except that it is inverted. */
52 {
53  int level, uni_code, uni_len;
54 
55  if(ff_v2_dc_chroma_table[255 + 256][1])
56  return;
57 
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  }
67 
68  if (level < 0)
69  l= (-level) ^ ((1 << size) - 1);
70  else
71  l= level;
72 
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
77 
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;
88 
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
93 
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 
109 {
110  switch(s->msmpeg4_version){
111  case 1:
112  case 2:
113  s->y_dc_scale_table=
115  break;
116  case 3:
117  if(s->workaround_bugs){
120  } else{
123  }
124  break;
125  case 4:
126  case 5:
129  break;
130 #if CONFIG_VC1_DECODER
131  case 6:
134  break;
135 #endif
136 
137  }
138 
139 
140  if(s->msmpeg4_version>=4){
145  }
146  //Note the default tables are set in common_init in mpegvideo.c
147 
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 */
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 
int inter_intra_pred
Definition: mpegvideo.h:650
float v
const char * s
Definition: avisynth_c.h:668
ScanTable intra_v_scantable
Definition: mpegvideo.h:302
int size
const uint8_t ff_mpeg4_c_dc_scale_table[32]
Definition: mpeg4data.h:363
const uint8_t * y_dc_scale_table
qscale -&gt; y_dc_scale table
Definition: mpegvideo.h:355
uint32_t ff_v2_dc_lum_table[512][2]
Definition: msmpeg4data.c:34
uint32_t ff_v2_dc_chroma_table[512][2]
Definition: msmpeg4data.c:35
int msmpeg4_version
0=not msmpeg4, 1=mp41, 2=mp42, 3=mp43/divx3 4=wmv1/7 5=wmv2/8
Definition: mpegvideo.h:644
const char * b
Definition: vf_curves.c:105
#define wrap(func)
Definition: w64xmmtest.h:70
mpegvideo header.
int stride
Definition: mace.c:144
#define av_cold
Definition: avcodec.h:653
av_cold void ff_msmpeg4_common_init(MpegEncContext *s)
Definition: msmpeg4.c:108
int block_wrap[6]
Definition: mpegvideo.h:470
VC-1 tables.
const uint32_t ff_inverse[257]
Definition: mathtables.c:25
uint8_t
const uint8_t ff_wmv3_dc_scale_table[32]
Definition: vc1data.c:648
Picture current_picture
copy of the current picture structure.
Definition: mpegvideo.h:347
const uint8_t ff_mpeg4_DCtab_chrom[13][2]
Definition: mpeg4data.h:41
MSMPEG4 data tables.
uint8_t idct_permutation[64]
idct input permutation.
Definition: dsputil.h:246
int lowres
low resolution decoding, 1-&gt; 1/2 size, 2-&gt;1/4 size
Definition: avcodec.h:2580
const uint8_t ff_wmv1_c_dc_scale_table[32]
Definition: msmpeg4data.c:1815
int16_t * dc_val[3]
used for mpeg4 DC prediction, all 3 arrays must be continuous
Definition: mpegvideo.h:354
Libavcodec external API header.
const uint8_t ff_mpeg4_DCtab_lum[13][2]
Definition: mpeg4data.h:35
const uint8_t ff_wmv1_scantable[WMV1_SCANTABLE_COUNT][64]
Definition: msmpeg4data.c:1825
int ff_msmpeg4_pred_dc(MpegEncContext *s, int n, int16_t **dc_val_ptr, int *dir_ptr)
Definition: msmpeg4.c:192
float y
const uint8_t ff_mpeg4_y_dc_scale_table[32]
Definition: mpeg4data.h:359
int n
Definition: avisynth_c.h:588
int block_index[6]
index to current MB in block based arrays with edges
Definition: mpegvideo.h:469
static const float pred[4]
Definition: siprdata.h:259
int first_slice_line
used in mpeg4 too to handle resync markers
Definition: mpegvideo.h:642
AVS_Value src
Definition: avisynth_c.h:523
ptrdiff_t linesize
line size, in bytes, may be different from width
Definition: mpegvideo.h:287
static int get_dc(uint8_t *src, int stride, int scale, int block_size)
Definition: msmpeg4.c:178
#define FASTDIV(a, b)
Definition: mathops.h:195
ScanTable intra_scantable
Definition: mpegvideo.h:300
uint8_t * coded_block
used for coded block pattern prediction (msmpeg4v3, wmv1)
Definition: mpegvideo.h:359
const uint8_t ff_mpeg1_dc_scale_table[128]
Definition: mpegvideo.c:66
av_cold void ff_init_scantable(uint8_t *permutation, ScanTable *st, const uint8_t *src_scantable)
Definition: dsputil.c:111
ScanTable intra_h_scantable
Definition: mpegvideo.h:301
ptrdiff_t uvlinesize
line size, for chroma in bytes, may be different from width
Definition: mpegvideo.h:288
DSPContext dsp
pointers for accelerated dsp functions
Definition: mpegvideo.h:395
static const uint16_t scale[4]
const uint8_t * c_dc_scale_table
qscale -&gt; c_dc_scale table
Definition: mpegvideo.h:356
uint8_t level
Definition: svq3.c:146
int b8_stride
2*mb_width+1 used for some 8x8 block arrays to allow simple addressing
Definition: mpegvideo.h:283
MpegEncContext.
Definition: mpegvideo.h:245
struct AVCodecContext * avctx
Definition: mpegvideo.h:247
static double c[64]
DSP utils.
const uint8_t ff_wmv1_y_dc_scale_table[32]
Definition: msmpeg4data.c:1811
struct AVFrame f
Definition: mpegvideo.h:98
const uint8_t ff_old_ff_y_dc_scale_table[32]
Definition: msmpeg4data.c:1820
int workaround_bugs
workaround bugs in encoders which cannot be detected automatically
Definition: mpegvideo.h:270
ScanTable inter_scantable
if inter == intra then intra should be used to reduce tha cache usage
Definition: mpegvideo.h:299
int ff_msmpeg4_coded_block_pred(MpegEncContext *s, int n, uint8_t **coded_block_ptr)
Definition: msmpeg4.c:152
int h263_aic_dir
AIC direction: 0 = left, 1 = top.
Definition: mpegvideo.h:552
static av_cold void init_h263_dc_for_msmpeg4(void)
Definition: msmpeg4.c:51
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:107