annotate mpegvideo.c @ 767:c75c3f1bef4b libavcodec

regression test for H263+
author michaelni
date Fri, 25 Oct 2002 10:50:02 +0000
parents 8d36b35a7e6e
children c3fc09466f92
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
rev   line source
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1 /*
986e461dc072 Initial revision
glantau
parents:
diff changeset
2 * The simplest mpeg encoder (well, it was the simplest!)
429
718a22dc121f license/copyright change
glantau
parents: 396
diff changeset
3 * Copyright (c) 2000,2001 Fabrice Bellard.
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4 *
429
718a22dc121f license/copyright change
glantau
parents: 396
diff changeset
5 * This library is free software; you can redistribute it and/or
718a22dc121f license/copyright change
glantau
parents: 396
diff changeset
6 * modify it under the terms of the GNU Lesser General Public
718a22dc121f license/copyright change
glantau
parents: 396
diff changeset
7 * License as published by the Free Software Foundation; either
718a22dc121f license/copyright change
glantau
parents: 396
diff changeset
8 * version 2 of the License, or (at your option) any later version.
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
9 *
429
718a22dc121f license/copyright change
glantau
parents: 396
diff changeset
10 * This library is distributed in the hope that it will be useful,
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
429
718a22dc121f license/copyright change
glantau
parents: 396
diff changeset
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
718a22dc121f license/copyright change
glantau
parents: 396
diff changeset
13 * Lesser General Public License for more details.
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
14 *
429
718a22dc121f license/copyright change
glantau
parents: 396
diff changeset
15 * You should have received a copy of the GNU Lesser General Public
718a22dc121f license/copyright change
glantau
parents: 396
diff changeset
16 * License along with this library; if not, write to the Free Software
718a22dc121f license/copyright change
glantau
parents: 396
diff changeset
17 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
295
6622b0fd036c mpeg4 4MV encoding
michaelni
parents: 294
diff changeset
18 *
325
15efd80cf51e mpeg2/mpeg4 dequantizer support (c & mmx)
michaelni
parents: 324
diff changeset
19 * 4MV & hq & b-frame encoding stuff by Michael Niedermayer <michaelni@gmx.at>
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
20 */
701
85b071dfc7e3 ff_get_fourcc() & XVIX support
michaelni
parents: 697
diff changeset
21
85b071dfc7e3 ff_get_fourcc() & XVIX support
michaelni
parents: 697
diff changeset
22 #include <ctype.h>
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
23 #include "avcodec.h"
986e461dc072 Initial revision
glantau
parents:
diff changeset
24 #include "dsputil.h"
986e461dc072 Initial revision
glantau
parents:
diff changeset
25 #include "mpegvideo.h"
706
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 704
diff changeset
26 #include "simple_idct.h"
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
27
17
b69fe46fd708 Adding fastmemcpy stuff to speedup mplayer project
nickols_k
parents: 13
diff changeset
28 #ifdef USE_FASTMEMCPY
b69fe46fd708 Adding fastmemcpy stuff to speedup mplayer project
nickols_k
parents: 13
diff changeset
29 #include "fastmemcpy.h"
b69fe46fd708 Adding fastmemcpy stuff to speedup mplayer project
nickols_k
parents: 13
diff changeset
30 #endif
b69fe46fd708 Adding fastmemcpy stuff to speedup mplayer project
nickols_k
parents: 13
diff changeset
31
706
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 704
diff changeset
32 //#undef NDEBUG
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 704
diff changeset
33 //#include <assert.h>
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 704
diff changeset
34
13
174ef88f619a use block[] in structure to have it aligned on 8 bytes for mmx optimizations - dct_unquantize is always a function pointer - added specialized dct_unquantize_h263
glantau
parents: 8
diff changeset
35 static void encode_picture(MpegEncContext *s, int picture_number);
174ef88f619a use block[] in structure to have it aligned on 8 bytes for mmx optimizations - dct_unquantize is always a function pointer - added specialized dct_unquantize_h263
glantau
parents: 8
diff changeset
36 static void dct_unquantize_mpeg1_c(MpegEncContext *s,
174ef88f619a use block[] in structure to have it aligned on 8 bytes for mmx optimizations - dct_unquantize is always a function pointer - added specialized dct_unquantize_h263
glantau
parents: 8
diff changeset
37 DCTELEM *block, int n, int qscale);
325
15efd80cf51e mpeg2/mpeg4 dequantizer support (c & mmx)
michaelni
parents: 324
diff changeset
38 static void dct_unquantize_mpeg2_c(MpegEncContext *s,
15efd80cf51e mpeg2/mpeg4 dequantizer support (c & mmx)
michaelni
parents: 324
diff changeset
39 DCTELEM *block, int n, int qscale);
13
174ef88f619a use block[] in structure to have it aligned on 8 bytes for mmx optimizations - dct_unquantize is always a function pointer - added specialized dct_unquantize_h263
glantau
parents: 8
diff changeset
40 static void dct_unquantize_h263_c(MpegEncContext *s,
174ef88f619a use block[] in structure to have it aligned on 8 bytes for mmx optimizations - dct_unquantize is always a function pointer - added specialized dct_unquantize_h263
glantau
parents: 8
diff changeset
41 DCTELEM *block, int n, int qscale);
206
994aa8623443 (commit by michael)
arpi_esp
parents: 200
diff changeset
42 static void draw_edges_c(UINT8 *buf, int wrap, int width, int height, int w);
344
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
43 static int dct_quantize_c(MpegEncContext *s, DCTELEM *block, int n, int qscale, int *overflow);
206
994aa8623443 (commit by michael)
arpi_esp
parents: 200
diff changeset
44
994aa8623443 (commit by michael)
arpi_esp
parents: 200
diff changeset
45 void (*draw_edges)(UINT8 *buf, int wrap, int width, int height, int w)= draw_edges_c;
566
c376a0b290cf fixing gmc with emu edges
michaelni
parents: 565
diff changeset
46 static void emulated_edge_mc(MpegEncContext *s, UINT8 *src, int linesize, int block_w, int block_h,
c376a0b290cf fixing gmc with emu edges
michaelni
parents: 565
diff changeset
47 int src_x, int src_y, int w, int h);
206
994aa8623443 (commit by michael)
arpi_esp
parents: 200
diff changeset
48
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
49 #define EDGE_WIDTH 16
986e461dc072 Initial revision
glantau
parents:
diff changeset
50
986e461dc072 Initial revision
glantau
parents:
diff changeset
51 /* enable all paranoid tests for rounding, overflows, etc... */
986e461dc072 Initial revision
glantau
parents:
diff changeset
52 //#define PARANOID
986e461dc072 Initial revision
glantau
parents:
diff changeset
53
986e461dc072 Initial revision
glantau
parents:
diff changeset
54 //#define DEBUG
986e461dc072 Initial revision
glantau
parents:
diff changeset
55
321
2b00e171b1d4 - ME method compatibility with legacy apps.
pulento
parents: 320
diff changeset
56
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
57 /* for jpeg fast DCT */
986e461dc072 Initial revision
glantau
parents:
diff changeset
58 #define CONST_BITS 14
986e461dc072 Initial revision
glantau
parents:
diff changeset
59
986e461dc072 Initial revision
glantau
parents:
diff changeset
60 static const unsigned short aanscales[64] = {
986e461dc072 Initial revision
glantau
parents:
diff changeset
61 /* precomputed values scaled up by 14 bits */
986e461dc072 Initial revision
glantau
parents:
diff changeset
62 16384, 22725, 21407, 19266, 16384, 12873, 8867, 4520,
986e461dc072 Initial revision
glantau
parents:
diff changeset
63 22725, 31521, 29692, 26722, 22725, 17855, 12299, 6270,
986e461dc072 Initial revision
glantau
parents:
diff changeset
64 21407, 29692, 27969, 25172, 21407, 16819, 11585, 5906,
986e461dc072 Initial revision
glantau
parents:
diff changeset
65 19266, 26722, 25172, 22654, 19266, 15137, 10426, 5315,
986e461dc072 Initial revision
glantau
parents:
diff changeset
66 16384, 22725, 21407, 19266, 16384, 12873, 8867, 4520,
986e461dc072 Initial revision
glantau
parents:
diff changeset
67 12873, 17855, 16819, 15137, 12873, 10114, 6967, 3552,
986e461dc072 Initial revision
glantau
parents:
diff changeset
68 8867, 12299, 11585, 10426, 8867, 6967, 4799, 2446,
986e461dc072 Initial revision
glantau
parents:
diff changeset
69 4520, 6270, 5906, 5315, 4520, 3552, 2446, 1247
986e461dc072 Initial revision
glantau
parents:
diff changeset
70 };
986e461dc072 Initial revision
glantau
parents:
diff changeset
71
986e461dc072 Initial revision
glantau
parents:
diff changeset
72 static UINT8 h263_chroma_roundtab[16] = {
986e461dc072 Initial revision
glantau
parents:
diff changeset
73 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2,
986e461dc072 Initial revision
glantau
parents:
diff changeset
74 };
986e461dc072 Initial revision
glantau
parents:
diff changeset
75
292
73a9ce3d9715 fcode_tables where too small, found by Klaas-Pieter Vlieg <vlieg@eurescom.de>
michaelni
parents: 288
diff changeset
76 static UINT16 default_mv_penalty[MAX_FCODE+1][MAX_MV*2+1];
277
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 271
diff changeset
77 static UINT8 default_fcode_tab[MAX_MV*2+1];
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 271
diff changeset
78
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
79 /* default motion estimation */
321
2b00e171b1d4 - ME method compatibility with legacy apps.
pulento
parents: 320
diff changeset
80 int motion_estimation_method = ME_EPZS;
200
6ab301aaa652 (commit by michael)
arpi_esp
parents: 198
diff changeset
81
625
bb6a69f9d409 slow but accurate integer dct from IJG (should be ok with the LGPL as the old DCT is the fast integer DCT from IJG)
michaelni
parents: 619
diff changeset
82 static void convert_matrix(MpegEncContext *s, int (*qmat)[64], uint16_t (*qmat16)[64], uint16_t (*qmat16_bias)[64],
709
afeff6ccb7f5 convert only needed matrixes in convert_matrix() (mjpeg calls it for every frame)
michaelni
parents: 706
diff changeset
83 const UINT16 *quant_matrix, int bias, int qmin, int qmax)
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
84 {
344
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
85 int qscale;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
86
709
afeff6ccb7f5 convert only needed matrixes in convert_matrix() (mjpeg calls it for every frame)
michaelni
parents: 706
diff changeset
87 for(qscale=qmin; qscale<=qmax; qscale++){
344
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
88 int i;
625
bb6a69f9d409 slow but accurate integer dct from IJG (should be ok with the LGPL as the old DCT is the fast integer DCT from IJG)
michaelni
parents: 619
diff changeset
89 if (s->fdct == ff_jpeg_fdct_islow) {
bb6a69f9d409 slow but accurate integer dct from IJG (should be ok with the LGPL as the old DCT is the fast integer DCT from IJG)
michaelni
parents: 619
diff changeset
90 for(i=0;i<64;i++) {
706
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 704
diff changeset
91 const int j= s->idct_permutation[i];
625
bb6a69f9d409 slow but accurate integer dct from IJG (should be ok with the LGPL as the old DCT is the fast integer DCT from IJG)
michaelni
parents: 619
diff changeset
92 /* 16 <= qscale * quant_matrix[i] <= 7905 */
bb6a69f9d409 slow but accurate integer dct from IJG (should be ok with the LGPL as the old DCT is the fast integer DCT from IJG)
michaelni
parents: 619
diff changeset
93 /* 19952 <= aanscales[i] * qscale * quant_matrix[i] <= 249205026 */
bb6a69f9d409 slow but accurate integer dct from IJG (should be ok with the LGPL as the old DCT is the fast integer DCT from IJG)
michaelni
parents: 619
diff changeset
94 /* (1<<36)/19952 >= (1<<36)/(aanscales[i] * qscale * quant_matrix[i]) >= (1<<36)/249205026 */
bb6a69f9d409 slow but accurate integer dct from IJG (should be ok with the LGPL as the old DCT is the fast integer DCT from IJG)
michaelni
parents: 619
diff changeset
95 /* 3444240 >= (1<<36)/(aanscales[i] * qscale * quant_matrix[i]) >= 275 */
bb6a69f9d409 slow but accurate integer dct from IJG (should be ok with the LGPL as the old DCT is the fast integer DCT from IJG)
michaelni
parents: 619
diff changeset
96
764
d4726182dfd2 optimize block_permute()
michaelni
parents: 763
diff changeset
97 qmat[qscale][i] = (int)((UINT64_C(1) << QMAT_SHIFT) /
625
bb6a69f9d409 slow but accurate integer dct from IJG (should be ok with the LGPL as the old DCT is the fast integer DCT from IJG)
michaelni
parents: 619
diff changeset
98 (qscale * quant_matrix[j]));
bb6a69f9d409 slow but accurate integer dct from IJG (should be ok with the LGPL as the old DCT is the fast integer DCT from IJG)
michaelni
parents: 619
diff changeset
99 }
bb6a69f9d409 slow but accurate integer dct from IJG (should be ok with the LGPL as the old DCT is the fast integer DCT from IJG)
michaelni
parents: 619
diff changeset
100 } else if (s->fdct == fdct_ifast) {
344
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
101 for(i=0;i<64;i++) {
706
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 704
diff changeset
102 const int j= s->idct_permutation[i];
344
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
103 /* 16 <= qscale * quant_matrix[i] <= 7905 */
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
104 /* 19952 <= aanscales[i] * qscale * quant_matrix[i] <= 249205026 */
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
105 /* (1<<36)/19952 >= (1<<36)/(aanscales[i] * qscale * quant_matrix[i]) >= (1<<36)/249205026 */
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
106 /* 3444240 >= (1<<36)/(aanscales[i] * qscale * quant_matrix[i]) >= 275 */
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
107
764
d4726182dfd2 optimize block_permute()
michaelni
parents: 763
diff changeset
108 qmat[qscale][i] = (int)((UINT64_C(1) << (QMAT_SHIFT + 14)) /
344
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
109 (aanscales[i] * qscale * quant_matrix[j]));
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
110 }
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
111 } else {
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
112 for(i=0;i<64;i++) {
706
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 704
diff changeset
113 const int j= s->idct_permutation[i];
344
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
114 /* We can safely suppose that 16 <= quant_matrix[i] <= 255
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
115 So 16 <= qscale * quant_matrix[i] <= 7905
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
116 so (1<<19) / 16 >= (1<<19) / (qscale * quant_matrix[i]) >= (1<<19) / 7905
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
117 so 32768 >= (1<<19) / (qscale * quant_matrix[i]) >= 67
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
118 */
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
119 qmat [qscale][i] = (1 << QMAT_SHIFT_MMX) / (qscale * quant_matrix[i]);
706
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 704
diff changeset
120 qmat16[qscale][i] = (1 << QMAT_SHIFT_MMX) / (qscale * quant_matrix[j]);
344
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
121
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
122 if(qmat16[qscale][i]==0 || qmat16[qscale][i]==128*256) qmat16[qscale][i]=128*256-1;
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
123 qmat16_bias[qscale][i]= ROUNDED_DIV(bias<<(16-QUANT_BIAS_SHIFT), qmat16[qscale][i]);
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
124 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
125 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
126 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
127 }
456
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
128 // move into common.c perhaps
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
129 #define CHECKED_ALLOCZ(p, size)\
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
130 {\
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
131 p= av_mallocz(size);\
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
132 if(p==NULL){\
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
133 perror("malloc");\
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
134 goto fail;\
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
135 }\
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
136 }
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 731
diff changeset
137
706
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 704
diff changeset
138 void ff_init_scantable(MpegEncContext *s, ScanTable *st, const UINT8 *src_scantable){
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 704
diff changeset
139 int i;
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 704
diff changeset
140 int end;
764
d4726182dfd2 optimize block_permute()
michaelni
parents: 763
diff changeset
141
d4726182dfd2 optimize block_permute()
michaelni
parents: 763
diff changeset
142 st->scantable= src_scantable;
706
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 704
diff changeset
143
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 704
diff changeset
144 for(i=0; i<64; i++){
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 704
diff changeset
145 int j;
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 704
diff changeset
146 j = src_scantable[i];
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 704
diff changeset
147 st->permutated[i] = s->idct_permutation[j];
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 704
diff changeset
148 }
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 704
diff changeset
149
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 704
diff changeset
150 end=-1;
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 704
diff changeset
151 for(i=0; i<64; i++){
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 704
diff changeset
152 int j;
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 704
diff changeset
153 j = st->permutated[i];
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 704
diff changeset
154 if(j>end) end=j;
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 704
diff changeset
155 st->raster_end[i]= end;
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 704
diff changeset
156 }
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 704
diff changeset
157 }
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 704
diff changeset
158
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 704
diff changeset
159 /* XXX: those functions should be suppressed ASAP when all IDCTs are
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 704
diff changeset
160 converted */
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 704
diff changeset
161 static void ff_jref_idct_put(UINT8 *dest, int line_size, DCTELEM *block)
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 704
diff changeset
162 {
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 704
diff changeset
163 j_rev_dct (block);
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 704
diff changeset
164 put_pixels_clamped(block, dest, line_size);
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 704
diff changeset
165 }
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 704
diff changeset
166 static void ff_jref_idct_add(UINT8 *dest, int line_size, DCTELEM *block)
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 704
diff changeset
167 {
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 704
diff changeset
168 j_rev_dct (block);
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 704
diff changeset
169 add_pixels_clamped(block, dest, line_size);
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 704
diff changeset
170 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
171
726
a91203b34e71 moved dct init out from mpv_common_init to dct_common_init (for less-uglier way for dv)
al3x
parents: 721
diff changeset
172 /* init common dct for both encoder and decoder */
a91203b34e71 moved dct init out from mpv_common_init to dct_common_init (for less-uglier way for dv)
al3x
parents: 721
diff changeset
173 int DCT_common_init(MpegEncContext *s)
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
174 {
726
a91203b34e71 moved dct init out from mpv_common_init to dct_common_init (for less-uglier way for dv)
al3x
parents: 721
diff changeset
175 int i;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
176
312
8cf5507e6ca5 mpeg4 mpeg quantizer support
michaelni
parents: 311
diff changeset
177 s->dct_unquantize_h263 = dct_unquantize_h263_c;
325
15efd80cf51e mpeg2/mpeg4 dequantizer support (c & mmx)
michaelni
parents: 324
diff changeset
178 s->dct_unquantize_mpeg1 = dct_unquantize_mpeg1_c;
15efd80cf51e mpeg2/mpeg4 dequantizer support (c & mmx)
michaelni
parents: 324
diff changeset
179 s->dct_unquantize_mpeg2 = dct_unquantize_mpeg2_c;
625
bb6a69f9d409 slow but accurate integer dct from IJG (should be ok with the LGPL as the old DCT is the fast integer DCT from IJG)
michaelni
parents: 619
diff changeset
180 s->dct_quantize= dct_quantize_c;
bb6a69f9d409 slow but accurate integer dct from IJG (should be ok with the LGPL as the old DCT is the fast integer DCT from IJG)
michaelni
parents: 619
diff changeset
181
bb6a69f9d409 slow but accurate integer dct from IJG (should be ok with the LGPL as the old DCT is the fast integer DCT from IJG)
michaelni
parents: 619
diff changeset
182 if(s->avctx->dct_algo==FF_DCT_FASTINT)
bb6a69f9d409 slow but accurate integer dct from IJG (should be ok with the LGPL as the old DCT is the fast integer DCT from IJG)
michaelni
parents: 619
diff changeset
183 s->fdct = fdct_ifast;
bb6a69f9d409 slow but accurate integer dct from IJG (should be ok with the LGPL as the old DCT is the fast integer DCT from IJG)
michaelni
parents: 619
diff changeset
184 else
706
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 704
diff changeset
185 s->fdct = ff_jpeg_fdct_islow; //slow/accurate/default
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 704
diff changeset
186
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 704
diff changeset
187 if(s->avctx->idct_algo==FF_IDCT_INT){
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 704
diff changeset
188 s->idct_put= ff_jref_idct_put;
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 704
diff changeset
189 s->idct_add= ff_jref_idct_add;
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 704
diff changeset
190 for(i=0; i<64; i++)
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 704
diff changeset
191 s->idct_permutation[i]= (i & 0x38) | ((i & 6) >> 1) | ((i & 1) << 2);
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 704
diff changeset
192 }else{ //accurate/default
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 704
diff changeset
193 s->idct_put= simple_idct_put;
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 704
diff changeset
194 s->idct_add= simple_idct_add;
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 704
diff changeset
195 for(i=0; i<64; i++)
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 704
diff changeset
196 s->idct_permutation[i]= i;
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 704
diff changeset
197 }
13
174ef88f619a use block[] in structure to have it aligned on 8 bytes for mmx optimizations - dct_unquantize is always a function pointer - added specialized dct_unquantize_h263
glantau
parents: 8
diff changeset
198
174ef88f619a use block[] in structure to have it aligned on 8 bytes for mmx optimizations - dct_unquantize is always a function pointer - added specialized dct_unquantize_h263
glantau
parents: 8
diff changeset
199 #ifdef HAVE_MMX
174ef88f619a use block[] in structure to have it aligned on 8 bytes for mmx optimizations - dct_unquantize is always a function pointer - added specialized dct_unquantize_h263
glantau
parents: 8
diff changeset
200 MPV_common_init_mmx(s);
8
1b4461b5a7fb Sync with mplayer's stuff
nickols_k
parents: 7
diff changeset
201 #endif
514
c9f724e3a797 Update and activate dct_unquantize_h263_mvi. Thanks to M«©ns Rullg«©rd
mellum
parents: 506
diff changeset
202 #ifdef ARCH_ALPHA
c9f724e3a797 Update and activate dct_unquantize_h263_mvi. Thanks to M«©ns Rullg«©rd
mellum
parents: 506
diff changeset
203 MPV_common_init_axp(s);
c9f724e3a797 Update and activate dct_unquantize_h263_mvi. Thanks to M«©ns Rullg«©rd
mellum
parents: 506
diff changeset
204 #endif
628
f596db4aa871 sun solaris compilation bugfix, patch by (Martin Olschewski <olschewski at zpr dot uni-koeln dot de>)
michaelni
parents: 625
diff changeset
205 #ifdef HAVE_MLIB
f596db4aa871 sun solaris compilation bugfix, patch by (Martin Olschewski <olschewski at zpr dot uni-koeln dot de>)
michaelni
parents: 625
diff changeset
206 MPV_common_init_mlib(s);
f596db4aa871 sun solaris compilation bugfix, patch by (Martin Olschewski <olschewski at zpr dot uni-koeln dot de>)
michaelni
parents: 625
diff changeset
207 #endif
721
71f669e9f633 ps2 optimizations update patch by (Leon van Stuivenberg <leonvs at iae dot nl>)
michaelni
parents: 717
diff changeset
208 #ifdef HAVE_MMI
71f669e9f633 ps2 optimizations update patch by (Leon van Stuivenberg <leonvs at iae dot nl>)
michaelni
parents: 717
diff changeset
209 MPV_common_init_mmi(s);
71f669e9f633 ps2 optimizations update patch by (Leon van Stuivenberg <leonvs at iae dot nl>)
michaelni
parents: 717
diff changeset
210 #endif
730
b24ea84b23e2 trying to fix the non-x86 IDCTs (untested)
michaelni
parents: 726
diff changeset
211 #ifdef ARCH_ARMV4L
b24ea84b23e2 trying to fix the non-x86 IDCTs (untested)
michaelni
parents: 726
diff changeset
212 MPV_common_init_armv4l();
b24ea84b23e2 trying to fix the non-x86 IDCTs (untested)
michaelni
parents: 726
diff changeset
213 #endif
b24ea84b23e2 trying to fix the non-x86 IDCTs (untested)
michaelni
parents: 726
diff changeset
214
706
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 704
diff changeset
215
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 704
diff changeset
216 /* load & permutate scantables
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 704
diff changeset
217 note: only wmv uses differnt ones
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 704
diff changeset
218 */
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 704
diff changeset
219 ff_init_scantable(s, &s->inter_scantable , ff_zigzag_direct);
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 704
diff changeset
220 ff_init_scantable(s, &s->intra_scantable , ff_zigzag_direct);
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 704
diff changeset
221 ff_init_scantable(s, &s->intra_h_scantable, ff_alternate_horizontal_scan);
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 704
diff changeset
222 ff_init_scantable(s, &s->intra_v_scantable, ff_alternate_vertical_scan);
591
d3f374218030 fixing mpeg4 mpeg quantizers
michaelni
parents: 588
diff changeset
223
726
a91203b34e71 moved dct init out from mpv_common_init to dct_common_init (for less-uglier way for dv)
al3x
parents: 721
diff changeset
224 return 0;
a91203b34e71 moved dct init out from mpv_common_init to dct_common_init (for less-uglier way for dv)
al3x
parents: 721
diff changeset
225 }
a91203b34e71 moved dct init out from mpv_common_init to dct_common_init (for less-uglier way for dv)
al3x
parents: 721
diff changeset
226
a91203b34e71 moved dct init out from mpv_common_init to dct_common_init (for less-uglier way for dv)
al3x
parents: 721
diff changeset
227 /* init common structure for both encoder and decoder */
a91203b34e71 moved dct init out from mpv_common_init to dct_common_init (for less-uglier way for dv)
al3x
parents: 721
diff changeset
228 int MPV_common_init(MpegEncContext *s)
a91203b34e71 moved dct init out from mpv_common_init to dct_common_init (for less-uglier way for dv)
al3x
parents: 721
diff changeset
229 {
a91203b34e71 moved dct init out from mpv_common_init to dct_common_init (for less-uglier way for dv)
al3x
parents: 721
diff changeset
230 UINT8 *pict;
756
f2644bb12a43 fixing h263 decoding (did segfault)
michaelni
parents: 755
diff changeset
231 int y_size, c_size, yc_size, i;
726
a91203b34e71 moved dct init out from mpv_common_init to dct_common_init (for less-uglier way for dv)
al3x
parents: 721
diff changeset
232
a91203b34e71 moved dct init out from mpv_common_init to dct_common_init (for less-uglier way for dv)
al3x
parents: 721
diff changeset
233 DCT_common_init(s);
754
b2767c9d6455 init flags before using it (found by arpi)
michaelni
parents: 753
diff changeset
234
b2767c9d6455 init flags before using it (found by arpi)
michaelni
parents: 753
diff changeset
235 s->flags= s->avctx->flags;
726
a91203b34e71 moved dct init out from mpv_common_init to dct_common_init (for less-uglier way for dv)
al3x
parents: 721
diff changeset
236
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
237 s->mb_width = (s->width + 15) / 16;
986e461dc072 Initial revision
glantau
parents:
diff changeset
238 s->mb_height = (s->height + 15) / 16;
582
5132a4ee50cd different edge positions fixed with edge emu / dr1
michaelni
parents: 575
diff changeset
239
756
f2644bb12a43 fixing h263 decoding (did segfault)
michaelni
parents: 755
diff changeset
240 y_size = (2 * s->mb_width + 2) * (2 * s->mb_height + 2);
f2644bb12a43 fixing h263 decoding (did segfault)
michaelni
parents: 755
diff changeset
241 c_size = (s->mb_width + 2) * (s->mb_height + 2);
f2644bb12a43 fixing h263 decoding (did segfault)
michaelni
parents: 755
diff changeset
242 yc_size = y_size + 2 * c_size;
f2644bb12a43 fixing h263 decoding (did segfault)
michaelni
parents: 755
diff changeset
243
582
5132a4ee50cd different edge positions fixed with edge emu / dr1
michaelni
parents: 575
diff changeset
244 /* set default edge pos, will be overriden in decode_header if needed */
5132a4ee50cd different edge positions fixed with edge emu / dr1
michaelni
parents: 575
diff changeset
245 s->h_edge_pos= s->mb_width*16;
5132a4ee50cd different edge positions fixed with edge emu / dr1
michaelni
parents: 575
diff changeset
246 s->v_edge_pos= s->mb_height*16;
701
85b071dfc7e3 ff_get_fourcc() & XVIX support
michaelni
parents: 697
diff changeset
247
85b071dfc7e3 ff_get_fourcc() & XVIX support
michaelni
parents: 697
diff changeset
248 /* convert fourcc to upper case */
85b071dfc7e3 ff_get_fourcc() & XVIX support
michaelni
parents: 697
diff changeset
249 s->avctx->fourcc= toupper( s->avctx->fourcc &0xFF)
85b071dfc7e3 ff_get_fourcc() & XVIX support
michaelni
parents: 697
diff changeset
250 + (toupper((s->avctx->fourcc>>8 )&0xFF)<<8 )
85b071dfc7e3 ff_get_fourcc() & XVIX support
michaelni
parents: 697
diff changeset
251 + (toupper((s->avctx->fourcc>>16)&0xFF)<<16)
85b071dfc7e3 ff_get_fourcc() & XVIX support
michaelni
parents: 697
diff changeset
252 + (toupper((s->avctx->fourcc>>24)&0xFF)<<24);
582
5132a4ee50cd different edge positions fixed with edge emu / dr1
michaelni
parents: 575
diff changeset
253
233
3f5b72726118 - More work on preliminary bit rate control, just to be able to get an
pulento
parents: 232
diff changeset
254 s->mb_num = s->mb_width * s->mb_height;
756
f2644bb12a43 fixing h263 decoding (did segfault)
michaelni
parents: 755
diff changeset
255
553
18ad513d92fe direct rendering method 1 support
michaelni
parents: 549
diff changeset
256 if(!(s->flags&CODEC_FLAG_DR1)){
556
762c67fd4078 uvlinesize
michaelni
parents: 554
diff changeset
257 s->linesize = s->mb_width * 16 + 2 * EDGE_WIDTH;
762c67fd4078 uvlinesize
michaelni
parents: 554
diff changeset
258 s->uvlinesize = s->mb_width * 8 + EDGE_WIDTH;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
259
553
18ad513d92fe direct rendering method 1 support
michaelni
parents: 549
diff changeset
260 for(i=0;i<3;i++) {
756
f2644bb12a43 fixing h263 decoding (did segfault)
michaelni
parents: 755
diff changeset
261 int w, h, shift, pict_start, size;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
262
986e461dc072 Initial revision
glantau
parents:
diff changeset
263 w = s->linesize;
986e461dc072 Initial revision
glantau
parents:
diff changeset
264 h = s->mb_height * 16 + 2 * EDGE_WIDTH;
986e461dc072 Initial revision
glantau
parents:
diff changeset
265 shift = (i == 0) ? 0 : 1;
756
f2644bb12a43 fixing h263 decoding (did segfault)
michaelni
parents: 755
diff changeset
266 size = (s->linesize>>shift) * (h >> shift);
556
762c67fd4078 uvlinesize
michaelni
parents: 554
diff changeset
267 pict_start = (s->linesize>>shift) * (EDGE_WIDTH >> shift) + (EDGE_WIDTH >> shift);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
268
756
f2644bb12a43 fixing h263 decoding (did segfault)
michaelni
parents: 755
diff changeset
269 CHECKED_ALLOCZ(pict, size)
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
270 s->last_picture_base[i] = pict;
986e461dc072 Initial revision
glantau
parents:
diff changeset
271 s->last_picture[i] = pict + pict_start;
756
f2644bb12a43 fixing h263 decoding (did segfault)
michaelni
parents: 755
diff changeset
272 if(i>0) memset(s->last_picture_base[i], 128, size);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
273
756
f2644bb12a43 fixing h263 decoding (did segfault)
michaelni
parents: 755
diff changeset
274 CHECKED_ALLOCZ(pict, size)
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
275 s->next_picture_base[i] = pict;
986e461dc072 Initial revision
glantau
parents:
diff changeset
276 s->next_picture[i] = pict + pict_start;
756
f2644bb12a43 fixing h263 decoding (did segfault)
michaelni
parents: 755
diff changeset
277 if(i>0) memset(s->next_picture_base[i], 128, size);
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
278
365
fdeec2834c79 there are divx5? encoded files without a userdata section but with b-frames :(
michaelni
parents: 350
diff changeset
279 if (s->has_b_frames || s->codec_id==CODEC_ID_MPEG4) {
fdeec2834c79 there are divx5? encoded files without a userdata section but with b-frames :(
michaelni
parents: 350
diff changeset
280 /* Note the MPEG4 stuff is here cuz of buggy encoders which dont set the low_delay flag but
fdeec2834c79 there are divx5? encoded files without a userdata section but with b-frames :(
michaelni
parents: 350
diff changeset
281 do low-delay encoding, so we cant allways distinguish b-frame containing streams from low_delay streams */
756
f2644bb12a43 fixing h263 decoding (did segfault)
michaelni
parents: 755
diff changeset
282 CHECKED_ALLOCZ(pict, size)
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
283 s->aux_picture_base[i] = pict;
986e461dc072 Initial revision
glantau
parents:
diff changeset
284 s->aux_picture[i] = pict + pict_start;
756
f2644bb12a43 fixing h263 decoding (did segfault)
michaelni
parents: 755
diff changeset
285 if(i>0) memset(s->aux_picture_base[i], 128, size);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
286 }
553
18ad513d92fe direct rendering method 1 support
michaelni
parents: 549
diff changeset
287 }
556
762c67fd4078 uvlinesize
michaelni
parents: 554
diff changeset
288 s->ip_buffer_count= 2;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
289 }
232
b640ec5948b0 - Now the ME is done for the entire picture when enconding, the
pulento
parents: 231
diff changeset
290
567
5a6eaaa9fba2 larger edge emu buffer (might have been too small)
michaelni
parents: 566
diff changeset
291 CHECKED_ALLOCZ(s->edge_emu_buffer, (s->width+64)*2*17*2); //(width + edge + align)*interlaced*MBsize*tolerance
553
18ad513d92fe direct rendering method 1 support
michaelni
parents: 549
diff changeset
292
232
b640ec5948b0 - Now the ME is done for the entire picture when enconding, the
pulento
parents: 231
diff changeset
293 if (s->encoding) {
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
294 int j;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
295 int mv_table_size= (s->mb_width+2)*(s->mb_height+2);
239
16cd8a9c4da4 - Minor changes on bitrate control
pulento
parents: 234
diff changeset
296
456
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
297 CHECKED_ALLOCZ(s->mb_var , s->mb_num * sizeof(INT16))
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
298 CHECKED_ALLOCZ(s->mc_mb_var, s->mb_num * sizeof(INT16))
690
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 673
diff changeset
299 CHECKED_ALLOCZ(s->mb_mean , s->mb_num * sizeof(INT8))
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
300
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
301 /* Allocate MV tables */
456
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
302 CHECKED_ALLOCZ(s->p_mv_table , mv_table_size * 2 * sizeof(INT16))
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
303 CHECKED_ALLOCZ(s->b_forw_mv_table , mv_table_size * 2 * sizeof(INT16))
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
304 CHECKED_ALLOCZ(s->b_back_mv_table , mv_table_size * 2 * sizeof(INT16))
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
305 CHECKED_ALLOCZ(s->b_bidir_forw_mv_table , mv_table_size * 2 * sizeof(INT16))
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
306 CHECKED_ALLOCZ(s->b_bidir_back_mv_table , mv_table_size * 2 * sizeof(INT16))
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
307 CHECKED_ALLOCZ(s->b_direct_forw_mv_table, mv_table_size * 2 * sizeof(INT16))
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
308 CHECKED_ALLOCZ(s->b_direct_back_mv_table, mv_table_size * 2 * sizeof(INT16))
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
309 CHECKED_ALLOCZ(s->b_direct_mv_table , mv_table_size * 2 * sizeof(INT16))
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
310
456
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
311 CHECKED_ALLOCZ(s->me_scratchpad, s->linesize*16*3*sizeof(uint8_t))
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
312
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
313 CHECKED_ALLOCZ(s->me_map , ME_MAP_SIZE*sizeof(uint32_t))
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
314 CHECKED_ALLOCZ(s->me_score_map, ME_MAP_SIZE*sizeof(uint16_t))
327
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 326
diff changeset
315
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
316 if(s->max_b_frames){
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
317 for(j=0; j<REORDER_BUFFER_SIZE; j++){
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
318 int i;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
319 for(i=0;i<3;i++) {
756
f2644bb12a43 fixing h263 decoding (did segfault)
michaelni
parents: 755
diff changeset
320 int w, h, shift, size;
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
321
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
322 w = s->linesize;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
323 h = s->mb_height * 16;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
324 shift = (i == 0) ? 0 : 1;
756
f2644bb12a43 fixing h263 decoding (did segfault)
michaelni
parents: 755
diff changeset
325 size = (w >> shift) * (h >> shift);
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
326
756
f2644bb12a43 fixing h263 decoding (did segfault)
michaelni
parents: 755
diff changeset
327 CHECKED_ALLOCZ(pict, size);
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
328 s->picture_buffer[j][i] = pict;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
329 }
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
330 }
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
331 }
456
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
332
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
333 if(s->codec_id==CODEC_ID_MPEG4){
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
334 CHECKED_ALLOCZ(s->tex_pb_buffer, PB_BUFFER_SIZE);
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
335 CHECKED_ALLOCZ( s->pb2_buffer, PB_BUFFER_SIZE);
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
336 }
612
c0005de2be59 new ratecontrol code
michaelni
parents: 611
diff changeset
337
650
ef4a33aad86e reducing sizeof MpegEncContext to avoid stack overflow on crap M$ windo$
michaelni
parents: 635
diff changeset
338 if(s->msmpeg4_version){
ef4a33aad86e reducing sizeof MpegEncContext to avoid stack overflow on crap M$ windo$
michaelni
parents: 635
diff changeset
339 CHECKED_ALLOCZ(s->ac_stats, 2*2*(MAX_LEVEL+1)*(MAX_RUN+1)*2*sizeof(int));
ef4a33aad86e reducing sizeof MpegEncContext to avoid stack overflow on crap M$ windo$
michaelni
parents: 635
diff changeset
340 }
612
c0005de2be59 new ratecontrol code
michaelni
parents: 611
diff changeset
341 CHECKED_ALLOCZ(s->avctx->stats_out, 256);
232
b640ec5948b0 - Now the ME is done for the entire picture when enconding, the
pulento
parents: 231
diff changeset
342 }
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 731
diff changeset
343
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 731
diff changeset
344 CHECKED_ALLOCZ(s->error_status_table, s->mb_num*sizeof(UINT8))
232
b640ec5948b0 - Now the ME is done for the entire picture when enconding, the
pulento
parents: 231
diff changeset
345
288
f82cce6cb182 10l (motion_val was uninitilized)
michaelni
parents: 287
diff changeset
346 if (s->out_format == FMT_H263 || s->encoding) {
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
347 int size;
456
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
348 /* Allocate MB type table */
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
349 CHECKED_ALLOCZ(s->mb_type , s->mb_num * sizeof(UINT8))
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
350
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
351 /* MV prediction */
986e461dc072 Initial revision
glantau
parents:
diff changeset
352 size = (2 * s->mb_width + 2) * (2 * s->mb_height + 2);
456
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
353 CHECKED_ALLOCZ(s->motion_val, size * 2 * sizeof(INT16));
664
00a882f626bd interlaced mpeg4 b frame decoding
michaelni
parents: 661
diff changeset
354 }
00a882f626bd interlaced mpeg4 b frame decoding
michaelni
parents: 661
diff changeset
355
00a882f626bd interlaced mpeg4 b frame decoding
michaelni
parents: 661
diff changeset
356 if(s->codec_id==CODEC_ID_MPEG4){
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 731
diff changeset
357 /* interlaced direct mode decoding tables */
664
00a882f626bd interlaced mpeg4 b frame decoding
michaelni
parents: 661
diff changeset
358 CHECKED_ALLOCZ(s->field_mv_table, s->mb_num*2*2 * sizeof(INT16))
00a882f626bd interlaced mpeg4 b frame decoding
michaelni
parents: 661
diff changeset
359 CHECKED_ALLOCZ(s->field_select_table, s->mb_num*2* sizeof(INT8))
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
360 }
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 731
diff changeset
361 /* 4mv b frame decoding table */
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 731
diff changeset
362 //note this is needed for h263 without b frames too (segfault on damaged streams otherwise)
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 731
diff changeset
363 CHECKED_ALLOCZ(s->co_located_type_table, s->mb_num * sizeof(UINT8))
767
c75c3f1bef4b regression test for H263+
michaelni
parents: 766
diff changeset
364 if (s->out_format == FMT_H263) {
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
365 /* ac values */
756
f2644bb12a43 fixing h263 decoding (did segfault)
michaelni
parents: 755
diff changeset
366 CHECKED_ALLOCZ(s->ac_val[0], yc_size * sizeof(INT16) * 16);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
367 s->ac_val[1] = s->ac_val[0] + y_size;
986e461dc072 Initial revision
glantau
parents:
diff changeset
368 s->ac_val[2] = s->ac_val[1] + c_size;
986e461dc072 Initial revision
glantau
parents:
diff changeset
369
986e461dc072 Initial revision
glantau
parents:
diff changeset
370 /* cbp values */
456
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
371 CHECKED_ALLOCZ(s->coded_block, y_size);
333
8aa87f1dfc52 divx 5.01 support
michaelni
parents: 329
diff changeset
372
8aa87f1dfc52 divx 5.01 support
michaelni
parents: 329
diff changeset
373 /* divx501 bitstream reorder buffer */
456
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
374 CHECKED_ALLOCZ(s->bitstream_buffer, BITSTREAM_BUFFER_SIZE);
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
375
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
376 /* cbp, ac_pred, pred_dir */
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
377 CHECKED_ALLOCZ(s->cbp_table , s->mb_num * sizeof(UINT8))
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
378 CHECKED_ALLOCZ(s->pred_dir_table, s->mb_num * sizeof(UINT8))
197
21abf1b20016 different fix, s->mbintra_table used only if h263_pred set. - patch by Michael Niedermayer <michaelni@gmx.at>
arpi_esp
parents: 196
diff changeset
379 }
756
f2644bb12a43 fixing h263 decoding (did segfault)
michaelni
parents: 755
diff changeset
380
f2644bb12a43 fixing h263 decoding (did segfault)
michaelni
parents: 755
diff changeset
381 if (s->h263_pred || s->h263_plus || !s->encoding) {
f2644bb12a43 fixing h263 decoding (did segfault)
michaelni
parents: 755
diff changeset
382 /* dc values */
f2644bb12a43 fixing h263 decoding (did segfault)
michaelni
parents: 755
diff changeset
383 //MN: we need these for error resilience of intra-frames
f2644bb12a43 fixing h263 decoding (did segfault)
michaelni
parents: 755
diff changeset
384 CHECKED_ALLOCZ(s->dc_val[0], yc_size * sizeof(INT16));
f2644bb12a43 fixing h263 decoding (did segfault)
michaelni
parents: 755
diff changeset
385 s->dc_val[1] = s->dc_val[0] + y_size;
f2644bb12a43 fixing h263 decoding (did segfault)
michaelni
parents: 755
diff changeset
386 s->dc_val[2] = s->dc_val[1] + c_size;
f2644bb12a43 fixing h263 decoding (did segfault)
michaelni
parents: 755
diff changeset
387 for(i=0;i<yc_size;i++)
f2644bb12a43 fixing h263 decoding (did segfault)
michaelni
parents: 755
diff changeset
388 s->dc_val[0][i] = 1024;
f2644bb12a43 fixing h263 decoding (did segfault)
michaelni
parents: 755
diff changeset
389 }
f2644bb12a43 fixing h263 decoding (did segfault)
michaelni
parents: 755
diff changeset
390
575
23eee7d73c4b minor optimizations
michaelni
parents: 570
diff changeset
391 CHECKED_ALLOCZ(s->qscale_table , s->mb_num * sizeof(UINT8))
23eee7d73c4b minor optimizations
michaelni
parents: 570
diff changeset
392
611
3214d3f4519e error concealment needs the mbintra_table so it should allways be allocated
michaelni
parents: 608
diff changeset
393 /* which mb is a intra block */
3214d3f4519e error concealment needs the mbintra_table so it should allways be allocated
michaelni
parents: 608
diff changeset
394 CHECKED_ALLOCZ(s->mbintra_table, s->mb_num);
3214d3f4519e error concealment needs the mbintra_table so it should allways be allocated
michaelni
parents: 608
diff changeset
395 memset(s->mbintra_table, 1, s->mb_num);
3214d3f4519e error concealment needs the mbintra_table so it should allways be allocated
michaelni
parents: 608
diff changeset
396
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
397 /* default structure is frame */
986e461dc072 Initial revision
glantau
parents:
diff changeset
398 s->picture_structure = PICT_FRAME;
553
18ad513d92fe direct rendering method 1 support
michaelni
parents: 549
diff changeset
399
7
1d3ac9654178 added skip macroblock optimization (big perf win on black regions for example)
glantau
parents: 0
diff changeset
400 /* init macroblock skip table */
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 731
diff changeset
401 CHECKED_ALLOCZ(s->mbskip_table, s->mb_num+1);
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 731
diff changeset
402 //Note the +1 is for a quicker mpeg4 slice_end detection
294
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 292
diff changeset
403
327
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 326
diff changeset
404 s->block= s->blocks[0];
7
1d3ac9654178 added skip macroblock optimization (big perf win on black regions for example)
glantau
parents: 0
diff changeset
405
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
406 s->context_initialized = 1;
986e461dc072 Initial revision
glantau
parents:
diff changeset
407 return 0;
986e461dc072 Initial revision
glantau
parents:
diff changeset
408 fail:
244
3860331a1ecb * eliminating duplicated code from MPV_common_end
kabi
parents: 239
diff changeset
409 MPV_common_end(s);
3860331a1ecb * eliminating duplicated code from MPV_common_end
kabi
parents: 239
diff changeset
410 return -1;
3860331a1ecb * eliminating duplicated code from MPV_common_end
kabi
parents: 239
diff changeset
411 }
3860331a1ecb * eliminating duplicated code from MPV_common_end
kabi
parents: 239
diff changeset
412
456
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
413
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
414 //extern int sads;
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
415
244
3860331a1ecb * eliminating duplicated code from MPV_common_end
kabi
parents: 239
diff changeset
416 /* init common structure for both encoder and decoder */
3860331a1ecb * eliminating duplicated code from MPV_common_end
kabi
parents: 239
diff changeset
417 void MPV_common_end(MpegEncContext *s)
3860331a1ecb * eliminating duplicated code from MPV_common_end
kabi
parents: 239
diff changeset
418 {
3860331a1ecb * eliminating duplicated code from MPV_common_end
kabi
parents: 239
diff changeset
419 int i;
3860331a1ecb * eliminating duplicated code from MPV_common_end
kabi
parents: 239
diff changeset
420
396
fce0a2520551 removed useless header includes - use av memory functions
glantau
parents: 376
diff changeset
421 av_freep(&s->mb_type);
fce0a2520551 removed useless header includes - use av memory functions
glantau
parents: 376
diff changeset
422 av_freep(&s->mb_var);
456
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
423 av_freep(&s->mc_mb_var);
690
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 673
diff changeset
424 av_freep(&s->mb_mean);
396
fce0a2520551 removed useless header includes - use av memory functions
glantau
parents: 376
diff changeset
425 av_freep(&s->p_mv_table);
fce0a2520551 removed useless header includes - use av memory functions
glantau
parents: 376
diff changeset
426 av_freep(&s->b_forw_mv_table);
fce0a2520551 removed useless header includes - use av memory functions
glantau
parents: 376
diff changeset
427 av_freep(&s->b_back_mv_table);
fce0a2520551 removed useless header includes - use av memory functions
glantau
parents: 376
diff changeset
428 av_freep(&s->b_bidir_forw_mv_table);
fce0a2520551 removed useless header includes - use av memory functions
glantau
parents: 376
diff changeset
429 av_freep(&s->b_bidir_back_mv_table);
fce0a2520551 removed useless header includes - use av memory functions
glantau
parents: 376
diff changeset
430 av_freep(&s->b_direct_forw_mv_table);
fce0a2520551 removed useless header includes - use av memory functions
glantau
parents: 376
diff changeset
431 av_freep(&s->b_direct_back_mv_table);
fce0a2520551 removed useless header includes - use av memory functions
glantau
parents: 376
diff changeset
432 av_freep(&s->b_direct_mv_table);
fce0a2520551 removed useless header includes - use av memory functions
glantau
parents: 376
diff changeset
433 av_freep(&s->motion_val);
fce0a2520551 removed useless header includes - use av memory functions
glantau
parents: 376
diff changeset
434 av_freep(&s->dc_val[0]);
fce0a2520551 removed useless header includes - use av memory functions
glantau
parents: 376
diff changeset
435 av_freep(&s->ac_val[0]);
fce0a2520551 removed useless header includes - use av memory functions
glantau
parents: 376
diff changeset
436 av_freep(&s->coded_block);
fce0a2520551 removed useless header includes - use av memory functions
glantau
parents: 376
diff changeset
437 av_freep(&s->mbintra_table);
456
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
438 av_freep(&s->cbp_table);
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
439 av_freep(&s->pred_dir_table);
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
440 av_freep(&s->qscale_table);
396
fce0a2520551 removed useless header includes - use av memory functions
glantau
parents: 376
diff changeset
441 av_freep(&s->me_scratchpad);
456
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
442 av_freep(&s->me_map);
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
443 av_freep(&s->me_score_map);
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
444
396
fce0a2520551 removed useless header includes - use av memory functions
glantau
parents: 376
diff changeset
445 av_freep(&s->mbskip_table);
fce0a2520551 removed useless header includes - use av memory functions
glantau
parents: 376
diff changeset
446 av_freep(&s->bitstream_buffer);
456
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
447 av_freep(&s->tex_pb_buffer);
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
448 av_freep(&s->pb2_buffer);
553
18ad513d92fe direct rendering method 1 support
michaelni
parents: 549
diff changeset
449 av_freep(&s->edge_emu_buffer);
664
00a882f626bd interlaced mpeg4 b frame decoding
michaelni
parents: 661
diff changeset
450 av_freep(&s->co_located_type_table);
00a882f626bd interlaced mpeg4 b frame decoding
michaelni
parents: 661
diff changeset
451 av_freep(&s->field_mv_table);
00a882f626bd interlaced mpeg4 b frame decoding
michaelni
parents: 661
diff changeset
452 av_freep(&s->field_select_table);
612
c0005de2be59 new ratecontrol code
michaelni
parents: 611
diff changeset
453 av_freep(&s->avctx->stats_out);
650
ef4a33aad86e reducing sizeof MpegEncContext to avoid stack overflow on crap M$ windo$
michaelni
parents: 635
diff changeset
454 av_freep(&s->ac_stats);
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 731
diff changeset
455 av_freep(&s->error_status_table);
612
c0005de2be59 new ratecontrol code
michaelni
parents: 611
diff changeset
456
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
457 for(i=0;i<3;i++) {
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
458 int j;
553
18ad513d92fe direct rendering method 1 support
michaelni
parents: 549
diff changeset
459 if(!(s->flags&CODEC_FLAG_DR1)){
18ad513d92fe direct rendering method 1 support
michaelni
parents: 549
diff changeset
460 av_freep(&s->last_picture_base[i]);
18ad513d92fe direct rendering method 1 support
michaelni
parents: 549
diff changeset
461 av_freep(&s->next_picture_base[i]);
18ad513d92fe direct rendering method 1 support
michaelni
parents: 549
diff changeset
462 av_freep(&s->aux_picture_base[i]);
18ad513d92fe direct rendering method 1 support
michaelni
parents: 549
diff changeset
463 }
18ad513d92fe direct rendering method 1 support
michaelni
parents: 549
diff changeset
464 s->last_picture_base[i]=
18ad513d92fe direct rendering method 1 support
michaelni
parents: 549
diff changeset
465 s->next_picture_base[i]=
18ad513d92fe direct rendering method 1 support
michaelni
parents: 549
diff changeset
466 s->aux_picture_base [i] = NULL;
18ad513d92fe direct rendering method 1 support
michaelni
parents: 549
diff changeset
467 s->last_picture[i]=
18ad513d92fe direct rendering method 1 support
michaelni
parents: 549
diff changeset
468 s->next_picture[i]=
18ad513d92fe direct rendering method 1 support
michaelni
parents: 549
diff changeset
469 s->aux_picture [i] = NULL;
18ad513d92fe direct rendering method 1 support
michaelni
parents: 549
diff changeset
470
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
471 for(j=0; j<REORDER_BUFFER_SIZE; j++){
396
fce0a2520551 removed useless header includes - use av memory functions
glantau
parents: 376
diff changeset
472 av_freep(&s->picture_buffer[j][i]);
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
473 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
474 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
475 s->context_initialized = 0;
986e461dc072 Initial revision
glantau
parents:
diff changeset
476 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
477
986e461dc072 Initial revision
glantau
parents:
diff changeset
478 /* init video encoder */
986e461dc072 Initial revision
glantau
parents:
diff changeset
479 int MPV_encode_init(AVCodecContext *avctx)
986e461dc072 Initial revision
glantau
parents:
diff changeset
480 {
986e461dc072 Initial revision
glantau
parents:
diff changeset
481 MpegEncContext *s = avctx->priv_data;
60
35c1141e23d9 moved matrix init away from MPV_common_init()
glantau
parents: 57
diff changeset
482 int i;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
483
315
40d8092e2ff0 * using pixtype as enum - by Philip Gladstone
kabi
parents: 312
diff changeset
484 avctx->pix_fmt = PIX_FMT_YUV420P;
40d8092e2ff0 * using pixtype as enum - by Philip Gladstone
kabi
parents: 312
diff changeset
485
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
486 s->bit_rate = avctx->bit_rate;
268
09ae29b27ed9 hopefully better bitrate controll
michaelni
parents: 266
diff changeset
487 s->bit_rate_tolerance = avctx->bit_rate_tolerance;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
488 s->frame_rate = avctx->frame_rate;
986e461dc072 Initial revision
glantau
parents:
diff changeset
489 s->width = avctx->width;
986e461dc072 Initial revision
glantau
parents:
diff changeset
490 s->height = avctx->height;
456
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
491 if(avctx->gop_size > 600){
462
3fdd0627f6bd typo (found by Bohdan Horst <nexus at hoth.amu.edu.pl>)
michaelni
parents: 461
diff changeset
492 fprintf(stderr, "Warning keyframe interval too large! reducing it ...\n");
456
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
493 avctx->gop_size=600;
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
494 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
495 s->gop_size = avctx->gop_size;
162
de80712db90b - Preliminary RTP friendly mode for H.263.
pulento
parents: 108
diff changeset
496 s->rtp_mode = avctx->rtp_mode;
de80712db90b - Preliminary RTP friendly mode for H.263.
pulento
parents: 108
diff changeset
497 s->rtp_payload_size = avctx->rtp_payload_size;
231
840cd25bf259 - Fixes on RTP and GOB headers for H.263.
pulento
parents: 230
diff changeset
498 if (avctx->rtp_callback)
840cd25bf259 - Fixes on RTP and GOB headers for H.263.
pulento
parents: 230
diff changeset
499 s->rtp_callback = avctx->rtp_callback;
268
09ae29b27ed9 hopefully better bitrate controll
michaelni
parents: 266
diff changeset
500 s->qmin= avctx->qmin;
09ae29b27ed9 hopefully better bitrate controll
michaelni
parents: 266
diff changeset
501 s->qmax= avctx->qmax;
09ae29b27ed9 hopefully better bitrate controll
michaelni
parents: 266
diff changeset
502 s->max_qdiff= avctx->max_qdiff;
09ae29b27ed9 hopefully better bitrate controll
michaelni
parents: 266
diff changeset
503 s->qcompress= avctx->qcompress;
09ae29b27ed9 hopefully better bitrate controll
michaelni
parents: 266
diff changeset
504 s->qblur= avctx->qblur;
194
27d1773552c9 mpeg4 encoder fix by Michael Niedermayer <michaelni@gmx.at>
arpi_esp
parents: 191
diff changeset
505 s->avctx = avctx;
281
1fc96b02142e mpeg4 aspect_ratio_info in AVCodecContext (requested by alex)
michaelni
parents: 280
diff changeset
506 s->aspect_ratio_info= avctx->aspect_ratio_info;
618
4f3d4a07d374 added aspected_width/height for EXTENDED_PAR
al3x
parents: 612
diff changeset
507 if (avctx->aspect_ratio_info == FF_ASPECT_EXTENDED)
4f3d4a07d374 added aspected_width/height for EXTENDED_PAR
al3x
parents: 612
diff changeset
508 {
4f3d4a07d374 added aspected_width/height for EXTENDED_PAR
al3x
parents: 612
diff changeset
509 s->aspected_width = avctx->aspected_width;
4f3d4a07d374 added aspected_width/height for EXTENDED_PAR
al3x
parents: 612
diff changeset
510 s->aspected_height = avctx->aspected_height;
4f3d4a07d374 added aspected_width/height for EXTENDED_PAR
al3x
parents: 612
diff changeset
511 }
294
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 292
diff changeset
512 s->flags= avctx->flags;
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
513 s->max_b_frames= avctx->max_b_frames;
329
5cc47d0ba53e fixed ratecontrol & b-frames
michaelni
parents: 327
diff changeset
514 s->b_frame_strategy= avctx->b_frame_strategy;
344
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
515 s->codec_id= avctx->codec->id;
456
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
516 s->luma_elim_threshold = avctx->luma_elim_threshold;
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
517 s->chroma_elim_threshold= avctx->chroma_elim_threshold;
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
518 s->strict_std_compliance= avctx->strict_std_compliance;
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
519 s->data_partitioning= avctx->flags & CODEC_FLAG_PART;
599
b1a191202f96 mpeg4 mpeg quantizer encoding
michaelni
parents: 598
diff changeset
520 s->mpeg_quant= avctx->mpeg_quant;
344
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
521
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
522 if (s->gop_size <= 1) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
523 s->intra_only = 1;
986e461dc072 Initial revision
glantau
parents:
diff changeset
524 s->gop_size = 12;
986e461dc072 Initial revision
glantau
parents:
diff changeset
525 } else {
986e461dc072 Initial revision
glantau
parents:
diff changeset
526 s->intra_only = 0;
986e461dc072 Initial revision
glantau
parents:
diff changeset
527 }
693
b6a7ff92df57 darkness masking (lumi masking does only bright stuff now)
michaelni
parents: 690
diff changeset
528
320
cda7d0857baf - ME setting moved to AVCodecContext/MpegEncContext, no longer a global.
pulento
parents: 315
diff changeset
529 /* ME algorithm */
321
2b00e171b1d4 - ME method compatibility with legacy apps.
pulento
parents: 320
diff changeset
530 if (avctx->me_method == 0)
2b00e171b1d4 - ME method compatibility with legacy apps.
pulento
parents: 320
diff changeset
531 /* For compatibility */
2b00e171b1d4 - ME method compatibility with legacy apps.
pulento
parents: 320
diff changeset
532 s->me_method = motion_estimation_method;
2b00e171b1d4 - ME method compatibility with legacy apps.
pulento
parents: 320
diff changeset
533 else
2b00e171b1d4 - ME method compatibility with legacy apps.
pulento
parents: 320
diff changeset
534 s->me_method = avctx->me_method;
693
b6a7ff92df57 darkness masking (lumi masking does only bright stuff now)
michaelni
parents: 690
diff changeset
535
320
cda7d0857baf - ME setting moved to AVCodecContext/MpegEncContext, no longer a global.
pulento
parents: 315
diff changeset
536 /* Fixed QSCALE */
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
537 s->fixed_qscale = (avctx->flags & CODEC_FLAG_QSCALE);
232
b640ec5948b0 - Now the ME is done for the entire picture when enconding, the
pulento
parents: 231
diff changeset
538
690
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 673
diff changeset
539 s->adaptive_quant= ( s->avctx->lumi_masking
693
b6a7ff92df57 darkness masking (lumi masking does only bright stuff now)
michaelni
parents: 690
diff changeset
540 || s->avctx->dark_masking
690
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 673
diff changeset
541 || s->avctx->temporal_cplx_masking
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 673
diff changeset
542 || s->avctx->spatial_cplx_masking
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 673
diff changeset
543 || s->avctx->p_masking)
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 673
diff changeset
544 && !s->fixed_qscale;
697
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
545
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
546 s->progressive_sequence= !(avctx->flags & CODEC_FLAG_INTERLACED_DCT);
693
b6a7ff92df57 darkness masking (lumi masking does only bright stuff now)
michaelni
parents: 690
diff changeset
547
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
548 switch(avctx->codec->id) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
549 case CODEC_ID_MPEG1VIDEO:
986e461dc072 Initial revision
glantau
parents:
diff changeset
550 s->out_format = FMT_MPEG1;
336
c56b45669214 export delay info
michaelni
parents: 333
diff changeset
551 avctx->delay=0; //FIXME not sure, should check the spec
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
552 break;
986e461dc072 Initial revision
glantau
parents:
diff changeset
553 case CODEC_ID_MJPEG:
986e461dc072 Initial revision
glantau
parents:
diff changeset
554 s->out_format = FMT_MJPEG;
986e461dc072 Initial revision
glantau
parents:
diff changeset
555 s->intra_only = 1; /* force intra only for jpeg */
232
b640ec5948b0 - Now the ME is done for the entire picture when enconding, the
pulento
parents: 231
diff changeset
556 s->mjpeg_write_tables = 1; /* write all tables */
370
0eca28d16cbd clamp intra matrix to 8bit for mjpeg (workaround for qscale>=25)
al3x
parents: 365
diff changeset
557 s->mjpeg_data_only_frames = 0; /* write all the needed headers */
232
b640ec5948b0 - Now the ME is done for the entire picture when enconding, the
pulento
parents: 231
diff changeset
558 s->mjpeg_vsample[0] = 2; /* set up default sampling factors */
b640ec5948b0 - Now the ME is done for the entire picture when enconding, the
pulento
parents: 231
diff changeset
559 s->mjpeg_vsample[1] = 1; /* the only currently supported values */
b640ec5948b0 - Now the ME is done for the entire picture when enconding, the
pulento
parents: 231
diff changeset
560 s->mjpeg_vsample[2] = 1;
370
0eca28d16cbd clamp intra matrix to 8bit for mjpeg (workaround for qscale>=25)
al3x
parents: 365
diff changeset
561 s->mjpeg_hsample[0] = 2;
232
b640ec5948b0 - Now the ME is done for the entire picture when enconding, the
pulento
parents: 231
diff changeset
562 s->mjpeg_hsample[1] = 1;
b640ec5948b0 - Now the ME is done for the entire picture when enconding, the
pulento
parents: 231
diff changeset
563 s->mjpeg_hsample[2] = 1;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
564 if (mjpeg_init(s) < 0)
986e461dc072 Initial revision
glantau
parents:
diff changeset
565 return -1;
336
c56b45669214 export delay info
michaelni
parents: 333
diff changeset
566 avctx->delay=0;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
567 break;
986e461dc072 Initial revision
glantau
parents:
diff changeset
568 case CODEC_ID_H263:
232
b640ec5948b0 - Now the ME is done for the entire picture when enconding, the
pulento
parents: 231
diff changeset
569 if (h263_get_picture_format(s->width, s->height) == 7) {
b640ec5948b0 - Now the ME is done for the entire picture when enconding, the
pulento
parents: 231
diff changeset
570 printf("Input picture size isn't suitable for h263 codec! try h263+\n");
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
571 return -1;
232
b640ec5948b0 - Now the ME is done for the entire picture when enconding, the
pulento
parents: 231
diff changeset
572 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
573 s->out_format = FMT_H263;
336
c56b45669214 export delay info
michaelni
parents: 333
diff changeset
574 avctx->delay=0;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
575 break;
986e461dc072 Initial revision
glantau
parents:
diff changeset
576 case CODEC_ID_H263P:
986e461dc072 Initial revision
glantau
parents:
diff changeset
577 s->out_format = FMT_H263;
986e461dc072 Initial revision
glantau
parents:
diff changeset
578 s->h263_plus = 1;
78
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 71
diff changeset
579 s->unrestricted_mv = 1;
350
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 347
diff changeset
580 s->h263_aic = 1;
79
82e579c37bc3 Moved some H.263+ variables to MpegEncContext to be thread-safe.
pulento
parents: 78
diff changeset
581
82e579c37bc3 Moved some H.263+ variables to MpegEncContext to be thread-safe.
pulento
parents: 78
diff changeset
582 /* These are just to be sure */
82e579c37bc3 Moved some H.263+ variables to MpegEncContext to be thread-safe.
pulento
parents: 78
diff changeset
583 s->umvplus = 0;
82e579c37bc3 Moved some H.263+ variables to MpegEncContext to be thread-safe.
pulento
parents: 78
diff changeset
584 s->umvplus_dec = 0;
336
c56b45669214 export delay info
michaelni
parents: 333
diff changeset
585 avctx->delay=0;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
586 break;
986e461dc072 Initial revision
glantau
parents:
diff changeset
587 case CODEC_ID_RV10:
986e461dc072 Initial revision
glantau
parents:
diff changeset
588 s->out_format = FMT_H263;
986e461dc072 Initial revision
glantau
parents:
diff changeset
589 s->h263_rv10 = 1;
336
c56b45669214 export delay info
michaelni
parents: 333
diff changeset
590 avctx->delay=0;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
591 break;
71
79be2c581c01 changed opendivx to mpeg4
glantau
parents: 64
diff changeset
592 case CODEC_ID_MPEG4:
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
593 s->out_format = FMT_H263;
986e461dc072 Initial revision
glantau
parents:
diff changeset
594 s->h263_pred = 1;
986e461dc072 Initial revision
glantau
parents:
diff changeset
595 s->unrestricted_mv = 1;
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
596 s->has_b_frames= s->max_b_frames ? 1 : 0;
731
f011a0df269f set low_delay on encoding if no b frames
michaelni
parents: 730
diff changeset
597 s->low_delay= !s->has_b_frames;
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 731
diff changeset
598 avctx->delay= s->low_delay ? 0 : (s->max_b_frames + 1);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
599 break;
307
764aeec1320e msmpeg4v2 decoding (no encoding yet)
michaelni
parents: 302
diff changeset
600 case CODEC_ID_MSMPEG4V1:
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
601 s->out_format = FMT_H263;
986e461dc072 Initial revision
glantau
parents:
diff changeset
602 s->h263_msmpeg4 = 1;
986e461dc072 Initial revision
glantau
parents:
diff changeset
603 s->h263_pred = 1;
986e461dc072 Initial revision
glantau
parents:
diff changeset
604 s->unrestricted_mv = 1;
307
764aeec1320e msmpeg4v2 decoding (no encoding yet)
michaelni
parents: 302
diff changeset
605 s->msmpeg4_version= 1;
336
c56b45669214 export delay info
michaelni
parents: 333
diff changeset
606 avctx->delay=0;
307
764aeec1320e msmpeg4v2 decoding (no encoding yet)
michaelni
parents: 302
diff changeset
607 break;
764aeec1320e msmpeg4v2 decoding (no encoding yet)
michaelni
parents: 302
diff changeset
608 case CODEC_ID_MSMPEG4V2:
764aeec1320e msmpeg4v2 decoding (no encoding yet)
michaelni
parents: 302
diff changeset
609 s->out_format = FMT_H263;
764aeec1320e msmpeg4v2 decoding (no encoding yet)
michaelni
parents: 302
diff changeset
610 s->h263_msmpeg4 = 1;
764aeec1320e msmpeg4v2 decoding (no encoding yet)
michaelni
parents: 302
diff changeset
611 s->h263_pred = 1;
764aeec1320e msmpeg4v2 decoding (no encoding yet)
michaelni
parents: 302
diff changeset
612 s->unrestricted_mv = 1;
764aeec1320e msmpeg4v2 decoding (no encoding yet)
michaelni
parents: 302
diff changeset
613 s->msmpeg4_version= 2;
336
c56b45669214 export delay info
michaelni
parents: 333
diff changeset
614 avctx->delay=0;
307
764aeec1320e msmpeg4v2 decoding (no encoding yet)
michaelni
parents: 302
diff changeset
615 break;
764aeec1320e msmpeg4v2 decoding (no encoding yet)
michaelni
parents: 302
diff changeset
616 case CODEC_ID_MSMPEG4V3:
764aeec1320e msmpeg4v2 decoding (no encoding yet)
michaelni
parents: 302
diff changeset
617 s->out_format = FMT_H263;
764aeec1320e msmpeg4v2 decoding (no encoding yet)
michaelni
parents: 302
diff changeset
618 s->h263_msmpeg4 = 1;
764aeec1320e msmpeg4v2 decoding (no encoding yet)
michaelni
parents: 302
diff changeset
619 s->h263_pred = 1;
764aeec1320e msmpeg4v2 decoding (no encoding yet)
michaelni
parents: 302
diff changeset
620 s->unrestricted_mv = 1;
764aeec1320e msmpeg4v2 decoding (no encoding yet)
michaelni
parents: 302
diff changeset
621 s->msmpeg4_version= 3;
336
c56b45669214 export delay info
michaelni
parents: 333
diff changeset
622 avctx->delay=0;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
623 break;
499
8b7a54d58549 wmv1 support
michaelni
parents: 487
diff changeset
624 case CODEC_ID_WMV1:
8b7a54d58549 wmv1 support
michaelni
parents: 487
diff changeset
625 s->out_format = FMT_H263;
8b7a54d58549 wmv1 support
michaelni
parents: 487
diff changeset
626 s->h263_msmpeg4 = 1;
8b7a54d58549 wmv1 support
michaelni
parents: 487
diff changeset
627 s->h263_pred = 1;
8b7a54d58549 wmv1 support
michaelni
parents: 487
diff changeset
628 s->unrestricted_mv = 1;
8b7a54d58549 wmv1 support
michaelni
parents: 487
diff changeset
629 s->msmpeg4_version= 4;
8b7a54d58549 wmv1 support
michaelni
parents: 487
diff changeset
630 avctx->delay=0;
8b7a54d58549 wmv1 support
michaelni
parents: 487
diff changeset
631 break;
8b7a54d58549 wmv1 support
michaelni
parents: 487
diff changeset
632 case CODEC_ID_WMV2:
8b7a54d58549 wmv1 support
michaelni
parents: 487
diff changeset
633 s->out_format = FMT_H263;
8b7a54d58549 wmv1 support
michaelni
parents: 487
diff changeset
634 s->h263_msmpeg4 = 1;
8b7a54d58549 wmv1 support
michaelni
parents: 487
diff changeset
635 s->h263_pred = 1;
8b7a54d58549 wmv1 support
michaelni
parents: 487
diff changeset
636 s->unrestricted_mv = 1;
8b7a54d58549 wmv1 support
michaelni
parents: 487
diff changeset
637 s->msmpeg4_version= 5;
8b7a54d58549 wmv1 support
michaelni
parents: 487
diff changeset
638 avctx->delay=0;
8b7a54d58549 wmv1 support
michaelni
parents: 487
diff changeset
639 break;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
640 default:
986e461dc072 Initial revision
glantau
parents:
diff changeset
641 return -1;
986e461dc072 Initial revision
glantau
parents:
diff changeset
642 }
295
6622b0fd036c mpeg4 4MV encoding
michaelni
parents: 294
diff changeset
643
277
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 271
diff changeset
644 { /* set up some save defaults, some codecs might override them later */
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 271
diff changeset
645 static int done=0;
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 271
diff changeset
646 if(!done){
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 271
diff changeset
647 int i;
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 271
diff changeset
648 done=1;
292
73a9ce3d9715 fcode_tables where too small, found by Klaas-Pieter Vlieg <vlieg@eurescom.de>
michaelni
parents: 288
diff changeset
649 memset(default_mv_penalty, 0, sizeof(UINT16)*(MAX_FCODE+1)*(2*MAX_MV+1));
277
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 271
diff changeset
650 memset(default_fcode_tab , 0, sizeof(UINT8)*(2*MAX_MV+1));
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 271
diff changeset
651
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 271
diff changeset
652 for(i=-16; i<16; i++){
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 271
diff changeset
653 default_fcode_tab[i + MAX_MV]= 1;
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 271
diff changeset
654 }
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 271
diff changeset
655 }
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 271
diff changeset
656 }
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 271
diff changeset
657 s->mv_penalty= default_mv_penalty;
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 271
diff changeset
658 s->fcode_tab= default_fcode_tab;
506
b9ed0ae72d51 init dc_scale tables to defaults (fixes mjpeg sig11)
michaelni
parents: 499
diff changeset
659 s->y_dc_scale_table=
b9ed0ae72d51 init dc_scale tables to defaults (fixes mjpeg sig11)
michaelni
parents: 499
diff changeset
660 s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
b9ed0ae72d51 init dc_scale tables to defaults (fixes mjpeg sig11)
michaelni
parents: 499
diff changeset
661
287
32a3dcce2e9b fixing motion estimation with h263p hopefully
michaelni
parents: 286
diff changeset
662 /* dont use mv_penalty table for crap MV as it would be confused */
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
663 if (s->me_method < ME_EPZS) s->mv_penalty = default_mv_penalty;
287
32a3dcce2e9b fixing motion estimation with h263p hopefully
michaelni
parents: 286
diff changeset
664
7
1d3ac9654178 added skip macroblock optimization (big perf win on black regions for example)
glantau
parents: 0
diff changeset
665 s->encoding = 1;
1d3ac9654178 added skip macroblock optimization (big perf win on black regions for example)
glantau
parents: 0
diff changeset
666
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
667 /* init */
986e461dc072 Initial revision
glantau
parents:
diff changeset
668 if (MPV_common_init(s) < 0)
986e461dc072 Initial revision
glantau
parents:
diff changeset
669 return -1;
986e461dc072 Initial revision
glantau
parents:
diff changeset
670
706
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 704
diff changeset
671 if (s->out_format == FMT_H263)
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 704
diff changeset
672 h263_encode_init(s);
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 704
diff changeset
673 else if (s->out_format == FMT_MPEG1)
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 704
diff changeset
674 ff_mpeg1_encode_init(s);
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 704
diff changeset
675 if(s->msmpeg4_version)
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 704
diff changeset
676 ff_msmpeg4_encode_init(s);
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 704
diff changeset
677
60
35c1141e23d9 moved matrix init away from MPV_common_init()
glantau
parents: 57
diff changeset
678 /* init default q matrix */
35c1141e23d9 moved matrix init away from MPV_common_init()
glantau
parents: 57
diff changeset
679 for(i=0;i<64;i++) {
706
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 704
diff changeset
680 int j= s->idct_permutation[i];
599
b1a191202f96 mpeg4 mpeg quantizer encoding
michaelni
parents: 598
diff changeset
681 if(s->codec_id==CODEC_ID_MPEG4 && s->mpeg_quant){
706
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 704
diff changeset
682 s->intra_matrix[j] = ff_mpeg4_default_intra_matrix[i];
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 704
diff changeset
683 s->inter_matrix[j] = ff_mpeg4_default_non_intra_matrix[i];
599
b1a191202f96 mpeg4 mpeg quantizer encoding
michaelni
parents: 598
diff changeset
684 }else if(s->out_format == FMT_H263){
706
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 704
diff changeset
685 s->intra_matrix[j] =
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 704
diff changeset
686 s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i];
599
b1a191202f96 mpeg4 mpeg quantizer encoding
michaelni
parents: 598
diff changeset
687 }else{ /* mpeg1 */
706
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 704
diff changeset
688 s->intra_matrix[j] = ff_mpeg1_default_intra_matrix[i];
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 704
diff changeset
689 s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i];
599
b1a191202f96 mpeg4 mpeg quantizer encoding
michaelni
parents: 598
diff changeset
690 }
344
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
691 }
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
692
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
693 /* precompute matrix */
350
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 347
diff changeset
694 /* for mjpeg, we do include qscale in the matrix */
344
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
695 if (s->out_format != FMT_MJPEG) {
625
bb6a69f9d409 slow but accurate integer dct from IJG (should be ok with the LGPL as the old DCT is the fast integer DCT from IJG)
michaelni
parents: 619
diff changeset
696 convert_matrix(s, s->q_intra_matrix, s->q_intra_matrix16, s->q_intra_matrix16_bias,
709
afeff6ccb7f5 convert only needed matrixes in convert_matrix() (mjpeg calls it for every frame)
michaelni
parents: 706
diff changeset
697 s->intra_matrix, s->intra_quant_bias, 1, 31);
625
bb6a69f9d409 slow but accurate integer dct from IJG (should be ok with the LGPL as the old DCT is the fast integer DCT from IJG)
michaelni
parents: 619
diff changeset
698 convert_matrix(s, s->q_inter_matrix, s->q_inter_matrix16, s->q_inter_matrix16_bias,
709
afeff6ccb7f5 convert only needed matrixes in convert_matrix() (mjpeg calls it for every frame)
michaelni
parents: 706
diff changeset
699 s->inter_matrix, s->inter_quant_bias, 1, 31);
60
35c1141e23d9 moved matrix init away from MPV_common_init()
glantau
parents: 57
diff changeset
700 }
35c1141e23d9 moved matrix init away from MPV_common_init()
glantau
parents: 57
diff changeset
701
329
5cc47d0ba53e fixed ratecontrol & b-frames
michaelni
parents: 327
diff changeset
702 if(ff_rate_control_init(s) < 0)
5cc47d0ba53e fixed ratecontrol & b-frames
michaelni
parents: 327
diff changeset
703 return -1;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
704
986e461dc072 Initial revision
glantau
parents:
diff changeset
705 s->picture_number = 0;
277
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 271
diff changeset
706 s->picture_in_gop_number = 0;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
707 s->fake_picture_number = 0;
986e461dc072 Initial revision
glantau
parents:
diff changeset
708 /* motion detector init */
986e461dc072 Initial revision
glantau
parents:
diff changeset
709 s->f_code = 1;
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
710 s->b_code = 1;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
711
986e461dc072 Initial revision
glantau
parents:
diff changeset
712 return 0;
986e461dc072 Initial revision
glantau
parents:
diff changeset
713 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
714
986e461dc072 Initial revision
glantau
parents:
diff changeset
715 int MPV_encode_end(AVCodecContext *avctx)
986e461dc072 Initial revision
glantau
parents:
diff changeset
716 {
986e461dc072 Initial revision
glantau
parents:
diff changeset
717 MpegEncContext *s = avctx->priv_data;
986e461dc072 Initial revision
glantau
parents:
diff changeset
718
986e461dc072 Initial revision
glantau
parents:
diff changeset
719 #ifdef STATS
986e461dc072 Initial revision
glantau
parents:
diff changeset
720 print_stats();
986e461dc072 Initial revision
glantau
parents:
diff changeset
721 #endif
329
5cc47d0ba53e fixed ratecontrol & b-frames
michaelni
parents: 327
diff changeset
722
5cc47d0ba53e fixed ratecontrol & b-frames
michaelni
parents: 327
diff changeset
723 ff_rate_control_uninit(s);
5cc47d0ba53e fixed ratecontrol & b-frames
michaelni
parents: 327
diff changeset
724
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
725 MPV_common_end(s);
986e461dc072 Initial revision
glantau
parents:
diff changeset
726 if (s->out_format == FMT_MJPEG)
986e461dc072 Initial revision
glantau
parents:
diff changeset
727 mjpeg_close(s);
232
b640ec5948b0 - Now the ME is done for the entire picture when enconding, the
pulento
parents: 231
diff changeset
728
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
729 return 0;
986e461dc072 Initial revision
glantau
parents:
diff changeset
730 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
731
986e461dc072 Initial revision
glantau
parents:
diff changeset
732 /* draw the edges of width 'w' of an image of size width, height */
619
2be2cc8fd0a1 mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents: 618
diff changeset
733 //FIXME check that this is ok for mpeg4 interlaced
206
994aa8623443 (commit by michael)
arpi_esp
parents: 200
diff changeset
734 static void draw_edges_c(UINT8 *buf, int wrap, int width, int height, int w)
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
735 {
986e461dc072 Initial revision
glantau
parents:
diff changeset
736 UINT8 *ptr, *last_line;
986e461dc072 Initial revision
glantau
parents:
diff changeset
737 int i;
986e461dc072 Initial revision
glantau
parents:
diff changeset
738
986e461dc072 Initial revision
glantau
parents:
diff changeset
739 last_line = buf + (height - 1) * wrap;
986e461dc072 Initial revision
glantau
parents:
diff changeset
740 for(i=0;i<w;i++) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
741 /* top and bottom */
986e461dc072 Initial revision
glantau
parents:
diff changeset
742 memcpy(buf - (i + 1) * wrap, buf, width);
986e461dc072 Initial revision
glantau
parents:
diff changeset
743 memcpy(last_line + (i + 1) * wrap, last_line, width);
986e461dc072 Initial revision
glantau
parents:
diff changeset
744 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
745 /* left and right */
986e461dc072 Initial revision
glantau
parents:
diff changeset
746 ptr = buf;
986e461dc072 Initial revision
glantau
parents:
diff changeset
747 for(i=0;i<height;i++) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
748 memset(ptr - w, ptr[0], w);
986e461dc072 Initial revision
glantau
parents:
diff changeset
749 memset(ptr + width, ptr[width-1], w);
986e461dc072 Initial revision
glantau
parents:
diff changeset
750 ptr += wrap;
986e461dc072 Initial revision
glantau
parents:
diff changeset
751 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
752 /* corners */
986e461dc072 Initial revision
glantau
parents:
diff changeset
753 for(i=0;i<w;i++) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
754 memset(buf - (i + 1) * wrap - w, buf[0], w); /* top left */
986e461dc072 Initial revision
glantau
parents:
diff changeset
755 memset(buf - (i + 1) * wrap + width, buf[width-1], w); /* top right */
986e461dc072 Initial revision
glantau
parents:
diff changeset
756 memset(last_line + (i + 1) * wrap - w, last_line[0], w); /* top left */
986e461dc072 Initial revision
glantau
parents:
diff changeset
757 memset(last_line + (i + 1) * wrap + width, last_line[width-1], w); /* top right */
986e461dc072 Initial revision
glantau
parents:
diff changeset
758 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
759 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
760
986e461dc072 Initial revision
glantau
parents:
diff changeset
761 /* generic function for encode/decode called before a frame is coded/decoded */
553
18ad513d92fe direct rendering method 1 support
michaelni
parents: 549
diff changeset
762 void MPV_frame_start(MpegEncContext *s, AVCodecContext *avctx)
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
763 {
986e461dc072 Initial revision
glantau
parents:
diff changeset
764 int i;
986e461dc072 Initial revision
glantau
parents:
diff changeset
765 UINT8 *tmp;
986e461dc072 Initial revision
glantau
parents:
diff changeset
766
46
931417475f5b fixed mpeg1 first block bug (pb with black picture optimisation for B frames)
glantau
parents: 40
diff changeset
767 s->mb_skiped = 0;
562
23e58889a108 exporting mbskip_table after it has been allocated
michaelni
parents: 557
diff changeset
768 avctx->mbskip_table= s->mbskip_table;
456
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
769
553
18ad513d92fe direct rendering method 1 support
michaelni
parents: 549
diff changeset
770 if(avctx->flags&CODEC_FLAG_DR1){
18ad513d92fe direct rendering method 1 support
michaelni
parents: 549
diff changeset
771 avctx->get_buffer_callback(avctx, s->width, s->height, s->pict_type);
18ad513d92fe direct rendering method 1 support
michaelni
parents: 549
diff changeset
772
556
762c67fd4078 uvlinesize
michaelni
parents: 554
diff changeset
773 s->linesize = avctx->dr_stride;
762c67fd4078 uvlinesize
michaelni
parents: 554
diff changeset
774 s->uvlinesize= avctx->dr_uvstride;
762c67fd4078 uvlinesize
michaelni
parents: 554
diff changeset
775 s->ip_buffer_count= avctx->dr_ip_buffer_count;
553
18ad513d92fe direct rendering method 1 support
michaelni
parents: 549
diff changeset
776 }
562
23e58889a108 exporting mbskip_table after it has been allocated
michaelni
parents: 557
diff changeset
777 avctx->dr_ip_buffer_count= s->ip_buffer_count;
553
18ad513d92fe direct rendering method 1 support
michaelni
parents: 549
diff changeset
778
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
779 if (s->pict_type == B_TYPE) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
780 for(i=0;i<3;i++) {
553
18ad513d92fe direct rendering method 1 support
michaelni
parents: 549
diff changeset
781 if(avctx->flags&CODEC_FLAG_DR1)
18ad513d92fe direct rendering method 1 support
michaelni
parents: 549
diff changeset
782 s->aux_picture[i]= avctx->dr_buffer[i];
569
395bb978b9ff fixing NULL reference frame with dr1
michaelni
parents: 567
diff changeset
783
395bb978b9ff fixing NULL reference frame with dr1
michaelni
parents: 567
diff changeset
784 //FIXME the following should never be needed, the decoder should drop b frames if no reference is available
395bb978b9ff fixing NULL reference frame with dr1
michaelni
parents: 567
diff changeset
785 if(s->next_picture[i]==NULL)
395bb978b9ff fixing NULL reference frame with dr1
michaelni
parents: 567
diff changeset
786 s->next_picture[i]= s->aux_picture[i];
395bb978b9ff fixing NULL reference frame with dr1
michaelni
parents: 567
diff changeset
787 if(s->last_picture[i]==NULL)
395bb978b9ff fixing NULL reference frame with dr1
michaelni
parents: 567
diff changeset
788 s->last_picture[i]= s->next_picture[i];
553
18ad513d92fe direct rendering method 1 support
michaelni
parents: 549
diff changeset
789
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
790 s->current_picture[i] = s->aux_picture[i];
986e461dc072 Initial revision
glantau
parents:
diff changeset
791 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
792 } else {
986e461dc072 Initial revision
glantau
parents:
diff changeset
793 for(i=0;i<3;i++) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
794 /* swap next and last */
553
18ad513d92fe direct rendering method 1 support
michaelni
parents: 549
diff changeset
795 if(avctx->flags&CODEC_FLAG_DR1)
18ad513d92fe direct rendering method 1 support
michaelni
parents: 549
diff changeset
796 tmp= avctx->dr_buffer[i];
18ad513d92fe direct rendering method 1 support
michaelni
parents: 549
diff changeset
797 else
18ad513d92fe direct rendering method 1 support
michaelni
parents: 549
diff changeset
798 tmp = s->last_picture[i];
18ad513d92fe direct rendering method 1 support
michaelni
parents: 549
diff changeset
799
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
800 s->last_picture[i] = s->next_picture[i];
986e461dc072 Initial revision
glantau
parents:
diff changeset
801 s->next_picture[i] = tmp;
986e461dc072 Initial revision
glantau
parents:
diff changeset
802 s->current_picture[i] = tmp;
553
18ad513d92fe direct rendering method 1 support
michaelni
parents: 549
diff changeset
803
592
909e50c67d0e last_picture should be never == NULL (it was with dr1) this might fix a segfault with error concealment
michaelni
parents: 591
diff changeset
804 if(s->last_picture[i]==NULL)
909e50c67d0e last_picture should be never == NULL (it was with dr1) this might fix a segfault with error concealment
michaelni
parents: 591
diff changeset
805 s->last_picture[i]= s->next_picture[i];
909e50c67d0e last_picture should be never == NULL (it was with dr1) this might fix a segfault with error concealment
michaelni
parents: 591
diff changeset
806
553
18ad513d92fe direct rendering method 1 support
michaelni
parents: 549
diff changeset
807 s->last_dr_opaque= s->next_dr_opaque;
18ad513d92fe direct rendering method 1 support
michaelni
parents: 549
diff changeset
808 s->next_dr_opaque= avctx->dr_opaque_frame;
18ad513d92fe direct rendering method 1 support
michaelni
parents: 549
diff changeset
809
557
c1e1be461662 direct rendering for SVQ1
michaelni
parents: 556
diff changeset
810 if(s->has_b_frames && s->last_dr_opaque && s->codec_id!=CODEC_ID_SVQ1)
553
18ad513d92fe direct rendering method 1 support
michaelni
parents: 549
diff changeset
811 avctx->dr_opaque_frame= s->last_dr_opaque;
18ad513d92fe direct rendering method 1 support
michaelni
parents: 549
diff changeset
812 else
18ad513d92fe direct rendering method 1 support
michaelni
parents: 549
diff changeset
813 avctx->dr_opaque_frame= s->next_dr_opaque;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
814 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
815 }
591
d3f374218030 fixing mpeg4 mpeg quantizers
michaelni
parents: 588
diff changeset
816 /* set dequantizer, we cant do it during init as it might change for mpeg4
d3f374218030 fixing mpeg4 mpeg quantizers
michaelni
parents: 588
diff changeset
817 and we cant do it in the header decode as init isnt called for mpeg4 there yet */
d3f374218030 fixing mpeg4 mpeg quantizers
michaelni
parents: 588
diff changeset
818 if(s->out_format == FMT_H263){
d3f374218030 fixing mpeg4 mpeg quantizers
michaelni
parents: 588
diff changeset
819 if(s->mpeg_quant)
d3f374218030 fixing mpeg4 mpeg quantizers
michaelni
parents: 588
diff changeset
820 s->dct_unquantize = s->dct_unquantize_mpeg2;
d3f374218030 fixing mpeg4 mpeg quantizers
michaelni
parents: 588
diff changeset
821 else
d3f374218030 fixing mpeg4 mpeg quantizers
michaelni
parents: 588
diff changeset
822 s->dct_unquantize = s->dct_unquantize_h263;
d3f374218030 fixing mpeg4 mpeg quantizers
michaelni
parents: 588
diff changeset
823 }else
d3f374218030 fixing mpeg4 mpeg quantizers
michaelni
parents: 588
diff changeset
824 s->dct_unquantize = s->dct_unquantize_mpeg1;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
825 }
13
174ef88f619a use block[] in structure to have it aligned on 8 bytes for mmx optimizations - dct_unquantize is always a function pointer - added specialized dct_unquantize_h263
glantau
parents: 8
diff changeset
826
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
827 /* generic function for encode/decode called after a frame has been coded/decoded */
986e461dc072 Initial revision
glantau
parents:
diff changeset
828 void MPV_frame_end(MpegEncContext *s)
986e461dc072 Initial revision
glantau
parents:
diff changeset
829 {
652
c7647afc3ce5 set pict_type & key_frame on decoding too
michaelni
parents: 651
diff changeset
830 s->avctx->key_frame = (s->pict_type == I_TYPE);
c7647afc3ce5 set pict_type & key_frame on decoding too
michaelni
parents: 651
diff changeset
831 s->avctx->pict_type = s->pict_type;
456
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
832
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
833 /* draw edge for correct motion prediction if outside */
553
18ad513d92fe direct rendering method 1 support
michaelni
parents: 549
diff changeset
834 if (s->pict_type != B_TYPE && !s->intra_only && !(s->flags&CODEC_FLAG_EMU_EDGE)) {
582
5132a4ee50cd different edge positions fixed with edge emu / dr1
michaelni
parents: 575
diff changeset
835 draw_edges(s->current_picture[0], s->linesize , s->h_edge_pos , s->v_edge_pos , EDGE_WIDTH );
5132a4ee50cd different edge positions fixed with edge emu / dr1
michaelni
parents: 575
diff changeset
836 draw_edges(s->current_picture[1], s->uvlinesize, s->h_edge_pos>>1, s->v_edge_pos>>1, EDGE_WIDTH/2);
5132a4ee50cd different edge positions fixed with edge emu / dr1
michaelni
parents: 575
diff changeset
837 draw_edges(s->current_picture[2], s->uvlinesize, s->h_edge_pos>>1, s->v_edge_pos>>1, EDGE_WIDTH/2);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
838 }
207
6954f2830e4a (commit by michael)
arpi_esp
parents: 206
diff changeset
839 emms_c();
329
5cc47d0ba53e fixed ratecontrol & b-frames
michaelni
parents: 327
diff changeset
840
612
c0005de2be59 new ratecontrol code
michaelni
parents: 611
diff changeset
841 s->last_pict_type = s->pict_type;
329
5cc47d0ba53e fixed ratecontrol & b-frames
michaelni
parents: 327
diff changeset
842 if(s->pict_type!=B_TYPE){
5cc47d0ba53e fixed ratecontrol & b-frames
michaelni
parents: 327
diff changeset
843 s->last_non_b_pict_type= s->pict_type;
341
bf26081c373c avcodec_flush_buffers()
michaelni
parents: 339
diff changeset
844 s->num_available_buffers++;
bf26081c373c avcodec_flush_buffers()
michaelni
parents: 339
diff changeset
845 if(s->num_available_buffers>2) s->num_available_buffers= 2;
329
5cc47d0ba53e fixed ratecontrol & b-frames
michaelni
parents: 327
diff changeset
846 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
847 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
848
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
849 /* reorder input for encoding */
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
850 void reorder_input(MpegEncContext *s, AVPicture *pict)
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
851 {
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
852 int i, j, index;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
853
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
854 if(s->max_b_frames > FF_MAX_B_FRAMES) s->max_b_frames= FF_MAX_B_FRAMES;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
855
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
856 // delay= s->max_b_frames+1; (or 0 if no b frames cuz decoder diff)
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
857
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
858 for(j=0; j<REORDER_BUFFER_SIZE-1; j++){
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
859 s->coded_order[j]= s->coded_order[j+1];
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
860 }
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
861 s->coded_order[j].picture[0]= s->coded_order[j].picture[1]= s->coded_order[j].picture[2]= NULL; //catch uninitalized buffers
339
b743a6bbab25 segfault fix
michaelni
parents: 336
diff changeset
862 s->coded_order[j].pict_type=0;
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
863
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
864 switch(s->input_pict_type){
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
865 default:
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
866 case I_TYPE:
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
867 case S_TYPE:
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
868 case P_TYPE:
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
869 index= s->max_b_frames - s->b_frames_since_non_b;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
870 s->b_frames_since_non_b=0;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
871 break;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
872 case B_TYPE:
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
873 index= s->max_b_frames + 1;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
874 s->b_frames_since_non_b++;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
875 break;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
876 }
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
877 //printf("index:%d type:%d strides: %d %d\n", index, s->input_pict_type, pict->linesize[0], s->linesize);
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
878 if( (index==0 || (s->flags&CODEC_FLAG_INPUT_PRESERVED))
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
879 && pict->linesize[0] == s->linesize
556
762c67fd4078 uvlinesize
michaelni
parents: 554
diff changeset
880 && pict->linesize[1] == s->uvlinesize
762c67fd4078 uvlinesize
michaelni
parents: 554
diff changeset
881 && pict->linesize[2] == s->uvlinesize){
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
882 //printf("ptr\n");
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
883 for(i=0; i<3; i++){
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
884 s->coded_order[index].picture[i]= pict->data[i];
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
885 }
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
886 }else{
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
887 //printf("copy\n");
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
888 for(i=0; i<3; i++){
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
889 uint8_t *src = pict->data[i];
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
890 uint8_t *dest;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
891 int src_wrap = pict->linesize[i];
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
892 int dest_wrap = s->linesize;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
893 int w = s->width;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
894 int h = s->height;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
895
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
896 if(index==0) dest= s->last_picture[i]+16; //is current_picture indeed but the switch hapens after reordering
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
897 else dest= s->picture_buffer[s->picture_buffer_index][i];
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
898
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
899 if (i >= 1) {
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
900 dest_wrap >>= 1;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
901 w >>= 1;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
902 h >>= 1;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
903 }
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
904
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
905 s->coded_order[index].picture[i]= dest;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
906 for(j=0;j<h;j++) {
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
907 memcpy(dest, src, w);
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
908 dest += dest_wrap;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
909 src += src_wrap;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
910 }
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
911 }
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
912 if(index!=0){
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
913 s->picture_buffer_index++;
588
9e271424160f max_b_frame=4 bugfix
michaelni
parents: 582
diff changeset
914 if(s->picture_buffer_index >= REORDER_BUFFER_SIZE) s->picture_buffer_index=0;
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
915 }
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
916 }
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
917 s->coded_order[index].pict_type = s->input_pict_type;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
918 s->coded_order[index].qscale = s->input_qscale;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
919 s->coded_order[index].force_type= s->force_input_type;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
920 s->coded_order[index].picture_in_gop_number= s->input_picture_in_gop_number;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
921 s->coded_order[index].picture_number= s->input_picture_number;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
922
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
923 for(i=0; i<3; i++){
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
924 s->new_picture[i]= s->coded_order[0].picture[i];
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
925 }
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
926 }
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
927
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
928 int MPV_encode_picture(AVCodecContext *avctx,
986e461dc072 Initial revision
glantau
parents:
diff changeset
929 unsigned char *buf, int buf_size, void *data)
986e461dc072 Initial revision
glantau
parents:
diff changeset
930 {
986e461dc072 Initial revision
glantau
parents:
diff changeset
931 MpegEncContext *s = avctx->priv_data;
986e461dc072 Initial revision
glantau
parents:
diff changeset
932 AVPicture *pict = data;
986e461dc072 Initial revision
glantau
parents:
diff changeset
933
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
934 s->input_qscale = avctx->quality;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
935
986e461dc072 Initial revision
glantau
parents:
diff changeset
936 init_put_bits(&s->pb, buf, buf_size, NULL, NULL);
986e461dc072 Initial revision
glantau
parents:
diff changeset
937
329
5cc47d0ba53e fixed ratecontrol & b-frames
michaelni
parents: 327
diff changeset
938 if(avctx->flags&CODEC_FLAG_TYPE){
5cc47d0ba53e fixed ratecontrol & b-frames
michaelni
parents: 327
diff changeset
939 s->input_pict_type=
5cc47d0ba53e fixed ratecontrol & b-frames
michaelni
parents: 327
diff changeset
940 s->force_input_type= avctx->key_frame ? I_TYPE : P_TYPE;
5cc47d0ba53e fixed ratecontrol & b-frames
michaelni
parents: 327
diff changeset
941 }else if(s->flags&CODEC_FLAG_PASS2){
5cc47d0ba53e fixed ratecontrol & b-frames
michaelni
parents: 327
diff changeset
942 s->input_pict_type=
5cc47d0ba53e fixed ratecontrol & b-frames
michaelni
parents: 327
diff changeset
943 s->force_input_type= s->rc_context.entry[s->input_picture_number].new_pict_type;
5cc47d0ba53e fixed ratecontrol & b-frames
michaelni
parents: 327
diff changeset
944 }else{
5cc47d0ba53e fixed ratecontrol & b-frames
michaelni
parents: 327
diff changeset
945 s->force_input_type=0;
5cc47d0ba53e fixed ratecontrol & b-frames
michaelni
parents: 327
diff changeset
946 if (!s->intra_only) {
5cc47d0ba53e fixed ratecontrol & b-frames
michaelni
parents: 327
diff changeset
947 /* first picture of GOP is intra */
5cc47d0ba53e fixed ratecontrol & b-frames
michaelni
parents: 327
diff changeset
948 if (s->input_picture_in_gop_number % s->gop_size==0){
5cc47d0ba53e fixed ratecontrol & b-frames
michaelni
parents: 327
diff changeset
949 s->input_pict_type = I_TYPE;
5cc47d0ba53e fixed ratecontrol & b-frames
michaelni
parents: 327
diff changeset
950 }else if(s->max_b_frames==0){
5cc47d0ba53e fixed ratecontrol & b-frames
michaelni
parents: 327
diff changeset
951 s->input_pict_type = P_TYPE;
5cc47d0ba53e fixed ratecontrol & b-frames
michaelni
parents: 327
diff changeset
952 }else{
5cc47d0ba53e fixed ratecontrol & b-frames
michaelni
parents: 327
diff changeset
953 if(s->b_frames_since_non_b < s->max_b_frames) //FIXME more IQ
5cc47d0ba53e fixed ratecontrol & b-frames
michaelni
parents: 327
diff changeset
954 s->input_pict_type = B_TYPE;
5cc47d0ba53e fixed ratecontrol & b-frames
michaelni
parents: 327
diff changeset
955 else
5cc47d0ba53e fixed ratecontrol & b-frames
michaelni
parents: 327
diff changeset
956 s->input_pict_type = P_TYPE;
5cc47d0ba53e fixed ratecontrol & b-frames
michaelni
parents: 327
diff changeset
957 }
5cc47d0ba53e fixed ratecontrol & b-frames
michaelni
parents: 327
diff changeset
958 } else {
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
959 s->input_pict_type = I_TYPE;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
960 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
961 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
962
329
5cc47d0ba53e fixed ratecontrol & b-frames
michaelni
parents: 327
diff changeset
963 if(s->input_pict_type==I_TYPE)
5cc47d0ba53e fixed ratecontrol & b-frames
michaelni
parents: 327
diff changeset
964 s->input_picture_in_gop_number=0;
5cc47d0ba53e fixed ratecontrol & b-frames
michaelni
parents: 327
diff changeset
965
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
966 reorder_input(s, pict);
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
967
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
968 /* output? */
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
969 if(s->coded_order[0].picture[0]){
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
970
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
971 s->pict_type= s->coded_order[0].pict_type;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
972 if (s->fixed_qscale) /* the ratecontrol needs the last qscale so we dont touch it for CBR */
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
973 s->qscale= s->coded_order[0].qscale;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
974 s->force_type= s->coded_order[0].force_type;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
975 s->picture_in_gop_number= s->coded_order[0].picture_in_gop_number;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
976 s->picture_number= s->coded_order[0].picture_number;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
977
553
18ad513d92fe direct rendering method 1 support
michaelni
parents: 549
diff changeset
978 MPV_frame_start(s, avctx);
286
91f7c38f5f37 statistics for 2-pass encoding
michaelni
parents: 281
diff changeset
979
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
980 encode_picture(s, s->picture_number);
652
c7647afc3ce5 set pict_type & key_frame on decoding too
michaelni
parents: 651
diff changeset
981
376
ba9c3b8088c0 - pict_type exported to AVCodecContext
pulento
parents: 370
diff changeset
982 avctx->real_pict_num = s->picture_number;
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
983 avctx->header_bits = s->header_bits;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
984 avctx->mv_bits = s->mv_bits;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
985 avctx->misc_bits = s->misc_bits;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
986 avctx->i_tex_bits = s->i_tex_bits;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
987 avctx->p_tex_bits = s->p_tex_bits;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
988 avctx->i_count = s->i_count;
656
e47fa3e3f2d5 statistics for forw & back p-MBs instead of just one counter for both
michaelni
parents: 652
diff changeset
989 avctx->p_count = s->mb_num - s->i_count - s->skip_count; //FIXME f/b_count in avctx
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
990 avctx->skip_count = s->skip_count;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
991
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
992 MPV_frame_end(s);
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
993
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
994 if (s->out_format == FMT_MJPEG)
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
995 mjpeg_picture_trailer(s);
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
996
690
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 673
diff changeset
997 if(!s->fixed_qscale)
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 673
diff changeset
998 avctx->quality = s->qscale;
329
5cc47d0ba53e fixed ratecontrol & b-frames
michaelni
parents: 327
diff changeset
999
5cc47d0ba53e fixed ratecontrol & b-frames
michaelni
parents: 327
diff changeset
1000 if(s->flags&CODEC_FLAG_PASS1)
5cc47d0ba53e fixed ratecontrol & b-frames
michaelni
parents: 327
diff changeset
1001 ff_write_pass1_stats(s);
456
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
1002
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
1003 }
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
1004
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
1005 s->input_picture_number++;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
1006 s->input_picture_in_gop_number++;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1007
986e461dc072 Initial revision
glantau
parents:
diff changeset
1008 flush_put_bits(&s->pb);
268
09ae29b27ed9 hopefully better bitrate controll
michaelni
parents: 266
diff changeset
1009 s->frame_bits = (pbBufPtr(&s->pb) - s->pb.buf) * 8;
612
c0005de2be59 new ratecontrol code
michaelni
parents: 611
diff changeset
1010
268
09ae29b27ed9 hopefully better bitrate controll
michaelni
parents: 266
diff changeset
1011 s->total_bits += s->frame_bits;
286
91f7c38f5f37 statistics for 2-pass encoding
michaelni
parents: 281
diff changeset
1012 avctx->frame_bits = s->frame_bits;
91f7c38f5f37 statistics for 2-pass encoding
michaelni
parents: 281
diff changeset
1013 //printf("fcode: %d, type: %d, head: %d, mv: %d, misc: %d, frame: %d, itex: %d, ptex: %d\n",
91f7c38f5f37 statistics for 2-pass encoding
michaelni
parents: 281
diff changeset
1014 //s->f_code, avctx->key_frame, s->header_bits, s->mv_bits, s->misc_bits, s->frame_bits, s->i_tex_bits, s->p_tex_bits);
612
c0005de2be59 new ratecontrol code
michaelni
parents: 611
diff changeset
1015 #if 0 //dump some stats to stats.txt for testing/debuging
c0005de2be59 new ratecontrol code
michaelni
parents: 611
diff changeset
1016 if(s->max_b_frames==0)
c0005de2be59 new ratecontrol code
michaelni
parents: 611
diff changeset
1017 {
c0005de2be59 new ratecontrol code
michaelni
parents: 611
diff changeset
1018 static FILE *f=NULL;
c0005de2be59 new ratecontrol code
michaelni
parents: 611
diff changeset
1019 if(!f) f= fopen("stats.txt", "wb");
c0005de2be59 new ratecontrol code
michaelni
parents: 611
diff changeset
1020 get_psnr(pict->data, s->current_picture,
c0005de2be59 new ratecontrol code
michaelni
parents: 611
diff changeset
1021 pict->linesize, s->linesize, avctx);
c0005de2be59 new ratecontrol code
michaelni
parents: 611
diff changeset
1022 fprintf(f, "%7d, %7d, %2.4f\n", pbBufPtr(&s->pb) - s->pb.buf, s->qscale, avctx->psnr_y);
c0005de2be59 new ratecontrol code
michaelni
parents: 611
diff changeset
1023 }
c0005de2be59 new ratecontrol code
michaelni
parents: 611
diff changeset
1024 #endif
234
5fc0c3af3fe4 alternative bitstream writer (disabled by default, uncomment #define ALT_BISTREAM_WRITER in common.h if u want to try it)
michaelni
parents: 233
diff changeset
1025
252
ddb1a0e94cf4 - Added PSNR feature to libavcodec and ffmpeg. By now just Y PSNR until I'm
pulento
parents: 251
diff changeset
1026 if (avctx->get_psnr) {
ddb1a0e94cf4 - Added PSNR feature to libavcodec and ffmpeg. By now just Y PSNR until I'm
pulento
parents: 251
diff changeset
1027 /* At this point pict->data should have the original frame */
ddb1a0e94cf4 - Added PSNR feature to libavcodec and ffmpeg. By now just Y PSNR until I'm
pulento
parents: 251
diff changeset
1028 /* an s->current_picture should have the coded/decoded frame */
ddb1a0e94cf4 - Added PSNR feature to libavcodec and ffmpeg. By now just Y PSNR until I'm
pulento
parents: 251
diff changeset
1029 get_psnr(pict->data, s->current_picture,
ddb1a0e94cf4 - Added PSNR feature to libavcodec and ffmpeg. By now just Y PSNR until I'm
pulento
parents: 251
diff changeset
1030 pict->linesize, s->linesize, avctx);
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
1031 // printf("%f\n", avctx->psnr_y);
252
ddb1a0e94cf4 - Added PSNR feature to libavcodec and ffmpeg. By now just Y PSNR until I'm
pulento
parents: 251
diff changeset
1032 }
234
5fc0c3af3fe4 alternative bitstream writer (disabled by default, uncomment #define ALT_BISTREAM_WRITER in common.h if u want to try it)
michaelni
parents: 233
diff changeset
1033 return pbBufPtr(&s->pb) - s->pb.buf;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1034 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
1035
255
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
1036 static inline void gmc1_motion(MpegEncContext *s,
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
1037 UINT8 *dest_y, UINT8 *dest_cb, UINT8 *dest_cr,
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
1038 int dest_offset,
753
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 745
diff changeset
1039 UINT8 **ref_picture, int src_offset)
255
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
1040 {
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
1041 UINT8 *ptr;
556
762c67fd4078 uvlinesize
michaelni
parents: 554
diff changeset
1042 int offset, src_x, src_y, linesize, uvlinesize;
255
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
1043 int motion_x, motion_y;
566
c376a0b290cf fixing gmc with emu edges
michaelni
parents: 565
diff changeset
1044 int emu=0;
255
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
1045
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
1046 motion_x= s->sprite_offset[0][0];
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
1047 motion_y= s->sprite_offset[0][1];
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
1048 src_x = s->mb_x * 16 + (motion_x >> (s->sprite_warping_accuracy+1));
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
1049 src_y = s->mb_y * 16 + (motion_y >> (s->sprite_warping_accuracy+1));
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
1050 motion_x<<=(3-s->sprite_warping_accuracy);
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
1051 motion_y<<=(3-s->sprite_warping_accuracy);
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
1052 src_x = clip(src_x, -16, s->width);
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
1053 if (src_x == s->width)
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
1054 motion_x =0;
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
1055 src_y = clip(src_y, -16, s->height);
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
1056 if (src_y == s->height)
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
1057 motion_y =0;
753
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 745
diff changeset
1058
255
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
1059 linesize = s->linesize;
556
762c67fd4078 uvlinesize
michaelni
parents: 554
diff changeset
1060 uvlinesize = s->uvlinesize;
753
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 745
diff changeset
1061
255
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
1062 ptr = ref_picture[0] + (src_y * linesize) + src_x + src_offset;
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
1063
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
1064 dest_y+=dest_offset;
566
c376a0b290cf fixing gmc with emu edges
michaelni
parents: 565
diff changeset
1065 if(s->flags&CODEC_FLAG_EMU_EDGE){
582
5132a4ee50cd different edge positions fixed with edge emu / dr1
michaelni
parents: 575
diff changeset
1066 if(src_x<0 || src_y<0 || src_x + (motion_x&15) + 16 > s->h_edge_pos
753
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 745
diff changeset
1067 || src_y + (motion_y&15) + 16 > s->v_edge_pos){
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 745
diff changeset
1068 emulated_edge_mc(s, ptr, linesize, 17, 17, src_x, src_y, s->h_edge_pos, s->v_edge_pos);
566
c376a0b290cf fixing gmc with emu edges
michaelni
parents: 565
diff changeset
1069 ptr= s->edge_emu_buffer;
c376a0b290cf fixing gmc with emu edges
michaelni
parents: 565
diff changeset
1070 emu=1;
c376a0b290cf fixing gmc with emu edges
michaelni
parents: 565
diff changeset
1071 }
c376a0b290cf fixing gmc with emu edges
michaelni
parents: 565
diff changeset
1072 }
753
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 745
diff changeset
1073
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 745
diff changeset
1074 if((motion_x|motion_y)&7){
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 745
diff changeset
1075 ff_gmc1(dest_y , ptr , linesize, 16, motion_x&15, motion_y&15, 128 - s->no_rounding);
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 745
diff changeset
1076 ff_gmc1(dest_y+8, ptr+8, linesize, 16, motion_x&15, motion_y&15, 128 - s->no_rounding);
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 745
diff changeset
1077 }else{
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 745
diff changeset
1078 int dxy;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 745
diff changeset
1079
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 745
diff changeset
1080 dxy= ((motion_x>>3)&1) | ((motion_y>>2)&2);
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 745
diff changeset
1081 if (s->no_rounding){
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 745
diff changeset
1082 put_no_rnd_pixels_tab[0][dxy](dest_y, ptr, linesize, 16);
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 745
diff changeset
1083 }else{
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 745
diff changeset
1084 put_pixels_tab [0][dxy](dest_y, ptr, linesize, 16);
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 745
diff changeset
1085 }
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 745
diff changeset
1086 }
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 745
diff changeset
1087
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 745
diff changeset
1088 if(s->flags&CODEC_FLAG_GRAY) return;
255
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
1089
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
1090 motion_x= s->sprite_offset[1][0];
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
1091 motion_y= s->sprite_offset[1][1];
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
1092 src_x = s->mb_x * 8 + (motion_x >> (s->sprite_warping_accuracy+1));
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
1093 src_y = s->mb_y * 8 + (motion_y >> (s->sprite_warping_accuracy+1));
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
1094 motion_x<<=(3-s->sprite_warping_accuracy);
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
1095 motion_y<<=(3-s->sprite_warping_accuracy);
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
1096 src_x = clip(src_x, -8, s->width>>1);
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
1097 if (src_x == s->width>>1)
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
1098 motion_x =0;
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
1099 src_y = clip(src_y, -8, s->height>>1);
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
1100 if (src_y == s->height>>1)
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
1101 motion_y =0;
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
1102
556
762c67fd4078 uvlinesize
michaelni
parents: 554
diff changeset
1103 offset = (src_y * uvlinesize) + src_x + (src_offset>>1);
255
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
1104 ptr = ref_picture[1] + offset;
566
c376a0b290cf fixing gmc with emu edges
michaelni
parents: 565
diff changeset
1105 if(emu){
753
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 745
diff changeset
1106 emulated_edge_mc(s, ptr, uvlinesize, 9, 9, src_x, src_y, s->h_edge_pos>>1, s->v_edge_pos>>1);
566
c376a0b290cf fixing gmc with emu edges
michaelni
parents: 565
diff changeset
1107 ptr= s->edge_emu_buffer;
c376a0b290cf fixing gmc with emu edges
michaelni
parents: 565
diff changeset
1108 }
753
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 745
diff changeset
1109 ff_gmc1(dest_cb + (dest_offset>>1), ptr, uvlinesize, 8, motion_x&15, motion_y&15, 128 - s->no_rounding);
566
c376a0b290cf fixing gmc with emu edges
michaelni
parents: 565
diff changeset
1110
255
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
1111 ptr = ref_picture[2] + offset;
566
c376a0b290cf fixing gmc with emu edges
michaelni
parents: 565
diff changeset
1112 if(emu){
753
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 745
diff changeset
1113 emulated_edge_mc(s, ptr, uvlinesize, 9, 9, src_x, src_y, s->h_edge_pos>>1, s->v_edge_pos>>1);
566
c376a0b290cf fixing gmc with emu edges
michaelni
parents: 565
diff changeset
1114 ptr= s->edge_emu_buffer;
c376a0b290cf fixing gmc with emu edges
michaelni
parents: 565
diff changeset
1115 }
753
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 745
diff changeset
1116 ff_gmc1(dest_cr + (dest_offset>>1), ptr, uvlinesize, 8, motion_x&15, motion_y&15, 128 - s->no_rounding);
255
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
1117
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
1118 return;
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
1119 }
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
1120
753
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 745
diff changeset
1121 static inline void gmc_motion(MpegEncContext *s,
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 745
diff changeset
1122 UINT8 *dest_y, UINT8 *dest_cb, UINT8 *dest_cr,
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 745
diff changeset
1123 int dest_offset,
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 745
diff changeset
1124 UINT8 **ref_picture, int src_offset)
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 745
diff changeset
1125 {
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 745
diff changeset
1126 UINT8 *ptr;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 745
diff changeset
1127 int linesize, uvlinesize;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 745
diff changeset
1128 const int a= s->sprite_warping_accuracy;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 745
diff changeset
1129 int ox, oy;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 745
diff changeset
1130
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 745
diff changeset
1131 linesize = s->linesize;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 745
diff changeset
1132 uvlinesize = s->uvlinesize;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 745
diff changeset
1133
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 745
diff changeset
1134 ptr = ref_picture[0] + src_offset;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 745
diff changeset
1135
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 745
diff changeset
1136 dest_y+=dest_offset;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 745
diff changeset
1137
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 745
diff changeset
1138 ox= s->sprite_offset[0][0] + s->sprite_delta[0][0]*s->mb_x*16 + s->sprite_delta[0][1]*s->mb_y*16;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 745
diff changeset
1139 oy= s->sprite_offset[0][1] + s->sprite_delta[1][0]*s->mb_x*16 + s->sprite_delta[1][1]*s->mb_y*16;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 745
diff changeset
1140
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 745
diff changeset
1141 ff_gmc(dest_y, ptr, linesize, 16,
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 745
diff changeset
1142 ox,
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 745
diff changeset
1143 oy,
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 745
diff changeset
1144 s->sprite_delta[0][0], s->sprite_delta[0][1],
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 745
diff changeset
1145 s->sprite_delta[1][0], s->sprite_delta[1][1],
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 745
diff changeset
1146 a+1, (1<<(2*a+1)) - s->no_rounding,
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 745
diff changeset
1147 s->h_edge_pos, s->v_edge_pos);
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 745
diff changeset
1148 ff_gmc(dest_y+8, ptr, linesize, 16,
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 745
diff changeset
1149 ox + s->sprite_delta[0][0]*8,
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 745
diff changeset
1150 oy + s->sprite_delta[1][0]*8,
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 745
diff changeset
1151 s->sprite_delta[0][0], s->sprite_delta[0][1],
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 745
diff changeset
1152 s->sprite_delta[1][0], s->sprite_delta[1][1],
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 745
diff changeset
1153 a+1, (1<<(2*a+1)) - s->no_rounding,
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 745
diff changeset
1154 s->h_edge_pos, s->v_edge_pos);
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 745
diff changeset
1155
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 745
diff changeset
1156 if(s->flags&CODEC_FLAG_GRAY) return;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 745
diff changeset
1157
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 745
diff changeset
1158
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 745
diff changeset
1159 dest_cb+=dest_offset>>1;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 745
diff changeset
1160 dest_cr+=dest_offset>>1;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 745
diff changeset
1161
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 745
diff changeset
1162 ox= s->sprite_offset[1][0] + s->sprite_delta[0][0]*s->mb_x*8 + s->sprite_delta[0][1]*s->mb_y*8;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 745
diff changeset
1163 oy= s->sprite_offset[1][1] + s->sprite_delta[1][0]*s->mb_x*8 + s->sprite_delta[1][1]*s->mb_y*8;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 745
diff changeset
1164
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 745
diff changeset
1165 ptr = ref_picture[1] + (src_offset>>1);
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 745
diff changeset
1166 ff_gmc(dest_cb, ptr, uvlinesize, 8,
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 745
diff changeset
1167 ox,
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 745
diff changeset
1168 oy,
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 745
diff changeset
1169 s->sprite_delta[0][0], s->sprite_delta[0][1],
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 745
diff changeset
1170 s->sprite_delta[1][0], s->sprite_delta[1][1],
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 745
diff changeset
1171 a+1, (1<<(2*a+1)) - s->no_rounding,
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 745
diff changeset
1172 s->h_edge_pos>>1, s->v_edge_pos>>1);
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 745
diff changeset
1173
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 745
diff changeset
1174 ptr = ref_picture[2] + (src_offset>>1);
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 745
diff changeset
1175 ff_gmc(dest_cr, ptr, uvlinesize, 8,
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 745
diff changeset
1176 ox,
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 745
diff changeset
1177 oy,
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 745
diff changeset
1178 s->sprite_delta[0][0], s->sprite_delta[0][1],
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 745
diff changeset
1179 s->sprite_delta[1][0], s->sprite_delta[1][1],
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 745
diff changeset
1180 a+1, (1<<(2*a+1)) - s->no_rounding,
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 745
diff changeset
1181 s->h_edge_pos>>1, s->v_edge_pos>>1);
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 745
diff changeset
1182 }
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 745
diff changeset
1183
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 745
diff changeset
1184
566
c376a0b290cf fixing gmc with emu edges
michaelni
parents: 565
diff changeset
1185 static void emulated_edge_mc(MpegEncContext *s, UINT8 *src, int linesize, int block_w, int block_h,
553
18ad513d92fe direct rendering method 1 support
michaelni
parents: 549
diff changeset
1186 int src_x, int src_y, int w, int h){
18ad513d92fe direct rendering method 1 support
michaelni
parents: 549
diff changeset
1187 int x, y;
18ad513d92fe direct rendering method 1 support
michaelni
parents: 549
diff changeset
1188 int start_y, start_x, end_y, end_x;
566
c376a0b290cf fixing gmc with emu edges
michaelni
parents: 565
diff changeset
1189 UINT8 *buf= s->edge_emu_buffer;
582
5132a4ee50cd different edge positions fixed with edge emu / dr1
michaelni
parents: 575
diff changeset
1190
553
18ad513d92fe direct rendering method 1 support
michaelni
parents: 549
diff changeset
1191 if(src_y>= h){
18ad513d92fe direct rendering method 1 support
michaelni
parents: 549
diff changeset
1192 src+= (h-1-src_y)*linesize;
18ad513d92fe direct rendering method 1 support
michaelni
parents: 549
diff changeset
1193 src_y=h-1;
554
3eb6fe38019a 4mv & qpel edge emu
michaelni
parents: 553
diff changeset
1194 }else if(src_y<=-block_h){
3eb6fe38019a 4mv & qpel edge emu
michaelni
parents: 553
diff changeset
1195 src+= (1-block_h-src_y)*linesize;
3eb6fe38019a 4mv & qpel edge emu
michaelni
parents: 553
diff changeset
1196 src_y=1-block_h;
553
18ad513d92fe direct rendering method 1 support
michaelni
parents: 549
diff changeset
1197 }
18ad513d92fe direct rendering method 1 support
michaelni
parents: 549
diff changeset
1198 if(src_x>= w){
18ad513d92fe direct rendering method 1 support
michaelni
parents: 549
diff changeset
1199 src+= (w-1-src_x);
18ad513d92fe direct rendering method 1 support
michaelni
parents: 549
diff changeset
1200 src_x=w-1;
554
3eb6fe38019a 4mv & qpel edge emu
michaelni
parents: 553
diff changeset
1201 }else if(src_x<=-block_w){
3eb6fe38019a 4mv & qpel edge emu
michaelni
parents: 553
diff changeset
1202 src+= (1-block_w-src_x);
3eb6fe38019a 4mv & qpel edge emu
michaelni
parents: 553
diff changeset
1203 src_x=1-block_w;
553
18ad513d92fe direct rendering method 1 support
michaelni
parents: 549
diff changeset
1204 }
18ad513d92fe direct rendering method 1 support
michaelni
parents: 549
diff changeset
1205
18ad513d92fe direct rendering method 1 support
michaelni
parents: 549
diff changeset
1206 start_y= MAX(0, -src_y);
18ad513d92fe direct rendering method 1 support
michaelni
parents: 549
diff changeset
1207 start_x= MAX(0, -src_x);
18ad513d92fe direct rendering method 1 support
michaelni
parents: 549
diff changeset
1208 end_y= MIN(block_h, h-src_y);
18ad513d92fe direct rendering method 1 support
michaelni
parents: 549
diff changeset
1209 end_x= MIN(block_w, w-src_x);
566
c376a0b290cf fixing gmc with emu edges
michaelni
parents: 565
diff changeset
1210
553
18ad513d92fe direct rendering method 1 support
michaelni
parents: 549
diff changeset
1211 // copy existing part
18ad513d92fe direct rendering method 1 support
michaelni
parents: 549
diff changeset
1212 for(y=start_y; y<end_y; y++){
18ad513d92fe direct rendering method 1 support
michaelni
parents: 549
diff changeset
1213 for(x=start_x; x<end_x; x++){
18ad513d92fe direct rendering method 1 support
michaelni
parents: 549
diff changeset
1214 buf[x + y*linesize]= src[x + y*linesize];
18ad513d92fe direct rendering method 1 support
michaelni
parents: 549
diff changeset
1215 }
18ad513d92fe direct rendering method 1 support
michaelni
parents: 549
diff changeset
1216 }
18ad513d92fe direct rendering method 1 support
michaelni
parents: 549
diff changeset
1217
18ad513d92fe direct rendering method 1 support
michaelni
parents: 549
diff changeset
1218 //top
18ad513d92fe direct rendering method 1 support
michaelni
parents: 549
diff changeset
1219 for(y=0; y<start_y; y++){
18ad513d92fe direct rendering method 1 support
michaelni
parents: 549
diff changeset
1220 for(x=start_x; x<end_x; x++){
18ad513d92fe direct rendering method 1 support
michaelni
parents: 549
diff changeset
1221 buf[x + y*linesize]= buf[x + start_y*linesize];
18ad513d92fe direct rendering method 1 support
michaelni
parents: 549
diff changeset
1222 }
18ad513d92fe direct rendering method 1 support
michaelni
parents: 549
diff changeset
1223 }
18ad513d92fe direct rendering method 1 support
michaelni
parents: 549
diff changeset
1224
18ad513d92fe direct rendering method 1 support
michaelni
parents: 549
diff changeset
1225 //bottom
18ad513d92fe direct rendering method 1 support
michaelni
parents: 549
diff changeset
1226 for(y=end_y; y<block_h; y++){
18ad513d92fe direct rendering method 1 support
michaelni
parents: 549
diff changeset
1227 for(x=start_x; x<end_x; x++){
18ad513d92fe direct rendering method 1 support
michaelni
parents: 549
diff changeset
1228 buf[x + y*linesize]= buf[x + (end_y-1)*linesize];
18ad513d92fe direct rendering method 1 support
michaelni
parents: 549
diff changeset
1229 }
18ad513d92fe direct rendering method 1 support
michaelni
parents: 549
diff changeset
1230 }
18ad513d92fe direct rendering method 1 support
michaelni
parents: 549
diff changeset
1231
18ad513d92fe direct rendering method 1 support
michaelni
parents: 549
diff changeset
1232 for(y=0; y<block_h; y++){
18ad513d92fe direct rendering method 1 support
michaelni
parents: 549
diff changeset
1233 //left
18ad513d92fe direct rendering method 1 support
michaelni
parents: 549
diff changeset
1234 for(x=0; x<start_x; x++){
18ad513d92fe direct rendering method 1 support
michaelni
parents: 549
diff changeset
1235 buf[x + y*linesize]= buf[start_x + y*linesize];
18ad513d92fe direct rendering method 1 support
michaelni
parents: 549
diff changeset
1236 }
18ad513d92fe direct rendering method 1 support
michaelni
parents: 549
diff changeset
1237
18ad513d92fe direct rendering method 1 support
michaelni
parents: 549
diff changeset
1238 //right
18ad513d92fe direct rendering method 1 support
michaelni
parents: 549
diff changeset
1239 for(x=end_x; x<block_w; x++){
18ad513d92fe direct rendering method 1 support
michaelni
parents: 549
diff changeset
1240 buf[x + y*linesize]= buf[end_x - 1 + y*linesize];
18ad513d92fe direct rendering method 1 support
michaelni
parents: 549
diff changeset
1241 }
18ad513d92fe direct rendering method 1 support
michaelni
parents: 549
diff changeset
1242 }
18ad513d92fe direct rendering method 1 support
michaelni
parents: 549
diff changeset
1243 }
18ad513d92fe direct rendering method 1 support
michaelni
parents: 549
diff changeset
1244
18ad513d92fe direct rendering method 1 support
michaelni
parents: 549
diff changeset
1245
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1246 /* apply one mpeg motion vector to the three components */
986e461dc072 Initial revision
glantau
parents:
diff changeset
1247 static inline void mpeg_motion(MpegEncContext *s,
986e461dc072 Initial revision
glantau
parents:
diff changeset
1248 UINT8 *dest_y, UINT8 *dest_cb, UINT8 *dest_cr,
986e461dc072 Initial revision
glantau
parents:
diff changeset
1249 int dest_offset,
986e461dc072 Initial revision
glantau
parents:
diff changeset
1250 UINT8 **ref_picture, int src_offset,
651
45e8f39fda50 put/avg_pixels16
michaelni
parents: 650
diff changeset
1251 int field_based, op_pixels_func (*pix_op)[4],
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1252 int motion_x, int motion_y, int h)
986e461dc072 Initial revision
glantau
parents:
diff changeset
1253 {
986e461dc072 Initial revision
glantau
parents:
diff changeset
1254 UINT8 *ptr;
582
5132a4ee50cd different edge positions fixed with edge emu / dr1
michaelni
parents: 575
diff changeset
1255 int dxy, offset, mx, my, src_x, src_y, height, v_edge_pos, linesize, uvlinesize;
553
18ad513d92fe direct rendering method 1 support
michaelni
parents: 549
diff changeset
1256 int emu=0;
651
45e8f39fda50 put/avg_pixels16
michaelni
parents: 650
diff changeset
1257 #if 0
255
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
1258 if(s->quarter_sample)
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
1259 {
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
1260 motion_x>>=1;
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
1261 motion_y>>=1;
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
1262 }
651
45e8f39fda50 put/avg_pixels16
michaelni
parents: 650
diff changeset
1263 #endif
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1264 dxy = ((motion_y & 1) << 1) | (motion_x & 1);
986e461dc072 Initial revision
glantau
parents:
diff changeset
1265 src_x = s->mb_x * 16 + (motion_x >> 1);
986e461dc072 Initial revision
glantau
parents:
diff changeset
1266 src_y = s->mb_y * (16 >> field_based) + (motion_y >> 1);
986e461dc072 Initial revision
glantau
parents:
diff changeset
1267
986e461dc072 Initial revision
glantau
parents:
diff changeset
1268 /* WARNING: do no forget half pels */
986e461dc072 Initial revision
glantau
parents:
diff changeset
1269 height = s->height >> field_based;
582
5132a4ee50cd different edge positions fixed with edge emu / dr1
michaelni
parents: 575
diff changeset
1270 v_edge_pos = s->v_edge_pos >> field_based;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1271 src_x = clip(src_x, -16, s->width);
986e461dc072 Initial revision
glantau
parents:
diff changeset
1272 if (src_x == s->width)
986e461dc072 Initial revision
glantau
parents:
diff changeset
1273 dxy &= ~1;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1274 src_y = clip(src_y, -16, height);
986e461dc072 Initial revision
glantau
parents:
diff changeset
1275 if (src_y == height)
986e461dc072 Initial revision
glantau
parents:
diff changeset
1276 dxy &= ~2;
565
44d744901ded interlaced mpeg2 fix ... replacing linesize>>1 by uvlinesize brainlessly wasnt a good idea
michaelni
parents: 562
diff changeset
1277 linesize = s->linesize << field_based;
44d744901ded interlaced mpeg2 fix ... replacing linesize>>1 by uvlinesize brainlessly wasnt a good idea
michaelni
parents: 562
diff changeset
1278 uvlinesize = s->uvlinesize << field_based;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1279 ptr = ref_picture[0] + (src_y * linesize) + (src_x) + src_offset;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1280 dest_y += dest_offset;
553
18ad513d92fe direct rendering method 1 support
michaelni
parents: 549
diff changeset
1281
18ad513d92fe direct rendering method 1 support
michaelni
parents: 549
diff changeset
1282 if(s->flags&CODEC_FLAG_EMU_EDGE){
582
5132a4ee50cd different edge positions fixed with edge emu / dr1
michaelni
parents: 575
diff changeset
1283 if(src_x<0 || src_y<0 || src_x + (motion_x&1) + 16 > s->h_edge_pos
5132a4ee50cd different edge positions fixed with edge emu / dr1
michaelni
parents: 575
diff changeset
1284 || src_y + (motion_y&1) + h > v_edge_pos){
763
339db642859d fixing interlaced MC & edge-emu
michaelni
parents: 760
diff changeset
1285 emulated_edge_mc(s, ptr - src_offset, s->linesize, 17, 17+field_based,
339db642859d fixing interlaced MC & edge-emu
michaelni
parents: 760
diff changeset
1286 src_x, src_y<<field_based, s->h_edge_pos, s->v_edge_pos);
339db642859d fixing interlaced MC & edge-emu
michaelni
parents: 760
diff changeset
1287 ptr= s->edge_emu_buffer + src_offset;
553
18ad513d92fe direct rendering method 1 support
michaelni
parents: 549
diff changeset
1288 emu=1;
18ad513d92fe direct rendering method 1 support
michaelni
parents: 549
diff changeset
1289 }
18ad513d92fe direct rendering method 1 support
michaelni
parents: 549
diff changeset
1290 }
651
45e8f39fda50 put/avg_pixels16
michaelni
parents: 650
diff changeset
1291 pix_op[0][dxy](dest_y, ptr, linesize, h);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1292
485
20108840b0e5 grayscale only decoding
michaelni
parents: 481
diff changeset
1293 if(s->flags&CODEC_FLAG_GRAY) return;
20108840b0e5 grayscale only decoding
michaelni
parents: 481
diff changeset
1294
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1295 if (s->out_format == FMT_H263) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
1296 dxy = 0;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1297 if ((motion_x & 3) != 0)
986e461dc072 Initial revision
glantau
parents:
diff changeset
1298 dxy |= 1;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1299 if ((motion_y & 3) != 0)
986e461dc072 Initial revision
glantau
parents:
diff changeset
1300 dxy |= 2;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1301 mx = motion_x >> 2;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1302 my = motion_y >> 2;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1303 } else {
986e461dc072 Initial revision
glantau
parents:
diff changeset
1304 mx = motion_x / 2;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1305 my = motion_y / 2;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1306 dxy = ((my & 1) << 1) | (mx & 1);
986e461dc072 Initial revision
glantau
parents:
diff changeset
1307 mx >>= 1;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1308 my >>= 1;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1309 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
1310
986e461dc072 Initial revision
glantau
parents:
diff changeset
1311 src_x = s->mb_x * 8 + mx;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1312 src_y = s->mb_y * (8 >> field_based) + my;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1313 src_x = clip(src_x, -8, s->width >> 1);
986e461dc072 Initial revision
glantau
parents:
diff changeset
1314 if (src_x == (s->width >> 1))
986e461dc072 Initial revision
glantau
parents:
diff changeset
1315 dxy &= ~1;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1316 src_y = clip(src_y, -8, height >> 1);
986e461dc072 Initial revision
glantau
parents:
diff changeset
1317 if (src_y == (height >> 1))
986e461dc072 Initial revision
glantau
parents:
diff changeset
1318 dxy &= ~2;
565
44d744901ded interlaced mpeg2 fix ... replacing linesize>>1 by uvlinesize brainlessly wasnt a good idea
michaelni
parents: 562
diff changeset
1319 offset = (src_y * uvlinesize) + src_x + (src_offset >> 1);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1320 ptr = ref_picture[1] + offset;
553
18ad513d92fe direct rendering method 1 support
michaelni
parents: 549
diff changeset
1321 if(emu){
763
339db642859d fixing interlaced MC & edge-emu
michaelni
parents: 760
diff changeset
1322 emulated_edge_mc(s, ptr - (src_offset >> 1), s->uvlinesize, 9, 9+field_based,
339db642859d fixing interlaced MC & edge-emu
michaelni
parents: 760
diff changeset
1323 src_x, src_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
339db642859d fixing interlaced MC & edge-emu
michaelni
parents: 760
diff changeset
1324 ptr= s->edge_emu_buffer + (src_offset >> 1);
553
18ad513d92fe direct rendering method 1 support
michaelni
parents: 549
diff changeset
1325 }
651
45e8f39fda50 put/avg_pixels16
michaelni
parents: 650
diff changeset
1326 pix_op[1][dxy](dest_cb + (dest_offset >> 1), ptr, uvlinesize, h >> 1);
553
18ad513d92fe direct rendering method 1 support
michaelni
parents: 549
diff changeset
1327
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1328 ptr = ref_picture[2] + offset;
553
18ad513d92fe direct rendering method 1 support
michaelni
parents: 549
diff changeset
1329 if(emu){
763
339db642859d fixing interlaced MC & edge-emu
michaelni
parents: 760
diff changeset
1330 emulated_edge_mc(s, ptr - (src_offset >> 1), s->uvlinesize, 9, 9+field_based,
339db642859d fixing interlaced MC & edge-emu
michaelni
parents: 760
diff changeset
1331 src_x, src_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
339db642859d fixing interlaced MC & edge-emu
michaelni
parents: 760
diff changeset
1332 ptr= s->edge_emu_buffer + (src_offset >> 1);
553
18ad513d92fe direct rendering method 1 support
michaelni
parents: 549
diff changeset
1333 }
651
45e8f39fda50 put/avg_pixels16
michaelni
parents: 650
diff changeset
1334 pix_op[1][dxy](dest_cr + (dest_offset >> 1), ptr, uvlinesize, h >> 1);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1335 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
1336
255
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
1337 static inline void qpel_motion(MpegEncContext *s,
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
1338 UINT8 *dest_y, UINT8 *dest_cb, UINT8 *dest_cr,
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
1339 int dest_offset,
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
1340 UINT8 **ref_picture, int src_offset,
651
45e8f39fda50 put/avg_pixels16
michaelni
parents: 650
diff changeset
1341 int field_based, op_pixels_func (*pix_op)[4],
45e8f39fda50 put/avg_pixels16
michaelni
parents: 650
diff changeset
1342 qpel_mc_func (*qpix_op)[16],
255
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
1343 int motion_x, int motion_y, int h)
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
1344 {
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
1345 UINT8 *ptr;
671
3f2e5a282f61 interlaced qpel mpeg4 fixed
michaelni
parents: 664
diff changeset
1346 int dxy, offset, mx, my, src_x, src_y, height, v_edge_pos, linesize, uvlinesize;
554
3eb6fe38019a 4mv & qpel edge emu
michaelni
parents: 553
diff changeset
1347 int emu=0;
255
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
1348
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
1349 dxy = ((motion_y & 3) << 2) | (motion_x & 3);
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
1350 src_x = s->mb_x * 16 + (motion_x >> 2);
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
1351 src_y = s->mb_y * (16 >> field_based) + (motion_y >> 2);
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
1352
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
1353 height = s->height >> field_based;
582
5132a4ee50cd different edge positions fixed with edge emu / dr1
michaelni
parents: 575
diff changeset
1354 v_edge_pos = s->v_edge_pos >> field_based;
255
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
1355 src_x = clip(src_x, -16, s->width);
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
1356 if (src_x == s->width)
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
1357 dxy &= ~3;
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
1358 src_y = clip(src_y, -16, height);
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
1359 if (src_y == height)
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
1360 dxy &= ~12;
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
1361 linesize = s->linesize << field_based;
671
3f2e5a282f61 interlaced qpel mpeg4 fixed
michaelni
parents: 664
diff changeset
1362 uvlinesize = s->uvlinesize << field_based;
255
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
1363 ptr = ref_picture[0] + (src_y * linesize) + src_x + src_offset;
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
1364 dest_y += dest_offset;
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
1365 //printf("%d %d %d\n", src_x, src_y, dxy);
554
3eb6fe38019a 4mv & qpel edge emu
michaelni
parents: 553
diff changeset
1366
3eb6fe38019a 4mv & qpel edge emu
michaelni
parents: 553
diff changeset
1367 if(s->flags&CODEC_FLAG_EMU_EDGE){
582
5132a4ee50cd different edge positions fixed with edge emu / dr1
michaelni
parents: 575
diff changeset
1368 if(src_x<0 || src_y<0 || src_x + (motion_x&3) + 16 > s->h_edge_pos
5132a4ee50cd different edge positions fixed with edge emu / dr1
michaelni
parents: 575
diff changeset
1369 || src_y + (motion_y&3) + h > v_edge_pos){
763
339db642859d fixing interlaced MC & edge-emu
michaelni
parents: 760
diff changeset
1370 emulated_edge_mc(s, ptr - src_offset, s->linesize, 17, 17+field_based,
339db642859d fixing interlaced MC & edge-emu
michaelni
parents: 760
diff changeset
1371 src_x, src_y<<field_based, s->h_edge_pos, s->v_edge_pos);
339db642859d fixing interlaced MC & edge-emu
michaelni
parents: 760
diff changeset
1372 ptr= s->edge_emu_buffer + src_offset;
554
3eb6fe38019a 4mv & qpel edge emu
michaelni
parents: 553
diff changeset
1373 emu=1;
3eb6fe38019a 4mv & qpel edge emu
michaelni
parents: 553
diff changeset
1374 }
3eb6fe38019a 4mv & qpel edge emu
michaelni
parents: 553
diff changeset
1375 }
671
3f2e5a282f61 interlaced qpel mpeg4 fixed
michaelni
parents: 664
diff changeset
1376 if(!field_based)
3f2e5a282f61 interlaced qpel mpeg4 fixed
michaelni
parents: 664
diff changeset
1377 qpix_op[0][dxy](dest_y, ptr, linesize);
3f2e5a282f61 interlaced qpel mpeg4 fixed
michaelni
parents: 664
diff changeset
1378 else{
3f2e5a282f61 interlaced qpel mpeg4 fixed
michaelni
parents: 664
diff changeset
1379 //damn interlaced mode
3f2e5a282f61 interlaced qpel mpeg4 fixed
michaelni
parents: 664
diff changeset
1380 //FIXME boundary mirroring is not exactly correct here
3f2e5a282f61 interlaced qpel mpeg4 fixed
michaelni
parents: 664
diff changeset
1381 qpix_op[1][dxy](dest_y , ptr , linesize);
3f2e5a282f61 interlaced qpel mpeg4 fixed
michaelni
parents: 664
diff changeset
1382 qpix_op[1][dxy](dest_y+8, ptr+8, linesize);
3f2e5a282f61 interlaced qpel mpeg4 fixed
michaelni
parents: 664
diff changeset
1383 }
651
45e8f39fda50 put/avg_pixels16
michaelni
parents: 650
diff changeset
1384
485
20108840b0e5 grayscale only decoding
michaelni
parents: 481
diff changeset
1385 if(s->flags&CODEC_FLAG_GRAY) return;
20108840b0e5 grayscale only decoding
michaelni
parents: 481
diff changeset
1386
671
3f2e5a282f61 interlaced qpel mpeg4 fixed
michaelni
parents: 664
diff changeset
1387 if(field_based){
3f2e5a282f61 interlaced qpel mpeg4 fixed
michaelni
parents: 664
diff changeset
1388 mx= motion_x/2;
3f2e5a282f61 interlaced qpel mpeg4 fixed
michaelni
parents: 664
diff changeset
1389 my= motion_y>>1;
760
e858fe220ce0 xvid qpel bug workaround
michaelni
parents: 756
diff changeset
1390 }else if(s->workaround_bugs&FF_BUG_QPEL_CHROMA){
671
3f2e5a282f61 interlaced qpel mpeg4 fixed
michaelni
parents: 664
diff changeset
1391 mx= (motion_x>>1)|(motion_x&1);
3f2e5a282f61 interlaced qpel mpeg4 fixed
michaelni
parents: 664
diff changeset
1392 my= (motion_y>>1)|(motion_y&1);
3f2e5a282f61 interlaced qpel mpeg4 fixed
michaelni
parents: 664
diff changeset
1393 }else{
3f2e5a282f61 interlaced qpel mpeg4 fixed
michaelni
parents: 664
diff changeset
1394 mx= motion_x/2;
3f2e5a282f61 interlaced qpel mpeg4 fixed
michaelni
parents: 664
diff changeset
1395 my= motion_y/2;
3f2e5a282f61 interlaced qpel mpeg4 fixed
michaelni
parents: 664
diff changeset
1396 }
3f2e5a282f61 interlaced qpel mpeg4 fixed
michaelni
parents: 664
diff changeset
1397 mx= (mx>>1)|(mx&1);
3f2e5a282f61 interlaced qpel mpeg4 fixed
michaelni
parents: 664
diff changeset
1398 my= (my>>1)|(my&1);
3f2e5a282f61 interlaced qpel mpeg4 fixed
michaelni
parents: 664
diff changeset
1399 dxy= (mx&1) | ((my&1)<<1);
3f2e5a282f61 interlaced qpel mpeg4 fixed
michaelni
parents: 664
diff changeset
1400 mx>>=1;
3f2e5a282f61 interlaced qpel mpeg4 fixed
michaelni
parents: 664
diff changeset
1401 my>>=1;
255
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
1402
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
1403 src_x = s->mb_x * 8 + mx;
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
1404 src_y = s->mb_y * (8 >> field_based) + my;
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
1405 src_x = clip(src_x, -8, s->width >> 1);
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
1406 if (src_x == (s->width >> 1))
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
1407 dxy &= ~1;
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
1408 src_y = clip(src_y, -8, height >> 1);
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
1409 if (src_y == (height >> 1))
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
1410 dxy &= ~2;
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
1411
671
3f2e5a282f61 interlaced qpel mpeg4 fixed
michaelni
parents: 664
diff changeset
1412 offset = (src_y * uvlinesize) + src_x + (src_offset >> 1);
255
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
1413 ptr = ref_picture[1] + offset;
554
3eb6fe38019a 4mv & qpel edge emu
michaelni
parents: 553
diff changeset
1414 if(emu){
763
339db642859d fixing interlaced MC & edge-emu
michaelni
parents: 760
diff changeset
1415 emulated_edge_mc(s, ptr - (src_offset >> 1), s->uvlinesize, 9, 9 + field_based,
339db642859d fixing interlaced MC & edge-emu
michaelni
parents: 760
diff changeset
1416 src_x, src_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
339db642859d fixing interlaced MC & edge-emu
michaelni
parents: 760
diff changeset
1417 ptr= s->edge_emu_buffer + (src_offset >> 1);
554
3eb6fe38019a 4mv & qpel edge emu
michaelni
parents: 553
diff changeset
1418 }
671
3f2e5a282f61 interlaced qpel mpeg4 fixed
michaelni
parents: 664
diff changeset
1419 pix_op[1][dxy](dest_cb + (dest_offset >> 1), ptr, uvlinesize, h >> 1);
554
3eb6fe38019a 4mv & qpel edge emu
michaelni
parents: 553
diff changeset
1420
255
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
1421 ptr = ref_picture[2] + offset;
554
3eb6fe38019a 4mv & qpel edge emu
michaelni
parents: 553
diff changeset
1422 if(emu){
763
339db642859d fixing interlaced MC & edge-emu
michaelni
parents: 760
diff changeset
1423 emulated_edge_mc(s, ptr - (src_offset >> 1), s->uvlinesize, 9, 9 + field_based,
339db642859d fixing interlaced MC & edge-emu
michaelni
parents: 760
diff changeset
1424 src_x, src_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
339db642859d fixing interlaced MC & edge-emu
michaelni
parents: 760
diff changeset
1425 ptr= s->edge_emu_buffer + (src_offset >> 1);
554
3eb6fe38019a 4mv & qpel edge emu
michaelni
parents: 553
diff changeset
1426 }
671
3f2e5a282f61 interlaced qpel mpeg4 fixed
michaelni
parents: 664
diff changeset
1427 pix_op[1][dxy](dest_cr + (dest_offset >> 1), ptr, uvlinesize, h >> 1);
255
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
1428 }
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
1429
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
1430
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1431 static inline void MPV_motion(MpegEncContext *s,
986e461dc072 Initial revision
glantau
parents:
diff changeset
1432 UINT8 *dest_y, UINT8 *dest_cb, UINT8 *dest_cr,
986e461dc072 Initial revision
glantau
parents:
diff changeset
1433 int dir, UINT8 **ref_picture,
651
45e8f39fda50 put/avg_pixels16
michaelni
parents: 650
diff changeset
1434 op_pixels_func (*pix_op)[4], qpel_mc_func (*qpix_op)[16])
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1435 {
986e461dc072 Initial revision
glantau
parents:
diff changeset
1436 int dxy, offset, mx, my, src_x, src_y, motion_x, motion_y;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1437 int mb_x, mb_y, i;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1438 UINT8 *ptr, *dest;
554
3eb6fe38019a 4mv & qpel edge emu
michaelni
parents: 553
diff changeset
1439 int emu=0;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1440
986e461dc072 Initial revision
glantau
parents:
diff changeset
1441 mb_x = s->mb_x;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1442 mb_y = s->mb_y;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1443
986e461dc072 Initial revision
glantau
parents:
diff changeset
1444 switch(s->mv_type) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
1445 case MV_TYPE_16X16:
255
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
1446 if(s->mcsel){
753
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 745
diff changeset
1447 if(s->real_sprite_warping_points==1){
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 745
diff changeset
1448 gmc1_motion(s, dest_y, dest_cb, dest_cr, 0,
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 745
diff changeset
1449 ref_picture, 0);
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 745
diff changeset
1450 }else{
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 745
diff changeset
1451 gmc_motion(s, dest_y, dest_cb, dest_cr, 0,
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 745
diff changeset
1452 ref_picture, 0);
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 745
diff changeset
1453 }
651
45e8f39fda50 put/avg_pixels16
michaelni
parents: 650
diff changeset
1454 }else if(s->quarter_sample){
255
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
1455 qpel_motion(s, dest_y, dest_cb, dest_cr, 0,
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
1456 ref_picture, 0,
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
1457 0, pix_op, qpix_op,
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
1458 s->mv[dir][0][0], s->mv[dir][0][1], 16);
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
1459 }else{
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
1460 mpeg_motion(s, dest_y, dest_cb, dest_cr, 0,
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
1461 ref_picture, 0,
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
1462 0, pix_op,
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
1463 s->mv[dir][0][0], s->mv[dir][0][1], 16);
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
1464 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1465 break;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1466 case MV_TYPE_8X8:
673
242f0f7d8c15 fixing qpel 4mv
michaelni
parents: 671
diff changeset
1467 mx = 0;
242f0f7d8c15 fixing qpel 4mv
michaelni
parents: 671
diff changeset
1468 my = 0;
242f0f7d8c15 fixing qpel 4mv
michaelni
parents: 671
diff changeset
1469 if(s->quarter_sample){
242f0f7d8c15 fixing qpel 4mv
michaelni
parents: 671
diff changeset
1470 for(i=0;i<4;i++) {
242f0f7d8c15 fixing qpel 4mv
michaelni
parents: 671
diff changeset
1471 motion_x = s->mv[dir][i][0];
242f0f7d8c15 fixing qpel 4mv
michaelni
parents: 671
diff changeset
1472 motion_y = s->mv[dir][i][1];
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1473
673
242f0f7d8c15 fixing qpel 4mv
michaelni
parents: 671
diff changeset
1474 dxy = ((motion_y & 3) << 2) | (motion_x & 3);
242f0f7d8c15 fixing qpel 4mv
michaelni
parents: 671
diff changeset
1475 src_x = mb_x * 16 + (motion_x >> 2) + (i & 1) * 8;
242f0f7d8c15 fixing qpel 4mv
michaelni
parents: 671
diff changeset
1476 src_y = mb_y * 16 + (motion_y >> 2) + (i >>1) * 8;
242f0f7d8c15 fixing qpel 4mv
michaelni
parents: 671
diff changeset
1477
242f0f7d8c15 fixing qpel 4mv
michaelni
parents: 671
diff changeset
1478 /* WARNING: do no forget half pels */
242f0f7d8c15 fixing qpel 4mv
michaelni
parents: 671
diff changeset
1479 src_x = clip(src_x, -16, s->width);
242f0f7d8c15 fixing qpel 4mv
michaelni
parents: 671
diff changeset
1480 if (src_x == s->width)
242f0f7d8c15 fixing qpel 4mv
michaelni
parents: 671
diff changeset
1481 dxy &= ~3;
242f0f7d8c15 fixing qpel 4mv
michaelni
parents: 671
diff changeset
1482 src_y = clip(src_y, -16, s->height);
242f0f7d8c15 fixing qpel 4mv
michaelni
parents: 671
diff changeset
1483 if (src_y == s->height)
242f0f7d8c15 fixing qpel 4mv
michaelni
parents: 671
diff changeset
1484 dxy &= ~12;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1485
673
242f0f7d8c15 fixing qpel 4mv
michaelni
parents: 671
diff changeset
1486 ptr = ref_picture[0] + (src_y * s->linesize) + (src_x);
242f0f7d8c15 fixing qpel 4mv
michaelni
parents: 671
diff changeset
1487 if(s->flags&CODEC_FLAG_EMU_EDGE){
242f0f7d8c15 fixing qpel 4mv
michaelni
parents: 671
diff changeset
1488 if(src_x<0 || src_y<0 || src_x + (motion_x&3) + 8 > s->h_edge_pos
242f0f7d8c15 fixing qpel 4mv
michaelni
parents: 671
diff changeset
1489 || src_y + (motion_y&3) + 8 > s->v_edge_pos){
242f0f7d8c15 fixing qpel 4mv
michaelni
parents: 671
diff changeset
1490 emulated_edge_mc(s, ptr, s->linesize, 9, 9, src_x, src_y, s->h_edge_pos, s->v_edge_pos);
242f0f7d8c15 fixing qpel 4mv
michaelni
parents: 671
diff changeset
1491 ptr= s->edge_emu_buffer;
242f0f7d8c15 fixing qpel 4mv
michaelni
parents: 671
diff changeset
1492 }
242f0f7d8c15 fixing qpel 4mv
michaelni
parents: 671
diff changeset
1493 }
242f0f7d8c15 fixing qpel 4mv
michaelni
parents: 671
diff changeset
1494 dest = dest_y + ((i & 1) * 8) + (i >> 1) * 8 * s->linesize;
242f0f7d8c15 fixing qpel 4mv
michaelni
parents: 671
diff changeset
1495 qpix_op[1][dxy](dest, ptr, s->linesize);
242f0f7d8c15 fixing qpel 4mv
michaelni
parents: 671
diff changeset
1496
242f0f7d8c15 fixing qpel 4mv
michaelni
parents: 671
diff changeset
1497 mx += s->mv[dir][i][0]/2;
242f0f7d8c15 fixing qpel 4mv
michaelni
parents: 671
diff changeset
1498 my += s->mv[dir][i][1]/2;
242f0f7d8c15 fixing qpel 4mv
michaelni
parents: 671
diff changeset
1499 }
242f0f7d8c15 fixing qpel 4mv
michaelni
parents: 671
diff changeset
1500 }else{
242f0f7d8c15 fixing qpel 4mv
michaelni
parents: 671
diff changeset
1501 for(i=0;i<4;i++) {
242f0f7d8c15 fixing qpel 4mv
michaelni
parents: 671
diff changeset
1502 motion_x = s->mv[dir][i][0];
242f0f7d8c15 fixing qpel 4mv
michaelni
parents: 671
diff changeset
1503 motion_y = s->mv[dir][i][1];
242f0f7d8c15 fixing qpel 4mv
michaelni
parents: 671
diff changeset
1504
242f0f7d8c15 fixing qpel 4mv
michaelni
parents: 671
diff changeset
1505 dxy = ((motion_y & 1) << 1) | (motion_x & 1);
242f0f7d8c15 fixing qpel 4mv
michaelni
parents: 671
diff changeset
1506 src_x = mb_x * 16 + (motion_x >> 1) + (i & 1) * 8;
242f0f7d8c15 fixing qpel 4mv
michaelni
parents: 671
diff changeset
1507 src_y = mb_y * 16 + (motion_y >> 1) + (i >>1) * 8;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1508
673
242f0f7d8c15 fixing qpel 4mv
michaelni
parents: 671
diff changeset
1509 /* WARNING: do no forget half pels */
242f0f7d8c15 fixing qpel 4mv
michaelni
parents: 671
diff changeset
1510 src_x = clip(src_x, -16, s->width);
242f0f7d8c15 fixing qpel 4mv
michaelni
parents: 671
diff changeset
1511 if (src_x == s->width)
242f0f7d8c15 fixing qpel 4mv
michaelni
parents: 671
diff changeset
1512 dxy &= ~1;
242f0f7d8c15 fixing qpel 4mv
michaelni
parents: 671
diff changeset
1513 src_y = clip(src_y, -16, s->height);
242f0f7d8c15 fixing qpel 4mv
michaelni
parents: 671
diff changeset
1514 if (src_y == s->height)
242f0f7d8c15 fixing qpel 4mv
michaelni
parents: 671
diff changeset
1515 dxy &= ~2;
242f0f7d8c15 fixing qpel 4mv
michaelni
parents: 671
diff changeset
1516
242f0f7d8c15 fixing qpel 4mv
michaelni
parents: 671
diff changeset
1517 ptr = ref_picture[0] + (src_y * s->linesize) + (src_x);
242f0f7d8c15 fixing qpel 4mv
michaelni
parents: 671
diff changeset
1518 if(s->flags&CODEC_FLAG_EMU_EDGE){
242f0f7d8c15 fixing qpel 4mv
michaelni
parents: 671
diff changeset
1519 if(src_x<0 || src_y<0 || src_x + (motion_x&1) + 8 > s->h_edge_pos
242f0f7d8c15 fixing qpel 4mv
michaelni
parents: 671
diff changeset
1520 || src_y + (motion_y&1) + 8 > s->v_edge_pos){
242f0f7d8c15 fixing qpel 4mv
michaelni
parents: 671
diff changeset
1521 emulated_edge_mc(s, ptr, s->linesize, 9, 9, src_x, src_y, s->h_edge_pos, s->v_edge_pos);
242f0f7d8c15 fixing qpel 4mv
michaelni
parents: 671
diff changeset
1522 ptr= s->edge_emu_buffer;
242f0f7d8c15 fixing qpel 4mv
michaelni
parents: 671
diff changeset
1523 }
554
3eb6fe38019a 4mv & qpel edge emu
michaelni
parents: 553
diff changeset
1524 }
673
242f0f7d8c15 fixing qpel 4mv
michaelni
parents: 671
diff changeset
1525 dest = dest_y + ((i & 1) * 8) + (i >> 1) * 8 * s->linesize;
242f0f7d8c15 fixing qpel 4mv
michaelni
parents: 671
diff changeset
1526 pix_op[1][dxy](dest, ptr, s->linesize, 8);
242f0f7d8c15 fixing qpel 4mv
michaelni
parents: 671
diff changeset
1527
242f0f7d8c15 fixing qpel 4mv
michaelni
parents: 671
diff changeset
1528 mx += s->mv[dir][i][0];
242f0f7d8c15 fixing qpel 4mv
michaelni
parents: 671
diff changeset
1529 my += s->mv[dir][i][1];
554
3eb6fe38019a 4mv & qpel edge emu
michaelni
parents: 553
diff changeset
1530 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1531 }
673
242f0f7d8c15 fixing qpel 4mv
michaelni
parents: 671
diff changeset
1532
485
20108840b0e5 grayscale only decoding
michaelni
parents: 481
diff changeset
1533 if(s->flags&CODEC_FLAG_GRAY) break;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1534 /* In case of 8X8, we construct a single chroma motion vector
986e461dc072 Initial revision
glantau
parents:
diff changeset
1535 with a special rounding */
986e461dc072 Initial revision
glantau
parents:
diff changeset
1536 for(i=0;i<4;i++) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
1537 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
1538 if (mx >= 0)
986e461dc072 Initial revision
glantau
parents:
diff changeset
1539 mx = (h263_chroma_roundtab[mx & 0xf] + ((mx >> 3) & ~1));
986e461dc072 Initial revision
glantau
parents:
diff changeset
1540 else {
986e461dc072 Initial revision
glantau
parents:
diff changeset
1541 mx = -mx;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1542 mx = -(h263_chroma_roundtab[mx & 0xf] + ((mx >> 3) & ~1));
986e461dc072 Initial revision
glantau
parents:
diff changeset
1543 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
1544 if (my >= 0)
986e461dc072 Initial revision
glantau
parents:
diff changeset
1545 my = (h263_chroma_roundtab[my & 0xf] + ((my >> 3) & ~1));
986e461dc072 Initial revision
glantau
parents:
diff changeset
1546 else {
986e461dc072 Initial revision
glantau
parents:
diff changeset
1547 my = -my;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1548 my = -(h263_chroma_roundtab[my & 0xf] + ((my >> 3) & ~1));
986e461dc072 Initial revision
glantau
parents:
diff changeset
1549 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
1550 dxy = ((my & 1) << 1) | (mx & 1);
986e461dc072 Initial revision
glantau
parents:
diff changeset
1551 mx >>= 1;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1552 my >>= 1;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1553
986e461dc072 Initial revision
glantau
parents:
diff changeset
1554 src_x = mb_x * 8 + mx;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1555 src_y = mb_y * 8 + my;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1556 src_x = clip(src_x, -8, s->width/2);
986e461dc072 Initial revision
glantau
parents:
diff changeset
1557 if (src_x == s->width/2)
986e461dc072 Initial revision
glantau
parents:
diff changeset
1558 dxy &= ~1;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1559 src_y = clip(src_y, -8, s->height/2);
986e461dc072 Initial revision
glantau
parents:
diff changeset
1560 if (src_y == s->height/2)
986e461dc072 Initial revision
glantau
parents:
diff changeset
1561 dxy &= ~2;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1562
556
762c67fd4078 uvlinesize
michaelni
parents: 554
diff changeset
1563 offset = (src_y * (s->uvlinesize)) + src_x;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1564 ptr = ref_picture[1] + offset;
554
3eb6fe38019a 4mv & qpel edge emu
michaelni
parents: 553
diff changeset
1565 if(s->flags&CODEC_FLAG_EMU_EDGE){
582
5132a4ee50cd different edge positions fixed with edge emu / dr1
michaelni
parents: 575
diff changeset
1566 if(src_x<0 || src_y<0 || src_x + (dxy &1) + 8 > s->h_edge_pos>>1
5132a4ee50cd different edge positions fixed with edge emu / dr1
michaelni
parents: 575
diff changeset
1567 || src_y + (dxy>>1) + 8 > s->v_edge_pos>>1){
5132a4ee50cd different edge positions fixed with edge emu / dr1
michaelni
parents: 575
diff changeset
1568 emulated_edge_mc(s, ptr, s->uvlinesize, 9, 9, src_x, src_y, s->h_edge_pos>>1, s->v_edge_pos>>1);
554
3eb6fe38019a 4mv & qpel edge emu
michaelni
parents: 553
diff changeset
1569 ptr= s->edge_emu_buffer;
3eb6fe38019a 4mv & qpel edge emu
michaelni
parents: 553
diff changeset
1570 emu=1;
3eb6fe38019a 4mv & qpel edge emu
michaelni
parents: 553
diff changeset
1571 }
3eb6fe38019a 4mv & qpel edge emu
michaelni
parents: 553
diff changeset
1572 }
651
45e8f39fda50 put/avg_pixels16
michaelni
parents: 650
diff changeset
1573 pix_op[1][dxy](dest_cb, ptr, s->uvlinesize, 8);
554
3eb6fe38019a 4mv & qpel edge emu
michaelni
parents: 553
diff changeset
1574
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1575 ptr = ref_picture[2] + offset;
554
3eb6fe38019a 4mv & qpel edge emu
michaelni
parents: 553
diff changeset
1576 if(emu){
582
5132a4ee50cd different edge positions fixed with edge emu / dr1
michaelni
parents: 575
diff changeset
1577 emulated_edge_mc(s, ptr, s->uvlinesize, 9, 9, src_x, src_y, s->h_edge_pos>>1, s->v_edge_pos>>1);
554
3eb6fe38019a 4mv & qpel edge emu
michaelni
parents: 553
diff changeset
1578 ptr= s->edge_emu_buffer;
3eb6fe38019a 4mv & qpel edge emu
michaelni
parents: 553
diff changeset
1579 }
651
45e8f39fda50 put/avg_pixels16
michaelni
parents: 650
diff changeset
1580 pix_op[1][dxy](dest_cr, ptr, s->uvlinesize, 8);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1581 break;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1582 case MV_TYPE_FIELD:
986e461dc072 Initial revision
glantau
parents:
diff changeset
1583 if (s->picture_structure == PICT_FRAME) {
671
3f2e5a282f61 interlaced qpel mpeg4 fixed
michaelni
parents: 664
diff changeset
1584 if(s->quarter_sample){
3f2e5a282f61 interlaced qpel mpeg4 fixed
michaelni
parents: 664
diff changeset
1585 /* top field */
3f2e5a282f61 interlaced qpel mpeg4 fixed
michaelni
parents: 664
diff changeset
1586 qpel_motion(s, dest_y, dest_cb, dest_cr, 0,
3f2e5a282f61 interlaced qpel mpeg4 fixed
michaelni
parents: 664
diff changeset
1587 ref_picture, s->field_select[dir][0] ? s->linesize : 0,
3f2e5a282f61 interlaced qpel mpeg4 fixed
michaelni
parents: 664
diff changeset
1588 1, pix_op, qpix_op,
3f2e5a282f61 interlaced qpel mpeg4 fixed
michaelni
parents: 664
diff changeset
1589 s->mv[dir][0][0], s->mv[dir][0][1], 8);
3f2e5a282f61 interlaced qpel mpeg4 fixed
michaelni
parents: 664
diff changeset
1590 /* bottom field */
3f2e5a282f61 interlaced qpel mpeg4 fixed
michaelni
parents: 664
diff changeset
1591 qpel_motion(s, dest_y, dest_cb, dest_cr, s->linesize,
3f2e5a282f61 interlaced qpel mpeg4 fixed
michaelni
parents: 664
diff changeset
1592 ref_picture, s->field_select[dir][1] ? s->linesize : 0,
3f2e5a282f61 interlaced qpel mpeg4 fixed
michaelni
parents: 664
diff changeset
1593 1, pix_op, qpix_op,
3f2e5a282f61 interlaced qpel mpeg4 fixed
michaelni
parents: 664
diff changeset
1594 s->mv[dir][1][0], s->mv[dir][1][1], 8);
3f2e5a282f61 interlaced qpel mpeg4 fixed
michaelni
parents: 664
diff changeset
1595 }else{
3f2e5a282f61 interlaced qpel mpeg4 fixed
michaelni
parents: 664
diff changeset
1596 /* top field */
3f2e5a282f61 interlaced qpel mpeg4 fixed
michaelni
parents: 664
diff changeset
1597 mpeg_motion(s, dest_y, dest_cb, dest_cr, 0,
3f2e5a282f61 interlaced qpel mpeg4 fixed
michaelni
parents: 664
diff changeset
1598 ref_picture, s->field_select[dir][0] ? s->linesize : 0,
3f2e5a282f61 interlaced qpel mpeg4 fixed
michaelni
parents: 664
diff changeset
1599 1, pix_op,
3f2e5a282f61 interlaced qpel mpeg4 fixed
michaelni
parents: 664
diff changeset
1600 s->mv[dir][0][0], s->mv[dir][0][1], 8);
3f2e5a282f61 interlaced qpel mpeg4 fixed
michaelni
parents: 664
diff changeset
1601 /* bottom field */
3f2e5a282f61 interlaced qpel mpeg4 fixed
michaelni
parents: 664
diff changeset
1602 mpeg_motion(s, dest_y, dest_cb, dest_cr, s->linesize,
3f2e5a282f61 interlaced qpel mpeg4 fixed
michaelni
parents: 664
diff changeset
1603 ref_picture, s->field_select[dir][1] ? s->linesize : 0,
3f2e5a282f61 interlaced qpel mpeg4 fixed
michaelni
parents: 664
diff changeset
1604 1, pix_op,
3f2e5a282f61 interlaced qpel mpeg4 fixed
michaelni
parents: 664
diff changeset
1605 s->mv[dir][1][0], s->mv[dir][1][1], 8);
3f2e5a282f61 interlaced qpel mpeg4 fixed
michaelni
parents: 664
diff changeset
1606 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1607 } else {
986e461dc072 Initial revision
glantau
parents:
diff changeset
1608
986e461dc072 Initial revision
glantau
parents:
diff changeset
1609
986e461dc072 Initial revision
glantau
parents:
diff changeset
1610 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
1611 break;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1612 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
1613 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
1614
986e461dc072 Initial revision
glantau
parents:
diff changeset
1615
986e461dc072 Initial revision
glantau
parents:
diff changeset
1616 /* put block[] to dest[] */
986e461dc072 Initial revision
glantau
parents:
diff changeset
1617 static inline void put_dct(MpegEncContext *s,
986e461dc072 Initial revision
glantau
parents:
diff changeset
1618 DCTELEM *block, int i, UINT8 *dest, int line_size)
986e461dc072 Initial revision
glantau
parents:
diff changeset
1619 {
711
dcbcf9676c9f optimizing mpeg1_decode_block()
michaelni
parents: 709
diff changeset
1620 s->dct_unquantize(s, block, i, s->qscale);
706
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 704
diff changeset
1621 s->idct_put (dest, line_size, block);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1622 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
1623
986e461dc072 Initial revision
glantau
parents:
diff changeset
1624 /* add block[] to dest[] */
986e461dc072 Initial revision
glantau
parents:
diff changeset
1625 static inline void add_dct(MpegEncContext *s,
986e461dc072 Initial revision
glantau
parents:
diff changeset
1626 DCTELEM *block, int i, UINT8 *dest, int line_size)
986e461dc072 Initial revision
glantau
parents:
diff changeset
1627 {
986e461dc072 Initial revision
glantau
parents:
diff changeset
1628 if (s->block_last_index[i] >= 0) {
706
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 704
diff changeset
1629 s->idct_add (dest, line_size, block);
481
29a7e17d19dd optimizing MPV_decode_mb
michaelni
parents: 478
diff changeset
1630 }
29a7e17d19dd optimizing MPV_decode_mb
michaelni
parents: 478
diff changeset
1631 }
29a7e17d19dd optimizing MPV_decode_mb
michaelni
parents: 478
diff changeset
1632
29a7e17d19dd optimizing MPV_decode_mb
michaelni
parents: 478
diff changeset
1633 static inline void add_dequant_dct(MpegEncContext *s,
29a7e17d19dd optimizing MPV_decode_mb
michaelni
parents: 478
diff changeset
1634 DCTELEM *block, int i, UINT8 *dest, int line_size)
29a7e17d19dd optimizing MPV_decode_mb
michaelni
parents: 478
diff changeset
1635 {
29a7e17d19dd optimizing MPV_decode_mb
michaelni
parents: 478
diff changeset
1636 if (s->block_last_index[i] >= 0) {
29a7e17d19dd optimizing MPV_decode_mb
michaelni
parents: 478
diff changeset
1637 s->dct_unquantize(s, block, i, s->qscale);
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
1638
706
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 704
diff changeset
1639 s->idct_add (dest, line_size, block);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1640 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
1641 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
1642
456
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
1643 /**
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
1644 * cleans dc, ac, coded_block for the current non intra MB
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
1645 */
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
1646 void ff_clean_intra_table_entries(MpegEncContext *s)
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
1647 {
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
1648 int wrap = s->block_wrap[0];
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
1649 int xy = s->block_index[0];
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
1650
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
1651 s->dc_val[0][xy ] =
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
1652 s->dc_val[0][xy + 1 ] =
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
1653 s->dc_val[0][xy + wrap] =
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
1654 s->dc_val[0][xy + 1 + wrap] = 1024;
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
1655 /* ac pred */
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
1656 memset(s->ac_val[0][xy ], 0, 32 * sizeof(INT16));
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
1657 memset(s->ac_val[0][xy + wrap], 0, 32 * sizeof(INT16));
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
1658 if (s->msmpeg4_version>=3) {
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
1659 s->coded_block[xy ] =
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
1660 s->coded_block[xy + 1 ] =
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
1661 s->coded_block[xy + wrap] =
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
1662 s->coded_block[xy + 1 + wrap] = 0;
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
1663 }
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
1664 /* chroma */
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
1665 wrap = s->block_wrap[4];
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
1666 xy = s->mb_x + 1 + (s->mb_y + 1) * wrap;
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
1667 s->dc_val[1][xy] =
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
1668 s->dc_val[2][xy] = 1024;
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
1669 /* ac pred */
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
1670 memset(s->ac_val[1][xy], 0, 16 * sizeof(INT16));
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
1671 memset(s->ac_val[2][xy], 0, 16 * sizeof(INT16));
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
1672
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
1673 s->mbintra_table[s->mb_x + s->mb_y*s->mb_width]= 0;
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
1674 }
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
1675
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1676 /* generic function called after a macroblock has been parsed by the
986e461dc072 Initial revision
glantau
parents:
diff changeset
1677 decoder or after it has been encoded by the encoder.
986e461dc072 Initial revision
glantau
parents:
diff changeset
1678
986e461dc072 Initial revision
glantau
parents:
diff changeset
1679 Important variables used:
986e461dc072 Initial revision
glantau
parents:
diff changeset
1680 s->mb_intra : true if intra macroblock
986e461dc072 Initial revision
glantau
parents:
diff changeset
1681 s->mv_dir : motion vector direction
986e461dc072 Initial revision
glantau
parents:
diff changeset
1682 s->mv_type : motion vector type
986e461dc072 Initial revision
glantau
parents:
diff changeset
1683 s->mv : motion vector
986e461dc072 Initial revision
glantau
parents:
diff changeset
1684 s->interlaced_dct : true if interlaced dct used (mpeg2)
986e461dc072 Initial revision
glantau
parents:
diff changeset
1685 */
986e461dc072 Initial revision
glantau
parents:
diff changeset
1686 void MPV_decode_mb(MpegEncContext *s, DCTELEM block[6][64])
986e461dc072 Initial revision
glantau
parents:
diff changeset
1687 {
244
3860331a1ecb * eliminating duplicated code from MPV_common_end
kabi
parents: 239
diff changeset
1688 int mb_x, mb_y;
481
29a7e17d19dd optimizing MPV_decode_mb
michaelni
parents: 478
diff changeset
1689 const int mb_xy = s->mb_y * s->mb_width + s->mb_x;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1690
986e461dc072 Initial revision
glantau
parents:
diff changeset
1691 mb_x = s->mb_x;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1692 mb_y = s->mb_y;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1693
108
1e4a4af694d1 exporting qscale data for postprocessing (for MPlayer)
arpi_esp
parents: 79
diff changeset
1694 #ifdef FF_POSTPROCESS
466
805714c0c10f new field for communicating with external postprocessing
nickols_k
parents: 462
diff changeset
1695 /* Obsolete. Exists for compatibility with mplayer only. */
108
1e4a4af694d1 exporting qscale data for postprocessing (for MPlayer)
arpi_esp
parents: 79
diff changeset
1696 quant_store[mb_y][mb_x]=s->qscale;
1e4a4af694d1 exporting qscale data for postprocessing (for MPlayer)
arpi_esp
parents: 79
diff changeset
1697 //printf("[%02d][%02d] %d\n",mb_x,mb_y,s->qscale);
466
805714c0c10f new field for communicating with external postprocessing
nickols_k
parents: 462
diff changeset
1698 #else
575
23eee7d73c4b minor optimizations
michaelni
parents: 570
diff changeset
1699 /* even more obsolete, exists for mplayer xp only */
467
ad65941c8eb5 use qstride instead of fixed constants
nickols_k
parents: 466
diff changeset
1700 if(s->avctx->quant_store) s->avctx->quant_store[mb_y*s->avctx->qstride+mb_x] = s->qscale;
108
1e4a4af694d1 exporting qscale data for postprocessing (for MPlayer)
arpi_esp
parents: 79
diff changeset
1701 #endif
575
23eee7d73c4b minor optimizations
michaelni
parents: 570
diff changeset
1702 s->qscale_table[mb_xy]= s->qscale;
108
1e4a4af694d1 exporting qscale data for postprocessing (for MPlayer)
arpi_esp
parents: 79
diff changeset
1703
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1704 /* update DC predictors for P macroblocks */
986e461dc072 Initial revision
glantau
parents:
diff changeset
1705 if (!s->mb_intra) {
249
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
1706 if (s->h263_pred || s->h263_aic) {
481
29a7e17d19dd optimizing MPV_decode_mb
michaelni
parents: 478
diff changeset
1707 if(s->mbintra_table[mb_xy])
456
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
1708 ff_clean_intra_table_entries(s);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1709 } else {
456
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
1710 s->last_dc[0] =
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
1711 s->last_dc[1] =
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1712 s->last_dc[2] = 128 << s->intra_dc_precision;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1713 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
1714 }
249
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
1715 else if (s->h263_pred || s->h263_aic)
481
29a7e17d19dd optimizing MPV_decode_mb
michaelni
parents: 478
diff changeset
1716 s->mbintra_table[mb_xy]=1;
191
883f184537e6 AC table reset (memset) optimization - patch by Michael Niedermayer <michaelni@gmx.at>
uid46427
parents: 189
diff changeset
1717
280
3dc1ca4ba717 fixing epzs & mpeg1 (hopefully now really ...)
michaelni
parents: 279
diff changeset
1718 /* update motion predictor, not for B-frames as they need the motion_val from the last P/S-Frame */
481
29a7e17d19dd optimizing MPV_decode_mb
michaelni
parents: 478
diff changeset
1719 if (s->out_format == FMT_H263 && s->pict_type!=B_TYPE) { //FIXME move into h263.c if possible, format specific stuff shouldnt be here
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1720
481
29a7e17d19dd optimizing MPV_decode_mb
michaelni
parents: 478
diff changeset
1721 const int wrap = s->block_wrap[0];
29a7e17d19dd optimizing MPV_decode_mb
michaelni
parents: 478
diff changeset
1722 const int xy = s->block_index[0];
664
00a882f626bd interlaced mpeg4 b frame decoding
michaelni
parents: 661
diff changeset
1723 const int mb_index= s->mb_x + s->mb_y*s->mb_width;
619
2be2cc8fd0a1 mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents: 618
diff changeset
1724 if(s->mv_type == MV_TYPE_8X8){
664
00a882f626bd interlaced mpeg4 b frame decoding
michaelni
parents: 661
diff changeset
1725 s->co_located_type_table[mb_index]= CO_LOCATED_TYPE_4MV;
619
2be2cc8fd0a1 mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents: 618
diff changeset
1726 } else {
2be2cc8fd0a1 mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents: 618
diff changeset
1727 int motion_x, motion_y;
2be2cc8fd0a1 mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents: 618
diff changeset
1728 if (s->mb_intra) {
2be2cc8fd0a1 mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents: 618
diff changeset
1729 motion_x = 0;
2be2cc8fd0a1 mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents: 618
diff changeset
1730 motion_y = 0;
664
00a882f626bd interlaced mpeg4 b frame decoding
michaelni
parents: 661
diff changeset
1731 if(s->co_located_type_table)
00a882f626bd interlaced mpeg4 b frame decoding
michaelni
parents: 661
diff changeset
1732 s->co_located_type_table[mb_index]= 0;
619
2be2cc8fd0a1 mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents: 618
diff changeset
1733 } else if (s->mv_type == MV_TYPE_16X16) {
2be2cc8fd0a1 mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents: 618
diff changeset
1734 motion_x = s->mv[0][0][0];
2be2cc8fd0a1 mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents: 618
diff changeset
1735 motion_y = s->mv[0][0][1];
664
00a882f626bd interlaced mpeg4 b frame decoding
michaelni
parents: 661
diff changeset
1736 if(s->co_located_type_table)
00a882f626bd interlaced mpeg4 b frame decoding
michaelni
parents: 661
diff changeset
1737 s->co_located_type_table[mb_index]= 0;
619
2be2cc8fd0a1 mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents: 618
diff changeset
1738 } else /*if (s->mv_type == MV_TYPE_FIELD)*/ {
664
00a882f626bd interlaced mpeg4 b frame decoding
michaelni
parents: 661
diff changeset
1739 int i;
619
2be2cc8fd0a1 mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents: 618
diff changeset
1740 motion_x = s->mv[0][0][0] + s->mv[0][1][0];
2be2cc8fd0a1 mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents: 618
diff changeset
1741 motion_y = s->mv[0][0][1] + s->mv[0][1][1];
2be2cc8fd0a1 mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents: 618
diff changeset
1742 motion_x = (motion_x>>1) | (motion_x&1);
664
00a882f626bd interlaced mpeg4 b frame decoding
michaelni
parents: 661
diff changeset
1743 for(i=0; i<2; i++){
00a882f626bd interlaced mpeg4 b frame decoding
michaelni
parents: 661
diff changeset
1744 s->field_mv_table[mb_index][i][0]= s->mv[0][i][0];
00a882f626bd interlaced mpeg4 b frame decoding
michaelni
parents: 661
diff changeset
1745 s->field_mv_table[mb_index][i][1]= s->mv[0][i][1];
00a882f626bd interlaced mpeg4 b frame decoding
michaelni
parents: 661
diff changeset
1746 s->field_select_table[mb_index][i]= s->field_select[0][i];
00a882f626bd interlaced mpeg4 b frame decoding
michaelni
parents: 661
diff changeset
1747 }
00a882f626bd interlaced mpeg4 b frame decoding
michaelni
parents: 661
diff changeset
1748 s->co_located_type_table[mb_index]= CO_LOCATED_TYPE_FIELDMV;
619
2be2cc8fd0a1 mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents: 618
diff changeset
1749 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1750 /* no update if 8X8 because it has been done during parsing */
244
3860331a1ecb * eliminating duplicated code from MPV_common_end
kabi
parents: 239
diff changeset
1751 s->motion_val[xy][0] = motion_x;
3860331a1ecb * eliminating duplicated code from MPV_common_end
kabi
parents: 239
diff changeset
1752 s->motion_val[xy][1] = motion_y;
3860331a1ecb * eliminating duplicated code from MPV_common_end
kabi
parents: 239
diff changeset
1753 s->motion_val[xy + 1][0] = motion_x;
3860331a1ecb * eliminating duplicated code from MPV_common_end
kabi
parents: 239
diff changeset
1754 s->motion_val[xy + 1][1] = motion_y;
3860331a1ecb * eliminating duplicated code from MPV_common_end
kabi
parents: 239
diff changeset
1755 s->motion_val[xy + wrap][0] = motion_x;
3860331a1ecb * eliminating duplicated code from MPV_common_end
kabi
parents: 239
diff changeset
1756 s->motion_val[xy + wrap][1] = motion_y;
3860331a1ecb * eliminating duplicated code from MPV_common_end
kabi
parents: 239
diff changeset
1757 s->motion_val[xy + 1 + wrap][0] = motion_x;
3860331a1ecb * eliminating duplicated code from MPV_common_end
kabi
parents: 239
diff changeset
1758 s->motion_val[xy + 1 + wrap][1] = motion_y;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1759 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
1760 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
1761
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
1762 if (!(s->encoding && (s->intra_only || s->pict_type==B_TYPE))) {
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1763 UINT8 *dest_y, *dest_cb, *dest_cr;
481
29a7e17d19dd optimizing MPV_decode_mb
michaelni
parents: 478
diff changeset
1764 int dct_linesize, dct_offset;
651
45e8f39fda50 put/avg_pixels16
michaelni
parents: 650
diff changeset
1765 op_pixels_func (*op_pix)[4];
45e8f39fda50 put/avg_pixels16
michaelni
parents: 650
diff changeset
1766 qpel_mc_func (*op_qpix)[16];
7
1d3ac9654178 added skip macroblock optimization (big perf win on black regions for example)
glantau
parents: 0
diff changeset
1767
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
1768 /* avoid copy if macroblock skipped in last frame too
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
1769 dont touch it for B-frames as they need the skip info from the next p-frame */
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
1770 if (s->pict_type != B_TYPE) {
481
29a7e17d19dd optimizing MPV_decode_mb
michaelni
parents: 478
diff changeset
1771 UINT8 *mbskip_ptr = &s->mbskip_table[mb_xy];
7
1d3ac9654178 added skip macroblock optimization (big perf win on black regions for example)
glantau
parents: 0
diff changeset
1772 if (s->mb_skiped) {
1d3ac9654178 added skip macroblock optimization (big perf win on black regions for example)
glantau
parents: 0
diff changeset
1773 s->mb_skiped = 0;
556
762c67fd4078 uvlinesize
michaelni
parents: 554
diff changeset
1774
762c67fd4078 uvlinesize
michaelni
parents: 554
diff changeset
1775 (*mbskip_ptr) ++; /* indicate that this time we skiped it */
762c67fd4078 uvlinesize
michaelni
parents: 554
diff changeset
1776 if(*mbskip_ptr >99) *mbskip_ptr= 99;
762c67fd4078 uvlinesize
michaelni
parents: 554
diff changeset
1777
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
1778 /* if previous was skipped too, then nothing to do !
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
1779 skip only during decoding as we might trash the buffers during encoding a bit */
556
762c67fd4078 uvlinesize
michaelni
parents: 554
diff changeset
1780 if (*mbskip_ptr >= s->ip_buffer_count && !s->encoding)
7
1d3ac9654178 added skip macroblock optimization (big perf win on black regions for example)
glantau
parents: 0
diff changeset
1781 goto the_end;
1d3ac9654178 added skip macroblock optimization (big perf win on black regions for example)
glantau
parents: 0
diff changeset
1782 } else {
1d3ac9654178 added skip macroblock optimization (big perf win on black regions for example)
glantau
parents: 0
diff changeset
1783 *mbskip_ptr = 0; /* not skipped */
1d3ac9654178 added skip macroblock optimization (big perf win on black regions for example)
glantau
parents: 0
diff changeset
1784 }
1d3ac9654178 added skip macroblock optimization (big perf win on black regions for example)
glantau
parents: 0
diff changeset
1785 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1786
717
6cba3b6196f0 optimization
michaelni
parents: 711
diff changeset
1787 if(s->pict_type==B_TYPE && s->avctx->draw_horiz_band){
6cba3b6196f0 optimization
michaelni
parents: 711
diff changeset
1788 dest_y = s->current_picture [0] + mb_x * 16;
6cba3b6196f0 optimization
michaelni
parents: 711
diff changeset
1789 dest_cb = s->current_picture[1] + mb_x * 8;
6cba3b6196f0 optimization
michaelni
parents: 711
diff changeset
1790 dest_cr = s->current_picture[2] + mb_x * 8;
6cba3b6196f0 optimization
michaelni
parents: 711
diff changeset
1791 }else{
6cba3b6196f0 optimization
michaelni
parents: 711
diff changeset
1792 dest_y = s->current_picture [0] + (mb_y * 16* s->linesize ) + mb_x * 16;
6cba3b6196f0 optimization
michaelni
parents: 711
diff changeset
1793 dest_cb = s->current_picture[1] + (mb_y * 8 * s->uvlinesize) + mb_x * 8;
6cba3b6196f0 optimization
michaelni
parents: 711
diff changeset
1794 dest_cr = s->current_picture[2] + (mb_y * 8 * s->uvlinesize) + mb_x * 8;
6cba3b6196f0 optimization
michaelni
parents: 711
diff changeset
1795 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1796
986e461dc072 Initial revision
glantau
parents:
diff changeset
1797 if (s->interlaced_dct) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
1798 dct_linesize = s->linesize * 2;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1799 dct_offset = s->linesize;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1800 } else {
986e461dc072 Initial revision
glantau
parents:
diff changeset
1801 dct_linesize = s->linesize;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1802 dct_offset = s->linesize * 8;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1803 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
1804
986e461dc072 Initial revision
glantau
parents:
diff changeset
1805 if (!s->mb_intra) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
1806 /* motion handling */
456
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
1807 /* decoding or more than one mb_type (MC was allready done otherwise) */
481
29a7e17d19dd optimizing MPV_decode_mb
michaelni
parents: 478
diff changeset
1808 if((!s->encoding) || (s->mb_type[mb_xy]&(s->mb_type[mb_xy]-1))){
327
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 326
diff changeset
1809 if ((!s->no_rounding) || s->pict_type==B_TYPE){
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
1810 op_pix = put_pixels_tab;
651
45e8f39fda50 put/avg_pixels16
michaelni
parents: 650
diff changeset
1811 op_qpix= put_qpel_pixels_tab;
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
1812 }else{
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
1813 op_pix = put_no_rnd_pixels_tab;
651
45e8f39fda50 put/avg_pixels16
michaelni
parents: 650
diff changeset
1814 op_qpix= put_no_rnd_qpel_pixels_tab;
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
1815 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1816
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
1817 if (s->mv_dir & MV_DIR_FORWARD) {
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
1818 MPV_motion(s, dest_y, dest_cb, dest_cr, 0, s->last_picture, op_pix, op_qpix);
651
45e8f39fda50 put/avg_pixels16
michaelni
parents: 650
diff changeset
1819 op_pix = avg_pixels_tab;
45e8f39fda50 put/avg_pixels16
michaelni
parents: 650
diff changeset
1820 op_qpix= avg_qpel_pixels_tab;
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
1821 }
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
1822 if (s->mv_dir & MV_DIR_BACKWARD) {
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
1823 MPV_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_picture, op_pix, op_qpix);
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
1824 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1825 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
1826
481
29a7e17d19dd optimizing MPV_decode_mb
michaelni
parents: 478
diff changeset
1827 /* skip dequant / idct if we are really late ;) */
29a7e17d19dd optimizing MPV_decode_mb
michaelni
parents: 478
diff changeset
1828 if(s->hurry_up>1) goto the_end;
29a7e17d19dd optimizing MPV_decode_mb
michaelni
parents: 478
diff changeset
1829
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1830 /* add dct residue */
711
dcbcf9676c9f optimizing mpeg1_decode_block()
michaelni
parents: 709
diff changeset
1831 if(s->encoding || !( s->mpeg2 || s->h263_msmpeg4 || s->codec_id==CODEC_ID_MPEG1VIDEO
dcbcf9676c9f optimizing mpeg1_decode_block()
michaelni
parents: 709
diff changeset
1832 || (s->codec_id==CODEC_ID_MPEG4 && !s->mpeg_quant))){
481
29a7e17d19dd optimizing MPV_decode_mb
michaelni
parents: 478
diff changeset
1833 add_dequant_dct(s, block[0], 0, dest_y, dct_linesize);
29a7e17d19dd optimizing MPV_decode_mb
michaelni
parents: 478
diff changeset
1834 add_dequant_dct(s, block[1], 1, dest_y + 8, dct_linesize);
29a7e17d19dd optimizing MPV_decode_mb
michaelni
parents: 478
diff changeset
1835 add_dequant_dct(s, block[2], 2, dest_y + dct_offset, dct_linesize);
29a7e17d19dd optimizing MPV_decode_mb
michaelni
parents: 478
diff changeset
1836 add_dequant_dct(s, block[3], 3, dest_y + dct_offset + 8, dct_linesize);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1837
485
20108840b0e5 grayscale only decoding
michaelni
parents: 481
diff changeset
1838 if(!(s->flags&CODEC_FLAG_GRAY)){
556
762c67fd4078 uvlinesize
michaelni
parents: 554
diff changeset
1839 add_dequant_dct(s, block[4], 4, dest_cb, s->uvlinesize);
762c67fd4078 uvlinesize
michaelni
parents: 554
diff changeset
1840 add_dequant_dct(s, block[5], 5, dest_cr, s->uvlinesize);
485
20108840b0e5 grayscale only decoding
michaelni
parents: 481
diff changeset
1841 }
481
29a7e17d19dd optimizing MPV_decode_mb
michaelni
parents: 478
diff changeset
1842 } else {
29a7e17d19dd optimizing MPV_decode_mb
michaelni
parents: 478
diff changeset
1843 add_dct(s, block[0], 0, dest_y, dct_linesize);
29a7e17d19dd optimizing MPV_decode_mb
michaelni
parents: 478
diff changeset
1844 add_dct(s, block[1], 1, dest_y + 8, dct_linesize);
29a7e17d19dd optimizing MPV_decode_mb
michaelni
parents: 478
diff changeset
1845 add_dct(s, block[2], 2, dest_y + dct_offset, dct_linesize);
29a7e17d19dd optimizing MPV_decode_mb
michaelni
parents: 478
diff changeset
1846 add_dct(s, block[3], 3, dest_y + dct_offset + 8, dct_linesize);
29a7e17d19dd optimizing MPV_decode_mb
michaelni
parents: 478
diff changeset
1847
485
20108840b0e5 grayscale only decoding
michaelni
parents: 481
diff changeset
1848 if(!(s->flags&CODEC_FLAG_GRAY)){
556
762c67fd4078 uvlinesize
michaelni
parents: 554
diff changeset
1849 add_dct(s, block[4], 4, dest_cb, s->uvlinesize);
762c67fd4078 uvlinesize
michaelni
parents: 554
diff changeset
1850 add_dct(s, block[5], 5, dest_cr, s->uvlinesize);
485
20108840b0e5 grayscale only decoding
michaelni
parents: 481
diff changeset
1851 }
481
29a7e17d19dd optimizing MPV_decode_mb
michaelni
parents: 478
diff changeset
1852 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1853 } else {
986e461dc072 Initial revision
glantau
parents:
diff changeset
1854 /* dct only in intra block */
711
dcbcf9676c9f optimizing mpeg1_decode_block()
michaelni
parents: 709
diff changeset
1855 if(s->encoding || !(s->mpeg2 || s->codec_id==CODEC_ID_MPEG1VIDEO)){
dcbcf9676c9f optimizing mpeg1_decode_block()
michaelni
parents: 709
diff changeset
1856 put_dct(s, block[0], 0, dest_y, dct_linesize);
dcbcf9676c9f optimizing mpeg1_decode_block()
michaelni
parents: 709
diff changeset
1857 put_dct(s, block[1], 1, dest_y + 8, dct_linesize);
dcbcf9676c9f optimizing mpeg1_decode_block()
michaelni
parents: 709
diff changeset
1858 put_dct(s, block[2], 2, dest_y + dct_offset, dct_linesize);
dcbcf9676c9f optimizing mpeg1_decode_block()
michaelni
parents: 709
diff changeset
1859 put_dct(s, block[3], 3, dest_y + dct_offset + 8, dct_linesize);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1860
711
dcbcf9676c9f optimizing mpeg1_decode_block()
michaelni
parents: 709
diff changeset
1861 if(!(s->flags&CODEC_FLAG_GRAY)){
dcbcf9676c9f optimizing mpeg1_decode_block()
michaelni
parents: 709
diff changeset
1862 put_dct(s, block[4], 4, dest_cb, s->uvlinesize);
dcbcf9676c9f optimizing mpeg1_decode_block()
michaelni
parents: 709
diff changeset
1863 put_dct(s, block[5], 5, dest_cr, s->uvlinesize);
dcbcf9676c9f optimizing mpeg1_decode_block()
michaelni
parents: 709
diff changeset
1864 }
dcbcf9676c9f optimizing mpeg1_decode_block()
michaelni
parents: 709
diff changeset
1865 }else{
dcbcf9676c9f optimizing mpeg1_decode_block()
michaelni
parents: 709
diff changeset
1866 s->idct_put(dest_y , dct_linesize, block[0]);
dcbcf9676c9f optimizing mpeg1_decode_block()
michaelni
parents: 709
diff changeset
1867 s->idct_put(dest_y + 8, dct_linesize, block[1]);
dcbcf9676c9f optimizing mpeg1_decode_block()
michaelni
parents: 709
diff changeset
1868 s->idct_put(dest_y + dct_offset , dct_linesize, block[2]);
dcbcf9676c9f optimizing mpeg1_decode_block()
michaelni
parents: 709
diff changeset
1869 s->idct_put(dest_y + dct_offset + 8, dct_linesize, block[3]);
dcbcf9676c9f optimizing mpeg1_decode_block()
michaelni
parents: 709
diff changeset
1870
dcbcf9676c9f optimizing mpeg1_decode_block()
michaelni
parents: 709
diff changeset
1871 if(!(s->flags&CODEC_FLAG_GRAY)){
dcbcf9676c9f optimizing mpeg1_decode_block()
michaelni
parents: 709
diff changeset
1872 s->idct_put(dest_cb, s->uvlinesize, block[4]);
dcbcf9676c9f optimizing mpeg1_decode_block()
michaelni
parents: 709
diff changeset
1873 s->idct_put(dest_cr, s->uvlinesize, block[5]);
dcbcf9676c9f optimizing mpeg1_decode_block()
michaelni
parents: 709
diff changeset
1874 }
485
20108840b0e5 grayscale only decoding
michaelni
parents: 481
diff changeset
1875 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1876 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
1877 }
7
1d3ac9654178 added skip macroblock optimization (big perf win on black regions for example)
glantau
parents: 0
diff changeset
1878 the_end:
294
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 292
diff changeset
1879 emms_c(); //FIXME remove
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 292
diff changeset
1880 }
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 292
diff changeset
1881
605
40874804a5af same dc skip behavior for chroma & luma elimination, its confusing otherwise imho
michaelni
parents: 604
diff changeset
1882 static inline void dct_single_coeff_elimination(MpegEncContext *s, int n, int threshold)
456
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
1883 {
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
1884 static const char tab[64]=
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
1885 {3,2,2,1,1,1,1,1,
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
1886 1,1,1,1,1,1,1,1,
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
1887 1,1,1,1,1,1,1,1,
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
1888 0,0,0,0,0,0,0,0,
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
1889 0,0,0,0,0,0,0,0,
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
1890 0,0,0,0,0,0,0,0,
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
1891 0,0,0,0,0,0,0,0,
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
1892 0,0,0,0,0,0,0,0};
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
1893 int score=0;
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
1894 int run=0;
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
1895 int i;
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
1896 DCTELEM *block= s->block[n];
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
1897 const int last_index= s->block_last_index[n];
605
40874804a5af same dc skip behavior for chroma & luma elimination, its confusing otherwise imho
michaelni
parents: 604
diff changeset
1898 int skip_dc;
456
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
1899
604
4344cc8033bd skip blocks with small chroma dc too (if the user wants it) needed to avoid IDCT(input coeffs !=0) == 0 problems which cause catastrophic error accumulation at qp=1
michaelni
parents: 599
diff changeset
1900 if(threshold<0){
4344cc8033bd skip blocks with small chroma dc too (if the user wants it) needed to avoid IDCT(input coeffs !=0) == 0 problems which cause catastrophic error accumulation at qp=1
michaelni
parents: 599
diff changeset
1901 skip_dc=0;
4344cc8033bd skip blocks with small chroma dc too (if the user wants it) needed to avoid IDCT(input coeffs !=0) == 0 problems which cause catastrophic error accumulation at qp=1
michaelni
parents: 599
diff changeset
1902 threshold= -threshold;
605
40874804a5af same dc skip behavior for chroma & luma elimination, its confusing otherwise imho
michaelni
parents: 604
diff changeset
1903 }else
40874804a5af same dc skip behavior for chroma & luma elimination, its confusing otherwise imho
michaelni
parents: 604
diff changeset
1904 skip_dc=1;
604
4344cc8033bd skip blocks with small chroma dc too (if the user wants it) needed to avoid IDCT(input coeffs !=0) == 0 problems which cause catastrophic error accumulation at qp=1
michaelni
parents: 599
diff changeset
1905
456
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
1906 /* are all which we could set to zero are allready zero? */
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
1907 if(last_index<=skip_dc - 1) return;
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
1908
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
1909 for(i=0; i<=last_index; i++){
706
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 704
diff changeset
1910 const int j = s->intra_scantable.permutated[i];
456
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
1911 const int level = ABS(block[j]);
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
1912 if(level==1){
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
1913 if(skip_dc && i==0) continue;
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
1914 score+= tab[run];
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
1915 run=0;
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
1916 }else if(level>1){
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
1917 return;
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
1918 }else{
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
1919 run++;
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
1920 }
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
1921 }
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
1922 if(score >= threshold) return;
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
1923 for(i=skip_dc; i<=last_index; i++){
706
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 704
diff changeset
1924 const int j = s->intra_scantable.permutated[i];
456
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
1925 block[j]=0;
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
1926 }
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
1927 if(block[0]) s->block_last_index[n]= 0;
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
1928 else s->block_last_index[n]= -1;
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
1929 }
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
1930
344
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
1931 static inline void clip_coeffs(MpegEncContext *s, DCTELEM *block, int last_index)
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
1932 {
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
1933 int i;
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
1934 const int maxlevel= s->max_qcoeff;
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
1935 const int minlevel= s->min_qcoeff;
706
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 704
diff changeset
1936
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 704
diff changeset
1937 if(s->mb_intra){
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 704
diff changeset
1938 i=1; //skip clipping of intra dc
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 704
diff changeset
1939 }else
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 704
diff changeset
1940 i=0;
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 704
diff changeset
1941
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 704
diff changeset
1942 for(;i<=last_index; i++){
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 704
diff changeset
1943 const int j= s->intra_scantable.permutated[i];
344
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
1944 int level = block[j];
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
1945
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
1946 if (level>maxlevel) level=maxlevel;
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
1947 else if(level<minlevel) level=minlevel;
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
1948 block[j]= level;
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
1949 }
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
1950 }
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
1951
697
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
1952 static inline void requantize_coeffs(MpegEncContext *s, DCTELEM block[64], int oldq, int newq, int n)
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
1953 {
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
1954 int i;
706
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 704
diff changeset
1955
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 704
diff changeset
1956 if(s->mb_intra){
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 704
diff changeset
1957 i=1; //skip clipping of intra dc
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 704
diff changeset
1958 //FIXME requantize, note (mpeg1/h263/h263p-aic dont need it,...)
697
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
1959 }else
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
1960 i=0;
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
1961
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
1962 for(;i<=s->block_last_index[n]; i++){
706
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 704
diff changeset
1963 const int j = s->intra_scantable.permutated[i];
697
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
1964 int level = block[j];
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
1965
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
1966 block[j]= ROUNDED_DIV(level*oldq, newq);
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
1967 }
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
1968
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
1969 for(i=s->block_last_index[n]; i>=0; i--){
706
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 704
diff changeset
1970 const int j = s->intra_scantable.permutated[i];
697
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
1971 if(block[j]) break;
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
1972 }
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
1973 s->block_last_index[n]= i;
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
1974 }
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
1975
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
1976 static inline void auto_requantize_coeffs(MpegEncContext *s, DCTELEM block[6][64])
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
1977 {
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
1978 int i,n, newq;
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
1979 const int maxlevel= s->max_qcoeff;
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
1980 const int minlevel= s->min_qcoeff;
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
1981 int largest=0, smallest=0;
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
1982
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
1983 assert(s->adaptive_quant);
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
1984
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
1985 for(n=0; n<6; n++){
706
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 704
diff changeset
1986 if(s->mb_intra){
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 704
diff changeset
1987 i=1; //skip clipping of intra dc
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 704
diff changeset
1988 //FIXME requantize, note (mpeg1/h263/h263p-aic dont need it,...)
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 704
diff changeset
1989 }else
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 704
diff changeset
1990 i=0;
697
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
1991
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
1992 for(;i<=s->block_last_index[n]; i++){
706
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 704
diff changeset
1993 const int j = s->intra_scantable.permutated[i];
697
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
1994 int level = block[n][j];
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
1995 if(largest < level) largest = level;
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
1996 if(smallest > level) smallest= level;
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
1997 }
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
1998 }
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
1999
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2000 for(newq=s->qscale+1; newq<32; newq++){
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2001 if( ROUNDED_DIV(smallest*s->qscale, newq) >= minlevel
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2002 && ROUNDED_DIV(largest *s->qscale, newq) <= maxlevel)
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2003 break;
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2004 }
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2005
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2006 if(s->out_format==FMT_H263){
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2007 /* h263 like formats cannot change qscale by more than 2 easiely */
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2008 if(s->avctx->qmin + 2 < newq)
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2009 newq= s->avctx->qmin + 2;
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2010 }
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2011
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2012 for(n=0; n<6; n++){
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2013 requantize_coeffs(s, block[n], s->qscale, newq, n);
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2014 clip_coeffs(s, block[n], s->block_last_index[n]);
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2015 }
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2016
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2017 s->dquant+= newq - s->qscale;
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2018 s->qscale= newq;
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2019 }
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2020 #if 0
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2021 static int pix_vcmp16x8(UINT8 *s, int stride){ //FIXME move to dsputil & optimize
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2022 int score=0;
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2023 int x,y;
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2024
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2025 for(y=0; y<7; y++){
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2026 for(x=0; x<16; x+=4){
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2027 score+= ABS(s[x ] - s[x +stride]) + ABS(s[x+1] - s[x+1+stride])
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2028 +ABS(s[x+2] - s[x+2+stride]) + ABS(s[x+3] - s[x+3+stride]);
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2029 }
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2030 s+= stride;
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2031 }
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2032
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2033 return score;
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2034 }
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2035
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2036 static int pix_diff_vcmp16x8(UINT8 *s1, UINT8*s2, int stride){ //FIXME move to dsputil & optimize
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2037 int score=0;
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2038 int x,y;
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2039
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2040 for(y=0; y<7; y++){
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2041 for(x=0; x<16; x++){
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2042 score+= ABS(s1[x ] - s2[x ] - s1[x +stride] + s2[x +stride]);
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2043 }
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2044 s1+= stride;
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2045 s2+= stride;
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2046 }
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2047
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2048 return score;
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2049 }
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2050 #else
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2051 #define SQ(a) ((a)*(a))
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2052
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2053 static int pix_vcmp16x8(UINT8 *s, int stride){ //FIXME move to dsputil & optimize
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2054 int score=0;
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2055 int x,y;
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2056
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2057 for(y=0; y<7; y++){
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2058 for(x=0; x<16; x+=4){
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2059 score+= SQ(s[x ] - s[x +stride]) + SQ(s[x+1] - s[x+1+stride])
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2060 +SQ(s[x+2] - s[x+2+stride]) + SQ(s[x+3] - s[x+3+stride]);
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2061 }
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2062 s+= stride;
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2063 }
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2064
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2065 return score;
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2066 }
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2067
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2068 static int pix_diff_vcmp16x8(UINT8 *s1, UINT8*s2, int stride){ //FIXME move to dsputil & optimize
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2069 int score=0;
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2070 int x,y;
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2071
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2072 for(y=0; y<7; y++){
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2073 for(x=0; x<16; x++){
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2074 score+= SQ(s1[x ] - s2[x ] - s1[x +stride] + s2[x +stride]);
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2075 }
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2076 s1+= stride;
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2077 s2+= stride;
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2078 }
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2079
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2080 return score;
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2081 }
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2082
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2083 #endif
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 731
diff changeset
2084
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 731
diff changeset
2085 void ff_draw_horiz_band(MpegEncContext *s){
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 731
diff changeset
2086 if ( s->avctx->draw_horiz_band
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 731
diff changeset
2087 && (s->num_available_buffers>=1 || (!s->has_b_frames)) ) {
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 731
diff changeset
2088 UINT8 *src_ptr[3];
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 731
diff changeset
2089 int y, h, offset;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 731
diff changeset
2090 y = s->mb_y * 16;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 731
diff changeset
2091 h = s->height - y;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 731
diff changeset
2092 if (h > 16)
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 731
diff changeset
2093 h = 16;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 731
diff changeset
2094
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 731
diff changeset
2095 if(s->pict_type==B_TYPE)
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 731
diff changeset
2096 offset = 0;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 731
diff changeset
2097 else
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 731
diff changeset
2098 offset = y * s->linesize;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 731
diff changeset
2099
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 731
diff changeset
2100 if(s->pict_type==B_TYPE || (!s->has_b_frames)){
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 731
diff changeset
2101 src_ptr[0] = s->current_picture[0] + offset;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 731
diff changeset
2102 src_ptr[1] = s->current_picture[1] + (offset >> 2);
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 731
diff changeset
2103 src_ptr[2] = s->current_picture[2] + (offset >> 2);
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 731
diff changeset
2104 } else {
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 731
diff changeset
2105 src_ptr[0] = s->last_picture[0] + offset;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 731
diff changeset
2106 src_ptr[1] = s->last_picture[1] + (offset >> 2);
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 731
diff changeset
2107 src_ptr[2] = s->last_picture[2] + (offset >> 2);
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 731
diff changeset
2108 }
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 731
diff changeset
2109 s->avctx->draw_horiz_band(s->avctx, src_ptr, s->linesize,
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 731
diff changeset
2110 y, s->width, h);
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 731
diff changeset
2111 }
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 731
diff changeset
2112 }
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 731
diff changeset
2113
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
2114 static void encode_mb(MpegEncContext *s, int motion_x, int motion_y)
294
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 292
diff changeset
2115 {
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 292
diff changeset
2116 const int mb_x= s->mb_x;
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 292
diff changeset
2117 const int mb_y= s->mb_y;
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 292
diff changeset
2118 int i;
456
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2119 int skip_dct[6];
697
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2120 int dct_offset = s->linesize*8; //default for progressive frames
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2121
456
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2122 for(i=0; i<6; i++) skip_dct[i]=0;
690
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 673
diff changeset
2123
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 673
diff changeset
2124 if(s->adaptive_quant){
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 673
diff changeset
2125 s->dquant= s->qscale_table[mb_x + mb_y*s->mb_width] - s->qscale;
697
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2126
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2127 if(s->out_format==FMT_H263){
690
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 673
diff changeset
2128 if (s->dquant> 2) s->dquant= 2;
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 673
diff changeset
2129 else if(s->dquant<-2) s->dquant=-2;
697
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2130 }
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2131
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2132 if(s->codec_id==CODEC_ID_MPEG4){
690
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 673
diff changeset
2133 if(!s->mb_intra){
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 673
diff changeset
2134 assert(s->dquant==0 || s->mv_type!=MV_TYPE_8X8);
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 673
diff changeset
2135
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 673
diff changeset
2136 if(s->mv_dir&MV_DIRECT)
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 673
diff changeset
2137 s->dquant=0;
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 673
diff changeset
2138 }
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 673
diff changeset
2139 }
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 673
diff changeset
2140 s->qscale+= s->dquant;
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 673
diff changeset
2141 s->y_dc_scale= s->y_dc_scale_table[ s->qscale ];
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 673
diff changeset
2142 s->c_dc_scale= s->c_dc_scale_table[ s->qscale ];
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 673
diff changeset
2143 }
294
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 292
diff changeset
2144
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
2145 if (s->mb_intra) {
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
2146 UINT8 *ptr;
697
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2147 int wrap_y;
570
274d9c5a75ee use edge emu for encoding of width or height %16!=0 files
michaelni
parents: 569
diff changeset
2148 int emu=0;
294
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 292
diff changeset
2149
697
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2150 wrap_y = s->linesize;
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2151 ptr = s->new_picture[0] + (mb_y * 16 * wrap_y) + mb_x * 16;
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2152
570
274d9c5a75ee use edge emu for encoding of width or height %16!=0 files
michaelni
parents: 569
diff changeset
2153 if(mb_x*16+16 > s->width || mb_y*16+16 > s->height){
697
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2154 emulated_edge_mc(s, ptr, wrap_y, 16, 16, mb_x*16, mb_y*16, s->width, s->height);
570
274d9c5a75ee use edge emu for encoding of width or height %16!=0 files
michaelni
parents: 569
diff changeset
2155 ptr= s->edge_emu_buffer;
274d9c5a75ee use edge emu for encoding of width or height %16!=0 files
michaelni
parents: 569
diff changeset
2156 emu=1;
274d9c5a75ee use edge emu for encoding of width or height %16!=0 files
michaelni
parents: 569
diff changeset
2157 }
697
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2158
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2159 if(s->flags&CODEC_FLAG_INTERLACED_DCT){
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2160 int progressive_score, interlaced_score;
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2161
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2162 progressive_score= pix_vcmp16x8(ptr, wrap_y ) + pix_vcmp16x8(ptr + wrap_y*8, wrap_y );
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2163 interlaced_score = pix_vcmp16x8(ptr, wrap_y*2) + pix_vcmp16x8(ptr + wrap_y , wrap_y*2);
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2164
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2165 if(progressive_score > interlaced_score + 100){
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2166 s->interlaced_dct=1;
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2167
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2168 dct_offset= wrap_y;
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2169 wrap_y<<=1;
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2170 }else
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2171 s->interlaced_dct=0;
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2172 }
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2173
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2174 get_pixels(s->block[0], ptr , wrap_y);
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2175 get_pixels(s->block[1], ptr + 8, wrap_y);
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2176 get_pixels(s->block[2], ptr + dct_offset , wrap_y);
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2177 get_pixels(s->block[3], ptr + dct_offset + 8, wrap_y);
294
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 292
diff changeset
2178
487
cee02f2f4a5a grayscale only encoding
michaelni
parents: 485
diff changeset
2179 if(s->flags&CODEC_FLAG_GRAY){
cee02f2f4a5a grayscale only encoding
michaelni
parents: 485
diff changeset
2180 skip_dct[4]= 1;
cee02f2f4a5a grayscale only encoding
michaelni
parents: 485
diff changeset
2181 skip_dct[5]= 1;
cee02f2f4a5a grayscale only encoding
michaelni
parents: 485
diff changeset
2182 }else{
697
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2183 int wrap_c = s->uvlinesize;
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2184 ptr = s->new_picture[1] + (mb_y * 8 * wrap_c) + mb_x * 8;
570
274d9c5a75ee use edge emu for encoding of width or height %16!=0 files
michaelni
parents: 569
diff changeset
2185 if(emu){
697
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2186 emulated_edge_mc(s, ptr, wrap_c, 8, 8, mb_x*8, mb_y*8, s->width>>1, s->height>>1);
570
274d9c5a75ee use edge emu for encoding of width or height %16!=0 files
michaelni
parents: 569
diff changeset
2187 ptr= s->edge_emu_buffer;
274d9c5a75ee use edge emu for encoding of width or height %16!=0 files
michaelni
parents: 569
diff changeset
2188 }
697
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2189 get_pixels(s->block[4], ptr, wrap_c);
294
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 292
diff changeset
2190
697
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2191 ptr = s->new_picture[2] + (mb_y * 8 * wrap_c) + mb_x * 8;
570
274d9c5a75ee use edge emu for encoding of width or height %16!=0 files
michaelni
parents: 569
diff changeset
2192 if(emu){
697
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2193 emulated_edge_mc(s, ptr, wrap_c, 8, 8, mb_x*8, mb_y*8, s->width>>1, s->height>>1);
570
274d9c5a75ee use edge emu for encoding of width or height %16!=0 files
michaelni
parents: 569
diff changeset
2194 ptr= s->edge_emu_buffer;
274d9c5a75ee use edge emu for encoding of width or height %16!=0 files
michaelni
parents: 569
diff changeset
2195 }
697
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2196 get_pixels(s->block[5], ptr, wrap_c);
487
cee02f2f4a5a grayscale only encoding
michaelni
parents: 485
diff changeset
2197 }
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
2198 }else{
651
45e8f39fda50 put/avg_pixels16
michaelni
parents: 650
diff changeset
2199 op_pixels_func (*op_pix)[4];
45e8f39fda50 put/avg_pixels16
michaelni
parents: 650
diff changeset
2200 qpel_mc_func (*op_qpix)[16];
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
2201 UINT8 *dest_y, *dest_cb, *dest_cr;
456
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2202 UINT8 *ptr_y, *ptr_cb, *ptr_cr;
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2203 int wrap_y, wrap_c;
570
274d9c5a75ee use edge emu for encoding of width or height %16!=0 files
michaelni
parents: 569
diff changeset
2204 int emu=0;
294
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 292
diff changeset
2205
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
2206 dest_y = s->current_picture[0] + (mb_y * 16 * s->linesize ) + mb_x * 16;
556
762c67fd4078 uvlinesize
michaelni
parents: 554
diff changeset
2207 dest_cb = s->current_picture[1] + (mb_y * 8 * (s->uvlinesize)) + mb_x * 8;
762c67fd4078 uvlinesize
michaelni
parents: 554
diff changeset
2208 dest_cr = s->current_picture[2] + (mb_y * 8 * (s->uvlinesize)) + mb_x * 8;
456
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2209 wrap_y = s->linesize;
697
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2210 wrap_c = s->uvlinesize;
456
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2211 ptr_y = s->new_picture[0] + (mb_y * 16 * wrap_y) + mb_x * 16;
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2212 ptr_cb = s->new_picture[1] + (mb_y * 8 * wrap_c) + mb_x * 8;
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2213 ptr_cr = s->new_picture[2] + (mb_y * 8 * wrap_c) + mb_x * 8;
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
2214
327
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 326
diff changeset
2215 if ((!s->no_rounding) || s->pict_type==B_TYPE){
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
2216 op_pix = put_pixels_tab;
651
45e8f39fda50 put/avg_pixels16
michaelni
parents: 650
diff changeset
2217 op_qpix= put_qpel_pixels_tab;
295
6622b0fd036c mpeg4 4MV encoding
michaelni
parents: 294
diff changeset
2218 }else{
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
2219 op_pix = put_no_rnd_pixels_tab;
651
45e8f39fda50 put/avg_pixels16
michaelni
parents: 650
diff changeset
2220 op_qpix= put_no_rnd_qpel_pixels_tab;
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
2221 }
295
6622b0fd036c mpeg4 4MV encoding
michaelni
parents: 294
diff changeset
2222
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
2223 if (s->mv_dir & MV_DIR_FORWARD) {
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
2224 MPV_motion(s, dest_y, dest_cb, dest_cr, 0, s->last_picture, op_pix, op_qpix);
651
45e8f39fda50 put/avg_pixels16
michaelni
parents: 650
diff changeset
2225 op_pix = avg_pixels_tab;
45e8f39fda50 put/avg_pixels16
michaelni
parents: 650
diff changeset
2226 op_qpix= avg_qpel_pixels_tab;
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
2227 }
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
2228 if (s->mv_dir & MV_DIR_BACKWARD) {
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
2229 MPV_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_picture, op_pix, op_qpix);
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
2230 }
295
6622b0fd036c mpeg4 4MV encoding
michaelni
parents: 294
diff changeset
2231
570
274d9c5a75ee use edge emu for encoding of width or height %16!=0 files
michaelni
parents: 569
diff changeset
2232 if(mb_x*16+16 > s->width || mb_y*16+16 > s->height){
274d9c5a75ee use edge emu for encoding of width or height %16!=0 files
michaelni
parents: 569
diff changeset
2233 emulated_edge_mc(s, ptr_y, wrap_y, 16, 16, mb_x*16, mb_y*16, s->width, s->height);
274d9c5a75ee use edge emu for encoding of width or height %16!=0 files
michaelni
parents: 569
diff changeset
2234 ptr_y= s->edge_emu_buffer;
274d9c5a75ee use edge emu for encoding of width or height %16!=0 files
michaelni
parents: 569
diff changeset
2235 emu=1;
274d9c5a75ee use edge emu for encoding of width or height %16!=0 files
michaelni
parents: 569
diff changeset
2236 }
697
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2237
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2238 if(s->flags&CODEC_FLAG_INTERLACED_DCT){
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2239 int progressive_score, interlaced_score;
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2240
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2241 progressive_score= pix_diff_vcmp16x8(ptr_y , dest_y , wrap_y )
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2242 + pix_diff_vcmp16x8(ptr_y + wrap_y*8, dest_y + wrap_y*8, wrap_y );
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2243 interlaced_score = pix_diff_vcmp16x8(ptr_y , dest_y , wrap_y*2)
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2244 + pix_diff_vcmp16x8(ptr_y + wrap_y , dest_y + wrap_y , wrap_y*2);
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2245
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2246 if(progressive_score > interlaced_score + 600){
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2247 s->interlaced_dct=1;
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2248
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2249 dct_offset= wrap_y;
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2250 wrap_y<<=1;
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2251 }else
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2252 s->interlaced_dct=0;
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2253 }
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2254
456
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2255 diff_pixels(s->block[0], ptr_y , dest_y , wrap_y);
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2256 diff_pixels(s->block[1], ptr_y + 8, dest_y + 8, wrap_y);
697
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2257 diff_pixels(s->block[2], ptr_y + dct_offset , dest_y + dct_offset , wrap_y);
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2258 diff_pixels(s->block[3], ptr_y + dct_offset + 8, dest_y + dct_offset + 8, wrap_y);
487
cee02f2f4a5a grayscale only encoding
michaelni
parents: 485
diff changeset
2259
cee02f2f4a5a grayscale only encoding
michaelni
parents: 485
diff changeset
2260 if(s->flags&CODEC_FLAG_GRAY){
cee02f2f4a5a grayscale only encoding
michaelni
parents: 485
diff changeset
2261 skip_dct[4]= 1;
cee02f2f4a5a grayscale only encoding
michaelni
parents: 485
diff changeset
2262 skip_dct[5]= 1;
cee02f2f4a5a grayscale only encoding
michaelni
parents: 485
diff changeset
2263 }else{
570
274d9c5a75ee use edge emu for encoding of width or height %16!=0 files
michaelni
parents: 569
diff changeset
2264 if(emu){
274d9c5a75ee use edge emu for encoding of width or height %16!=0 files
michaelni
parents: 569
diff changeset
2265 emulated_edge_mc(s, ptr_cb, wrap_c, 8, 8, mb_x*8, mb_y*8, s->width>>1, s->height>>1);
274d9c5a75ee use edge emu for encoding of width or height %16!=0 files
michaelni
parents: 569
diff changeset
2266 ptr_cb= s->edge_emu_buffer;
274d9c5a75ee use edge emu for encoding of width or height %16!=0 files
michaelni
parents: 569
diff changeset
2267 }
487
cee02f2f4a5a grayscale only encoding
michaelni
parents: 485
diff changeset
2268 diff_pixels(s->block[4], ptr_cb, dest_cb, wrap_c);
570
274d9c5a75ee use edge emu for encoding of width or height %16!=0 files
michaelni
parents: 569
diff changeset
2269 if(emu){
274d9c5a75ee use edge emu for encoding of width or height %16!=0 files
michaelni
parents: 569
diff changeset
2270 emulated_edge_mc(s, ptr_cr, wrap_c, 8, 8, mb_x*8, mb_y*8, s->width>>1, s->height>>1);
274d9c5a75ee use edge emu for encoding of width or height %16!=0 files
michaelni
parents: 569
diff changeset
2271 ptr_cr= s->edge_emu_buffer;
274d9c5a75ee use edge emu for encoding of width or height %16!=0 files
michaelni
parents: 569
diff changeset
2272 }
487
cee02f2f4a5a grayscale only encoding
michaelni
parents: 485
diff changeset
2273 diff_pixels(s->block[5], ptr_cr, dest_cr, wrap_c);
cee02f2f4a5a grayscale only encoding
michaelni
parents: 485
diff changeset
2274 }
cee02f2f4a5a grayscale only encoding
michaelni
parents: 485
diff changeset
2275
456
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2276 /* pre quantization */
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2277 if(s->mc_mb_var[s->mb_width*mb_y+ mb_x]<2*s->qscale*s->qscale){
697
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2278 //FIXME optimize
456
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2279 if(pix_abs8x8(ptr_y , dest_y , wrap_y) < 20*s->qscale) skip_dct[0]= 1;
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2280 if(pix_abs8x8(ptr_y + 8, dest_y + 8, wrap_y) < 20*s->qscale) skip_dct[1]= 1;
697
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2281 if(pix_abs8x8(ptr_y +dct_offset , dest_y +dct_offset , wrap_y) < 20*s->qscale) skip_dct[2]= 1;
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2282 if(pix_abs8x8(ptr_y +dct_offset+ 8, dest_y +dct_offset+ 8, wrap_y) < 20*s->qscale) skip_dct[3]= 1;
456
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2283 if(pix_abs8x8(ptr_cb , dest_cb , wrap_y) < 20*s->qscale) skip_dct[4]= 1;
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2284 if(pix_abs8x8(ptr_cr , dest_cr , wrap_y) < 20*s->qscale) skip_dct[5]= 1;
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2285 #if 0
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2286 {
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2287 static int stat[7];
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2288 int num=0;
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2289 for(i=0; i<6; i++)
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2290 if(skip_dct[i]) num++;
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2291 stat[num]++;
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2292
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2293 if(s->mb_x==0 && s->mb_y==0){
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2294 for(i=0; i<7; i++){
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2295 printf("%6d %1d\n", stat[i], i);
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2296 }
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2297 }
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2298 }
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2299 #endif
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2300 }
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
2301
294
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 292
diff changeset
2302 }
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 292
diff changeset
2303
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 292
diff changeset
2304 #if 0
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 292
diff changeset
2305 {
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 292
diff changeset
2306 float adap_parm;
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 292
diff changeset
2307
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 292
diff changeset
2308 adap_parm = ((s->avg_mb_var << 1) + s->mb_var[s->mb_width*mb_y+mb_x] + 1.0) /
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 292
diff changeset
2309 ((s->mb_var[s->mb_width*mb_y+mb_x] << 1) + s->avg_mb_var + 1.0);
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 292
diff changeset
2310
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 292
diff changeset
2311 printf("\ntype=%c qscale=%2d adap=%0.2f dquant=%4.2f var=%4d avgvar=%4d",
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 292
diff changeset
2312 (s->mb_type[s->mb_width*mb_y+mb_x] > 0) ? 'I' : 'P',
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 292
diff changeset
2313 s->qscale, adap_parm, s->qscale*adap_parm,
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 292
diff changeset
2314 s->mb_var[s->mb_width*mb_y+mb_x], s->avg_mb_var);
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 292
diff changeset
2315 }
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 292
diff changeset
2316 #endif
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 292
diff changeset
2317 /* DCT & quantize */
344
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
2318 if(s->out_format==FMT_MJPEG){
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
2319 for(i=0;i<6;i++) {
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
2320 int overflow;
625
bb6a69f9d409 slow but accurate integer dct from IJG (should be ok with the LGPL as the old DCT is the fast integer DCT from IJG)
michaelni
parents: 619
diff changeset
2321 s->block_last_index[i] = s->dct_quantize(s, s->block[i], i, 8, &overflow);
350
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 347
diff changeset
2322 if (overflow) clip_coeffs(s, s->block[i], s->block_last_index[i]);
344
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
2323 }
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
2324 }else{
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
2325 for(i=0;i<6;i++) {
456
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2326 if(!skip_dct[i]){
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2327 int overflow;
625
bb6a69f9d409 slow but accurate integer dct from IJG (should be ok with the LGPL as the old DCT is the fast integer DCT from IJG)
michaelni
parents: 619
diff changeset
2328 s->block_last_index[i] = s->dct_quantize(s, s->block[i], i, s->qscale, &overflow);
344
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
2329 // FIXME we could decide to change to quantizer instead of clipping
350
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 347
diff changeset
2330 // JS: I don't think that would be a good idea it could lower quality instead
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 347
diff changeset
2331 // of improve it. Just INTRADC clipping deserves changes in quantizer
456
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2332 if (overflow) clip_coeffs(s, s->block[i], s->block_last_index[i]);
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2333 }else
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2334 s->block_last_index[i]= -1;
344
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
2335 }
456
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2336 if(s->luma_elim_threshold && !s->mb_intra)
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2337 for(i=0; i<4; i++)
605
40874804a5af same dc skip behavior for chroma & luma elimination, its confusing otherwise imho
michaelni
parents: 604
diff changeset
2338 dct_single_coeff_elimination(s, i, s->luma_elim_threshold);
456
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2339 if(s->chroma_elim_threshold && !s->mb_intra)
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2340 for(i=4; i<6; i++)
605
40874804a5af same dc skip behavior for chroma & luma elimination, its confusing otherwise imho
michaelni
parents: 604
diff changeset
2341 dct_single_coeff_elimination(s, i, s->chroma_elim_threshold);
294
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 292
diff changeset
2342 }
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 292
diff changeset
2343
487
cee02f2f4a5a grayscale only encoding
michaelni
parents: 485
diff changeset
2344 if((s->flags&CODEC_FLAG_GRAY) && s->mb_intra){
cee02f2f4a5a grayscale only encoding
michaelni
parents: 485
diff changeset
2345 s->block_last_index[4]=
cee02f2f4a5a grayscale only encoding
michaelni
parents: 485
diff changeset
2346 s->block_last_index[5]= 0;
cee02f2f4a5a grayscale only encoding
michaelni
parents: 485
diff changeset
2347 s->block[4][0]=
cee02f2f4a5a grayscale only encoding
michaelni
parents: 485
diff changeset
2348 s->block[5][0]= 128;
cee02f2f4a5a grayscale only encoding
michaelni
parents: 485
diff changeset
2349 }
cee02f2f4a5a grayscale only encoding
michaelni
parents: 485
diff changeset
2350
294
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 292
diff changeset
2351 /* huffman encode */
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 292
diff changeset
2352 switch(s->out_format) {
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 292
diff changeset
2353 case FMT_MPEG1:
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 292
diff changeset
2354 mpeg1_encode_mb(s, s->block, motion_x, motion_y);
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 292
diff changeset
2355 break;
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 292
diff changeset
2356 case FMT_H263:
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 292
diff changeset
2357 if (s->h263_msmpeg4)
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 292
diff changeset
2358 msmpeg4_encode_mb(s, s->block, motion_x, motion_y);
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 292
diff changeset
2359 else if(s->h263_pred)
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 292
diff changeset
2360 mpeg4_encode_mb(s, s->block, motion_x, motion_y);
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 292
diff changeset
2361 else
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 292
diff changeset
2362 h263_encode_mb(s, s->block, motion_x, motion_y);
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 292
diff changeset
2363 break;
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 292
diff changeset
2364 case FMT_MJPEG:
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 292
diff changeset
2365 mjpeg_encode_mb(s, s->block);
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 292
diff changeset
2366 break;
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 292
diff changeset
2367 }
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 292
diff changeset
2368 }
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 292
diff changeset
2369
456
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2370 void ff_copy_bits(PutBitContext *pb, UINT8 *src, int length)
294
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 292
diff changeset
2371 {
326
6ebb8680885d fixing hq mode with mpeg1 and 2-pass
michaelni
parents: 325
diff changeset
2372 int bytes= length>>4;
6ebb8680885d fixing hq mode with mpeg1 and 2-pass
michaelni
parents: 325
diff changeset
2373 int bits= length&15;
6ebb8680885d fixing hq mode with mpeg1 and 2-pass
michaelni
parents: 325
diff changeset
2374 int i;
6ebb8680885d fixing hq mode with mpeg1 and 2-pass
michaelni
parents: 325
diff changeset
2375
456
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2376 if(length==0) return;
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2377
326
6ebb8680885d fixing hq mode with mpeg1 and 2-pass
michaelni
parents: 325
diff changeset
2378 for(i=0; i<bytes; i++) put_bits(pb, 16, be2me_16(((uint16_t*)src)[i]));
6ebb8680885d fixing hq mode with mpeg1 and 2-pass
michaelni
parents: 325
diff changeset
2379 put_bits(pb, bits, be2me_16(((uint16_t*)src)[i])>>(16-bits));
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2380 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
2381
456
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2382 static inline void copy_context_before_encode(MpegEncContext *d, MpegEncContext *s, int type){
326
6ebb8680885d fixing hq mode with mpeg1 and 2-pass
michaelni
parents: 325
diff changeset
2383 int i;
6ebb8680885d fixing hq mode with mpeg1 and 2-pass
michaelni
parents: 325
diff changeset
2384
6ebb8680885d fixing hq mode with mpeg1 and 2-pass
michaelni
parents: 325
diff changeset
2385 memcpy(d->last_mv, s->last_mv, 2*2*2*sizeof(int)); //FIXME is memcpy faster then a loop?
6ebb8680885d fixing hq mode with mpeg1 and 2-pass
michaelni
parents: 325
diff changeset
2386
6ebb8680885d fixing hq mode with mpeg1 and 2-pass
michaelni
parents: 325
diff changeset
2387 /* mpeg1 */
6ebb8680885d fixing hq mode with mpeg1 and 2-pass
michaelni
parents: 325
diff changeset
2388 d->mb_incr= s->mb_incr;
6ebb8680885d fixing hq mode with mpeg1 and 2-pass
michaelni
parents: 325
diff changeset
2389 for(i=0; i<3; i++)
6ebb8680885d fixing hq mode with mpeg1 and 2-pass
michaelni
parents: 325
diff changeset
2390 d->last_dc[i]= s->last_dc[i];
6ebb8680885d fixing hq mode with mpeg1 and 2-pass
michaelni
parents: 325
diff changeset
2391
6ebb8680885d fixing hq mode with mpeg1 and 2-pass
michaelni
parents: 325
diff changeset
2392 /* statistics */
6ebb8680885d fixing hq mode with mpeg1 and 2-pass
michaelni
parents: 325
diff changeset
2393 d->mv_bits= s->mv_bits;
6ebb8680885d fixing hq mode with mpeg1 and 2-pass
michaelni
parents: 325
diff changeset
2394 d->i_tex_bits= s->i_tex_bits;
6ebb8680885d fixing hq mode with mpeg1 and 2-pass
michaelni
parents: 325
diff changeset
2395 d->p_tex_bits= s->p_tex_bits;
6ebb8680885d fixing hq mode with mpeg1 and 2-pass
michaelni
parents: 325
diff changeset
2396 d->i_count= s->i_count;
656
e47fa3e3f2d5 statistics for forw & back p-MBs instead of just one counter for both
michaelni
parents: 652
diff changeset
2397 d->f_count= s->f_count;
e47fa3e3f2d5 statistics for forw & back p-MBs instead of just one counter for both
michaelni
parents: 652
diff changeset
2398 d->b_count= s->b_count;
326
6ebb8680885d fixing hq mode with mpeg1 and 2-pass
michaelni
parents: 325
diff changeset
2399 d->skip_count= s->skip_count;
6ebb8680885d fixing hq mode with mpeg1 and 2-pass
michaelni
parents: 325
diff changeset
2400 d->misc_bits= s->misc_bits;
329
5cc47d0ba53e fixed ratecontrol & b-frames
michaelni
parents: 327
diff changeset
2401 d->last_bits= 0;
327
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 326
diff changeset
2402
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 326
diff changeset
2403 d->mb_skiped= s->mb_skiped;
326
6ebb8680885d fixing hq mode with mpeg1 and 2-pass
michaelni
parents: 325
diff changeset
2404 }
6ebb8680885d fixing hq mode with mpeg1 and 2-pass
michaelni
parents: 325
diff changeset
2405
456
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2406 static inline void copy_context_after_encode(MpegEncContext *d, MpegEncContext *s, int type){
326
6ebb8680885d fixing hq mode with mpeg1 and 2-pass
michaelni
parents: 325
diff changeset
2407 int i;
6ebb8680885d fixing hq mode with mpeg1 and 2-pass
michaelni
parents: 325
diff changeset
2408
6ebb8680885d fixing hq mode with mpeg1 and 2-pass
michaelni
parents: 325
diff changeset
2409 memcpy(d->mv, s->mv, 2*4*2*sizeof(int));
6ebb8680885d fixing hq mode with mpeg1 and 2-pass
michaelni
parents: 325
diff changeset
2410 memcpy(d->last_mv, s->last_mv, 2*2*2*sizeof(int)); //FIXME is memcpy faster then a loop?
6ebb8680885d fixing hq mode with mpeg1 and 2-pass
michaelni
parents: 325
diff changeset
2411
6ebb8680885d fixing hq mode with mpeg1 and 2-pass
michaelni
parents: 325
diff changeset
2412 /* mpeg1 */
6ebb8680885d fixing hq mode with mpeg1 and 2-pass
michaelni
parents: 325
diff changeset
2413 d->mb_incr= s->mb_incr;
6ebb8680885d fixing hq mode with mpeg1 and 2-pass
michaelni
parents: 325
diff changeset
2414 for(i=0; i<3; i++)
6ebb8680885d fixing hq mode with mpeg1 and 2-pass
michaelni
parents: 325
diff changeset
2415 d->last_dc[i]= s->last_dc[i];
6ebb8680885d fixing hq mode with mpeg1 and 2-pass
michaelni
parents: 325
diff changeset
2416
6ebb8680885d fixing hq mode with mpeg1 and 2-pass
michaelni
parents: 325
diff changeset
2417 /* statistics */
6ebb8680885d fixing hq mode with mpeg1 and 2-pass
michaelni
parents: 325
diff changeset
2418 d->mv_bits= s->mv_bits;
6ebb8680885d fixing hq mode with mpeg1 and 2-pass
michaelni
parents: 325
diff changeset
2419 d->i_tex_bits= s->i_tex_bits;
6ebb8680885d fixing hq mode with mpeg1 and 2-pass
michaelni
parents: 325
diff changeset
2420 d->p_tex_bits= s->p_tex_bits;
6ebb8680885d fixing hq mode with mpeg1 and 2-pass
michaelni
parents: 325
diff changeset
2421 d->i_count= s->i_count;
656
e47fa3e3f2d5 statistics for forw & back p-MBs instead of just one counter for both
michaelni
parents: 652
diff changeset
2422 d->f_count= s->f_count;
e47fa3e3f2d5 statistics for forw & back p-MBs instead of just one counter for both
michaelni
parents: 652
diff changeset
2423 d->b_count= s->b_count;
326
6ebb8680885d fixing hq mode with mpeg1 and 2-pass
michaelni
parents: 325
diff changeset
2424 d->skip_count= s->skip_count;
6ebb8680885d fixing hq mode with mpeg1 and 2-pass
michaelni
parents: 325
diff changeset
2425 d->misc_bits= s->misc_bits;
6ebb8680885d fixing hq mode with mpeg1 and 2-pass
michaelni
parents: 325
diff changeset
2426
6ebb8680885d fixing hq mode with mpeg1 and 2-pass
michaelni
parents: 325
diff changeset
2427 d->mb_intra= s->mb_intra;
327
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 326
diff changeset
2428 d->mb_skiped= s->mb_skiped;
326
6ebb8680885d fixing hq mode with mpeg1 and 2-pass
michaelni
parents: 325
diff changeset
2429 d->mv_type= s->mv_type;
6ebb8680885d fixing hq mode with mpeg1 and 2-pass
michaelni
parents: 325
diff changeset
2430 d->mv_dir= s->mv_dir;
6ebb8680885d fixing hq mode with mpeg1 and 2-pass
michaelni
parents: 325
diff changeset
2431 d->pb= s->pb;
456
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2432 if(s->data_partitioning){
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2433 d->pb2= s->pb2;
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2434 d->tex_pb= s->tex_pb;
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2435 }
326
6ebb8680885d fixing hq mode with mpeg1 and 2-pass
michaelni
parents: 325
diff changeset
2436 d->block= s->block;
6ebb8680885d fixing hq mode with mpeg1 and 2-pass
michaelni
parents: 325
diff changeset
2437 for(i=0; i<6; i++)
6ebb8680885d fixing hq mode with mpeg1 and 2-pass
michaelni
parents: 325
diff changeset
2438 d->block_last_index[i]= s->block_last_index[i];
755
d17846a6c164 fixing interlaced dct + hq mode
michaelni
parents: 754
diff changeset
2439 d->interlaced_dct= s->interlaced_dct;
326
6ebb8680885d fixing hq mode with mpeg1 and 2-pass
michaelni
parents: 325
diff changeset
2440 }
6ebb8680885d fixing hq mode with mpeg1 and 2-pass
michaelni
parents: 325
diff changeset
2441
456
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2442 static inline void encode_mb_hq(MpegEncContext *s, MpegEncContext *backup, MpegEncContext *best, int type,
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2443 PutBitContext pb[2], PutBitContext pb2[2], PutBitContext tex_pb[2],
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2444 int *dmin, int *next_block, int motion_x, int motion_y)
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2445 {
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2446 int bits_count;
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2447
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2448 copy_context_before_encode(s, backup, type);
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2449
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2450 s->block= s->blocks[*next_block];
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2451 s->pb= pb[*next_block];
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2452 if(s->data_partitioning){
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2453 s->pb2 = pb2 [*next_block];
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2454 s->tex_pb= tex_pb[*next_block];
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2455 }
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2456
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2457 encode_mb(s, motion_x, motion_y);
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2458
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2459 bits_count= get_bit_count(&s->pb);
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2460 if(s->data_partitioning){
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2461 bits_count+= get_bit_count(&s->pb2);
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2462 bits_count+= get_bit_count(&s->tex_pb);
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2463 }
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2464
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2465 if(bits_count<*dmin){
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2466 *dmin= bits_count;
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2467 *next_block^=1;
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2468
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2469 copy_context_after_encode(best, s, type);
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2470 }
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2471 }
326
6ebb8680885d fixing hq mode with mpeg1 and 2-pass
michaelni
parents: 325
diff changeset
2472
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2473 static void encode_picture(MpegEncContext *s, int picture_number)
986e461dc072 Initial revision
glantau
parents:
diff changeset
2474 {
766
8d36b35a7e6e slice encoding cleanup
michaelni
parents: 764
diff changeset
2475 int mb_x, mb_y, pdif = 0;
294
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 292
diff changeset
2476 int i;
286
91f7c38f5f37 statistics for 2-pass encoding
michaelni
parents: 281
diff changeset
2477 int bits;
326
6ebb8680885d fixing hq mode with mpeg1 and 2-pass
michaelni
parents: 325
diff changeset
2478 MpegEncContext best_s, backup_s;
456
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2479 UINT8 bit_buf[2][3000];
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2480 UINT8 bit_buf2[2][3000];
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2481 UINT8 bit_buf_tex[2][3000];
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2482 PutBitContext pb[2], pb2[2], tex_pb[2];
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2483
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2484 for(i=0; i<2; i++){
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2485 init_put_bits(&pb [i], bit_buf [i], 3000, NULL, NULL);
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2486 init_put_bits(&pb2 [i], bit_buf2 [i], 3000, NULL, NULL);
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2487 init_put_bits(&tex_pb[i], bit_buf_tex[i], 3000, NULL, NULL);
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2488 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2489
986e461dc072 Initial revision
glantau
parents:
diff changeset
2490 s->picture_number = picture_number;
268
09ae29b27ed9 hopefully better bitrate controll
michaelni
parents: 266
diff changeset
2491
294
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 292
diff changeset
2492 s->block_wrap[0]=
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 292
diff changeset
2493 s->block_wrap[1]=
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 292
diff changeset
2494 s->block_wrap[2]=
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 292
diff changeset
2495 s->block_wrap[3]= s->mb_width*2 + 2;
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 292
diff changeset
2496 s->block_wrap[4]=
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 292
diff changeset
2497 s->block_wrap[5]= s->mb_width + 2;
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 292
diff changeset
2498
268
09ae29b27ed9 hopefully better bitrate controll
michaelni
parents: 266
diff changeset
2499 /* Reset the average MB variance */
456
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2500 s->mb_var_sum = 0;
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2501 s->mc_mb_var_sum = 0;
327
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 326
diff changeset
2502
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 326
diff changeset
2503 /* we need to initialize some time vars before we can encode b-frames */
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 326
diff changeset
2504 if (s->h263_pred && !s->h263_msmpeg4)
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 326
diff changeset
2505 ff_set_mpeg4_time(s, s->picture_number);
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 326
diff changeset
2506
608
98e39397636b better scene change detection
michaelni
parents: 605
diff changeset
2507 s->scene_change_score=0;
690
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 673
diff changeset
2508
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 673
diff changeset
2509 s->qscale= (int)(s->frame_qscale + 0.5); //FIXME qscale / ... stuff for ME ratedistoration
608
98e39397636b better scene change detection
michaelni
parents: 605
diff changeset
2510
268
09ae29b27ed9 hopefully better bitrate controll
michaelni
parents: 266
diff changeset
2511 /* Estimate motion for every MB */
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
2512 if(s->pict_type != I_TYPE){
294
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 292
diff changeset
2513 for(mb_y=0; mb_y < s->mb_height; mb_y++) {
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 292
diff changeset
2514 s->block_index[0]= s->block_wrap[0]*(mb_y*2 + 1) - 1;
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 292
diff changeset
2515 s->block_index[1]= s->block_wrap[0]*(mb_y*2 + 1);
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 292
diff changeset
2516 s->block_index[2]= s->block_wrap[0]*(mb_y*2 + 2) - 1;
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 292
diff changeset
2517 s->block_index[3]= s->block_wrap[0]*(mb_y*2 + 2);
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 292
diff changeset
2518 for(mb_x=0; mb_x < s->mb_width; mb_x++) {
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 292
diff changeset
2519 s->mb_x = mb_x;
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 292
diff changeset
2520 s->mb_y = mb_y;
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 292
diff changeset
2521 s->block_index[0]+=2;
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 292
diff changeset
2522 s->block_index[1]+=2;
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 292
diff changeset
2523 s->block_index[2]+=2;
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 292
diff changeset
2524 s->block_index[3]+=2;
268
09ae29b27ed9 hopefully better bitrate controll
michaelni
parents: 266
diff changeset
2525
294
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 292
diff changeset
2526 /* compute motion vector & mb_type and store in context */
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
2527 if(s->pict_type==B_TYPE)
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
2528 ff_estimate_b_frame_motion(s, mb_x, mb_y);
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
2529 else
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
2530 ff_estimate_p_frame_motion(s, mb_x, mb_y);
294
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 292
diff changeset
2531 // s->mb_type[mb_y*s->mb_width + mb_x]=MB_TYPE_INTER;
268
09ae29b27ed9 hopefully better bitrate controll
michaelni
parents: 266
diff changeset
2532 }
09ae29b27ed9 hopefully better bitrate controll
michaelni
parents: 266
diff changeset
2533 }
294
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 292
diff changeset
2534 emms_c();
456
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2535 }else /* if(s->pict_type == I_TYPE) */{
294
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 292
diff changeset
2536 /* I-Frame */
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 292
diff changeset
2537 //FIXME do we need to zero them?
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 292
diff changeset
2538 memset(s->motion_val[0], 0, sizeof(INT16)*(s->mb_width*2 + 2)*(s->mb_height*2 + 2)*2);
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
2539 memset(s->p_mv_table , 0, sizeof(INT16)*(s->mb_width+2)*(s->mb_height+2)*2);
294
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 292
diff changeset
2540 memset(s->mb_type , MB_TYPE_INTRA, sizeof(UINT8)*s->mb_width*s->mb_height);
612
c0005de2be59 new ratecontrol code
michaelni
parents: 611
diff changeset
2541
c0005de2be59 new ratecontrol code
michaelni
parents: 611
diff changeset
2542 if(!s->fixed_qscale){
c0005de2be59 new ratecontrol code
michaelni
parents: 611
diff changeset
2543 /* finding spatial complexity for I-frame rate control */
c0005de2be59 new ratecontrol code
michaelni
parents: 611
diff changeset
2544 for(mb_y=0; mb_y < s->mb_height; mb_y++) {
c0005de2be59 new ratecontrol code
michaelni
parents: 611
diff changeset
2545 for(mb_x=0; mb_x < s->mb_width; mb_x++) {
c0005de2be59 new ratecontrol code
michaelni
parents: 611
diff changeset
2546 int xx = mb_x * 16;
c0005de2be59 new ratecontrol code
michaelni
parents: 611
diff changeset
2547 int yy = mb_y * 16;
c0005de2be59 new ratecontrol code
michaelni
parents: 611
diff changeset
2548 uint8_t *pix = s->new_picture[0] + (yy * s->linesize) + xx;
c0005de2be59 new ratecontrol code
michaelni
parents: 611
diff changeset
2549 int varc;
c0005de2be59 new ratecontrol code
michaelni
parents: 611
diff changeset
2550 int sum = pix_sum(pix, s->linesize);
c0005de2be59 new ratecontrol code
michaelni
parents: 611
diff changeset
2551
c0005de2be59 new ratecontrol code
michaelni
parents: 611
diff changeset
2552 sum= (sum+8)>>4;
c0005de2be59 new ratecontrol code
michaelni
parents: 611
diff changeset
2553 varc = (pix_norm1(pix, s->linesize) - sum*sum + 500 + 128)>>8;
c0005de2be59 new ratecontrol code
michaelni
parents: 611
diff changeset
2554
690
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 673
diff changeset
2555 s->mb_var [s->mb_width * mb_y + mb_x] = varc;
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 673
diff changeset
2556 s->mb_mean[s->mb_width * mb_y + mb_x] = (sum+7)>>4;
612
c0005de2be59 new ratecontrol code
michaelni
parents: 611
diff changeset
2557 s->mb_var_sum += varc;
c0005de2be59 new ratecontrol code
michaelni
parents: 611
diff changeset
2558 }
c0005de2be59 new ratecontrol code
michaelni
parents: 611
diff changeset
2559 }
c0005de2be59 new ratecontrol code
michaelni
parents: 611
diff changeset
2560 }
268
09ae29b27ed9 hopefully better bitrate controll
michaelni
parents: 266
diff changeset
2561 }
608
98e39397636b better scene change detection
michaelni
parents: 605
diff changeset
2562 if(s->scene_change_score > 0 && s->pict_type == P_TYPE){
271
997aac7d4e3e scene change detection
michaelni
parents: 270
diff changeset
2563 s->pict_type= I_TYPE;
294
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 292
diff changeset
2564 memset(s->mb_type , MB_TYPE_INTRA, sizeof(UINT8)*s->mb_width*s->mb_height);
329
5cc47d0ba53e fixed ratecontrol & b-frames
michaelni
parents: 327
diff changeset
2565 if(s->max_b_frames==0){
5cc47d0ba53e fixed ratecontrol & b-frames
michaelni
parents: 327
diff changeset
2566 s->input_pict_type= I_TYPE;
5cc47d0ba53e fixed ratecontrol & b-frames
michaelni
parents: 327
diff changeset
2567 s->input_picture_in_gop_number=0;
5cc47d0ba53e fixed ratecontrol & b-frames
michaelni
parents: 327
diff changeset
2568 }
612
c0005de2be59 new ratecontrol code
michaelni
parents: 611
diff changeset
2569 //printf("Scene change detected, encoding as I Frame %d %d\n", s->mb_var_sum, s->mc_mb_var_sum);
271
997aac7d4e3e scene change detection
michaelni
parents: 270
diff changeset
2570 }
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
2571
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
2572 if(s->pict_type==P_TYPE || s->pict_type==S_TYPE)
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
2573 s->f_code= ff_get_best_fcode(s, s->p_mv_table, MB_TYPE_INTER);
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
2574 ff_fix_long_p_mvs(s);
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
2575 if(s->pict_type==B_TYPE){
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
2576 s->f_code= ff_get_best_fcode(s, s->b_forw_mv_table, MB_TYPE_FORWARD);
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
2577 s->b_code= ff_get_best_fcode(s, s->b_back_mv_table, MB_TYPE_BACKWARD);
327
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 326
diff changeset
2578
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 326
diff changeset
2579 ff_fix_long_b_mvs(s, s->b_forw_mv_table, s->f_code, MB_TYPE_FORWARD);
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 326
diff changeset
2580 ff_fix_long_b_mvs(s, s->b_back_mv_table, s->b_code, MB_TYPE_BACKWARD);
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 326
diff changeset
2581 ff_fix_long_b_mvs(s, s->b_bidir_forw_mv_table, s->f_code, MB_TYPE_BIDIR);
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 326
diff changeset
2582 ff_fix_long_b_mvs(s, s->b_bidir_back_mv_table, s->b_code, MB_TYPE_BIDIR);
277
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 271
diff changeset
2583 }
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
2584
690
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 673
diff changeset
2585 if (s->fixed_qscale)
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 673
diff changeset
2586 s->frame_qscale = s->avctx->quality;
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 673
diff changeset
2587 else
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 673
diff changeset
2588 s->frame_qscale = ff_rate_estimate_qscale(s);
277
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 271
diff changeset
2589
695
3525da287ee2 adaptive quantization for h263
michaelni
parents: 693
diff changeset
2590 if(s->adaptive_quant){
3525da287ee2 adaptive quantization for h263
michaelni
parents: 693
diff changeset
2591 switch(s->codec_id){
3525da287ee2 adaptive quantization for h263
michaelni
parents: 693
diff changeset
2592 case CODEC_ID_MPEG4:
3525da287ee2 adaptive quantization for h263
michaelni
parents: 693
diff changeset
2593 ff_clean_mpeg4_qscales(s);
3525da287ee2 adaptive quantization for h263
michaelni
parents: 693
diff changeset
2594 break;
3525da287ee2 adaptive quantization for h263
michaelni
parents: 693
diff changeset
2595 case CODEC_ID_H263:
3525da287ee2 adaptive quantization for h263
michaelni
parents: 693
diff changeset
2596 case CODEC_ID_H263P:
3525da287ee2 adaptive quantization for h263
michaelni
parents: 693
diff changeset
2597 ff_clean_h263_qscales(s);
3525da287ee2 adaptive quantization for h263
michaelni
parents: 693
diff changeset
2598 break;
3525da287ee2 adaptive quantization for h263
michaelni
parents: 693
diff changeset
2599 }
3525da287ee2 adaptive quantization for h263
michaelni
parents: 693
diff changeset
2600
690
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 673
diff changeset
2601 s->qscale= s->qscale_table[0];
695
3525da287ee2 adaptive quantization for h263
michaelni
parents: 693
diff changeset
2602 }else
690
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 673
diff changeset
2603 s->qscale= (int)(s->frame_qscale + 0.5);
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 673
diff changeset
2604
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2605 if (s->out_format == FMT_MJPEG) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
2606 /* for mjpeg, we do include qscale in the matrix */
533
3c07cf9595de adding ff prefix to avoid global name conficts with xvid (patch by Marko Kreen <marko at l-t.ee>)
michaelni
parents: 514
diff changeset
2607 s->intra_matrix[0] = ff_mpeg1_default_intra_matrix[0];
706
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 704
diff changeset
2608 for(i=1;i<64;i++){
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 704
diff changeset
2609 int j= s->idct_permutation[i];
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 704
diff changeset
2610
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 704
diff changeset
2611 s->intra_matrix[j] = CLAMP_TO_8BIT((ff_mpeg1_default_intra_matrix[i] * s->qscale) >> 3);
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 704
diff changeset
2612 }
625
bb6a69f9d409 slow but accurate integer dct from IJG (should be ok with the LGPL as the old DCT is the fast integer DCT from IJG)
michaelni
parents: 619
diff changeset
2613 convert_matrix(s, s->q_intra_matrix, s->q_intra_matrix16,
709
afeff6ccb7f5 convert only needed matrixes in convert_matrix() (mjpeg calls it for every frame)
michaelni
parents: 706
diff changeset
2614 s->q_intra_matrix16_bias, s->intra_matrix, s->intra_quant_bias, 8, 8);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2615 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
2616
286
91f7c38f5f37 statistics for 2-pass encoding
michaelni
parents: 281
diff changeset
2617 s->last_bits= get_bit_count(&s->pb);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2618 switch(s->out_format) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
2619 case FMT_MJPEG:
986e461dc072 Initial revision
glantau
parents:
diff changeset
2620 mjpeg_picture_header(s);
986e461dc072 Initial revision
glantau
parents:
diff changeset
2621 break;
986e461dc072 Initial revision
glantau
parents:
diff changeset
2622 case FMT_H263:
986e461dc072 Initial revision
glantau
parents:
diff changeset
2623 if (s->h263_msmpeg4)
986e461dc072 Initial revision
glantau
parents:
diff changeset
2624 msmpeg4_encode_picture_header(s, picture_number);
986e461dc072 Initial revision
glantau
parents:
diff changeset
2625 else if (s->h263_pred)
986e461dc072 Initial revision
glantau
parents:
diff changeset
2626 mpeg4_encode_picture_header(s, picture_number);
986e461dc072 Initial revision
glantau
parents:
diff changeset
2627 else if (s->h263_rv10)
986e461dc072 Initial revision
glantau
parents:
diff changeset
2628 rv10_encode_picture_header(s, picture_number);
986e461dc072 Initial revision
glantau
parents:
diff changeset
2629 else
986e461dc072 Initial revision
glantau
parents:
diff changeset
2630 h263_encode_picture_header(s, picture_number);
986e461dc072 Initial revision
glantau
parents:
diff changeset
2631 break;
986e461dc072 Initial revision
glantau
parents:
diff changeset
2632 case FMT_MPEG1:
986e461dc072 Initial revision
glantau
parents:
diff changeset
2633 mpeg1_encode_picture_header(s, picture_number);
986e461dc072 Initial revision
glantau
parents:
diff changeset
2634 break;
986e461dc072 Initial revision
glantau
parents:
diff changeset
2635 }
286
91f7c38f5f37 statistics for 2-pass encoding
michaelni
parents: 281
diff changeset
2636 bits= get_bit_count(&s->pb);
91f7c38f5f37 statistics for 2-pass encoding
michaelni
parents: 281
diff changeset
2637 s->header_bits= bits - s->last_bits;
91f7c38f5f37 statistics for 2-pass encoding
michaelni
parents: 281
diff changeset
2638 s->last_bits= bits;
91f7c38f5f37 statistics for 2-pass encoding
michaelni
parents: 281
diff changeset
2639 s->mv_bits=0;
91f7c38f5f37 statistics for 2-pass encoding
michaelni
parents: 281
diff changeset
2640 s->misc_bits=0;
91f7c38f5f37 statistics for 2-pass encoding
michaelni
parents: 281
diff changeset
2641 s->i_tex_bits=0;
91f7c38f5f37 statistics for 2-pass encoding
michaelni
parents: 281
diff changeset
2642 s->p_tex_bits=0;
91f7c38f5f37 statistics for 2-pass encoding
michaelni
parents: 281
diff changeset
2643 s->i_count=0;
656
e47fa3e3f2d5 statistics for forw & back p-MBs instead of just one counter for both
michaelni
parents: 652
diff changeset
2644 s->f_count=0;
e47fa3e3f2d5 statistics for forw & back p-MBs instead of just one counter for both
michaelni
parents: 652
diff changeset
2645 s->b_count=0;
286
91f7c38f5f37 statistics for 2-pass encoding
michaelni
parents: 281
diff changeset
2646 s->skip_count=0;
91f7c38f5f37 statistics for 2-pass encoding
michaelni
parents: 281
diff changeset
2647
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2648 /* init last dc values */
986e461dc072 Initial revision
glantau
parents:
diff changeset
2649 /* note: quant matrix value (8) is implied here */
986e461dc072 Initial revision
glantau
parents:
diff changeset
2650 s->last_dc[0] = 128;
986e461dc072 Initial revision
glantau
parents:
diff changeset
2651 s->last_dc[1] = 128;
986e461dc072 Initial revision
glantau
parents:
diff changeset
2652 s->last_dc[2] = 128;
986e461dc072 Initial revision
glantau
parents:
diff changeset
2653 s->mb_incr = 1;
986e461dc072 Initial revision
glantau
parents:
diff changeset
2654 s->last_mv[0][0][0] = 0;
986e461dc072 Initial revision
glantau
parents:
diff changeset
2655 s->last_mv[0][0][1] = 0;
986e461dc072 Initial revision
glantau
parents:
diff changeset
2656
766
8d36b35a7e6e slice encoding cleanup
michaelni
parents: 764
diff changeset
2657 if (s->codec_id==CODEC_ID_H263 || s->codec_id==CODEC_ID_H263P)
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 731
diff changeset
2658 s->gob_index = ff_h263_get_gob_height(s);
456
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2659
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 731
diff changeset
2660 if(s->codec_id==CODEC_ID_MPEG4 && s->partitioned_frame)
456
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2661 ff_mpeg4_init_partitions(s);
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2662
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2663 s->resync_mb_x=0;
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2664 s->resync_mb_y=0;
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 731
diff changeset
2665 s->first_slice_line = 1;
766
8d36b35a7e6e slice encoding cleanup
michaelni
parents: 764
diff changeset
2666 s->ptr_lastgob = s->pb.buf;
8d36b35a7e6e slice encoding cleanup
michaelni
parents: 764
diff changeset
2667 s->ptr_last_mb_line = s->pb.buf;
233
3f5b72726118 - More work on preliminary bit rate control, just to be able to get an
pulento
parents: 232
diff changeset
2668 for(mb_y=0; mb_y < s->mb_height; mb_y++) {
499
8b7a54d58549 wmv1 support
michaelni
parents: 487
diff changeset
2669 s->y_dc_scale= s->y_dc_scale_table[ s->qscale ];
8b7a54d58549 wmv1 support
michaelni
parents: 487
diff changeset
2670 s->c_dc_scale= s->c_dc_scale_table[ s->qscale ];
233
3f5b72726118 - More work on preliminary bit rate control, just to be able to get an
pulento
parents: 232
diff changeset
2671
266
252444e5259b optimization
michaelni
parents: 265
diff changeset
2672 s->block_index[0]= s->block_wrap[0]*(mb_y*2 + 1) - 1;
252444e5259b optimization
michaelni
parents: 265
diff changeset
2673 s->block_index[1]= s->block_wrap[0]*(mb_y*2 + 1);
252444e5259b optimization
michaelni
parents: 265
diff changeset
2674 s->block_index[2]= s->block_wrap[0]*(mb_y*2 + 2) - 1;
252444e5259b optimization
michaelni
parents: 265
diff changeset
2675 s->block_index[3]= s->block_wrap[0]*(mb_y*2 + 2);
252444e5259b optimization
michaelni
parents: 265
diff changeset
2676 s->block_index[4]= s->block_wrap[4]*(mb_y + 1) + s->block_wrap[0]*(s->mb_height*2 + 2);
252444e5259b optimization
michaelni
parents: 265
diff changeset
2677 s->block_index[5]= s->block_wrap[4]*(mb_y + 1 + s->mb_height + 2) + s->block_wrap[0]*(s->mb_height*2 + 2);
232
b640ec5948b0 - Now the ME is done for the entire picture when enconding, the
pulento
parents: 231
diff changeset
2678 for(mb_x=0; mb_x < s->mb_width; mb_x++) {
327
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 326
diff changeset
2679 const int mb_type= s->mb_type[mb_y * s->mb_width + mb_x];
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 326
diff changeset
2680 const int xy= (mb_y+1) * (s->mb_width+2) + mb_x + 1;
456
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2681 // int d;
294
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 292
diff changeset
2682 int dmin=10000000;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2683
232
b640ec5948b0 - Now the ME is done for the entire picture when enconding, the
pulento
parents: 231
diff changeset
2684 s->mb_x = mb_x;
b640ec5948b0 - Now the ME is done for the entire picture when enconding, the
pulento
parents: 231
diff changeset
2685 s->mb_y = mb_y;
266
252444e5259b optimization
michaelni
parents: 265
diff changeset
2686 s->block_index[0]+=2;
252444e5259b optimization
michaelni
parents: 265
diff changeset
2687 s->block_index[1]+=2;
252444e5259b optimization
michaelni
parents: 265
diff changeset
2688 s->block_index[2]+=2;
252444e5259b optimization
michaelni
parents: 265
diff changeset
2689 s->block_index[3]+=2;
252444e5259b optimization
michaelni
parents: 265
diff changeset
2690 s->block_index[4]++;
252444e5259b optimization
michaelni
parents: 265
diff changeset
2691 s->block_index[5]++;
456
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2692
766
8d36b35a7e6e slice encoding cleanup
michaelni
parents: 764
diff changeset
2693 /* write gob / video packet header */
8d36b35a7e6e slice encoding cleanup
michaelni
parents: 764
diff changeset
2694 if(s->rtp_mode){
8d36b35a7e6e slice encoding cleanup
michaelni
parents: 764
diff changeset
2695 int current_packet_size, is_gob_start;
8d36b35a7e6e slice encoding cleanup
michaelni
parents: 764
diff changeset
2696
8d36b35a7e6e slice encoding cleanup
michaelni
parents: 764
diff changeset
2697 current_packet_size= pbBufPtr(&s->pb) - s->ptr_lastgob;
8d36b35a7e6e slice encoding cleanup
michaelni
parents: 764
diff changeset
2698 is_gob_start=0;
8d36b35a7e6e slice encoding cleanup
michaelni
parents: 764
diff changeset
2699
8d36b35a7e6e slice encoding cleanup
michaelni
parents: 764
diff changeset
2700 if(s->codec_id==CODEC_ID_MPEG4){
8d36b35a7e6e slice encoding cleanup
michaelni
parents: 764
diff changeset
2701 if(current_packet_size + s->mb_line_avgsize/s->mb_width >= s->rtp_payload_size
8d36b35a7e6e slice encoding cleanup
michaelni
parents: 764
diff changeset
2702 && s->mb_y + s->mb_x>0){
8d36b35a7e6e slice encoding cleanup
michaelni
parents: 764
diff changeset
2703
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 731
diff changeset
2704 if(s->partitioned_frame){
456
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2705 ff_mpeg4_merge_partitions(s);
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2706 ff_mpeg4_init_partitions(s);
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2707 }
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2708 ff_mpeg4_encode_video_packet_header(s);
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2709
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2710 if(s->flags&CODEC_FLAG_PASS1){
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2711 int bits= get_bit_count(&s->pb);
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2712 s->misc_bits+= bits - s->last_bits;
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2713 s->last_bits= bits;
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2714 }
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2715 ff_mpeg4_clean_buffers(s);
766
8d36b35a7e6e slice encoding cleanup
michaelni
parents: 764
diff changeset
2716 is_gob_start=1;
456
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2717 }
766
8d36b35a7e6e slice encoding cleanup
michaelni
parents: 764
diff changeset
2718 }else{
8d36b35a7e6e slice encoding cleanup
michaelni
parents: 764
diff changeset
2719 if(current_packet_size + s->mb_line_avgsize*s->gob_index >= s->rtp_payload_size
8d36b35a7e6e slice encoding cleanup
michaelni
parents: 764
diff changeset
2720 && s->mb_x==0 && s->mb_y>0 && s->mb_y%s->gob_index==0){
8d36b35a7e6e slice encoding cleanup
michaelni
parents: 764
diff changeset
2721
8d36b35a7e6e slice encoding cleanup
michaelni
parents: 764
diff changeset
2722 h263_encode_gob_header(s, mb_y);
8d36b35a7e6e slice encoding cleanup
michaelni
parents: 764
diff changeset
2723 is_gob_start=1;
8d36b35a7e6e slice encoding cleanup
michaelni
parents: 764
diff changeset
2724 }
8d36b35a7e6e slice encoding cleanup
michaelni
parents: 764
diff changeset
2725 }
8d36b35a7e6e slice encoding cleanup
michaelni
parents: 764
diff changeset
2726
8d36b35a7e6e slice encoding cleanup
michaelni
parents: 764
diff changeset
2727 if(is_gob_start){
456
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2728 s->ptr_lastgob = pbBufPtr(&s->pb);
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2729 s->first_slice_line=1;
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2730 s->resync_mb_x=mb_x;
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2731 s->resync_mb_y=mb_y;
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2732 }
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 731
diff changeset
2733 }
456
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2734
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 731
diff changeset
2735 if( (s->resync_mb_x == s->mb_x)
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 731
diff changeset
2736 && s->resync_mb_y+1 == s->mb_y){
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 731
diff changeset
2737 s->first_slice_line=0;
456
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2738 }
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2739
294
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 292
diff changeset
2740 if(mb_type & (mb_type-1)){ // more than 1 MB type possible
327
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 326
diff changeset
2741 int next_block=0;
456
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2742 int pb_bits_count, pb2_bits_count, tex_pb_bits_count;
326
6ebb8680885d fixing hq mode with mpeg1 and 2-pass
michaelni
parents: 325
diff changeset
2743
6ebb8680885d fixing hq mode with mpeg1 and 2-pass
michaelni
parents: 325
diff changeset
2744 copy_context_before_encode(&backup_s, s, -1);
456
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2745 backup_s.pb= s->pb;
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2746 best_s.data_partitioning= s->data_partitioning;
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 731
diff changeset
2747 best_s.partitioned_frame= s->partitioned_frame;
456
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2748 if(s->data_partitioning){
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2749 backup_s.pb2= s->pb2;
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2750 backup_s.tex_pb= s->tex_pb;
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2751 }
326
6ebb8680885d fixing hq mode with mpeg1 and 2-pass
michaelni
parents: 325
diff changeset
2752
294
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 292
diff changeset
2753 if(mb_type&MB_TYPE_INTER){
327
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 326
diff changeset
2754 s->mv_dir = MV_DIR_FORWARD;
295
6622b0fd036c mpeg4 4MV encoding
michaelni
parents: 294
diff changeset
2755 s->mv_type = MV_TYPE_16X16;
294
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 292
diff changeset
2756 s->mb_intra= 0;
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
2757 s->mv[0][0][0] = s->p_mv_table[xy][0];
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
2758 s->mv[0][0][1] = s->p_mv_table[xy][1];
456
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2759 encode_mb_hq(s, &backup_s, &best_s, MB_TYPE_INTER, pb, pb2, tex_pb,
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2760 &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2761 }
326
6ebb8680885d fixing hq mode with mpeg1 and 2-pass
michaelni
parents: 325
diff changeset
2762 if(mb_type&MB_TYPE_INTER4V){
327
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 326
diff changeset
2763 s->mv_dir = MV_DIR_FORWARD;
295
6622b0fd036c mpeg4 4MV encoding
michaelni
parents: 294
diff changeset
2764 s->mv_type = MV_TYPE_8X8;
6622b0fd036c mpeg4 4MV encoding
michaelni
parents: 294
diff changeset
2765 s->mb_intra= 0;
6622b0fd036c mpeg4 4MV encoding
michaelni
parents: 294
diff changeset
2766 for(i=0; i<4; i++){
6622b0fd036c mpeg4 4MV encoding
michaelni
parents: 294
diff changeset
2767 s->mv[0][i][0] = s->motion_val[s->block_index[i]][0];
6622b0fd036c mpeg4 4MV encoding
michaelni
parents: 294
diff changeset
2768 s->mv[0][i][1] = s->motion_val[s->block_index[i]][1];
6622b0fd036c mpeg4 4MV encoding
michaelni
parents: 294
diff changeset
2769 }
456
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2770 encode_mb_hq(s, &backup_s, &best_s, MB_TYPE_INTER4V, pb, pb2, tex_pb,
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2771 &dmin, &next_block, 0, 0);
327
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 326
diff changeset
2772 }
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 326
diff changeset
2773 if(mb_type&MB_TYPE_FORWARD){
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 326
diff changeset
2774 s->mv_dir = MV_DIR_FORWARD;
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 326
diff changeset
2775 s->mv_type = MV_TYPE_16X16;
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 326
diff changeset
2776 s->mb_intra= 0;
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 326
diff changeset
2777 s->mv[0][0][0] = s->b_forw_mv_table[xy][0];
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 326
diff changeset
2778 s->mv[0][0][1] = s->b_forw_mv_table[xy][1];
456
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2779 encode_mb_hq(s, &backup_s, &best_s, MB_TYPE_FORWARD, pb, pb2, tex_pb,
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2780 &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
327
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 326
diff changeset
2781 }
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 326
diff changeset
2782 if(mb_type&MB_TYPE_BACKWARD){
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 326
diff changeset
2783 s->mv_dir = MV_DIR_BACKWARD;
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 326
diff changeset
2784 s->mv_type = MV_TYPE_16X16;
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 326
diff changeset
2785 s->mb_intra= 0;
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 326
diff changeset
2786 s->mv[1][0][0] = s->b_back_mv_table[xy][0];
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 326
diff changeset
2787 s->mv[1][0][1] = s->b_back_mv_table[xy][1];
456
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2788 encode_mb_hq(s, &backup_s, &best_s, MB_TYPE_BACKWARD, pb, pb2, tex_pb,
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2789 &dmin, &next_block, s->mv[1][0][0], s->mv[1][0][1]);
327
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 326
diff changeset
2790 }
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 326
diff changeset
2791 if(mb_type&MB_TYPE_BIDIR){
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 326
diff changeset
2792 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 326
diff changeset
2793 s->mv_type = MV_TYPE_16X16;
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 326
diff changeset
2794 s->mb_intra= 0;
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 326
diff changeset
2795 s->mv[0][0][0] = s->b_bidir_forw_mv_table[xy][0];
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 326
diff changeset
2796 s->mv[0][0][1] = s->b_bidir_forw_mv_table[xy][1];
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 326
diff changeset
2797 s->mv[1][0][0] = s->b_bidir_back_mv_table[xy][0];
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 326
diff changeset
2798 s->mv[1][0][1] = s->b_bidir_back_mv_table[xy][1];
456
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2799 encode_mb_hq(s, &backup_s, &best_s, MB_TYPE_BIDIR, pb, pb2, tex_pb,
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2800 &dmin, &next_block, 0, 0);
327
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 326
diff changeset
2801 }
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 326
diff changeset
2802 if(mb_type&MB_TYPE_DIRECT){
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 326
diff changeset
2803 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 326
diff changeset
2804 s->mv_type = MV_TYPE_16X16; //FIXME
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 326
diff changeset
2805 s->mb_intra= 0;
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 326
diff changeset
2806 s->mv[0][0][0] = s->b_direct_forw_mv_table[xy][0];
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 326
diff changeset
2807 s->mv[0][0][1] = s->b_direct_forw_mv_table[xy][1];
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 326
diff changeset
2808 s->mv[1][0][0] = s->b_direct_back_mv_table[xy][0];
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 326
diff changeset
2809 s->mv[1][0][1] = s->b_direct_back_mv_table[xy][1];
456
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2810 encode_mb_hq(s, &backup_s, &best_s, MB_TYPE_DIRECT, pb, pb2, tex_pb,
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2811 &dmin, &next_block, s->b_direct_mv_table[xy][0], s->b_direct_mv_table[xy][1]);
295
6622b0fd036c mpeg4 4MV encoding
michaelni
parents: 294
diff changeset
2812 }
294
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 292
diff changeset
2813 if(mb_type&MB_TYPE_INTRA){
327
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 326
diff changeset
2814 s->mv_dir = MV_DIR_FORWARD;
295
6622b0fd036c mpeg4 4MV encoding
michaelni
parents: 294
diff changeset
2815 s->mv_type = MV_TYPE_16X16;
294
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 292
diff changeset
2816 s->mb_intra= 1;
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 292
diff changeset
2817 s->mv[0][0][0] = 0;
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 292
diff changeset
2818 s->mv[0][0][1] = 0;
456
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2819 encode_mb_hq(s, &backup_s, &best_s, MB_TYPE_INTRA, pb, pb2, tex_pb,
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2820 &dmin, &next_block, 0, 0);
326
6ebb8680885d fixing hq mode with mpeg1 and 2-pass
michaelni
parents: 325
diff changeset
2821 /* force cleaning of ac/dc pred stuff if needed ... */
6ebb8680885d fixing hq mode with mpeg1 and 2-pass
michaelni
parents: 325
diff changeset
2822 if(s->h263_pred || s->h263_aic)
6ebb8680885d fixing hq mode with mpeg1 and 2-pass
michaelni
parents: 325
diff changeset
2823 s->mbintra_table[mb_x + mb_y*s->mb_width]=1;
295
6622b0fd036c mpeg4 4MV encoding
michaelni
parents: 294
diff changeset
2824 }
326
6ebb8680885d fixing hq mode with mpeg1 and 2-pass
michaelni
parents: 325
diff changeset
2825 copy_context_after_encode(s, &best_s, -1);
456
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2826
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2827 pb_bits_count= get_bit_count(&s->pb);
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2828 flush_put_bits(&s->pb);
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2829 ff_copy_bits(&backup_s.pb, bit_buf[next_block^1], pb_bits_count);
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2830 s->pb= backup_s.pb;
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2831
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2832 if(s->data_partitioning){
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2833 pb2_bits_count= get_bit_count(&s->pb2);
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2834 flush_put_bits(&s->pb2);
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2835 ff_copy_bits(&backup_s.pb2, bit_buf2[next_block^1], pb2_bits_count);
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2836 s->pb2= backup_s.pb2;
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2837
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2838 tex_pb_bits_count= get_bit_count(&s->tex_pb);
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2839 flush_put_bits(&s->tex_pb);
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2840 ff_copy_bits(&backup_s.tex_pb, bit_buf_tex[next_block^1], tex_pb_bits_count);
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2841 s->tex_pb= backup_s.tex_pb;
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2842 }
329
5cc47d0ba53e fixed ratecontrol & b-frames
michaelni
parents: 327
diff changeset
2843 s->last_bits= get_bit_count(&s->pb);
294
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 292
diff changeset
2844 } else {
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
2845 int motion_x, motion_y;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
2846 s->mv_type=MV_TYPE_16X16;
294
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 292
diff changeset
2847 // only one MB-Type possible
327
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 326
diff changeset
2848 switch(mb_type){
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 326
diff changeset
2849 case MB_TYPE_INTRA:
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
2850 s->mv_dir = MV_DIR_FORWARD;
294
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 292
diff changeset
2851 s->mb_intra= 1;
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
2852 motion_x= s->mv[0][0][0] = 0;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
2853 motion_y= s->mv[0][0][1] = 0;
327
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 326
diff changeset
2854 break;
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 326
diff changeset
2855 case MB_TYPE_INTER:
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
2856 s->mv_dir = MV_DIR_FORWARD;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
2857 s->mb_intra= 0;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
2858 motion_x= s->mv[0][0][0] = s->p_mv_table[xy][0];
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
2859 motion_y= s->mv[0][0][1] = s->p_mv_table[xy][1];
327
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 326
diff changeset
2860 break;
456
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2861 case MB_TYPE_INTER4V:
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2862 s->mv_dir = MV_DIR_FORWARD;
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2863 s->mv_type = MV_TYPE_8X8;
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2864 s->mb_intra= 0;
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2865 for(i=0; i<4; i++){
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2866 s->mv[0][i][0] = s->motion_val[s->block_index[i]][0];
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2867 s->mv[0][i][1] = s->motion_val[s->block_index[i]][1];
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2868 }
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2869 motion_x= motion_y= 0;
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2870 break;
327
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 326
diff changeset
2871 case MB_TYPE_DIRECT:
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
2872 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
2873 s->mb_intra= 0;
327
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 326
diff changeset
2874 motion_x=s->b_direct_mv_table[xy][0];
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 326
diff changeset
2875 motion_y=s->b_direct_mv_table[xy][1];
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 326
diff changeset
2876 s->mv[0][0][0] = s->b_direct_forw_mv_table[xy][0];
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 326
diff changeset
2877 s->mv[0][0][1] = s->b_direct_forw_mv_table[xy][1];
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 326
diff changeset
2878 s->mv[1][0][0] = s->b_direct_back_mv_table[xy][0];
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 326
diff changeset
2879 s->mv[1][0][1] = s->b_direct_back_mv_table[xy][1];
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 326
diff changeset
2880 break;
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 326
diff changeset
2881 case MB_TYPE_BIDIR:
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
2882 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
294
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 292
diff changeset
2883 s->mb_intra= 0;
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
2884 motion_x=0;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
2885 motion_y=0;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
2886 s->mv[0][0][0] = s->b_bidir_forw_mv_table[xy][0];
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
2887 s->mv[0][0][1] = s->b_bidir_forw_mv_table[xy][1];
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
2888 s->mv[1][0][0] = s->b_bidir_back_mv_table[xy][0];
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
2889 s->mv[1][0][1] = s->b_bidir_back_mv_table[xy][1];
327
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 326
diff changeset
2890 break;
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 326
diff changeset
2891 case MB_TYPE_BACKWARD:
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
2892 s->mv_dir = MV_DIR_BACKWARD;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
2893 s->mb_intra= 0;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
2894 motion_x= s->mv[1][0][0] = s->b_back_mv_table[xy][0];
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
2895 motion_y= s->mv[1][0][1] = s->b_back_mv_table[xy][1];
327
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 326
diff changeset
2896 break;
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 326
diff changeset
2897 case MB_TYPE_FORWARD:
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
2898 s->mv_dir = MV_DIR_FORWARD;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
2899 s->mb_intra= 0;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
2900 motion_x= s->mv[0][0][0] = s->b_forw_mv_table[xy][0];
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
2901 motion_y= s->mv[0][0][1] = s->b_forw_mv_table[xy][1];
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
2902 // printf(" %d %d ", motion_x, motion_y);
327
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 326
diff changeset
2903 break;
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 326
diff changeset
2904 default:
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
2905 motion_x=motion_y=0; //gcc warning fix
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
2906 printf("illegal MB type\n");
294
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 292
diff changeset
2907 }
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
2908 encode_mb(s, motion_x, motion_y);
248
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 244
diff changeset
2909 }
327
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 326
diff changeset
2910 /* clean the MV table in IPS frames for direct mode in B frames */
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 326
diff changeset
2911 if(s->mb_intra /* && I,P,S_TYPE */){
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 326
diff changeset
2912 s->p_mv_table[xy][0]=0;
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 326
diff changeset
2913 s->p_mv_table[xy][1]=0;
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 326
diff changeset
2914 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2915
13
174ef88f619a use block[] in structure to have it aligned on 8 bytes for mmx optimizations - dct_unquantize is always a function pointer - added specialized dct_unquantize_h263
glantau
parents: 8
diff changeset
2916 MPV_decode_mb(s, s->block);
456
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2917 //printf("MB %d %d bits\n", s->mb_x+s->mb_y*s->mb_width, get_bit_count(&s->pb));
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2918 }
234
5fc0c3af3fe4 alternative bitstream writer (disabled by default, uncomment #define ALT_BISTREAM_WRITER in common.h if u want to try it)
michaelni
parents: 233
diff changeset
2919
5fc0c3af3fe4 alternative bitstream writer (disabled by default, uncomment #define ALT_BISTREAM_WRITER in common.h if u want to try it)
michaelni
parents: 233
diff changeset
2920
766
8d36b35a7e6e slice encoding cleanup
michaelni
parents: 764
diff changeset
2921 /* Obtain average mb_row size for RTP */
231
840cd25bf259 - Fixes on RTP and GOB headers for H.263.
pulento
parents: 230
diff changeset
2922 if (s->rtp_mode) {
766
8d36b35a7e6e slice encoding cleanup
michaelni
parents: 764
diff changeset
2923 if (mb_y==0)
234
5fc0c3af3fe4 alternative bitstream writer (disabled by default, uncomment #define ALT_BISTREAM_WRITER in common.h if u want to try it)
michaelni
parents: 233
diff changeset
2924 s->mb_line_avgsize = pbBufPtr(&s->pb) - s->ptr_last_mb_line;
766
8d36b35a7e6e slice encoding cleanup
michaelni
parents: 764
diff changeset
2925 else {
234
5fc0c3af3fe4 alternative bitstream writer (disabled by default, uncomment #define ALT_BISTREAM_WRITER in common.h if u want to try it)
michaelni
parents: 233
diff changeset
2926 s->mb_line_avgsize = (s->mb_line_avgsize + pbBufPtr(&s->pb) - s->ptr_last_mb_line) >> 1;
231
840cd25bf259 - Fixes on RTP and GOB headers for H.263.
pulento
parents: 230
diff changeset
2927 }
766
8d36b35a7e6e slice encoding cleanup
michaelni
parents: 764
diff changeset
2928 s->ptr_last_mb_line = pbBufPtr(&s->pb);
231
840cd25bf259 - Fixes on RTP and GOB headers for H.263.
pulento
parents: 230
diff changeset
2929 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2930 }
294
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 292
diff changeset
2931 emms_c();
286
91f7c38f5f37 statistics for 2-pass encoding
michaelni
parents: 281
diff changeset
2932
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 731
diff changeset
2933 if(s->codec_id==CODEC_ID_MPEG4 && s->partitioned_frame)
456
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2934 ff_mpeg4_merge_partitions(s);
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2935
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2936 if (s->msmpeg4_version && s->msmpeg4_version<4 && s->pict_type == I_TYPE)
208
2eb04d6be309 (commit by michael)
arpi_esp
parents: 207
diff changeset
2937 msmpeg4_encode_ext_header(s);
2eb04d6be309 (commit by michael)
arpi_esp
parents: 207
diff changeset
2938
456
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2939 if(s->codec_id==CODEC_ID_MPEG4)
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2940 ff_mpeg4_stuffing(&s->pb);
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2941
162
de80712db90b - Preliminary RTP friendly mode for H.263.
pulento
parents: 108
diff changeset
2942 //if (s->gob_number)
de80712db90b - Preliminary RTP friendly mode for H.263.
pulento
parents: 108
diff changeset
2943 // fprintf(stderr,"\nNumber of GOB: %d", s->gob_number);
231
840cd25bf259 - Fixes on RTP and GOB headers for H.263.
pulento
parents: 230
diff changeset
2944
840cd25bf259 - Fixes on RTP and GOB headers for H.263.
pulento
parents: 230
diff changeset
2945 /* Send the last GOB if RTP */
840cd25bf259 - Fixes on RTP and GOB headers for H.263.
pulento
parents: 230
diff changeset
2946 if (s->rtp_mode) {
840cd25bf259 - Fixes on RTP and GOB headers for H.263.
pulento
parents: 230
diff changeset
2947 flush_put_bits(&s->pb);
234
5fc0c3af3fe4 alternative bitstream writer (disabled by default, uncomment #define ALT_BISTREAM_WRITER in common.h if u want to try it)
michaelni
parents: 233
diff changeset
2948 pdif = pbBufPtr(&s->pb) - s->ptr_lastgob;
231
840cd25bf259 - Fixes on RTP and GOB headers for H.263.
pulento
parents: 230
diff changeset
2949 /* Call the RTP callback to send the last GOB */
840cd25bf259 - Fixes on RTP and GOB headers for H.263.
pulento
parents: 230
diff changeset
2950 if (s->rtp_callback)
840cd25bf259 - Fixes on RTP and GOB headers for H.263.
pulento
parents: 230
diff changeset
2951 s->rtp_callback(s->ptr_lastgob, pdif, s->gob_number);
234
5fc0c3af3fe4 alternative bitstream writer (disabled by default, uncomment #define ALT_BISTREAM_WRITER in common.h if u want to try it)
michaelni
parents: 233
diff changeset
2952 s->ptr_lastgob = pbBufPtr(&s->pb);
231
840cd25bf259 - Fixes on RTP and GOB headers for H.263.
pulento
parents: 230
diff changeset
2953 //fprintf(stderr,"\nGOB: %2d size: %d (last)", s->gob_number, pdif);
840cd25bf259 - Fixes on RTP and GOB headers for H.263.
pulento
parents: 230
diff changeset
2954 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2955 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
2956
220
0b234715e205 (commit by michael)
arpi_esp
parents: 217
diff changeset
2957 static int dct_quantize_c(MpegEncContext *s,
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2958 DCTELEM *block, int n,
344
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
2959 int qscale, int *overflow)
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2960 {
986e461dc072 Initial revision
glantau
parents:
diff changeset
2961 int i, j, level, last_non_zero, q;
986e461dc072 Initial revision
glantau
parents:
diff changeset
2962 const int *qmat;
764
d4726182dfd2 optimize block_permute()
michaelni
parents: 763
diff changeset
2963 const UINT8 *scantable= s->intra_scantable.scantable;
344
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
2964 int bias;
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
2965 int max=0;
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
2966 unsigned int threshold1, threshold2;
456
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2967
625
bb6a69f9d409 slow but accurate integer dct from IJG (should be ok with the LGPL as the old DCT is the fast integer DCT from IJG)
michaelni
parents: 619
diff changeset
2968 s->fdct (block);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2969
986e461dc072 Initial revision
glantau
parents:
diff changeset
2970 if (s->mb_intra) {
350
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 347
diff changeset
2971 if (!s->h263_aic) {
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 347
diff changeset
2972 if (n < 4)
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 347
diff changeset
2973 q = s->y_dc_scale;
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 347
diff changeset
2974 else
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 347
diff changeset
2975 q = s->c_dc_scale;
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 347
diff changeset
2976 q = q << 3;
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 347
diff changeset
2977 } else
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 347
diff changeset
2978 /* For AIC we skip quant/dequant of INTRADC */
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 347
diff changeset
2979 q = 1 << 3;
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 347
diff changeset
2980
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2981 /* note: block[0] is assumed to be positive */
986e461dc072 Initial revision
glantau
parents:
diff changeset
2982 block[0] = (block[0] + (q >> 1)) / q;
986e461dc072 Initial revision
glantau
parents:
diff changeset
2983 i = 1;
986e461dc072 Initial revision
glantau
parents:
diff changeset
2984 last_non_zero = 0;
344
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
2985 qmat = s->q_intra_matrix[qscale];
635
3e0f62e5eed6 dct cleanup
michaelni
parents: 628
diff changeset
2986 bias= s->intra_quant_bias<<(QMAT_SHIFT - QUANT_BIAS_SHIFT);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2987 } else {
986e461dc072 Initial revision
glantau
parents:
diff changeset
2988 i = 0;
986e461dc072 Initial revision
glantau
parents:
diff changeset
2989 last_non_zero = -1;
344
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
2990 qmat = s->q_inter_matrix[qscale];
635
3e0f62e5eed6 dct cleanup
michaelni
parents: 628
diff changeset
2991 bias= s->inter_quant_bias<<(QMAT_SHIFT - QUANT_BIAS_SHIFT);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2992 }
635
3e0f62e5eed6 dct cleanup
michaelni
parents: 628
diff changeset
2993 threshold1= (1<<QMAT_SHIFT) - bias - 1;
3e0f62e5eed6 dct cleanup
michaelni
parents: 628
diff changeset
2994 threshold2= (threshold1<<1);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2995
986e461dc072 Initial revision
glantau
parents:
diff changeset
2996 for(;i<64;i++) {
764
d4726182dfd2 optimize block_permute()
michaelni
parents: 763
diff changeset
2997 j = scantable[i];
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2998 level = block[j];
986e461dc072 Initial revision
glantau
parents:
diff changeset
2999 level = level * qmat[j];
344
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
3000
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
3001 // if( bias+level >= (1<<(QMAT_SHIFT - 3))
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
3002 // || bias-level >= (1<<(QMAT_SHIFT - 3))){
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
3003 if(((unsigned)(level+threshold1))>threshold2){
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
3004 if(level>0){
635
3e0f62e5eed6 dct cleanup
michaelni
parents: 628
diff changeset
3005 level= (bias + level)>>QMAT_SHIFT;
344
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
3006 block[j]= level;
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
3007 }else{
635
3e0f62e5eed6 dct cleanup
michaelni
parents: 628
diff changeset
3008 level= (bias - level)>>QMAT_SHIFT;
344
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
3009 block[j]= -level;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3010 }
344
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
3011 max |=level;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3012 last_non_zero = i;
344
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
3013 }else{
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
3014 block[j]=0;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3015 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
3016 }
344
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
3017 *overflow= s->max_qcoeff < max; //overflow might have happend
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
3018
764
d4726182dfd2 optimize block_permute()
michaelni
parents: 763
diff changeset
3019 /* we need this permutation so that we correct the IDCT, we only permute the !=0 elements */
d4726182dfd2 optimize block_permute()
michaelni
parents: 763
diff changeset
3020 ff_block_permute(block, s->idct_permutation, scantable, last_non_zero);
d4726182dfd2 optimize block_permute()
michaelni
parents: 763
diff changeset
3021
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3022 return last_non_zero;
986e461dc072 Initial revision
glantau
parents:
diff changeset
3023 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
3024
13
174ef88f619a use block[] in structure to have it aligned on 8 bytes for mmx optimizations - dct_unquantize is always a function pointer - added specialized dct_unquantize_h263
glantau
parents: 8
diff changeset
3025 static void dct_unquantize_mpeg1_c(MpegEncContext *s,
174ef88f619a use block[] in structure to have it aligned on 8 bytes for mmx optimizations - dct_unquantize is always a function pointer - added specialized dct_unquantize_h263
glantau
parents: 8
diff changeset
3026 DCTELEM *block, int n, int qscale)
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3027 {
200
6ab301aaa652 (commit by michael)
arpi_esp
parents: 198
diff changeset
3028 int i, level, nCoeffs;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3029 const UINT16 *quant_matrix;
986e461dc072 Initial revision
glantau
parents:
diff changeset
3030
706
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 704
diff changeset
3031 nCoeffs= s->block_last_index[n];
200
6ab301aaa652 (commit by michael)
arpi_esp
parents: 198
diff changeset
3032
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3033 if (s->mb_intra) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
3034 if (n < 4)
986e461dc072 Initial revision
glantau
parents:
diff changeset
3035 block[0] = block[0] * s->y_dc_scale;
986e461dc072 Initial revision
glantau
parents:
diff changeset
3036 else
986e461dc072 Initial revision
glantau
parents:
diff changeset
3037 block[0] = block[0] * s->c_dc_scale;
986e461dc072 Initial revision
glantau
parents:
diff changeset
3038 /* XXX: only mpeg1 */
986e461dc072 Initial revision
glantau
parents:
diff changeset
3039 quant_matrix = s->intra_matrix;
706
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 704
diff changeset
3040 for(i=1;i<=nCoeffs;i++) {
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 704
diff changeset
3041 int j= s->intra_scantable.permutated[i];
200
6ab301aaa652 (commit by michael)
arpi_esp
parents: 198
diff changeset
3042 level = block[j];
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3043 if (level) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
3044 if (level < 0) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
3045 level = -level;
200
6ab301aaa652 (commit by michael)
arpi_esp
parents: 198
diff changeset
3046 level = (int)(level * qscale * quant_matrix[j]) >> 3;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3047 level = (level - 1) | 1;
986e461dc072 Initial revision
glantau
parents:
diff changeset
3048 level = -level;
986e461dc072 Initial revision
glantau
parents:
diff changeset
3049 } else {
200
6ab301aaa652 (commit by michael)
arpi_esp
parents: 198
diff changeset
3050 level = (int)(level * qscale * quant_matrix[j]) >> 3;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3051 level = (level - 1) | 1;
986e461dc072 Initial revision
glantau
parents:
diff changeset
3052 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
3053 #ifdef PARANOID
986e461dc072 Initial revision
glantau
parents:
diff changeset
3054 if (level < -2048 || level > 2047)
986e461dc072 Initial revision
glantau
parents:
diff changeset
3055 fprintf(stderr, "unquant error %d %d\n", i, level);
986e461dc072 Initial revision
glantau
parents:
diff changeset
3056 #endif
200
6ab301aaa652 (commit by michael)
arpi_esp
parents: 198
diff changeset
3057 block[j] = level;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3058 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
3059 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
3060 } else {
986e461dc072 Initial revision
glantau
parents:
diff changeset
3061 i = 0;
344
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
3062 quant_matrix = s->inter_matrix;
706
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 704
diff changeset
3063 for(;i<=nCoeffs;i++) {
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 704
diff changeset
3064 int j= s->intra_scantable.permutated[i];
200
6ab301aaa652 (commit by michael)
arpi_esp
parents: 198
diff changeset
3065 level = block[j];
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3066 if (level) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
3067 if (level < 0) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
3068 level = -level;
986e461dc072 Initial revision
glantau
parents:
diff changeset
3069 level = (((level << 1) + 1) * qscale *
200
6ab301aaa652 (commit by michael)
arpi_esp
parents: 198
diff changeset
3070 ((int) (quant_matrix[j]))) >> 4;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3071 level = (level - 1) | 1;
986e461dc072 Initial revision
glantau
parents:
diff changeset
3072 level = -level;
986e461dc072 Initial revision
glantau
parents:
diff changeset
3073 } else {
986e461dc072 Initial revision
glantau
parents:
diff changeset
3074 level = (((level << 1) + 1) * qscale *
200
6ab301aaa652 (commit by michael)
arpi_esp
parents: 198
diff changeset
3075 ((int) (quant_matrix[j]))) >> 4;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3076 level = (level - 1) | 1;
986e461dc072 Initial revision
glantau
parents:
diff changeset
3077 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
3078 #ifdef PARANOID
986e461dc072 Initial revision
glantau
parents:
diff changeset
3079 if (level < -2048 || level > 2047)
986e461dc072 Initial revision
glantau
parents:
diff changeset
3080 fprintf(stderr, "unquant error %d %d\n", i, level);
986e461dc072 Initial revision
glantau
parents:
diff changeset
3081 #endif
200
6ab301aaa652 (commit by michael)
arpi_esp
parents: 198
diff changeset
3082 block[j] = level;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3083 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
3084 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
3085 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
3086 }
13
174ef88f619a use block[] in structure to have it aligned on 8 bytes for mmx optimizations - dct_unquantize is always a function pointer - added specialized dct_unquantize_h263
glantau
parents: 8
diff changeset
3087
325
15efd80cf51e mpeg2/mpeg4 dequantizer support (c & mmx)
michaelni
parents: 324
diff changeset
3088 static void dct_unquantize_mpeg2_c(MpegEncContext *s,
15efd80cf51e mpeg2/mpeg4 dequantizer support (c & mmx)
michaelni
parents: 324
diff changeset
3089 DCTELEM *block, int n, int qscale)
15efd80cf51e mpeg2/mpeg4 dequantizer support (c & mmx)
michaelni
parents: 324
diff changeset
3090 {
15efd80cf51e mpeg2/mpeg4 dequantizer support (c & mmx)
michaelni
parents: 324
diff changeset
3091 int i, level, nCoeffs;
15efd80cf51e mpeg2/mpeg4 dequantizer support (c & mmx)
michaelni
parents: 324
diff changeset
3092 const UINT16 *quant_matrix;
15efd80cf51e mpeg2/mpeg4 dequantizer support (c & mmx)
michaelni
parents: 324
diff changeset
3093
706
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 704
diff changeset
3094 if(s->alternate_scan) nCoeffs= 63;
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 704
diff changeset
3095 else nCoeffs= s->block_last_index[n];
325
15efd80cf51e mpeg2/mpeg4 dequantizer support (c & mmx)
michaelni
parents: 324
diff changeset
3096
15efd80cf51e mpeg2/mpeg4 dequantizer support (c & mmx)
michaelni
parents: 324
diff changeset
3097 if (s->mb_intra) {
15efd80cf51e mpeg2/mpeg4 dequantizer support (c & mmx)
michaelni
parents: 324
diff changeset
3098 if (n < 4)
15efd80cf51e mpeg2/mpeg4 dequantizer support (c & mmx)
michaelni
parents: 324
diff changeset
3099 block[0] = block[0] * s->y_dc_scale;
15efd80cf51e mpeg2/mpeg4 dequantizer support (c & mmx)
michaelni
parents: 324
diff changeset
3100 else
15efd80cf51e mpeg2/mpeg4 dequantizer support (c & mmx)
michaelni
parents: 324
diff changeset
3101 block[0] = block[0] * s->c_dc_scale;
15efd80cf51e mpeg2/mpeg4 dequantizer support (c & mmx)
michaelni
parents: 324
diff changeset
3102 quant_matrix = s->intra_matrix;
706
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 704
diff changeset
3103 for(i=1;i<=nCoeffs;i++) {
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 704
diff changeset
3104 int j= s->intra_scantable.permutated[i];
325
15efd80cf51e mpeg2/mpeg4 dequantizer support (c & mmx)
michaelni
parents: 324
diff changeset
3105 level = block[j];
15efd80cf51e mpeg2/mpeg4 dequantizer support (c & mmx)
michaelni
parents: 324
diff changeset
3106 if (level) {
15efd80cf51e mpeg2/mpeg4 dequantizer support (c & mmx)
michaelni
parents: 324
diff changeset
3107 if (level < 0) {
15efd80cf51e mpeg2/mpeg4 dequantizer support (c & mmx)
michaelni
parents: 324
diff changeset
3108 level = -level;
15efd80cf51e mpeg2/mpeg4 dequantizer support (c & mmx)
michaelni
parents: 324
diff changeset
3109 level = (int)(level * qscale * quant_matrix[j]) >> 3;
15efd80cf51e mpeg2/mpeg4 dequantizer support (c & mmx)
michaelni
parents: 324
diff changeset
3110 level = -level;
15efd80cf51e mpeg2/mpeg4 dequantizer support (c & mmx)
michaelni
parents: 324
diff changeset
3111 } else {
15efd80cf51e mpeg2/mpeg4 dequantizer support (c & mmx)
michaelni
parents: 324
diff changeset
3112 level = (int)(level * qscale * quant_matrix[j]) >> 3;
15efd80cf51e mpeg2/mpeg4 dequantizer support (c & mmx)
michaelni
parents: 324
diff changeset
3113 }
15efd80cf51e mpeg2/mpeg4 dequantizer support (c & mmx)
michaelni
parents: 324
diff changeset
3114 #ifdef PARANOID
15efd80cf51e mpeg2/mpeg4 dequantizer support (c & mmx)
michaelni
parents: 324
diff changeset
3115 if (level < -2048 || level > 2047)
15efd80cf51e mpeg2/mpeg4 dequantizer support (c & mmx)
michaelni
parents: 324
diff changeset
3116 fprintf(stderr, "unquant error %d %d\n", i, level);
15efd80cf51e mpeg2/mpeg4 dequantizer support (c & mmx)
michaelni
parents: 324
diff changeset
3117 #endif
15efd80cf51e mpeg2/mpeg4 dequantizer support (c & mmx)
michaelni
parents: 324
diff changeset
3118 block[j] = level;
15efd80cf51e mpeg2/mpeg4 dequantizer support (c & mmx)
michaelni
parents: 324
diff changeset
3119 }
15efd80cf51e mpeg2/mpeg4 dequantizer support (c & mmx)
michaelni
parents: 324
diff changeset
3120 }
15efd80cf51e mpeg2/mpeg4 dequantizer support (c & mmx)
michaelni
parents: 324
diff changeset
3121 } else {
15efd80cf51e mpeg2/mpeg4 dequantizer support (c & mmx)
michaelni
parents: 324
diff changeset
3122 int sum=-1;
15efd80cf51e mpeg2/mpeg4 dequantizer support (c & mmx)
michaelni
parents: 324
diff changeset
3123 i = 0;
344
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
3124 quant_matrix = s->inter_matrix;
706
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 704
diff changeset
3125 for(;i<=nCoeffs;i++) {
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 704
diff changeset
3126 int j= s->intra_scantable.permutated[i];
325
15efd80cf51e mpeg2/mpeg4 dequantizer support (c & mmx)
michaelni
parents: 324
diff changeset
3127 level = block[j];
15efd80cf51e mpeg2/mpeg4 dequantizer support (c & mmx)
michaelni
parents: 324
diff changeset
3128 if (level) {
15efd80cf51e mpeg2/mpeg4 dequantizer support (c & mmx)
michaelni
parents: 324
diff changeset
3129 if (level < 0) {
15efd80cf51e mpeg2/mpeg4 dequantizer support (c & mmx)
michaelni
parents: 324
diff changeset
3130 level = -level;
15efd80cf51e mpeg2/mpeg4 dequantizer support (c & mmx)
michaelni
parents: 324
diff changeset
3131 level = (((level << 1) + 1) * qscale *
15efd80cf51e mpeg2/mpeg4 dequantizer support (c & mmx)
michaelni
parents: 324
diff changeset
3132 ((int) (quant_matrix[j]))) >> 4;
15efd80cf51e mpeg2/mpeg4 dequantizer support (c & mmx)
michaelni
parents: 324
diff changeset
3133 level = -level;
15efd80cf51e mpeg2/mpeg4 dequantizer support (c & mmx)
michaelni
parents: 324
diff changeset
3134 } else {
15efd80cf51e mpeg2/mpeg4 dequantizer support (c & mmx)
michaelni
parents: 324
diff changeset
3135 level = (((level << 1) + 1) * qscale *
15efd80cf51e mpeg2/mpeg4 dequantizer support (c & mmx)
michaelni
parents: 324
diff changeset
3136 ((int) (quant_matrix[j]))) >> 4;
15efd80cf51e mpeg2/mpeg4 dequantizer support (c & mmx)
michaelni
parents: 324
diff changeset
3137 }
15efd80cf51e mpeg2/mpeg4 dequantizer support (c & mmx)
michaelni
parents: 324
diff changeset
3138 #ifdef PARANOID
15efd80cf51e mpeg2/mpeg4 dequantizer support (c & mmx)
michaelni
parents: 324
diff changeset
3139 if (level < -2048 || level > 2047)
15efd80cf51e mpeg2/mpeg4 dequantizer support (c & mmx)
michaelni
parents: 324
diff changeset
3140 fprintf(stderr, "unquant error %d %d\n", i, level);
15efd80cf51e mpeg2/mpeg4 dequantizer support (c & mmx)
michaelni
parents: 324
diff changeset
3141 #endif
15efd80cf51e mpeg2/mpeg4 dequantizer support (c & mmx)
michaelni
parents: 324
diff changeset
3142 block[j] = level;
15efd80cf51e mpeg2/mpeg4 dequantizer support (c & mmx)
michaelni
parents: 324
diff changeset
3143 sum+=level;
15efd80cf51e mpeg2/mpeg4 dequantizer support (c & mmx)
michaelni
parents: 324
diff changeset
3144 }
15efd80cf51e mpeg2/mpeg4 dequantizer support (c & mmx)
michaelni
parents: 324
diff changeset
3145 }
15efd80cf51e mpeg2/mpeg4 dequantizer support (c & mmx)
michaelni
parents: 324
diff changeset
3146 block[63]^=sum&1;
15efd80cf51e mpeg2/mpeg4 dequantizer support (c & mmx)
michaelni
parents: 324
diff changeset
3147 }
15efd80cf51e mpeg2/mpeg4 dequantizer support (c & mmx)
michaelni
parents: 324
diff changeset
3148 }
15efd80cf51e mpeg2/mpeg4 dequantizer support (c & mmx)
michaelni
parents: 324
diff changeset
3149
15efd80cf51e mpeg2/mpeg4 dequantizer support (c & mmx)
michaelni
parents: 324
diff changeset
3150
13
174ef88f619a use block[] in structure to have it aligned on 8 bytes for mmx optimizations - dct_unquantize is always a function pointer - added specialized dct_unquantize_h263
glantau
parents: 8
diff changeset
3151 static void dct_unquantize_h263_c(MpegEncContext *s,
174ef88f619a use block[] in structure to have it aligned on 8 bytes for mmx optimizations - dct_unquantize is always a function pointer - added specialized dct_unquantize_h263
glantau
parents: 8
diff changeset
3152 DCTELEM *block, int n, int qscale)
174ef88f619a use block[] in structure to have it aligned on 8 bytes for mmx optimizations - dct_unquantize is always a function pointer - added specialized dct_unquantize_h263
glantau
parents: 8
diff changeset
3153 {
174ef88f619a use block[] in structure to have it aligned on 8 bytes for mmx optimizations - dct_unquantize is always a function pointer - added specialized dct_unquantize_h263
glantau
parents: 8
diff changeset
3154 int i, level, qmul, qadd;
200
6ab301aaa652 (commit by michael)
arpi_esp
parents: 198
diff changeset
3155 int nCoeffs;
249
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
3156
706
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 704
diff changeset
3157 assert(s->block_last_index[n]>=0);
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 704
diff changeset
3158
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 704
diff changeset
3159 qadd = (qscale - 1) | 1;
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 704
diff changeset
3160 qmul = qscale << 1;
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 704
diff changeset
3161
13
174ef88f619a use block[] in structure to have it aligned on 8 bytes for mmx optimizations - dct_unquantize is always a function pointer - added specialized dct_unquantize_h263
glantau
parents: 8
diff changeset
3162 if (s->mb_intra) {
249
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
3163 if (!s->h263_aic) {
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
3164 if (n < 4)
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
3165 block[0] = block[0] * s->y_dc_scale;
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
3166 else
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
3167 block[0] = block[0] * s->c_dc_scale;
706
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 704
diff changeset
3168 }else
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 704
diff changeset
3169 qadd = 0;
13
174ef88f619a use block[] in structure to have it aligned on 8 bytes for mmx optimizations - dct_unquantize is always a function pointer - added specialized dct_unquantize_h263
glantau
parents: 8
diff changeset
3170 i = 1;
706
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 704
diff changeset
3171 nCoeffs= 63; //does not allways use zigzag table
13
174ef88f619a use block[] in structure to have it aligned on 8 bytes for mmx optimizations - dct_unquantize is always a function pointer - added specialized dct_unquantize_h263
glantau
parents: 8
diff changeset
3172 } else {
174ef88f619a use block[] in structure to have it aligned on 8 bytes for mmx optimizations - dct_unquantize is always a function pointer - added specialized dct_unquantize_h263
glantau
parents: 8
diff changeset
3173 i = 0;
706
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 704
diff changeset
3174 nCoeffs= s->intra_scantable.raster_end[ s->block_last_index[n] ];
13
174ef88f619a use block[] in structure to have it aligned on 8 bytes for mmx optimizations - dct_unquantize is always a function pointer - added specialized dct_unquantize_h263
glantau
parents: 8
diff changeset
3175 }
174ef88f619a use block[] in structure to have it aligned on 8 bytes for mmx optimizations - dct_unquantize is always a function pointer - added specialized dct_unquantize_h263
glantau
parents: 8
diff changeset
3176
706
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 704
diff changeset
3177 for(;i<=nCoeffs;i++) {
13
174ef88f619a use block[] in structure to have it aligned on 8 bytes for mmx optimizations - dct_unquantize is always a function pointer - added specialized dct_unquantize_h263
glantau
parents: 8
diff changeset
3178 level = block[i];
174ef88f619a use block[] in structure to have it aligned on 8 bytes for mmx optimizations - dct_unquantize is always a function pointer - added specialized dct_unquantize_h263
glantau
parents: 8
diff changeset
3179 if (level) {
174ef88f619a use block[] in structure to have it aligned on 8 bytes for mmx optimizations - dct_unquantize is always a function pointer - added specialized dct_unquantize_h263
glantau
parents: 8
diff changeset
3180 if (level < 0) {
174ef88f619a use block[] in structure to have it aligned on 8 bytes for mmx optimizations - dct_unquantize is always a function pointer - added specialized dct_unquantize_h263
glantau
parents: 8
diff changeset
3181 level = level * qmul - qadd;
174ef88f619a use block[] in structure to have it aligned on 8 bytes for mmx optimizations - dct_unquantize is always a function pointer - added specialized dct_unquantize_h263
glantau
parents: 8
diff changeset
3182 } else {
174ef88f619a use block[] in structure to have it aligned on 8 bytes for mmx optimizations - dct_unquantize is always a function pointer - added specialized dct_unquantize_h263
glantau
parents: 8
diff changeset
3183 level = level * qmul + qadd;
174ef88f619a use block[] in structure to have it aligned on 8 bytes for mmx optimizations - dct_unquantize is always a function pointer - added specialized dct_unquantize_h263
glantau
parents: 8
diff changeset
3184 }
174ef88f619a use block[] in structure to have it aligned on 8 bytes for mmx optimizations - dct_unquantize is always a function pointer - added specialized dct_unquantize_h263
glantau
parents: 8
diff changeset
3185 #ifdef PARANOID
174ef88f619a use block[] in structure to have it aligned on 8 bytes for mmx optimizations - dct_unquantize is always a function pointer - added specialized dct_unquantize_h263
glantau
parents: 8
diff changeset
3186 if (level < -2048 || level > 2047)
174ef88f619a use block[] in structure to have it aligned on 8 bytes for mmx optimizations - dct_unquantize is always a function pointer - added specialized dct_unquantize_h263
glantau
parents: 8
diff changeset
3187 fprintf(stderr, "unquant error %d %d\n", i, level);
174ef88f619a use block[] in structure to have it aligned on 8 bytes for mmx optimizations - dct_unquantize is always a function pointer - added specialized dct_unquantize_h263
glantau
parents: 8
diff changeset
3188 #endif
174ef88f619a use block[] in structure to have it aligned on 8 bytes for mmx optimizations - dct_unquantize is always a function pointer - added specialized dct_unquantize_h263
glantau
parents: 8
diff changeset
3189 block[i] = level;
174ef88f619a use block[] in structure to have it aligned on 8 bytes for mmx optimizations - dct_unquantize is always a function pointer - added specialized dct_unquantize_h263
glantau
parents: 8
diff changeset
3190 }
174ef88f619a use block[] in structure to have it aligned on 8 bytes for mmx optimizations - dct_unquantize is always a function pointer - added specialized dct_unquantize_h263
glantau
parents: 8
diff changeset
3191 }
174ef88f619a use block[] in structure to have it aligned on 8 bytes for mmx optimizations - dct_unquantize is always a function pointer - added specialized dct_unquantize_h263
glantau
parents: 8
diff changeset
3192 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3193
986e461dc072 Initial revision
glantau
parents:
diff changeset
3194 AVCodec mpeg1video_encoder = {
986e461dc072 Initial revision
glantau
parents:
diff changeset
3195 "mpeg1video",
986e461dc072 Initial revision
glantau
parents:
diff changeset
3196 CODEC_TYPE_VIDEO,
986e461dc072 Initial revision
glantau
parents:
diff changeset
3197 CODEC_ID_MPEG1VIDEO,
986e461dc072 Initial revision
glantau
parents:
diff changeset
3198 sizeof(MpegEncContext),
986e461dc072 Initial revision
glantau
parents:
diff changeset
3199 MPV_encode_init,
986e461dc072 Initial revision
glantau
parents:
diff changeset
3200 MPV_encode_picture,
986e461dc072 Initial revision
glantau
parents:
diff changeset
3201 MPV_encode_end,
986e461dc072 Initial revision
glantau
parents:
diff changeset
3202 };
986e461dc072 Initial revision
glantau
parents:
diff changeset
3203
986e461dc072 Initial revision
glantau
parents:
diff changeset
3204 AVCodec h263_encoder = {
986e461dc072 Initial revision
glantau
parents:
diff changeset
3205 "h263",
986e461dc072 Initial revision
glantau
parents:
diff changeset
3206 CODEC_TYPE_VIDEO,
986e461dc072 Initial revision
glantau
parents:
diff changeset
3207 CODEC_ID_H263,
986e461dc072 Initial revision
glantau
parents:
diff changeset
3208 sizeof(MpegEncContext),
986e461dc072 Initial revision
glantau
parents:
diff changeset
3209 MPV_encode_init,
986e461dc072 Initial revision
glantau
parents:
diff changeset
3210 MPV_encode_picture,
986e461dc072 Initial revision
glantau
parents:
diff changeset
3211 MPV_encode_end,
986e461dc072 Initial revision
glantau
parents:
diff changeset
3212 };
986e461dc072 Initial revision
glantau
parents:
diff changeset
3213
986e461dc072 Initial revision
glantau
parents:
diff changeset
3214 AVCodec h263p_encoder = {
986e461dc072 Initial revision
glantau
parents:
diff changeset
3215 "h263p",
986e461dc072 Initial revision
glantau
parents:
diff changeset
3216 CODEC_TYPE_VIDEO,
986e461dc072 Initial revision
glantau
parents:
diff changeset
3217 CODEC_ID_H263P,
986e461dc072 Initial revision
glantau
parents:
diff changeset
3218 sizeof(MpegEncContext),
986e461dc072 Initial revision
glantau
parents:
diff changeset
3219 MPV_encode_init,
986e461dc072 Initial revision
glantau
parents:
diff changeset
3220 MPV_encode_picture,
986e461dc072 Initial revision
glantau
parents:
diff changeset
3221 MPV_encode_end,
986e461dc072 Initial revision
glantau
parents:
diff changeset
3222 };
986e461dc072 Initial revision
glantau
parents:
diff changeset
3223
986e461dc072 Initial revision
glantau
parents:
diff changeset
3224 AVCodec rv10_encoder = {
986e461dc072 Initial revision
glantau
parents:
diff changeset
3225 "rv10",
986e461dc072 Initial revision
glantau
parents:
diff changeset
3226 CODEC_TYPE_VIDEO,
986e461dc072 Initial revision
glantau
parents:
diff changeset
3227 CODEC_ID_RV10,
986e461dc072 Initial revision
glantau
parents:
diff changeset
3228 sizeof(MpegEncContext),
986e461dc072 Initial revision
glantau
parents:
diff changeset
3229 MPV_encode_init,
986e461dc072 Initial revision
glantau
parents:
diff changeset
3230 MPV_encode_picture,
986e461dc072 Initial revision
glantau
parents:
diff changeset
3231 MPV_encode_end,
986e461dc072 Initial revision
glantau
parents:
diff changeset
3232 };
986e461dc072 Initial revision
glantau
parents:
diff changeset
3233
986e461dc072 Initial revision
glantau
parents:
diff changeset
3234 AVCodec mjpeg_encoder = {
986e461dc072 Initial revision
glantau
parents:
diff changeset
3235 "mjpeg",
986e461dc072 Initial revision
glantau
parents:
diff changeset
3236 CODEC_TYPE_VIDEO,
986e461dc072 Initial revision
glantau
parents:
diff changeset
3237 CODEC_ID_MJPEG,
986e461dc072 Initial revision
glantau
parents:
diff changeset
3238 sizeof(MpegEncContext),
986e461dc072 Initial revision
glantau
parents:
diff changeset
3239 MPV_encode_init,
986e461dc072 Initial revision
glantau
parents:
diff changeset
3240 MPV_encode_picture,
986e461dc072 Initial revision
glantau
parents:
diff changeset
3241 MPV_encode_end,
986e461dc072 Initial revision
glantau
parents:
diff changeset
3242 };
986e461dc072 Initial revision
glantau
parents:
diff changeset
3243
71
79be2c581c01 changed opendivx to mpeg4
glantau
parents: 64
diff changeset
3244 AVCodec mpeg4_encoder = {
79be2c581c01 changed opendivx to mpeg4
glantau
parents: 64
diff changeset
3245 "mpeg4",
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3246 CODEC_TYPE_VIDEO,
71
79be2c581c01 changed opendivx to mpeg4
glantau
parents: 64
diff changeset
3247 CODEC_ID_MPEG4,
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3248 sizeof(MpegEncContext),
986e461dc072 Initial revision
glantau
parents:
diff changeset
3249 MPV_encode_init,
986e461dc072 Initial revision
glantau
parents:
diff changeset
3250 MPV_encode_picture,
986e461dc072 Initial revision
glantau
parents:
diff changeset
3251 MPV_encode_end,
986e461dc072 Initial revision
glantau
parents:
diff changeset
3252 };
986e461dc072 Initial revision
glantau
parents:
diff changeset
3253
307
764aeec1320e msmpeg4v2 decoding (no encoding yet)
michaelni
parents: 302
diff changeset
3254 AVCodec msmpeg4v1_encoder = {
764aeec1320e msmpeg4v2 decoding (no encoding yet)
michaelni
parents: 302
diff changeset
3255 "msmpeg4v1",
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3256 CODEC_TYPE_VIDEO,
307
764aeec1320e msmpeg4v2 decoding (no encoding yet)
michaelni
parents: 302
diff changeset
3257 CODEC_ID_MSMPEG4V1,
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3258 sizeof(MpegEncContext),
986e461dc072 Initial revision
glantau
parents:
diff changeset
3259 MPV_encode_init,
986e461dc072 Initial revision
glantau
parents:
diff changeset
3260 MPV_encode_picture,
986e461dc072 Initial revision
glantau
parents:
diff changeset
3261 MPV_encode_end,
986e461dc072 Initial revision
glantau
parents:
diff changeset
3262 };
307
764aeec1320e msmpeg4v2 decoding (no encoding yet)
michaelni
parents: 302
diff changeset
3263
764aeec1320e msmpeg4v2 decoding (no encoding yet)
michaelni
parents: 302
diff changeset
3264 AVCodec msmpeg4v2_encoder = {
764aeec1320e msmpeg4v2 decoding (no encoding yet)
michaelni
parents: 302
diff changeset
3265 "msmpeg4v2",
764aeec1320e msmpeg4v2 decoding (no encoding yet)
michaelni
parents: 302
diff changeset
3266 CODEC_TYPE_VIDEO,
764aeec1320e msmpeg4v2 decoding (no encoding yet)
michaelni
parents: 302
diff changeset
3267 CODEC_ID_MSMPEG4V2,
764aeec1320e msmpeg4v2 decoding (no encoding yet)
michaelni
parents: 302
diff changeset
3268 sizeof(MpegEncContext),
764aeec1320e msmpeg4v2 decoding (no encoding yet)
michaelni
parents: 302
diff changeset
3269 MPV_encode_init,
764aeec1320e msmpeg4v2 decoding (no encoding yet)
michaelni
parents: 302
diff changeset
3270 MPV_encode_picture,
764aeec1320e msmpeg4v2 decoding (no encoding yet)
michaelni
parents: 302
diff changeset
3271 MPV_encode_end,
764aeec1320e msmpeg4v2 decoding (no encoding yet)
michaelni
parents: 302
diff changeset
3272 };
764aeec1320e msmpeg4v2 decoding (no encoding yet)
michaelni
parents: 302
diff changeset
3273
764aeec1320e msmpeg4v2 decoding (no encoding yet)
michaelni
parents: 302
diff changeset
3274 AVCodec msmpeg4v3_encoder = {
764aeec1320e msmpeg4v2 decoding (no encoding yet)
michaelni
parents: 302
diff changeset
3275 "msmpeg4",
764aeec1320e msmpeg4v2 decoding (no encoding yet)
michaelni
parents: 302
diff changeset
3276 CODEC_TYPE_VIDEO,
764aeec1320e msmpeg4v2 decoding (no encoding yet)
michaelni
parents: 302
diff changeset
3277 CODEC_ID_MSMPEG4V3,
764aeec1320e msmpeg4v2 decoding (no encoding yet)
michaelni
parents: 302
diff changeset
3278 sizeof(MpegEncContext),
764aeec1320e msmpeg4v2 decoding (no encoding yet)
michaelni
parents: 302
diff changeset
3279 MPV_encode_init,
764aeec1320e msmpeg4v2 decoding (no encoding yet)
michaelni
parents: 302
diff changeset
3280 MPV_encode_picture,
764aeec1320e msmpeg4v2 decoding (no encoding yet)
michaelni
parents: 302
diff changeset
3281 MPV_encode_end,
764aeec1320e msmpeg4v2 decoding (no encoding yet)
michaelni
parents: 302
diff changeset
3282 };
499
8b7a54d58549 wmv1 support
michaelni
parents: 487
diff changeset
3283
8b7a54d58549 wmv1 support
michaelni
parents: 487
diff changeset
3284 AVCodec wmv1_encoder = {
8b7a54d58549 wmv1 support
michaelni
parents: 487
diff changeset
3285 "wmv1",
8b7a54d58549 wmv1 support
michaelni
parents: 487
diff changeset
3286 CODEC_TYPE_VIDEO,
8b7a54d58549 wmv1 support
michaelni
parents: 487
diff changeset
3287 CODEC_ID_WMV1,
8b7a54d58549 wmv1 support
michaelni
parents: 487
diff changeset
3288 sizeof(MpegEncContext),
8b7a54d58549 wmv1 support
michaelni
parents: 487
diff changeset
3289 MPV_encode_init,
8b7a54d58549 wmv1 support
michaelni
parents: 487
diff changeset
3290 MPV_encode_picture,
8b7a54d58549 wmv1 support
michaelni
parents: 487
diff changeset
3291 MPV_encode_end,
8b7a54d58549 wmv1 support
michaelni
parents: 487
diff changeset
3292 };
8b7a54d58549 wmv1 support
michaelni
parents: 487
diff changeset
3293
8b7a54d58549 wmv1 support
michaelni
parents: 487
diff changeset
3294 AVCodec wmv2_encoder = {
8b7a54d58549 wmv1 support
michaelni
parents: 487
diff changeset
3295 "wmv2",
8b7a54d58549 wmv1 support
michaelni
parents: 487
diff changeset
3296 CODEC_TYPE_VIDEO,
8b7a54d58549 wmv1 support
michaelni
parents: 487
diff changeset
3297 CODEC_ID_WMV2,
8b7a54d58549 wmv1 support
michaelni
parents: 487
diff changeset
3298 sizeof(MpegEncContext),
8b7a54d58549 wmv1 support
michaelni
parents: 487
diff changeset
3299 MPV_encode_init,
8b7a54d58549 wmv1 support
michaelni
parents: 487
diff changeset
3300 MPV_encode_picture,
8b7a54d58549 wmv1 support
michaelni
parents: 487
diff changeset
3301 MPV_encode_end,
8b7a54d58549 wmv1 support
michaelni
parents: 487
diff changeset
3302 };