annotate mpegvideo.c @ 721:71f669e9f633 libavcodec

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