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 "libavutil/thread.h"
31 
32 #include "avcodec.h"
33 #include "idctdsp.h"
34 #include "mpegvideo.h"
35 #include "msmpeg4.h"
36 #include "libavutil/x86/asm.h"
37 #include "mpeg4videodata.h"
38 #include "msmpeg4data.h"
39 #include "msmpeg4_vc1_data.h"
40 #include "mpegvideodata.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  for (int level = -256; level < 256; level++) {
55  int uni_code, uni_len;
56  int size, v, l;
57  /* find number of bits */
58  size = 0;
59  v = abs(level);
60  while (v) {
61  v >>= 1;
62  size++;
63  }
64 
65  if (level < 0)
66  l = (-level) ^ ((1 << size) - 1);
67  else
68  l = level;
69 
70  /* luminance H.263 */
71  uni_code = ff_mpeg4_DCtab_lum[size][0];
72  uni_len = ff_mpeg4_DCtab_lum[size][1];
73  uni_code ^= (1 << uni_len) - 1; //M$ does not like compatibility
74 
75  if (size > 0) {
76  uni_code <<= size; uni_code |= l;
77  uni_len += size;
78  if (size > 8) {
79  uni_code <<= 1; uni_code |= 1;
80  uni_len++;
81  }
82  }
83  ff_v2_dc_lum_table[level + 256][0] = uni_code;
84  ff_v2_dc_lum_table[level + 256][1] = uni_len;
85 
86  /* chrominance H.263 */
87  uni_code = ff_mpeg4_DCtab_chrom[size][0];
88  uni_len = ff_mpeg4_DCtab_chrom[size][1];
89  uni_code ^= (1 << uni_len) - 1; //M$ does not like compatibility
90 
91  if (size > 0) {
92  uni_code <<= size; uni_code |= l;
93  uni_len +=size;
94  if (size > 8) {
95  uni_code <<= 1; uni_code |= 1;
96  uni_len++;
97  }
98  }
99  ff_v2_dc_chroma_table[level + 256][0] = uni_code;
100  ff_v2_dc_chroma_table[level + 256][1] = uni_len;
101  }
102 }
103 
105 {
106  static uint8_t rl_table_store[NB_RL_TABLES][2][2 * MAX_RUN + MAX_LEVEL + 3];
107 
108  for (int i = 0; i < NB_RL_TABLES; i++)
109  ff_rl_init(&ff_rl_table[i], rl_table_store[i]);
110 
112 }
113 
115 {
116  static AVOnce init_static_once = AV_ONCE_INIT;
117 
118  switch(s->msmpeg4_version){
119  case 1:
120  case 2:
121  s->y_dc_scale_table=
122  s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
123  break;
124  case 3:
125  if(s->workaround_bugs){
126  s->y_dc_scale_table= ff_old_ff_y_dc_scale_table;
127  s->c_dc_scale_table= ff_wmv1_c_dc_scale_table;
128  } else{
129  s->y_dc_scale_table= ff_mpeg4_y_dc_scale_table;
130  s->c_dc_scale_table= ff_mpeg4_c_dc_scale_table;
131  }
132  break;
133  case 4:
134  case 5:
135  s->y_dc_scale_table= ff_wmv1_y_dc_scale_table;
136  s->c_dc_scale_table= ff_wmv1_c_dc_scale_table;
137  break;
138  }
139 
140  if(s->msmpeg4_version>=4){
141  ff_init_scantable(s->idsp.idct_permutation, &s->intra_scantable, ff_wmv1_scantable[1]);
142  ff_init_scantable(s->idsp.idct_permutation, &s->inter_scantable, ff_wmv1_scantable[0]);
143  ff_permute_scantable(s->permutated_intra_h_scantable, ff_wmv1_scantable[2],
144  s->idsp.idct_permutation);
145  ff_permute_scantable(s->permutated_intra_v_scantable, ff_wmv1_scantable[3],
146  s->idsp.idct_permutation);
147  }
148  //Note the default tables are set in common_init in mpegvideo.c
149 
150  ff_thread_once(&init_static_once, msmpeg4_common_init_static);
151 }
152 
153 /* predict coded block */
154 int ff_msmpeg4_coded_block_pred(MpegEncContext * s, int n, uint8_t **coded_block_ptr)
155 {
156  int xy, wrap, pred, a, b, c;
157 
158  xy = s->block_index[n];
159  wrap = s->b8_stride;
160 
161  /* B C
162  * A X
163  */
164  a = s->coded_block[xy - 1 ];
165  b = s->coded_block[xy - 1 - wrap];
166  c = s->coded_block[xy - wrap];
167 
168  if (b == c) {
169  pred = a;
170  } else {
171  pred = c;
172  }
173 
174  /* store value */
175  *coded_block_ptr = &s->coded_block[xy];
176 
177  return pred;
178 }
179 
180 static int get_dc(uint8_t *src, int stride, int scale, int block_size)
181 {
182  int y;
183  int sum=0;
184  for(y=0; y<block_size; y++){
185  int x;
186  for(x=0; x<block_size; x++){
187  sum+=src[x + y*stride];
188  }
189  }
190  return FASTDIV((sum + (scale>>1)), scale);
191 }
192 
193 /* dir = 0: left, dir = 1: top prediction */
195  int16_t **dc_val_ptr, int *dir_ptr)
196 {
197  int a, b, c, wrap, pred, scale;
198  int16_t *dc_val;
199 
200  /* find prediction */
201  if (n < 4) {
202  scale = s->y_dc_scale;
203  } else {
204  scale = s->c_dc_scale;
205  }
206 
207  wrap = s->block_wrap[n];
208  dc_val= s->dc_val[0] + s->block_index[n];
209 
210  /* B C
211  * A X
212  */
213  a = dc_val[ - 1];
214  b = dc_val[ - 1 - wrap];
215  c = dc_val[ - wrap];
216 
217  if(s->first_slice_line && (n&2)==0 && s->msmpeg4_version<4){
218  b=c=1024;
219  }
220 
221  /* XXX: the following solution consumes divisions, but it does not
222  necessitate to modify mpegvideo.c. The problem comes from the
223  fact they decided to store the quantized DC (which would lead
224  to problems if Q could vary !) */
225 #if ARCH_X86 && HAVE_7REGS && HAVE_EBX_AVAILABLE
226  __asm__ volatile(
227  "movl %3, %%eax \n\t"
228  "shrl $1, %%eax \n\t"
229  "addl %%eax, %2 \n\t"
230  "addl %%eax, %1 \n\t"
231  "addl %0, %%eax \n\t"
232  "imull %4 \n\t"
233  "movl %%edx, %0 \n\t"
234  "movl %1, %%eax \n\t"
235  "imull %4 \n\t"
236  "movl %%edx, %1 \n\t"
237  "movl %2, %%eax \n\t"
238  "imull %4 \n\t"
239  "movl %%edx, %2 \n\t"
240  : "+b" (a), "+c" (b), "+D" (c)
241  : "g" (scale), "S" (ff_inverse[scale])
242  : "%eax", "%edx"
243  );
244 #else
245  /* Divisions are costly everywhere; optimize the most common case. */
246  if (scale == 8) {
247  a = (a + (8 >> 1)) / 8;
248  b = (b + (8 >> 1)) / 8;
249  c = (c + (8 >> 1)) / 8;
250  } else {
251  a = FASTDIV((a + (scale >> 1)), scale);
252  b = FASTDIV((b + (scale >> 1)), scale);
253  c = FASTDIV((c + (scale >> 1)), scale);
254  }
255 #endif
256  /* XXX: WARNING: they did not choose the same test as MPEG-4. This
257  is very important ! */
258  if(s->msmpeg4_version>3){
259  if(s->inter_intra_pred){
260  uint8_t *dest;
261  int wrap;
262 
263  if(n==1){
264  pred=a;
265  *dir_ptr = 0;
266  }else if(n==2){
267  pred=c;
268  *dir_ptr = 1;
269  }else if(n==3){
270  if (abs(a - b) < abs(b - c)) {
271  pred = c;
272  *dir_ptr = 1;
273  } else {
274  pred = a;
275  *dir_ptr = 0;
276  }
277  }else{
278  int bs = 8 >> s->avctx->lowres;
279  if(n<4){
280  wrap= s->linesize;
281  dest= s->current_picture.f->data[0] + (((n >> 1) + 2*s->mb_y) * bs* wrap ) + ((n & 1) + 2*s->mb_x) * bs;
282  }else{
283  wrap= s->uvlinesize;
284  dest= s->current_picture.f->data[n - 3] + (s->mb_y * bs * wrap) + s->mb_x * bs;
285  }
286  if(s->mb_x==0) a= (1024 + (scale>>1))/scale;
287  else a= get_dc(dest-bs, wrap, scale*8>>(2*s->avctx->lowres), bs);
288  if(s->mb_y==0) c= (1024 + (scale>>1))/scale;
289  else c= get_dc(dest-bs*wrap, wrap, scale*8>>(2*s->avctx->lowres), bs);
290 
291  if (s->h263_aic_dir==0) {
292  pred= a;
293  *dir_ptr = 0;
294  }else if (s->h263_aic_dir==1) {
295  if(n==0){
296  pred= c;
297  *dir_ptr = 1;
298  }else{
299  pred= a;
300  *dir_ptr = 0;
301  }
302  }else if (s->h263_aic_dir==2) {
303  if(n==0){
304  pred= a;
305  *dir_ptr = 0;
306  }else{
307  pred= c;
308  *dir_ptr = 1;
309  }
310  } else {
311  pred= c;
312  *dir_ptr = 1;
313  }
314  }
315  }else{
316  if (abs(a - b) < abs(b - c)) {
317  pred = c;
318  *dir_ptr = 1;
319  } else {
320  pred = a;
321  *dir_ptr = 0;
322  }
323  }
324  }else{
325  if (abs(a - b) <= abs(b - c)) {
326  pred = c;
327  *dir_ptr = 1;
328  } else {
329  pred = a;
330  *dir_ptr = 0;
331  }
332  }
333 
334  /* update predictor */
335  *dc_val_ptr = &dc_val[0];
336  return pred;
337 }
338 
level
uint8_t level
Definition: svq3.c:204
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:114
b
#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
scale
static av_always_inline float scale(float x, float s)
Definition: vf_v360.c:1389
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:184
av_cold
#define av_cold
Definition: attributes.h:90
msmpeg4data.h
s
#define s(width, name)
Definition: cbs_vp9.c:256
ff_mpeg1_dc_scale_table
static const uint8_t *const ff_mpeg1_dc_scale_table
Definition: mpegvideodata.h:32
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:182
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:180
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:205
AVOnce
#define AVOnce
Definition: thread.h:181
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
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
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
ff_msmpeg4_pred_dc
int ff_msmpeg4_pred_dc(MpegEncContext *s, int n, int16_t **dc_val_ptr, int *dir_ptr)
Definition: msmpeg4.c:194
mpegvideodata.h
ff_init_scantable
av_cold void ff_init_scantable(const uint8_t *permutation, ScanTable *st, const uint8_t *src_scantable)
Definition: mpegvideo.c:321
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:269
msmpeg4_common_init_static
static av_cold void msmpeg4_common_init_static(void)
Definition: msmpeg4.c:104
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]
Definition: msmpeg4data.c:1633
init_h263_dc_for_msmpeg4
static av_cold void init_h263_dc_for_msmpeg4(void)
Definition: msmpeg4.c:52
mpeg4videodata.h
src
INIT_CLIP pixel * src
Definition: h264pred_template.c:418
ff_wmv1_c_dc_scale_table
const uint8_t ff_wmv1_c_dc_scale_table[32]
Definition: msmpeg4data.c:1637
MpegEncContext
MpegEncContext.
Definition: mpegvideo.h:70
ff_wmv1_scantable
const uint8_t ff_wmv1_scantable[WMV1_SCANTABLE_COUNT][64]
Definition: msmpeg4_vc1_data.c:221
ff_msmpeg4_coded_block_pred
int ff_msmpeg4_coded_block_pred(MpegEncContext *s, int n, uint8_t **coded_block_ptr)
Definition: msmpeg4.c:154