annotate mpegvideo.c @ 1095:c7604e6291c5 libavcodec

extended option for h263+ patch by (fixounet at free dot fr) with some minor modifications
author michaelni
date Wed, 05 Mar 2003 16:10:13 +0000
parents 0ed00edd4d74
children 5e6e505d8997
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>
1021
2d7c9f5738de trying to fix mb skip bug in mpeg1/2 if slices are not used
michaelni
parents: 1014
diff changeset
23 #include <limits.h>
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
24 #include "avcodec.h"
986e461dc072 Initial revision
glantau
parents:
diff changeset
25 #include "dsputil.h"
986e461dc072 Initial revision
glantau
parents:
diff changeset
26 #include "mpegvideo.h"
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
1070
6da5ae9ee199 more #ifdef CONFIG_ENCODERS patch by (Wolfgang Hesseler <qv at multimediaware dot com>) with modifications by me (s/WOLFGANG/CONFIG_ENCODERS/ and some other fixes)
michaelni
parents: 1064
diff changeset
35 #ifdef CONFIG_ENCODERS
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
36 static void encode_picture(MpegEncContext *s, int picture_number);
1070
6da5ae9ee199 more #ifdef CONFIG_ENCODERS patch by (Wolfgang Hesseler <qv at multimediaware dot com>) with modifications by me (s/WOLFGANG/CONFIG_ENCODERS/ and some other fixes)
michaelni
parents: 1064
diff changeset
37 #endif //CONFIG_ENCODERS
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
38 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
39 DCTELEM *block, int n, int qscale);
325
15efd80cf51e mpeg2/mpeg4 dequantizer support (c & mmx)
michaelni
parents: 324
diff changeset
40 static void dct_unquantize_mpeg2_c(MpegEncContext *s,
15efd80cf51e mpeg2/mpeg4 dequantizer support (c & mmx)
michaelni
parents: 324
diff changeset
41 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
42 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
43 DCTELEM *block, int n, int qscale);
1064
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1059
diff changeset
44 static void draw_edges_c(uint8_t *buf, int wrap, int width, int height, int w);
1070
6da5ae9ee199 more #ifdef CONFIG_ENCODERS patch by (Wolfgang Hesseler <qv at multimediaware dot com>) with modifications by me (s/WOLFGANG/CONFIG_ENCODERS/ and some other fixes)
michaelni
parents: 1064
diff changeset
45 #ifdef CONFIG_ENCODERS
344
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
46 static int dct_quantize_c(MpegEncContext *s, DCTELEM *block, int n, int qscale, int *overflow);
945
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
47 static int dct_quantize_trellis_c(MpegEncContext *s, DCTELEM *block, int n, int qscale, int *overflow);
1070
6da5ae9ee199 more #ifdef CONFIG_ENCODERS patch by (Wolfgang Hesseler <qv at multimediaware dot com>) with modifications by me (s/WOLFGANG/CONFIG_ENCODERS/ and some other fixes)
michaelni
parents: 1064
diff changeset
48 #endif //CONFIG_ENCODERS
206
994aa8623443 (commit by michael)
arpi_esp
parents: 200
diff changeset
49
1064
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1059
diff changeset
50 void (*draw_edges)(uint8_t *buf, int wrap, int width, int height, int w)= draw_edges_c;
206
994aa8623443 (commit by michael)
arpi_esp
parents: 200
diff changeset
51
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
52
986e461dc072 Initial revision
glantau
parents:
diff changeset
53 /* enable all paranoid tests for rounding, overflows, etc... */
986e461dc072 Initial revision
glantau
parents:
diff changeset
54 //#define PARANOID
986e461dc072 Initial revision
glantau
parents:
diff changeset
55
986e461dc072 Initial revision
glantau
parents:
diff changeset
56 //#define DEBUG
986e461dc072 Initial revision
glantau
parents:
diff changeset
57
321
2b00e171b1d4 - ME method compatibility with legacy apps.
pulento
parents: 320
diff changeset
58
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
59 /* for jpeg fast DCT */
986e461dc072 Initial revision
glantau
parents:
diff changeset
60 #define CONST_BITS 14
986e461dc072 Initial revision
glantau
parents:
diff changeset
61
853
eacc2dd8fd9d * using DSPContext - so each codec could use its local (sub)set of CPU extension
kabi
parents: 847
diff changeset
62 static const uint16_t aanscales[64] = {
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
63 /* precomputed values scaled up by 14 bits */
986e461dc072 Initial revision
glantau
parents:
diff changeset
64 16384, 22725, 21407, 19266, 16384, 12873, 8867, 4520,
986e461dc072 Initial revision
glantau
parents:
diff changeset
65 22725, 31521, 29692, 26722, 22725, 17855, 12299, 6270,
986e461dc072 Initial revision
glantau
parents:
diff changeset
66 21407, 29692, 27969, 25172, 21407, 16819, 11585, 5906,
986e461dc072 Initial revision
glantau
parents:
diff changeset
67 19266, 26722, 25172, 22654, 19266, 15137, 10426, 5315,
986e461dc072 Initial revision
glantau
parents:
diff changeset
68 16384, 22725, 21407, 19266, 16384, 12873, 8867, 4520,
986e461dc072 Initial revision
glantau
parents:
diff changeset
69 12873, 17855, 16819, 15137, 12873, 10114, 6967, 3552,
936
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
70 8867 , 12299, 11585, 10426, 8867, 6967, 4799, 2446,
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
71 4520 , 6270, 5906, 5315, 4520, 3552, 2446, 1247
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
72 };
986e461dc072 Initial revision
glantau
parents:
diff changeset
73
853
eacc2dd8fd9d * using DSPContext - so each codec could use its local (sub)set of CPU extension
kabi
parents: 847
diff changeset
74 static const uint8_t h263_chroma_roundtab[16] = {
1013
5d4c95f323d0 finetuneing thresholds/factors
michaelni
parents: 1011
diff changeset
75 // 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
76 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2,
986e461dc072 Initial revision
glantau
parents:
diff changeset
77 };
986e461dc072 Initial revision
glantau
parents:
diff changeset
78
1070
6da5ae9ee199 more #ifdef CONFIG_ENCODERS patch by (Wolfgang Hesseler <qv at multimediaware dot com>) with modifications by me (s/WOLFGANG/CONFIG_ENCODERS/ and some other fixes)
michaelni
parents: 1064
diff changeset
79 #ifdef CONFIG_ENCODERS
1064
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1059
diff changeset
80 static uint16_t (*default_mv_penalty)[MAX_MV*2+1]=NULL;
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1059
diff changeset
81 static uint8_t default_fcode_tab[MAX_MV*2+1];
277
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 271
diff changeset
82
998
6129c88a6393 get_format()
michaelni
parents: 956
diff changeset
83 enum PixelFormat ff_yuv420p_list[2]= {PIX_FMT_YUV420P, -1};
6129c88a6393 get_format()
michaelni
parents: 956
diff changeset
84
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
85 static void convert_matrix(MpegEncContext *s, int (*qmat)[64], uint16_t (*qmat16)[64], uint16_t (*qmat16_bias)[64],
1064
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1059
diff changeset
86 const uint16_t *quant_matrix, int bias, int qmin, int qmax)
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
87 {
344
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
88 int qscale;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
89
709
afeff6ccb7f5 convert only needed matrixes in convert_matrix() (mjpeg calls it for every frame)
michaelni
parents: 706
diff changeset
90 for(qscale=qmin; qscale<=qmax; qscale++){
344
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
91 int i;
1092
f59c3f66363b MpegEncContext.(i)dct_* -> DspContext.(i)dct_*
michaelni
parents: 1089
diff changeset
92 if (s->dsp.fdct == ff_jpeg_fdct_islow) {
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
93 for(i=0;i<64;i++) {
1092
f59c3f66363b MpegEncContext.(i)dct_* -> DspContext.(i)dct_*
michaelni
parents: 1089
diff changeset
94 const int j= s->dsp.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
95 /* 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
96 /* 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
97 /* (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
98 /* 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
99
1064
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1059
diff changeset
100 qmat[qscale][i] = (int)((uint64_t_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
101 (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
102 }
1092
f59c3f66363b MpegEncContext.(i)dct_* -> DspContext.(i)dct_*
michaelni
parents: 1089
diff changeset
103 } else if (s->dsp.fdct == fdct_ifast) {
344
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
104 for(i=0;i<64;i++) {
1092
f59c3f66363b MpegEncContext.(i)dct_* -> DspContext.(i)dct_*
michaelni
parents: 1089
diff changeset
105 const int j= s->dsp.idct_permutation[i];
344
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
106 /* 16 <= qscale * quant_matrix[i] <= 7905 */
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
107 /* 19952 <= aanscales[i] * qscale * quant_matrix[i] <= 249205026 */
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
108 /* (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
109 /* 3444240 >= (1<<36)/(aanscales[i] * qscale * quant_matrix[i]) >= 275 */
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
110
1064
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1059
diff changeset
111 qmat[qscale][i] = (int)((uint64_t_C(1) << (QMAT_SHIFT + 14)) /
344
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
112 (aanscales[i] * qscale * quant_matrix[j]));
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
113 }
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
114 } else {
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
115 for(i=0;i<64;i++) {
1092
f59c3f66363b MpegEncContext.(i)dct_* -> DspContext.(i)dct_*
michaelni
parents: 1089
diff changeset
116 const int j= s->dsp.idct_permutation[i];
344
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
117 /* We can safely suppose that 16 <= quant_matrix[i] <= 255
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
118 So 16 <= qscale * quant_matrix[i] <= 7905
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
119 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
120 so 32768 >= (1<<19) / (qscale * quant_matrix[i]) >= 67
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
121 */
1064
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1059
diff changeset
122 qmat[qscale][i] = (int)((uint64_t_C(1) << QMAT_SHIFT) / (qscale * quant_matrix[j]));
945
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
123 // 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
124 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
125
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
126 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
127 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
128 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
129 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
130 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
131 }
1070
6da5ae9ee199 more #ifdef CONFIG_ENCODERS patch by (Wolfgang Hesseler <qv at multimediaware dot com>) with modifications by me (s/WOLFGANG/CONFIG_ENCODERS/ and some other fixes)
michaelni
parents: 1064
diff changeset
132 #endif //CONFIG_ENCODERS
6da5ae9ee199 more #ifdef CONFIG_ENCODERS patch by (Wolfgang Hesseler <qv at multimediaware dot com>) with modifications by me (s/WOLFGANG/CONFIG_ENCODERS/ and some other fixes)
michaelni
parents: 1064
diff changeset
133
456
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
134 // move into common.c perhaps
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
135 #define CHECKED_ALLOCZ(p, size)\
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
136 {\
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
137 p= av_mallocz(size);\
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
138 if(p==NULL){\
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
139 perror("malloc");\
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
140 goto fail;\
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
141 }\
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
142 }
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 731
diff changeset
143
1064
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1059
diff changeset
144 void ff_init_scantable(MpegEncContext *s, ScanTable *st, const uint8_t *src_scantable){
706
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 704
diff changeset
145 int i;
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 704
diff changeset
146 int end;
764
d4726182dfd2 optimize block_permute()
michaelni
parents: 763
diff changeset
147
d4726182dfd2 optimize block_permute()
michaelni
parents: 763
diff changeset
148 st->scantable= src_scantable;
706
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 for(i=0; i<64; i++){
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 704
diff changeset
151 int j;
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 704
diff changeset
152 j = src_scantable[i];
1092
f59c3f66363b MpegEncContext.(i)dct_* -> DspContext.(i)dct_*
michaelni
parents: 1089
diff changeset
153 st->permutated[i] = s->dsp.idct_permutation[j];
828
ace3ccd18dd2 Altivec Patch (Mark III) by (Dieter Shirley <dieters at schemasoft dot com>)
michaelni
parents: 815
diff changeset
154 #ifdef ARCH_POWERPC
ace3ccd18dd2 Altivec Patch (Mark III) by (Dieter Shirley <dieters at schemasoft dot com>)
michaelni
parents: 815
diff changeset
155 st->inverse[j] = i;
ace3ccd18dd2 Altivec Patch (Mark III) by (Dieter Shirley <dieters at schemasoft dot com>)
michaelni
parents: 815
diff changeset
156 #endif
706
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 704
diff changeset
157 }
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 704
diff changeset
158
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 704
diff changeset
159 end=-1;
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 704
diff changeset
160 for(i=0; i<64; i++){
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 704
diff changeset
161 int j;
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 704
diff changeset
162 j = st->permutated[i];
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 704
diff changeset
163 if(j>end) end=j;
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 704
diff changeset
164 st->raster_end[i]= end;
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 704
diff changeset
165 }
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 704
diff changeset
166 }
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 704
diff changeset
167
726
a91203b34e71 moved dct init out from mpv_common_init to dct_common_init (for less-uglier way for dv)
al3x
parents: 721
diff changeset
168 /* init common dct for both encoder and decoder */
a91203b34e71 moved dct init out from mpv_common_init to dct_common_init (for less-uglier way for dv)
al3x
parents: 721
diff changeset
169 int DCT_common_init(MpegEncContext *s)
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
170 {
312
8cf5507e6ca5 mpeg4 mpeg quantizer support
michaelni
parents: 311
diff changeset
171 s->dct_unquantize_h263 = dct_unquantize_h263_c;
325
15efd80cf51e mpeg2/mpeg4 dequantizer support (c & mmx)
michaelni
parents: 324
diff changeset
172 s->dct_unquantize_mpeg1 = dct_unquantize_mpeg1_c;
15efd80cf51e mpeg2/mpeg4 dequantizer support (c & mmx)
michaelni
parents: 324
diff changeset
173 s->dct_unquantize_mpeg2 = dct_unquantize_mpeg2_c;
1092
f59c3f66363b MpegEncContext.(i)dct_* -> DspContext.(i)dct_*
michaelni
parents: 1089
diff changeset
174
1070
6da5ae9ee199 more #ifdef CONFIG_ENCODERS patch by (Wolfgang Hesseler <qv at multimediaware dot com>) with modifications by me (s/WOLFGANG/CONFIG_ENCODERS/ and some other fixes)
michaelni
parents: 1064
diff changeset
175 #ifdef CONFIG_ENCODERS
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
176 s->dct_quantize= dct_quantize_c;
1092
f59c3f66363b MpegEncContext.(i)dct_* -> DspContext.(i)dct_*
michaelni
parents: 1089
diff changeset
177 #endif
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
178
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
179 #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
180 MPV_common_init_mmx(s);
8
1b4461b5a7fb Sync with mplayer's stuff
nickols_k
parents: 7
diff changeset
181 #endif
514
c9f724e3a797 Update and activate dct_unquantize_h263_mvi. Thanks to M«©ns Rullg«©rd
mellum
parents: 506
diff changeset
182 #ifdef ARCH_ALPHA
c9f724e3a797 Update and activate dct_unquantize_h263_mvi. Thanks to M«©ns Rullg«©rd
mellum
parents: 506
diff changeset
183 MPV_common_init_axp(s);
c9f724e3a797 Update and activate dct_unquantize_h263_mvi. Thanks to M«©ns Rullg«©rd
mellum
parents: 506
diff changeset
184 #endif
628
f596db4aa871 sun solaris compilation bugfix, patch by (Martin Olschewski <olschewski at zpr dot uni-koeln dot de>)
michaelni
parents: 625
diff changeset
185 #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
186 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
187 #endif
721
71f669e9f633 ps2 optimizations update patch by (Leon van Stuivenberg <leonvs at iae dot nl>)
michaelni
parents: 717
diff changeset
188 #ifdef HAVE_MMI
71f669e9f633 ps2 optimizations update patch by (Leon van Stuivenberg <leonvs at iae dot nl>)
michaelni
parents: 717
diff changeset
189 MPV_common_init_mmi(s);
71f669e9f633 ps2 optimizations update patch by (Leon van Stuivenberg <leonvs at iae dot nl>)
michaelni
parents: 717
diff changeset
190 #endif
730
b24ea84b23e2 trying to fix the non-x86 IDCTs (untested)
michaelni
parents: 726
diff changeset
191 #ifdef ARCH_ARMV4L
874
8cc0d241da37 * compilation fix (ARM users please check)
kabi
parents: 862
diff changeset
192 MPV_common_init_armv4l(s);
730
b24ea84b23e2 trying to fix the non-x86 IDCTs (untested)
michaelni
parents: 726
diff changeset
193 #endif
828
ace3ccd18dd2 Altivec Patch (Mark III) by (Dieter Shirley <dieters at schemasoft dot com>)
michaelni
parents: 815
diff changeset
194 #ifdef ARCH_POWERPC
ace3ccd18dd2 Altivec Patch (Mark III) by (Dieter Shirley <dieters at schemasoft dot com>)
michaelni
parents: 815
diff changeset
195 MPV_common_init_ppc(s);
ace3ccd18dd2 Altivec Patch (Mark III) by (Dieter Shirley <dieters at schemasoft dot com>)
michaelni
parents: 815
diff changeset
196 #endif
730
b24ea84b23e2 trying to fix the non-x86 IDCTs (untested)
michaelni
parents: 726
diff changeset
197
1070
6da5ae9ee199 more #ifdef CONFIG_ENCODERS patch by (Wolfgang Hesseler <qv at multimediaware dot com>) with modifications by me (s/WOLFGANG/CONFIG_ENCODERS/ and some other fixes)
michaelni
parents: 1064
diff changeset
198 #ifdef CONFIG_ENCODERS
1007
b2cf2a1d9a51 more compare functions (rd & bit)
michaelni
parents: 1002
diff changeset
199 s->fast_dct_quantize= s->dct_quantize;
b2cf2a1d9a51 more compare functions (rd & bit)
michaelni
parents: 1002
diff changeset
200
945
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
201 if(s->flags&CODEC_FLAG_TRELLIS_QUANT){
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
202 s->dct_quantize= dct_quantize_trellis_c; //move before MPV_common_init_*
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
203 }
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
204
1070
6da5ae9ee199 more #ifdef CONFIG_ENCODERS patch by (Wolfgang Hesseler <qv at multimediaware dot com>) with modifications by me (s/WOLFGANG/CONFIG_ENCODERS/ and some other fixes)
michaelni
parents: 1064
diff changeset
205 #endif //CONFIG_ENCODERS
6da5ae9ee199 more #ifdef CONFIG_ENCODERS patch by (Wolfgang Hesseler <qv at multimediaware dot com>) with modifications by me (s/WOLFGANG/CONFIG_ENCODERS/ and some other fixes)
michaelni
parents: 1064
diff changeset
206
706
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 704
diff changeset
207 /* load & permutate scantables
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 704
diff changeset
208 note: only wmv uses differnt ones
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 704
diff changeset
209 */
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 704
diff changeset
210 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
211 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
212 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
213 ff_init_scantable(s, &s->intra_v_scantable, ff_alternate_vertical_scan);
591
d3f374218030 fixing mpeg4 mpeg quantizers
michaelni
parents: 588
diff changeset
214
726
a91203b34e71 moved dct init out from mpv_common_init to dct_common_init (for less-uglier way for dv)
al3x
parents: 721
diff changeset
215 return 0;
a91203b34e71 moved dct init out from mpv_common_init to dct_common_init (for less-uglier way for dv)
al3x
parents: 721
diff changeset
216 }
a91203b34e71 moved dct init out from mpv_common_init to dct_common_init (for less-uglier way for dv)
al3x
parents: 721
diff changeset
217
903
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
218 /**
924
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
219 * allocates a Picture
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
220 * The pixels are allocated/set by calling get_buffer() if shared=0
903
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
221 */
924
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
222 static int alloc_picture(MpegEncContext *s, Picture *pic, int shared){
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
223
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
224 if(shared){
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
225 assert(pic->data[0]);
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
226 assert(pic->type == 0 || pic->type == FF_BUFFER_TYPE_SHARED);
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
227 pic->type= FF_BUFFER_TYPE_SHARED;
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
228 }else{
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
229 int r;
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
230
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
231 assert(!pic->data[0]);
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
232
925
7fccaa0d699d AVVideoFrame -> AVFrame
michaelni
parents: 924
diff changeset
233 r= s->avctx->get_buffer(s->avctx, (AVFrame*)pic);
924
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
234
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
235 if(r<0 || !pic->age || !pic->type || !pic->data[0]){
1014
48349e11c9b2 C99 initializers and kill warnings patch by (mru at users dot sourceforge dot net (M«©ns Rullg«©rd))
michaelni
parents: 1013
diff changeset
236 fprintf(stderr, "get_buffer() failed (%d %d %d %p)\n", r, pic->age, pic->type, pic->data[0]);
924
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
237 return -1;
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
238 }
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
239
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
240 if(s->linesize && (s->linesize != pic->linesize[0] || s->uvlinesize != pic->linesize[1])){
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
241 fprintf(stderr, "get_buffer() failed (stride changed)\n");
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
242 return -1;
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
243 }
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
244
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
245 if(pic->linesize[1] != pic->linesize[2]){
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
246 fprintf(stderr, "get_buffer() failed (uv stride missmatch)\n");
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
247 return -1;
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
248 }
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
249
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
250 s->linesize = pic->linesize[0];
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
251 s->uvlinesize= pic->linesize[1];
903
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
252 }
924
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
253
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
254 if(pic->qscale_table==NULL){
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
255 if (s->encoding) {
1064
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1059
diff changeset
256 CHECKED_ALLOCZ(pic->mb_var , s->mb_num * sizeof(int16_t))
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1059
diff changeset
257 CHECKED_ALLOCZ(pic->mc_mb_var, s->mb_num * sizeof(int16_t))
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1059
diff changeset
258 CHECKED_ALLOCZ(pic->mb_mean , s->mb_num * sizeof(int8_t))
1013
5d4c95f323d0 finetuneing thresholds/factors
michaelni
parents: 1011
diff changeset
259 CHECKED_ALLOCZ(pic->mb_cmp_score, s->mb_num * sizeof(int32_t))
924
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
260 }
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
261
1064
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1059
diff changeset
262 CHECKED_ALLOCZ(pic->mbskip_table , s->mb_num * sizeof(uint8_t)+1) //the +1 is for the slice end check
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1059
diff changeset
263 CHECKED_ALLOCZ(pic->qscale_table , s->mb_num * sizeof(uint8_t))
924
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
264 pic->qstride= s->mb_width;
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
265 }
903
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
266
1021
2d7c9f5738de trying to fix mb skip bug in mpeg1/2 if slices are not used
michaelni
parents: 1014
diff changeset
267 //it might be nicer if the application would keep track of these but it would require a API change
2d7c9f5738de trying to fix mb skip bug in mpeg1/2 if slices are not used
michaelni
parents: 1014
diff changeset
268 memmove(s->prev_pict_types+1, s->prev_pict_types, PREV_PICT_TYPES_BUFFER_SIZE-1);
2d7c9f5738de trying to fix mb skip bug in mpeg1/2 if slices are not used
michaelni
parents: 1014
diff changeset
269 s->prev_pict_types[0]= s->pict_type;
2d7c9f5738de trying to fix mb skip bug in mpeg1/2 if slices are not used
michaelni
parents: 1014
diff changeset
270 if(pic->age < PREV_PICT_TYPES_BUFFER_SIZE && s->prev_pict_types[pic->age] == B_TYPE)
2d7c9f5738de trying to fix mb skip bug in mpeg1/2 if slices are not used
michaelni
parents: 1014
diff changeset
271 pic->age= INT_MAX; // skiped MBs in b frames are quite rare in mpeg1/2 and its a bit tricky to skip them anyway
2d7c9f5738de trying to fix mb skip bug in mpeg1/2 if slices are not used
michaelni
parents: 1014
diff changeset
272
903
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
273 return 0;
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
274 fail: //for the CHECKED_ALLOCZ macro
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
275 return -1;
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
276 }
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
277
924
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
278 /**
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
279 * deallocates a picture
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
280 */
903
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
281 static void free_picture(MpegEncContext *s, Picture *pic){
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
282 int i;
924
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
283
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
284 if(pic->data[0] && pic->type!=FF_BUFFER_TYPE_SHARED){
925
7fccaa0d699d AVVideoFrame -> AVFrame
michaelni
parents: 924
diff changeset
285 s->avctx->release_buffer(s->avctx, (AVFrame*)pic);
924
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
286 }
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
287
903
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
288 av_freep(&pic->mb_var);
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
289 av_freep(&pic->mc_mb_var);
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
290 av_freep(&pic->mb_mean);
1013
5d4c95f323d0 finetuneing thresholds/factors
michaelni
parents: 1011
diff changeset
291 av_freep(&pic->mb_cmp_score);
903
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
292 av_freep(&pic->mbskip_table);
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
293 av_freep(&pic->qscale_table);
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
294
924
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
295 if(pic->type == FF_BUFFER_TYPE_INTERNAL){
903
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
296 for(i=0; i<4; i++){
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
297 av_freep(&pic->base[i]);
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
298 pic->data[i]= NULL;
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
299 }
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
300 av_freep(&pic->opaque);
924
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
301 pic->type= 0;
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
302 }else if(pic->type == FF_BUFFER_TYPE_SHARED){
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
303 for(i=0; i<4; i++){
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
304 pic->base[i]=
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
305 pic->data[i]= NULL;
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
306 }
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
307 pic->type= 0;
903
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
308 }
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
309 }
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
310
726
a91203b34e71 moved dct init out from mpv_common_init to dct_common_init (for less-uglier way for dv)
al3x
parents: 721
diff changeset
311 /* init common structure for both encoder and decoder */
a91203b34e71 moved dct init out from mpv_common_init to dct_common_init (for less-uglier way for dv)
al3x
parents: 721
diff changeset
312 int MPV_common_init(MpegEncContext *s)
a91203b34e71 moved dct init out from mpv_common_init to dct_common_init (for less-uglier way for dv)
al3x
parents: 721
diff changeset
313 {
756
f2644bb12a43 fixing h263 decoding (did segfault)
michaelni
parents: 755
diff changeset
314 int y_size, c_size, yc_size, i;
726
a91203b34e71 moved dct init out from mpv_common_init to dct_common_init (for less-uglier way for dv)
al3x
parents: 721
diff changeset
315
1092
f59c3f66363b MpegEncContext.(i)dct_* -> DspContext.(i)dct_*
michaelni
parents: 1089
diff changeset
316 dsputil_init(&s->dsp, s->avctx);
726
a91203b34e71 moved dct init out from mpv_common_init to dct_common_init (for less-uglier way for dv)
al3x
parents: 721
diff changeset
317 DCT_common_init(s);
853
eacc2dd8fd9d * using DSPContext - so each codec could use its local (sub)set of CPU extension
kabi
parents: 847
diff changeset
318
754
b2767c9d6455 init flags before using it (found by arpi)
michaelni
parents: 753
diff changeset
319 s->flags= s->avctx->flags;
726
a91203b34e71 moved dct init out from mpv_common_init to dct_common_init (for less-uglier way for dv)
al3x
parents: 721
diff changeset
320
903
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
321 s->mb_width = (s->width + 15) / 16;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
322 s->mb_height = (s->height + 15) / 16;
853
eacc2dd8fd9d * using DSPContext - so each codec could use its local (sub)set of CPU extension
kabi
parents: 847
diff changeset
323
eacc2dd8fd9d * using DSPContext - so each codec could use its local (sub)set of CPU extension
kabi
parents: 847
diff changeset
324 /* set default edge pos, will be overriden in decode_header if needed */
eacc2dd8fd9d * using DSPContext - so each codec could use its local (sub)set of CPU extension
kabi
parents: 847
diff changeset
325 s->h_edge_pos= s->mb_width*16;
eacc2dd8fd9d * using DSPContext - so each codec could use its local (sub)set of CPU extension
kabi
parents: 847
diff changeset
326 s->v_edge_pos= s->mb_height*16;
eacc2dd8fd9d * using DSPContext - so each codec could use its local (sub)set of CPU extension
kabi
parents: 847
diff changeset
327
eacc2dd8fd9d * using DSPContext - so each codec could use its local (sub)set of CPU extension
kabi
parents: 847
diff changeset
328 s->mb_num = s->mb_width * s->mb_height;
eacc2dd8fd9d * using DSPContext - so each codec could use its local (sub)set of CPU extension
kabi
parents: 847
diff changeset
329
756
f2644bb12a43 fixing h263 decoding (did segfault)
michaelni
parents: 755
diff changeset
330 y_size = (2 * s->mb_width + 2) * (2 * s->mb_height + 2);
f2644bb12a43 fixing h263 decoding (did segfault)
michaelni
parents: 755
diff changeset
331 c_size = (s->mb_width + 2) * (s->mb_height + 2);
f2644bb12a43 fixing h263 decoding (did segfault)
michaelni
parents: 755
diff changeset
332 yc_size = y_size + 2 * c_size;
853
eacc2dd8fd9d * using DSPContext - so each codec could use its local (sub)set of CPU extension
kabi
parents: 847
diff changeset
333
701
85b071dfc7e3 ff_get_fourcc() & XVIX support
michaelni
parents: 697
diff changeset
334 /* convert fourcc to upper case */
85b071dfc7e3 ff_get_fourcc() & XVIX support
michaelni
parents: 697
diff changeset
335 s->avctx->fourcc= toupper( s->avctx->fourcc &0xFF)
85b071dfc7e3 ff_get_fourcc() & XVIX support
michaelni
parents: 697
diff changeset
336 + (toupper((s->avctx->fourcc>>8 )&0xFF)<<8 )
85b071dfc7e3 ff_get_fourcc() & XVIX support
michaelni
parents: 697
diff changeset
337 + (toupper((s->avctx->fourcc>>16)&0xFF)<<16)
85b071dfc7e3 ff_get_fourcc() & XVIX support
michaelni
parents: 697
diff changeset
338 + (toupper((s->avctx->fourcc>>24)&0xFF)<<24);
582
5132a4ee50cd different edge positions fixed with edge emu / dr1
michaelni
parents: 575
diff changeset
339
956
45bd748e305f negative linesize support (so mplayer -flip works)
michaelni
parents: 955
diff changeset
340 CHECKED_ALLOCZ(s->allocated_edge_emu_buffer, (s->width+64)*2*17*2); //(width + edge + align)*interlaced*MBsize*tolerance
45bd748e305f negative linesize support (so mplayer -flip works)
michaelni
parents: 955
diff changeset
341 s->edge_emu_buffer= s->allocated_edge_emu_buffer + (s->width+64)*2*17;
903
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
342
925
7fccaa0d699d AVVideoFrame -> AVFrame
michaelni
parents: 924
diff changeset
343 s->avctx->coded_frame= (AVFrame*)&s->current_picture;
903
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
344
232
b640ec5948b0 - Now the ME is done for the entire picture when enconding, the
pulento
parents: 231
diff changeset
345 if (s->encoding) {
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
346 int mv_table_size= (s->mb_width+2)*(s->mb_height+2);
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
347
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
348 /* Allocate MV tables */
1064
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1059
diff changeset
349 CHECKED_ALLOCZ(s->p_mv_table , mv_table_size * 2 * sizeof(int16_t))
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1059
diff changeset
350 CHECKED_ALLOCZ(s->b_forw_mv_table , mv_table_size * 2 * sizeof(int16_t))
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1059
diff changeset
351 CHECKED_ALLOCZ(s->b_back_mv_table , mv_table_size * 2 * sizeof(int16_t))
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1059
diff changeset
352 CHECKED_ALLOCZ(s->b_bidir_forw_mv_table , mv_table_size * 2 * sizeof(int16_t))
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1059
diff changeset
353 CHECKED_ALLOCZ(s->b_bidir_back_mv_table , mv_table_size * 2 * sizeof(int16_t))
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1059
diff changeset
354 CHECKED_ALLOCZ(s->b_direct_mv_table , mv_table_size * 2 * sizeof(int16_t))
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
355
903
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
356 //FIXME should be linesize instead of s->width*2 but that isnt known before get_buffer()
936
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
357 CHECKED_ALLOCZ(s->me.scratchpad, s->width*2*16*3*sizeof(uint8_t))
456
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
358
936
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
359 CHECKED_ALLOCZ(s->me.map , ME_MAP_SIZE*sizeof(uint32_t))
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
360 CHECKED_ALLOCZ(s->me.score_map, ME_MAP_SIZE*sizeof(uint32_t))
327
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 326
diff changeset
361
456
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
362 if(s->codec_id==CODEC_ID_MPEG4){
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
363 CHECKED_ALLOCZ(s->tex_pb_buffer, PB_BUFFER_SIZE);
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
364 CHECKED_ALLOCZ( s->pb2_buffer, PB_BUFFER_SIZE);
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
365 }
612
c0005de2be59 new ratecontrol code
michaelni
parents: 611
diff changeset
366
650
ef4a33aad86e reducing sizeof MpegEncContext to avoid stack overflow on crap M$ windo$
michaelni
parents: 635
diff changeset
367 if(s->msmpeg4_version){
ef4a33aad86e reducing sizeof MpegEncContext to avoid stack overflow on crap M$ windo$
michaelni
parents: 635
diff changeset
368 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
369 }
612
c0005de2be59 new ratecontrol code
michaelni
parents: 611
diff changeset
370 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
371 }
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 731
diff changeset
372
1064
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1059
diff changeset
373 CHECKED_ALLOCZ(s->error_status_table, s->mb_num*sizeof(uint8_t))
232
b640ec5948b0 - Now the ME is done for the entire picture when enconding, the
pulento
parents: 231
diff changeset
374
288
f82cce6cb182 10l (motion_val was uninitilized)
michaelni
parents: 287
diff changeset
375 if (s->out_format == FMT_H263 || s->encoding) {
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
376 int size;
456
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
377 /* Allocate MB type table */
1064
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1059
diff changeset
378 CHECKED_ALLOCZ(s->mb_type , s->mb_num * sizeof(uint8_t))
456
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
379
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
380 /* MV prediction */
986e461dc072 Initial revision
glantau
parents:
diff changeset
381 size = (2 * s->mb_width + 2) * (2 * s->mb_height + 2);
1064
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1059
diff changeset
382 CHECKED_ALLOCZ(s->motion_val, size * 2 * sizeof(int16_t));
664
00a882f626bd interlaced mpeg4 b frame decoding
michaelni
parents: 661
diff changeset
383 }
00a882f626bd interlaced mpeg4 b frame decoding
michaelni
parents: 661
diff changeset
384
00a882f626bd interlaced mpeg4 b frame decoding
michaelni
parents: 661
diff changeset
385 if(s->codec_id==CODEC_ID_MPEG4){
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 731
diff changeset
386 /* interlaced direct mode decoding tables */
1064
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1059
diff changeset
387 CHECKED_ALLOCZ(s->field_mv_table, s->mb_num*2*2 * sizeof(int16_t))
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1059
diff changeset
388 CHECKED_ALLOCZ(s->field_select_table, s->mb_num*2* sizeof(int8_t))
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
389 }
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 731
diff changeset
390 /* 4mv b frame decoding table */
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 731
diff changeset
391 //note this is needed for h263 without b frames too (segfault on damaged streams otherwise)
1064
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1059
diff changeset
392 CHECKED_ALLOCZ(s->co_located_type_table, s->mb_num * sizeof(uint8_t))
767
c75c3f1bef4b regression test for H263+
michaelni
parents: 766
diff changeset
393 if (s->out_format == FMT_H263) {
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
394 /* ac values */
1064
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1059
diff changeset
395 CHECKED_ALLOCZ(s->ac_val[0], yc_size * sizeof(int16_t) * 16);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
396 s->ac_val[1] = s->ac_val[0] + y_size;
986e461dc072 Initial revision
glantau
parents:
diff changeset
397 s->ac_val[2] = s->ac_val[1] + c_size;
986e461dc072 Initial revision
glantau
parents:
diff changeset
398
986e461dc072 Initial revision
glantau
parents:
diff changeset
399 /* cbp values */
456
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
400 CHECKED_ALLOCZ(s->coded_block, y_size);
333
8aa87f1dfc52 divx 5.01 support
michaelni
parents: 329
diff changeset
401
8aa87f1dfc52 divx 5.01 support
michaelni
parents: 329
diff changeset
402 /* divx501 bitstream reorder buffer */
456
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
403 CHECKED_ALLOCZ(s->bitstream_buffer, BITSTREAM_BUFFER_SIZE);
843
8c81f1ee9271 cleanup
michaelni
parents: 842
diff changeset
404
456
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
405 /* cbp, ac_pred, pred_dir */
1064
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1059
diff changeset
406 CHECKED_ALLOCZ(s->cbp_table , s->mb_num * sizeof(uint8_t))
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1059
diff changeset
407 CHECKED_ALLOCZ(s->pred_dir_table, s->mb_num * sizeof(uint8_t))
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
408 }
756
f2644bb12a43 fixing h263 decoding (did segfault)
michaelni
parents: 755
diff changeset
409
f2644bb12a43 fixing h263 decoding (did segfault)
michaelni
parents: 755
diff changeset
410 if (s->h263_pred || s->h263_plus || !s->encoding) {
f2644bb12a43 fixing h263 decoding (did segfault)
michaelni
parents: 755
diff changeset
411 /* dc values */
f2644bb12a43 fixing h263 decoding (did segfault)
michaelni
parents: 755
diff changeset
412 //MN: we need these for error resilience of intra-frames
1064
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1059
diff changeset
413 CHECKED_ALLOCZ(s->dc_val[0], yc_size * sizeof(int16_t));
756
f2644bb12a43 fixing h263 decoding (did segfault)
michaelni
parents: 755
diff changeset
414 s->dc_val[1] = s->dc_val[0] + y_size;
f2644bb12a43 fixing h263 decoding (did segfault)
michaelni
parents: 755
diff changeset
415 s->dc_val[2] = s->dc_val[1] + c_size;
f2644bb12a43 fixing h263 decoding (did segfault)
michaelni
parents: 755
diff changeset
416 for(i=0;i<yc_size;i++)
f2644bb12a43 fixing h263 decoding (did segfault)
michaelni
parents: 755
diff changeset
417 s->dc_val[0][i] = 1024;
f2644bb12a43 fixing h263 decoding (did segfault)
michaelni
parents: 755
diff changeset
418 }
f2644bb12a43 fixing h263 decoding (did segfault)
michaelni
parents: 755
diff changeset
419
611
3214d3f4519e error concealment needs the mbintra_table so it should allways be allocated
michaelni
parents: 608
diff changeset
420 /* which mb is a intra block */
3214d3f4519e error concealment needs the mbintra_table so it should allways be allocated
michaelni
parents: 608
diff changeset
421 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
422 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
423
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
424 /* default structure is frame */
986e461dc072 Initial revision
glantau
parents:
diff changeset
425 s->picture_structure = PICT_FRAME;
553
18ad513d92fe direct rendering method 1 support
michaelni
parents: 549
diff changeset
426
7
1d3ac9654178 added skip macroblock optimization (big perf win on black regions for example)
glantau
parents: 0
diff changeset
427 /* init macroblock skip table */
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 731
diff changeset
428 CHECKED_ALLOCZ(s->mbskip_table, s->mb_num+1);
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 731
diff changeset
429 //Note the +1 is for a quicker mpeg4 slice_end detection
1021
2d7c9f5738de trying to fix mb skip bug in mpeg1/2 if slices are not used
michaelni
parents: 1014
diff changeset
430 CHECKED_ALLOCZ(s->prev_pict_types, PREV_PICT_TYPES_BUFFER_SIZE);
294
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 292
diff changeset
431
327
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 326
diff changeset
432 s->block= s->blocks[0];
7
1d3ac9654178 added skip macroblock optimization (big perf win on black regions for example)
glantau
parents: 0
diff changeset
433
842
e460775adb38 cleanup (breaks compatibility, requested by fabrice)
michaelni
parents: 828
diff changeset
434 s->parse_context.state= -1;
e460775adb38 cleanup (breaks compatibility, requested by fabrice)
michaelni
parents: 828
diff changeset
435
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
436 s->context_initialized = 1;
986e461dc072 Initial revision
glantau
parents:
diff changeset
437 return 0;
986e461dc072 Initial revision
glantau
parents:
diff changeset
438 fail:
244
3860331a1ecb * eliminating duplicated code from MPV_common_end
kabi
parents: 239
diff changeset
439 MPV_common_end(s);
3860331a1ecb * eliminating duplicated code from MPV_common_end
kabi
parents: 239
diff changeset
440 return -1;
3860331a1ecb * eliminating duplicated code from MPV_common_end
kabi
parents: 239
diff changeset
441 }
3860331a1ecb * eliminating duplicated code from MPV_common_end
kabi
parents: 239
diff changeset
442
456
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
443
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
444 //extern int sads;
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
445
244
3860331a1ecb * eliminating duplicated code from MPV_common_end
kabi
parents: 239
diff changeset
446 /* init common structure for both encoder and decoder */
3860331a1ecb * eliminating duplicated code from MPV_common_end
kabi
parents: 239
diff changeset
447 void MPV_common_end(MpegEncContext *s)
3860331a1ecb * eliminating duplicated code from MPV_common_end
kabi
parents: 239
diff changeset
448 {
3860331a1ecb * eliminating duplicated code from MPV_common_end
kabi
parents: 239
diff changeset
449 int i;
3860331a1ecb * eliminating duplicated code from MPV_common_end
kabi
parents: 239
diff changeset
450
396
fce0a2520551 removed useless header includes - use av memory functions
glantau
parents: 376
diff changeset
451 av_freep(&s->mb_type);
fce0a2520551 removed useless header includes - use av memory functions
glantau
parents: 376
diff changeset
452 av_freep(&s->p_mv_table);
fce0a2520551 removed useless header includes - use av memory functions
glantau
parents: 376
diff changeset
453 av_freep(&s->b_forw_mv_table);
fce0a2520551 removed useless header includes - use av memory functions
glantau
parents: 376
diff changeset
454 av_freep(&s->b_back_mv_table);
fce0a2520551 removed useless header includes - use av memory functions
glantau
parents: 376
diff changeset
455 av_freep(&s->b_bidir_forw_mv_table);
fce0a2520551 removed useless header includes - use av memory functions
glantau
parents: 376
diff changeset
456 av_freep(&s->b_bidir_back_mv_table);
fce0a2520551 removed useless header includes - use av memory functions
glantau
parents: 376
diff changeset
457 av_freep(&s->b_direct_mv_table);
fce0a2520551 removed useless header includes - use av memory functions
glantau
parents: 376
diff changeset
458 av_freep(&s->motion_val);
fce0a2520551 removed useless header includes - use av memory functions
glantau
parents: 376
diff changeset
459 av_freep(&s->dc_val[0]);
fce0a2520551 removed useless header includes - use av memory functions
glantau
parents: 376
diff changeset
460 av_freep(&s->ac_val[0]);
fce0a2520551 removed useless header includes - use av memory functions
glantau
parents: 376
diff changeset
461 av_freep(&s->coded_block);
fce0a2520551 removed useless header includes - use av memory functions
glantau
parents: 376
diff changeset
462 av_freep(&s->mbintra_table);
456
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
463 av_freep(&s->cbp_table);
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
464 av_freep(&s->pred_dir_table);
936
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
465 av_freep(&s->me.scratchpad);
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
466 av_freep(&s->me.map);
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
467 av_freep(&s->me.score_map);
456
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
468
396
fce0a2520551 removed useless header includes - use av memory functions
glantau
parents: 376
diff changeset
469 av_freep(&s->mbskip_table);
1021
2d7c9f5738de trying to fix mb skip bug in mpeg1/2 if slices are not used
michaelni
parents: 1014
diff changeset
470 av_freep(&s->prev_pict_types);
396
fce0a2520551 removed useless header includes - use av memory functions
glantau
parents: 376
diff changeset
471 av_freep(&s->bitstream_buffer);
456
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
472 av_freep(&s->tex_pb_buffer);
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
473 av_freep(&s->pb2_buffer);
956
45bd748e305f negative linesize support (so mplayer -flip works)
michaelni
parents: 955
diff changeset
474 av_freep(&s->allocated_edge_emu_buffer); s->edge_emu_buffer= NULL;
664
00a882f626bd interlaced mpeg4 b frame decoding
michaelni
parents: 661
diff changeset
475 av_freep(&s->co_located_type_table);
00a882f626bd interlaced mpeg4 b frame decoding
michaelni
parents: 661
diff changeset
476 av_freep(&s->field_mv_table);
00a882f626bd interlaced mpeg4 b frame decoding
michaelni
parents: 661
diff changeset
477 av_freep(&s->field_select_table);
612
c0005de2be59 new ratecontrol code
michaelni
parents: 611
diff changeset
478 av_freep(&s->avctx->stats_out);
650
ef4a33aad86e reducing sizeof MpegEncContext to avoid stack overflow on crap M$ windo$
michaelni
parents: 635
diff changeset
479 av_freep(&s->ac_stats);
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 731
diff changeset
480 av_freep(&s->error_status_table);
903
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
481
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
482 for(i=0; i<MAX_PICTURE_COUNT; i++){
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
483 free_picture(s, &s->picture[i]);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
484 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
485 s->context_initialized = 0;
986e461dc072 Initial revision
glantau
parents:
diff changeset
486 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
487
1070
6da5ae9ee199 more #ifdef CONFIG_ENCODERS patch by (Wolfgang Hesseler <qv at multimediaware dot com>) with modifications by me (s/WOLFGANG/CONFIG_ENCODERS/ and some other fixes)
michaelni
parents: 1064
diff changeset
488 #ifdef CONFIG_ENCODERS
6da5ae9ee199 more #ifdef CONFIG_ENCODERS patch by (Wolfgang Hesseler <qv at multimediaware dot com>) with modifications by me (s/WOLFGANG/CONFIG_ENCODERS/ and some other fixes)
michaelni
parents: 1064
diff changeset
489
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
490 /* init video encoder */
986e461dc072 Initial revision
glantau
parents:
diff changeset
491 int MPV_encode_init(AVCodecContext *avctx)
986e461dc072 Initial revision
glantau
parents:
diff changeset
492 {
986e461dc072 Initial revision
glantau
parents:
diff changeset
493 MpegEncContext *s = avctx->priv_data;
60
35c1141e23d9 moved matrix init away from MPV_common_init()
glantau
parents: 57
diff changeset
494 int i;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
495
315
40d8092e2ff0 * using pixtype as enum - by Philip Gladstone
kabi
parents: 312
diff changeset
496 avctx->pix_fmt = PIX_FMT_YUV420P;
40d8092e2ff0 * using pixtype as enum - by Philip Gladstone
kabi
parents: 312
diff changeset
497
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
498 s->bit_rate = avctx->bit_rate;
268
09ae29b27ed9 hopefully better bitrate controll
michaelni
parents: 266
diff changeset
499 s->bit_rate_tolerance = avctx->bit_rate_tolerance;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
500 s->frame_rate = avctx->frame_rate;
986e461dc072 Initial revision
glantau
parents:
diff changeset
501 s->width = avctx->width;
986e461dc072 Initial revision
glantau
parents:
diff changeset
502 s->height = avctx->height;
456
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
503 if(avctx->gop_size > 600){
462
3fdd0627f6bd typo (found by Bohdan Horst <nexus at hoth.amu.edu.pl>)
michaelni
parents: 461
diff changeset
504 fprintf(stderr, "Warning keyframe interval too large! reducing it ...\n");
456
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
505 avctx->gop_size=600;
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
506 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
507 s->gop_size = avctx->gop_size;
162
de80712db90b - Preliminary RTP friendly mode for H.263.
pulento
parents: 108
diff changeset
508 s->rtp_mode = avctx->rtp_mode;
de80712db90b - Preliminary RTP friendly mode for H.263.
pulento
parents: 108
diff changeset
509 s->rtp_payload_size = avctx->rtp_payload_size;
231
840cd25bf259 - Fixes on RTP and GOB headers for H.263.
pulento
parents: 230
diff changeset
510 if (avctx->rtp_callback)
840cd25bf259 - Fixes on RTP and GOB headers for H.263.
pulento
parents: 230
diff changeset
511 s->rtp_callback = avctx->rtp_callback;
268
09ae29b27ed9 hopefully better bitrate controll
michaelni
parents: 266
diff changeset
512 s->qmin= avctx->qmin;
09ae29b27ed9 hopefully better bitrate controll
michaelni
parents: 266
diff changeset
513 s->qmax= avctx->qmax;
09ae29b27ed9 hopefully better bitrate controll
michaelni
parents: 266
diff changeset
514 s->max_qdiff= avctx->max_qdiff;
09ae29b27ed9 hopefully better bitrate controll
michaelni
parents: 266
diff changeset
515 s->qcompress= avctx->qcompress;
09ae29b27ed9 hopefully better bitrate controll
michaelni
parents: 266
diff changeset
516 s->qblur= avctx->qblur;
194
27d1773552c9 mpeg4 encoder fix by Michael Niedermayer <michaelni@gmx.at>
arpi_esp
parents: 191
diff changeset
517 s->avctx = avctx;
294
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 292
diff changeset
518 s->flags= avctx->flags;
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
519 s->max_b_frames= avctx->max_b_frames;
329
5cc47d0ba53e fixed ratecontrol & b-frames
michaelni
parents: 327
diff changeset
520 s->b_frame_strategy= avctx->b_frame_strategy;
344
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
521 s->codec_id= avctx->codec->id;
456
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
522 s->luma_elim_threshold = avctx->luma_elim_threshold;
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
523 s->chroma_elim_threshold= avctx->chroma_elim_threshold;
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
524 s->strict_std_compliance= avctx->strict_std_compliance;
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
525 s->data_partitioning= avctx->flags & CODEC_FLAG_PART;
936
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
526 s->quarter_sample= (avctx->flags & CODEC_FLAG_QPEL)!=0;
599
b1a191202f96 mpeg4 mpeg quantizer encoding
michaelni
parents: 598
diff changeset
527 s->mpeg_quant= avctx->mpeg_quant;
344
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
528
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
529 if (s->gop_size <= 1) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
530 s->intra_only = 1;
986e461dc072 Initial revision
glantau
parents:
diff changeset
531 s->gop_size = 12;
986e461dc072 Initial revision
glantau
parents:
diff changeset
532 } else {
986e461dc072 Initial revision
glantau
parents:
diff changeset
533 s->intra_only = 0;
986e461dc072 Initial revision
glantau
parents:
diff changeset
534 }
693
b6a7ff92df57 darkness masking (lumi masking does only bright stuff now)
michaelni
parents: 690
diff changeset
535
936
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
536 s->me_method = avctx->me_method;
693
b6a7ff92df57 darkness masking (lumi masking does only bright stuff now)
michaelni
parents: 690
diff changeset
537
320
cda7d0857baf - ME setting moved to AVCodecContext/MpegEncContext, no longer a global.
pulento
parents: 315
diff changeset
538 /* Fixed QSCALE */
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
539 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
540
690
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 673
diff changeset
541 s->adaptive_quant= ( s->avctx->lumi_masking
693
b6a7ff92df57 darkness masking (lumi masking does only bright stuff now)
michaelni
parents: 690
diff changeset
542 || s->avctx->dark_masking
690
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 673
diff changeset
543 || s->avctx->temporal_cplx_masking
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 673
diff changeset
544 || s->avctx->spatial_cplx_masking
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 673
diff changeset
545 || s->avctx->p_masking)
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 673
diff changeset
546 && !s->fixed_qscale;
697
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
547
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
548 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
549
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
550 switch(avctx->codec->id) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
551 case CODEC_ID_MPEG1VIDEO:
986e461dc072 Initial revision
glantau
parents:
diff changeset
552 s->out_format = FMT_MPEG1;
336
c56b45669214 export delay info
michaelni
parents: 333
diff changeset
553 avctx->delay=0; //FIXME not sure, should check the spec
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
554 break;
986e461dc072 Initial revision
glantau
parents:
diff changeset
555 case CODEC_ID_MJPEG:
986e461dc072 Initial revision
glantau
parents:
diff changeset
556 s->out_format = FMT_MJPEG;
986e461dc072 Initial revision
glantau
parents:
diff changeset
557 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
558 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
559 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
560 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
561 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
562 s->mjpeg_vsample[2] = 1;
370
0eca28d16cbd clamp intra matrix to 8bit for mjpeg (workaround for qscale>=25)
al3x
parents: 365
diff changeset
563 s->mjpeg_hsample[0] = 2;
232
b640ec5948b0 - Now the ME is done for the entire picture when enconding, the
pulento
parents: 231
diff changeset
564 s->mjpeg_hsample[1] = 1;
b640ec5948b0 - Now the ME is done for the entire picture when enconding, the
pulento
parents: 231
diff changeset
565 s->mjpeg_hsample[2] = 1;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
566 if (mjpeg_init(s) < 0)
986e461dc072 Initial revision
glantau
parents:
diff changeset
567 return -1;
336
c56b45669214 export delay info
michaelni
parents: 333
diff changeset
568 avctx->delay=0;
924
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
569 s->low_delay=1;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
570 break;
1042
a78f6f72d54e --disable-risky support
michaelni
parents: 1026
diff changeset
571 #ifdef CONFIG_RISKY
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
572 case CODEC_ID_H263:
232
b640ec5948b0 - Now the ME is done for the entire picture when enconding, the
pulento
parents: 231
diff changeset
573 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
574 printf("Input picture size isn't suitable for h263 codec! try h263+\n");
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
575 return -1;
232
b640ec5948b0 - Now the ME is done for the entire picture when enconding, the
pulento
parents: 231
diff changeset
576 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
577 s->out_format = FMT_H263;
336
c56b45669214 export delay info
michaelni
parents: 333
diff changeset
578 avctx->delay=0;
924
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
579 s->low_delay=1;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
580 break;
986e461dc072 Initial revision
glantau
parents:
diff changeset
581 case CODEC_ID_H263P:
986e461dc072 Initial revision
glantau
parents:
diff changeset
582 s->out_format = FMT_H263;
986e461dc072 Initial revision
glantau
parents:
diff changeset
583 s->h263_plus = 1;
1095
c7604e6291c5 extended option for h263+ patch by (fixounet at free dot fr) with some minor modifications
michaelni
parents: 1094
diff changeset
584 /* Fx */
c7604e6291c5 extended option for h263+ patch by (fixounet at free dot fr) with some minor modifications
michaelni
parents: 1094
diff changeset
585 s->unrestricted_mv=(avctx->flags & CODEC_FLAG_H263P_UMV) ? 1:0;
c7604e6291c5 extended option for h263+ patch by (fixounet at free dot fr) with some minor modifications
michaelni
parents: 1094
diff changeset
586 s->h263_aic= (avctx->flags & CODEC_FLAG_H263P_AIC) ? 1:0;
c7604e6291c5 extended option for h263+ patch by (fixounet at free dot fr) with some minor modifications
michaelni
parents: 1094
diff changeset
587 /* /Fx */
79
82e579c37bc3 Moved some H.263+ variables to MpegEncContext to be thread-safe.
pulento
parents: 78
diff changeset
588 /* These are just to be sure */
1089
7e79a58954b1 h263(+) clenaup & bugfixes
michaelni
parents: 1086
diff changeset
589 s->umvplus = 1;
336
c56b45669214 export delay info
michaelni
parents: 333
diff changeset
590 avctx->delay=0;
924
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
591 s->low_delay=1;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
592 break;
986e461dc072 Initial revision
glantau
parents:
diff changeset
593 case CODEC_ID_RV10:
986e461dc072 Initial revision
glantau
parents:
diff changeset
594 s->out_format = FMT_H263;
986e461dc072 Initial revision
glantau
parents:
diff changeset
595 s->h263_rv10 = 1;
336
c56b45669214 export delay info
michaelni
parents: 333
diff changeset
596 avctx->delay=0;
924
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
597 s->low_delay=1;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
598 break;
71
79be2c581c01 changed opendivx to mpeg4
glantau
parents: 64
diff changeset
599 case CODEC_ID_MPEG4:
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
600 s->out_format = FMT_H263;
986e461dc072 Initial revision
glantau
parents:
diff changeset
601 s->h263_pred = 1;
986e461dc072 Initial revision
glantau
parents:
diff changeset
602 s->unrestricted_mv = 1;
924
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
603 s->low_delay= s->max_b_frames ? 0 : 1;
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 731
diff changeset
604 avctx->delay= s->low_delay ? 0 : (s->max_b_frames + 1);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
605 break;
307
764aeec1320e msmpeg4v2 decoding (no encoding yet)
michaelni
parents: 302
diff changeset
606 case CODEC_ID_MSMPEG4V1:
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
607 s->out_format = FMT_H263;
986e461dc072 Initial revision
glantau
parents:
diff changeset
608 s->h263_msmpeg4 = 1;
986e461dc072 Initial revision
glantau
parents:
diff changeset
609 s->h263_pred = 1;
986e461dc072 Initial revision
glantau
parents:
diff changeset
610 s->unrestricted_mv = 1;
307
764aeec1320e msmpeg4v2 decoding (no encoding yet)
michaelni
parents: 302
diff changeset
611 s->msmpeg4_version= 1;
336
c56b45669214 export delay info
michaelni
parents: 333
diff changeset
612 avctx->delay=0;
924
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
613 s->low_delay=1;
307
764aeec1320e msmpeg4v2 decoding (no encoding yet)
michaelni
parents: 302
diff changeset
614 break;
764aeec1320e msmpeg4v2 decoding (no encoding yet)
michaelni
parents: 302
diff changeset
615 case CODEC_ID_MSMPEG4V2:
764aeec1320e msmpeg4v2 decoding (no encoding yet)
michaelni
parents: 302
diff changeset
616 s->out_format = FMT_H263;
764aeec1320e msmpeg4v2 decoding (no encoding yet)
michaelni
parents: 302
diff changeset
617 s->h263_msmpeg4 = 1;
764aeec1320e msmpeg4v2 decoding (no encoding yet)
michaelni
parents: 302
diff changeset
618 s->h263_pred = 1;
764aeec1320e msmpeg4v2 decoding (no encoding yet)
michaelni
parents: 302
diff changeset
619 s->unrestricted_mv = 1;
764aeec1320e msmpeg4v2 decoding (no encoding yet)
michaelni
parents: 302
diff changeset
620 s->msmpeg4_version= 2;
336
c56b45669214 export delay info
michaelni
parents: 333
diff changeset
621 avctx->delay=0;
924
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
622 s->low_delay=1;
307
764aeec1320e msmpeg4v2 decoding (no encoding yet)
michaelni
parents: 302
diff changeset
623 break;
764aeec1320e msmpeg4v2 decoding (no encoding yet)
michaelni
parents: 302
diff changeset
624 case CODEC_ID_MSMPEG4V3:
764aeec1320e msmpeg4v2 decoding (no encoding yet)
michaelni
parents: 302
diff changeset
625 s->out_format = FMT_H263;
764aeec1320e msmpeg4v2 decoding (no encoding yet)
michaelni
parents: 302
diff changeset
626 s->h263_msmpeg4 = 1;
764aeec1320e msmpeg4v2 decoding (no encoding yet)
michaelni
parents: 302
diff changeset
627 s->h263_pred = 1;
764aeec1320e msmpeg4v2 decoding (no encoding yet)
michaelni
parents: 302
diff changeset
628 s->unrestricted_mv = 1;
764aeec1320e msmpeg4v2 decoding (no encoding yet)
michaelni
parents: 302
diff changeset
629 s->msmpeg4_version= 3;
336
c56b45669214 export delay info
michaelni
parents: 333
diff changeset
630 avctx->delay=0;
924
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
631 s->low_delay=1;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
632 break;
499
8b7a54d58549 wmv1 support
michaelni
parents: 487
diff changeset
633 case CODEC_ID_WMV1:
8b7a54d58549 wmv1 support
michaelni
parents: 487
diff changeset
634 s->out_format = FMT_H263;
8b7a54d58549 wmv1 support
michaelni
parents: 487
diff changeset
635 s->h263_msmpeg4 = 1;
8b7a54d58549 wmv1 support
michaelni
parents: 487
diff changeset
636 s->h263_pred = 1;
8b7a54d58549 wmv1 support
michaelni
parents: 487
diff changeset
637 s->unrestricted_mv = 1;
8b7a54d58549 wmv1 support
michaelni
parents: 487
diff changeset
638 s->msmpeg4_version= 4;
8b7a54d58549 wmv1 support
michaelni
parents: 487
diff changeset
639 avctx->delay=0;
924
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
640 s->low_delay=1;
499
8b7a54d58549 wmv1 support
michaelni
parents: 487
diff changeset
641 break;
8b7a54d58549 wmv1 support
michaelni
parents: 487
diff changeset
642 case CODEC_ID_WMV2:
8b7a54d58549 wmv1 support
michaelni
parents: 487
diff changeset
643 s->out_format = FMT_H263;
8b7a54d58549 wmv1 support
michaelni
parents: 487
diff changeset
644 s->h263_msmpeg4 = 1;
8b7a54d58549 wmv1 support
michaelni
parents: 487
diff changeset
645 s->h263_pred = 1;
8b7a54d58549 wmv1 support
michaelni
parents: 487
diff changeset
646 s->unrestricted_mv = 1;
8b7a54d58549 wmv1 support
michaelni
parents: 487
diff changeset
647 s->msmpeg4_version= 5;
8b7a54d58549 wmv1 support
michaelni
parents: 487
diff changeset
648 avctx->delay=0;
924
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
649 s->low_delay=1;
499
8b7a54d58549 wmv1 support
michaelni
parents: 487
diff changeset
650 break;
1042
a78f6f72d54e --disable-risky support
michaelni
parents: 1026
diff changeset
651 #endif
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
652 default:
986e461dc072 Initial revision
glantau
parents:
diff changeset
653 return -1;
986e461dc072 Initial revision
glantau
parents:
diff changeset
654 }
295
6622b0fd036c mpeg4 4MV encoding
michaelni
parents: 294
diff changeset
655
277
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 271
diff changeset
656 { /* 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
657 static int done=0;
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 271
diff changeset
658 if(!done){
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 271
diff changeset
659 int i;
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 271
diff changeset
660 done=1;
815
78accc54493b put a few large tables under #ifdef CONFIG_ENCODERS or dynamically allocate them
michaelni
parents: 814
diff changeset
661
1064
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1059
diff changeset
662 default_mv_penalty= av_mallocz( sizeof(uint16_t)*(MAX_FCODE+1)*(2*MAX_MV+1) );
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1059
diff changeset
663 memset(default_mv_penalty, 0, sizeof(uint16_t)*(MAX_FCODE+1)*(2*MAX_MV+1));
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1059
diff changeset
664 memset(default_fcode_tab , 0, sizeof(uint8_t)*(2*MAX_MV+1));
277
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 271
diff changeset
665
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 271
diff changeset
666 for(i=-16; i<16; i++){
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 271
diff changeset
667 default_fcode_tab[i + MAX_MV]= 1;
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 271
diff changeset
668 }
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 271
diff changeset
669 }
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 271
diff changeset
670 }
936
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
671 s->me.mv_penalty= default_mv_penalty;
277
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 271
diff changeset
672 s->fcode_tab= default_fcode_tab;
506
b9ed0ae72d51 init dc_scale tables to defaults (fixes mjpeg sig11)
michaelni
parents: 499
diff changeset
673 s->y_dc_scale_table=
b9ed0ae72d51 init dc_scale tables to defaults (fixes mjpeg sig11)
michaelni
parents: 499
diff changeset
674 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
675
287
32a3dcce2e9b fixing motion estimation with h263p hopefully
michaelni
parents: 286
diff changeset
676 /* dont use mv_penalty table for crap MV as it would be confused */
936
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
677 //FIXME remove after fixing / removing old ME
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
678 if (s->me_method < ME_EPZS) s->me.mv_penalty = default_mv_penalty;
287
32a3dcce2e9b fixing motion estimation with h263p hopefully
michaelni
parents: 286
diff changeset
679
7
1d3ac9654178 added skip macroblock optimization (big perf win on black regions for example)
glantau
parents: 0
diff changeset
680 s->encoding = 1;
1d3ac9654178 added skip macroblock optimization (big perf win on black regions for example)
glantau
parents: 0
diff changeset
681
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
682 /* init */
986e461dc072 Initial revision
glantau
parents:
diff changeset
683 if (MPV_common_init(s) < 0)
986e461dc072 Initial revision
glantau
parents:
diff changeset
684 return -1;
986e461dc072 Initial revision
glantau
parents:
diff changeset
685
936
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
686 ff_init_me(s);
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
687
815
78accc54493b put a few large tables under #ifdef CONFIG_ENCODERS or dynamically allocate them
michaelni
parents: 814
diff changeset
688 #ifdef CONFIG_ENCODERS
1042
a78f6f72d54e --disable-risky support
michaelni
parents: 1026
diff changeset
689 #ifdef CONFIG_RISKY
706
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 704
diff changeset
690 if (s->out_format == FMT_H263)
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 704
diff changeset
691 h263_encode_init(s);
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 704
diff changeset
692 if(s->msmpeg4_version)
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 704
diff changeset
693 ff_msmpeg4_encode_init(s);
815
78accc54493b put a few large tables under #ifdef CONFIG_ENCODERS or dynamically allocate them
michaelni
parents: 814
diff changeset
694 #endif
1042
a78f6f72d54e --disable-risky support
michaelni
parents: 1026
diff changeset
695 if (s->out_format == FMT_MPEG1)
a78f6f72d54e --disable-risky support
michaelni
parents: 1026
diff changeset
696 ff_mpeg1_encode_init(s);
a78f6f72d54e --disable-risky support
michaelni
parents: 1026
diff changeset
697 #endif
706
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 704
diff changeset
698
60
35c1141e23d9 moved matrix init away from MPV_common_init()
glantau
parents: 57
diff changeset
699 /* init default q matrix */
35c1141e23d9 moved matrix init away from MPV_common_init()
glantau
parents: 57
diff changeset
700 for(i=0;i<64;i++) {
1092
f59c3f66363b MpegEncContext.(i)dct_* -> DspContext.(i)dct_*
michaelni
parents: 1089
diff changeset
701 int j= s->dsp.idct_permutation[i];
1042
a78f6f72d54e --disable-risky support
michaelni
parents: 1026
diff changeset
702 #ifdef CONFIG_RISKY
599
b1a191202f96 mpeg4 mpeg quantizer encoding
michaelni
parents: 598
diff changeset
703 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
704 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
705 s->inter_matrix[j] = ff_mpeg4_default_non_intra_matrix[i];
599
b1a191202f96 mpeg4 mpeg quantizer encoding
michaelni
parents: 598
diff changeset
706 }else if(s->out_format == FMT_H263){
706
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 704
diff changeset
707 s->intra_matrix[j] =
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 704
diff changeset
708 s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i];
1042
a78f6f72d54e --disable-risky support
michaelni
parents: 1026
diff changeset
709 }else
a78f6f72d54e --disable-risky support
michaelni
parents: 1026
diff changeset
710 #endif
a78f6f72d54e --disable-risky support
michaelni
parents: 1026
diff changeset
711 { /* mpeg1 */
706
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 704
diff changeset
712 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
713 s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i];
599
b1a191202f96 mpeg4 mpeg quantizer encoding
michaelni
parents: 598
diff changeset
714 }
344
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
715 }
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
716
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
717 /* precompute matrix */
350
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 347
diff changeset
718 /* for mjpeg, we do include qscale in the matrix */
344
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
719 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
720 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
721 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
722 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
723 s->inter_matrix, s->inter_quant_bias, 1, 31);
60
35c1141e23d9 moved matrix init away from MPV_common_init()
glantau
parents: 57
diff changeset
724 }
35c1141e23d9 moved matrix init away from MPV_common_init()
glantau
parents: 57
diff changeset
725
329
5cc47d0ba53e fixed ratecontrol & b-frames
michaelni
parents: 327
diff changeset
726 if(ff_rate_control_init(s) < 0)
5cc47d0ba53e fixed ratecontrol & b-frames
michaelni
parents: 327
diff changeset
727 return -1;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
728
986e461dc072 Initial revision
glantau
parents:
diff changeset
729 s->picture_number = 0;
277
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 271
diff changeset
730 s->picture_in_gop_number = 0;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
731 s->fake_picture_number = 0;
986e461dc072 Initial revision
glantau
parents:
diff changeset
732 /* motion detector init */
986e461dc072 Initial revision
glantau
parents:
diff changeset
733 s->f_code = 1;
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
734 s->b_code = 1;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
735
986e461dc072 Initial revision
glantau
parents:
diff changeset
736 return 0;
986e461dc072 Initial revision
glantau
parents:
diff changeset
737 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
738
986e461dc072 Initial revision
glantau
parents:
diff changeset
739 int MPV_encode_end(AVCodecContext *avctx)
986e461dc072 Initial revision
glantau
parents:
diff changeset
740 {
986e461dc072 Initial revision
glantau
parents:
diff changeset
741 MpegEncContext *s = avctx->priv_data;
986e461dc072 Initial revision
glantau
parents:
diff changeset
742
986e461dc072 Initial revision
glantau
parents:
diff changeset
743 #ifdef STATS
986e461dc072 Initial revision
glantau
parents:
diff changeset
744 print_stats();
986e461dc072 Initial revision
glantau
parents:
diff changeset
745 #endif
329
5cc47d0ba53e fixed ratecontrol & b-frames
michaelni
parents: 327
diff changeset
746
5cc47d0ba53e fixed ratecontrol & b-frames
michaelni
parents: 327
diff changeset
747 ff_rate_control_uninit(s);
5cc47d0ba53e fixed ratecontrol & b-frames
michaelni
parents: 327
diff changeset
748
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
749 MPV_common_end(s);
986e461dc072 Initial revision
glantau
parents:
diff changeset
750 if (s->out_format == FMT_MJPEG)
986e461dc072 Initial revision
glantau
parents:
diff changeset
751 mjpeg_close(s);
232
b640ec5948b0 - Now the ME is done for the entire picture when enconding, the
pulento
parents: 231
diff changeset
752
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
753 return 0;
986e461dc072 Initial revision
glantau
parents:
diff changeset
754 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
755
1070
6da5ae9ee199 more #ifdef CONFIG_ENCODERS patch by (Wolfgang Hesseler <qv at multimediaware dot com>) with modifications by me (s/WOLFGANG/CONFIG_ENCODERS/ and some other fixes)
michaelni
parents: 1064
diff changeset
756 #endif //CONFIG_ENCODERS
6da5ae9ee199 more #ifdef CONFIG_ENCODERS patch by (Wolfgang Hesseler <qv at multimediaware dot com>) with modifications by me (s/WOLFGANG/CONFIG_ENCODERS/ and some other fixes)
michaelni
parents: 1064
diff changeset
757
1042
a78f6f72d54e --disable-risky support
michaelni
parents: 1026
diff changeset
758 void init_rl(RLTable *rl)
a78f6f72d54e --disable-risky support
michaelni
parents: 1026
diff changeset
759 {
1064
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1059
diff changeset
760 int8_t max_level[MAX_RUN+1], max_run[MAX_LEVEL+1];
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1059
diff changeset
761 uint8_t index_run[MAX_RUN+1];
1042
a78f6f72d54e --disable-risky support
michaelni
parents: 1026
diff changeset
762 int last, run, level, start, end, i;
a78f6f72d54e --disable-risky support
michaelni
parents: 1026
diff changeset
763
a78f6f72d54e --disable-risky support
michaelni
parents: 1026
diff changeset
764 /* compute max_level[], max_run[] and index_run[] */
a78f6f72d54e --disable-risky support
michaelni
parents: 1026
diff changeset
765 for(last=0;last<2;last++) {
a78f6f72d54e --disable-risky support
michaelni
parents: 1026
diff changeset
766 if (last == 0) {
a78f6f72d54e --disable-risky support
michaelni
parents: 1026
diff changeset
767 start = 0;
a78f6f72d54e --disable-risky support
michaelni
parents: 1026
diff changeset
768 end = rl->last;
a78f6f72d54e --disable-risky support
michaelni
parents: 1026
diff changeset
769 } else {
a78f6f72d54e --disable-risky support
michaelni
parents: 1026
diff changeset
770 start = rl->last;
a78f6f72d54e --disable-risky support
michaelni
parents: 1026
diff changeset
771 end = rl->n;
a78f6f72d54e --disable-risky support
michaelni
parents: 1026
diff changeset
772 }
a78f6f72d54e --disable-risky support
michaelni
parents: 1026
diff changeset
773
a78f6f72d54e --disable-risky support
michaelni
parents: 1026
diff changeset
774 memset(max_level, 0, MAX_RUN + 1);
a78f6f72d54e --disable-risky support
michaelni
parents: 1026
diff changeset
775 memset(max_run, 0, MAX_LEVEL + 1);
a78f6f72d54e --disable-risky support
michaelni
parents: 1026
diff changeset
776 memset(index_run, rl->n, MAX_RUN + 1);
a78f6f72d54e --disable-risky support
michaelni
parents: 1026
diff changeset
777 for(i=start;i<end;i++) {
a78f6f72d54e --disable-risky support
michaelni
parents: 1026
diff changeset
778 run = rl->table_run[i];
a78f6f72d54e --disable-risky support
michaelni
parents: 1026
diff changeset
779 level = rl->table_level[i];
a78f6f72d54e --disable-risky support
michaelni
parents: 1026
diff changeset
780 if (index_run[run] == rl->n)
a78f6f72d54e --disable-risky support
michaelni
parents: 1026
diff changeset
781 index_run[run] = i;
a78f6f72d54e --disable-risky support
michaelni
parents: 1026
diff changeset
782 if (level > max_level[run])
a78f6f72d54e --disable-risky support
michaelni
parents: 1026
diff changeset
783 max_level[run] = level;
a78f6f72d54e --disable-risky support
michaelni
parents: 1026
diff changeset
784 if (run > max_run[level])
a78f6f72d54e --disable-risky support
michaelni
parents: 1026
diff changeset
785 max_run[level] = run;
a78f6f72d54e --disable-risky support
michaelni
parents: 1026
diff changeset
786 }
a78f6f72d54e --disable-risky support
michaelni
parents: 1026
diff changeset
787 rl->max_level[last] = av_malloc(MAX_RUN + 1);
a78f6f72d54e --disable-risky support
michaelni
parents: 1026
diff changeset
788 memcpy(rl->max_level[last], max_level, MAX_RUN + 1);
a78f6f72d54e --disable-risky support
michaelni
parents: 1026
diff changeset
789 rl->max_run[last] = av_malloc(MAX_LEVEL + 1);
a78f6f72d54e --disable-risky support
michaelni
parents: 1026
diff changeset
790 memcpy(rl->max_run[last], max_run, MAX_LEVEL + 1);
a78f6f72d54e --disable-risky support
michaelni
parents: 1026
diff changeset
791 rl->index_run[last] = av_malloc(MAX_RUN + 1);
a78f6f72d54e --disable-risky support
michaelni
parents: 1026
diff changeset
792 memcpy(rl->index_run[last], index_run, MAX_RUN + 1);
a78f6f72d54e --disable-risky support
michaelni
parents: 1026
diff changeset
793 }
a78f6f72d54e --disable-risky support
michaelni
parents: 1026
diff changeset
794 }
a78f6f72d54e --disable-risky support
michaelni
parents: 1026
diff changeset
795
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
796 /* 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
797 //FIXME check that this is ok for mpeg4 interlaced
1064
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1059
diff changeset
798 static void draw_edges_c(uint8_t *buf, int wrap, int width, int height, int w)
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
799 {
1064
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1059
diff changeset
800 uint8_t *ptr, *last_line;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
801 int i;
986e461dc072 Initial revision
glantau
parents:
diff changeset
802
986e461dc072 Initial revision
glantau
parents:
diff changeset
803 last_line = buf + (height - 1) * wrap;
986e461dc072 Initial revision
glantau
parents:
diff changeset
804 for(i=0;i<w;i++) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
805 /* top and bottom */
986e461dc072 Initial revision
glantau
parents:
diff changeset
806 memcpy(buf - (i + 1) * wrap, buf, width);
986e461dc072 Initial revision
glantau
parents:
diff changeset
807 memcpy(last_line + (i + 1) * wrap, last_line, width);
986e461dc072 Initial revision
glantau
parents:
diff changeset
808 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
809 /* left and right */
986e461dc072 Initial revision
glantau
parents:
diff changeset
810 ptr = buf;
986e461dc072 Initial revision
glantau
parents:
diff changeset
811 for(i=0;i<height;i++) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
812 memset(ptr - w, ptr[0], w);
986e461dc072 Initial revision
glantau
parents:
diff changeset
813 memset(ptr + width, ptr[width-1], w);
986e461dc072 Initial revision
glantau
parents:
diff changeset
814 ptr += wrap;
986e461dc072 Initial revision
glantau
parents:
diff changeset
815 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
816 /* corners */
986e461dc072 Initial revision
glantau
parents:
diff changeset
817 for(i=0;i<w;i++) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
818 memset(buf - (i + 1) * wrap - w, buf[0], w); /* top left */
986e461dc072 Initial revision
glantau
parents:
diff changeset
819 memset(buf - (i + 1) * wrap + width, buf[width-1], w); /* top right */
986e461dc072 Initial revision
glantau
parents:
diff changeset
820 memset(last_line + (i + 1) * wrap - w, last_line[0], w); /* top left */
986e461dc072 Initial revision
glantau
parents:
diff changeset
821 memset(last_line + (i + 1) * wrap + width, last_line[width-1], w); /* top right */
986e461dc072 Initial revision
glantau
parents:
diff changeset
822 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
823 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
824
924
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
825 static int find_unused_picture(MpegEncContext *s, int shared){
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
826 int i;
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
827
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
828 if(shared){
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
829 for(i=0; i<MAX_PICTURE_COUNT; i++){
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
830 if(s->picture[i].data[0]==NULL && s->picture[i].type==0) break;
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
831 }
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
832 }else{
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
833 for(i=0; i<MAX_PICTURE_COUNT; i++){
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
834 if(s->picture[i].data[0]==NULL && s->picture[i].type!=0) break;
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
835 }
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
836 for(i=0; i<MAX_PICTURE_COUNT; i++){
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
837 if(s->picture[i].data[0]==NULL) break;
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
838 }
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
839 }
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
840
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
841 assert(i<MAX_PICTURE_COUNT);
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
842 return i;
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
843 }
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
844
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
845 /* generic function for encode/decode called before a frame is coded/decoded */
771
d4cc92144266 handle direct rendering buffer allocation failure
michaelni
parents: 768
diff changeset
846 int MPV_frame_start(MpegEncContext *s, AVCodecContext *avctx)
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
847 {
924
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
848 int i;
925
7fccaa0d699d AVVideoFrame -> AVFrame
michaelni
parents: 924
diff changeset
849 AVFrame *pic;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
850
46
931417475f5b fixed mpeg1 first block bug (pb with black picture optimisation for B frames)
glantau
parents: 40
diff changeset
851 s->mb_skiped = 0;
903
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
852
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
853 /* mark&release old frames */
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
854 if (s->pict_type != B_TYPE && s->last_picture.data[0]) {
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
855 for(i=0; i<MAX_PICTURE_COUNT; i++){
924
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
856 //printf("%8X %d %d %X %X\n", s->picture[i].data[0], s->picture[i].type, i, s->next_picture.data[0], s->last_picture.data[0]);
903
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
857 if(s->picture[i].data[0] == s->last_picture.data[0]){
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
858 // s->picture[i].reference=0;
925
7fccaa0d699d AVVideoFrame -> AVFrame
michaelni
parents: 924
diff changeset
859 avctx->release_buffer(avctx, (AVFrame*)&s->picture[i]);
903
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
860 break;
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
861 }
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
862 }
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
863 assert(i<MAX_PICTURE_COUNT);
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
864
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
865 /* release forgotten pictures */
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
866 /* if(mpeg124/h263) */
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
867 if(!s->encoding){
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
868 for(i=0; i<MAX_PICTURE_COUNT; i++){
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
869 if(s->picture[i].data[0] && s->picture[i].data[0] != s->next_picture.data[0] && s->picture[i].reference){
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
870 fprintf(stderr, "releasing zombie picture\n");
925
7fccaa0d699d AVVideoFrame -> AVFrame
michaelni
parents: 924
diff changeset
871 avctx->release_buffer(avctx, (AVFrame*)&s->picture[i]);
903
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
872 }
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
873 }
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
874 }
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
875 }
910
eb448df811be fixing files where the first frame isn a keyframe
michaelni
parents: 909
diff changeset
876 alloc:
eb448df811be fixing files where the first frame isn a keyframe
michaelni
parents: 909
diff changeset
877 if(!s->encoding){
924
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
878 i= find_unused_picture(s, 0);
903
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
879
925
7fccaa0d699d AVVideoFrame -> AVFrame
michaelni
parents: 924
diff changeset
880 pic= (AVFrame*)&s->picture[i];
903
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
881 pic->reference= s->pict_type != B_TYPE;
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
882 pic->coded_picture_number= s->current_picture.coded_picture_number+1;
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
883
924
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
884 alloc_picture(s, (Picture*)pic, 0);
903
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
885
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
886 s->current_picture= s->picture[i];
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
887 }
456
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
888
903
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
889 if (s->pict_type != B_TYPE) {
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
890 s->last_picture= s->next_picture;
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
891 s->next_picture= s->current_picture;
553
18ad513d92fe direct rendering method 1 support
michaelni
parents: 549
diff changeset
892 }
910
eb448df811be fixing files where the first frame isn a keyframe
michaelni
parents: 909
diff changeset
893
eb448df811be fixing files where the first frame isn a keyframe
michaelni
parents: 909
diff changeset
894 if(s->pict_type != I_TYPE && s->last_picture.data[0]==NULL){
eb448df811be fixing files where the first frame isn a keyframe
michaelni
parents: 909
diff changeset
895 fprintf(stderr, "warning: first frame is no keyframe\n");
eb448df811be fixing files where the first frame isn a keyframe
michaelni
parents: 909
diff changeset
896 assert(s->pict_type != B_TYPE); //these should have been dropped if we dont have a reference
eb448df811be fixing files where the first frame isn a keyframe
michaelni
parents: 909
diff changeset
897 goto alloc;
eb448df811be fixing files where the first frame isn a keyframe
michaelni
parents: 909
diff changeset
898 }
903
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
899
910
eb448df811be fixing files where the first frame isn a keyframe
michaelni
parents: 909
diff changeset
900 s->hurry_up= s->avctx->hurry_up;
eb448df811be fixing files where the first frame isn a keyframe
michaelni
parents: 909
diff changeset
901 s->error_resilience= avctx->error_resilience;
eb448df811be fixing files where the first frame isn a keyframe
michaelni
parents: 909
diff changeset
902
591
d3f374218030 fixing mpeg4 mpeg quantizers
michaelni
parents: 588
diff changeset
903 /* set dequantizer, we cant do it during init as it might change for mpeg4
d3f374218030 fixing mpeg4 mpeg quantizers
michaelni
parents: 588
diff changeset
904 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
905 if(s->out_format == FMT_H263){
d3f374218030 fixing mpeg4 mpeg quantizers
michaelni
parents: 588
diff changeset
906 if(s->mpeg_quant)
d3f374218030 fixing mpeg4 mpeg quantizers
michaelni
parents: 588
diff changeset
907 s->dct_unquantize = s->dct_unquantize_mpeg2;
d3f374218030 fixing mpeg4 mpeg quantizers
michaelni
parents: 588
diff changeset
908 else
d3f374218030 fixing mpeg4 mpeg quantizers
michaelni
parents: 588
diff changeset
909 s->dct_unquantize = s->dct_unquantize_h263;
d3f374218030 fixing mpeg4 mpeg quantizers
michaelni
parents: 588
diff changeset
910 }else
d3f374218030 fixing mpeg4 mpeg quantizers
michaelni
parents: 588
diff changeset
911 s->dct_unquantize = s->dct_unquantize_mpeg1;
771
d4cc92144266 handle direct rendering buffer allocation failure
michaelni
parents: 768
diff changeset
912
d4cc92144266 handle direct rendering buffer allocation failure
michaelni
parents: 768
diff changeset
913 return 0;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
914 }
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
915
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
916 /* generic function for encode/decode called after a frame has been coded/decoded */
986e461dc072 Initial revision
glantau
parents:
diff changeset
917 void MPV_frame_end(MpegEncContext *s)
986e461dc072 Initial revision
glantau
parents:
diff changeset
918 {
903
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
919 int i;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
920 /* draw edge for correct motion prediction if outside */
903
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
921 if(s->codec_id!=CODEC_ID_SVQ1){
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
922 if (s->pict_type != B_TYPE && !s->intra_only && !(s->flags&CODEC_FLAG_EMU_EDGE)) {
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
923 draw_edges(s->current_picture.data[0], s->linesize , s->h_edge_pos , s->v_edge_pos , EDGE_WIDTH );
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
924 draw_edges(s->current_picture.data[1], s->uvlinesize, s->h_edge_pos>>1, s->v_edge_pos>>1, EDGE_WIDTH/2);
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
925 draw_edges(s->current_picture.data[2], s->uvlinesize, s->h_edge_pos>>1, s->v_edge_pos>>1, EDGE_WIDTH/2);
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
926 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
927 }
207
6954f2830e4a (commit by michael)
arpi_esp
parents: 206
diff changeset
928 emms_c();
329
5cc47d0ba53e fixed ratecontrol & b-frames
michaelni
parents: 327
diff changeset
929
612
c0005de2be59 new ratecontrol code
michaelni
parents: 611
diff changeset
930 s->last_pict_type = s->pict_type;
329
5cc47d0ba53e fixed ratecontrol & b-frames
michaelni
parents: 327
diff changeset
931 if(s->pict_type!=B_TYPE){
5cc47d0ba53e fixed ratecontrol & b-frames
michaelni
parents: 327
diff changeset
932 s->last_non_b_pict_type= s->pict_type;
5cc47d0ba53e fixed ratecontrol & b-frames
michaelni
parents: 327
diff changeset
933 }
903
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
934
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
935 s->current_picture.quality= s->qscale; //FIXME get average of qscale_table
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
936 s->current_picture.pict_type= s->pict_type;
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
937 s->current_picture.key_frame= s->pict_type == I_TYPE;
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
938
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
939 /* copy back current_picture variables */
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
940 for(i=0; i<MAX_PICTURE_COUNT; i++){
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
941 if(s->picture[i].data[0] == s->current_picture.data[0]){
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
942 s->picture[i]= s->current_picture;
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
943 break;
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
944 }
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
945 }
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
946 assert(i<MAX_PICTURE_COUNT);
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
947
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
948 /* release non refernce frames */
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
949 for(i=0; i<MAX_PICTURE_COUNT; i++){
924
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
950 if(s->picture[i].data[0] && !s->picture[i].reference /*&& s->picture[i].type!=FF_BUFFER_TYPE_SHARED*/)
925
7fccaa0d699d AVVideoFrame -> AVFrame
michaelni
parents: 924
diff changeset
951 s->avctx->release_buffer(s->avctx, (AVFrame*)&s->picture[i]);
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
952 }
936
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
953 if(s->avctx->debug&FF_DEBUG_SKIP){
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
954 int x,y;
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
955 for(y=0; y<s->mb_height; y++){
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
956 for(x=0; x<s->mb_width; x++){
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
957 int count= s->mbskip_table[x + y*s->mb_width];
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
958 if(count>9) count=9;
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
959 printf(" %1d", count);
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
960 }
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
961 printf("\n");
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
962 }
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
963 printf("pict type: %d\n", s->pict_type);
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
964 }
903
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
965 }
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
966
1070
6da5ae9ee199 more #ifdef CONFIG_ENCODERS patch by (Wolfgang Hesseler <qv at multimediaware dot com>) with modifications by me (s/WOLFGANG/CONFIG_ENCODERS/ and some other fixes)
michaelni
parents: 1064
diff changeset
967 #ifdef CONFIG_ENCODERS
6da5ae9ee199 more #ifdef CONFIG_ENCODERS patch by (Wolfgang Hesseler <qv at multimediaware dot com>) with modifications by me (s/WOLFGANG/CONFIG_ENCODERS/ and some other fixes)
michaelni
parents: 1064
diff changeset
968
915
75ee49a4a516 fixing 2pass assert failure
michaelni
parents: 912
diff changeset
969 static int get_sae(uint8_t *src, int ref, int stride){
75ee49a4a516 fixing 2pass assert failure
michaelni
parents: 912
diff changeset
970 int x,y;
75ee49a4a516 fixing 2pass assert failure
michaelni
parents: 912
diff changeset
971 int acc=0;
75ee49a4a516 fixing 2pass assert failure
michaelni
parents: 912
diff changeset
972
75ee49a4a516 fixing 2pass assert failure
michaelni
parents: 912
diff changeset
973 for(y=0; y<16; y++){
75ee49a4a516 fixing 2pass assert failure
michaelni
parents: 912
diff changeset
974 for(x=0; x<16; x++){
75ee49a4a516 fixing 2pass assert failure
michaelni
parents: 912
diff changeset
975 acc+= ABS(src[x+y*stride] - ref);
75ee49a4a516 fixing 2pass assert failure
michaelni
parents: 912
diff changeset
976 }
75ee49a4a516 fixing 2pass assert failure
michaelni
parents: 912
diff changeset
977 }
75ee49a4a516 fixing 2pass assert failure
michaelni
parents: 912
diff changeset
978
75ee49a4a516 fixing 2pass assert failure
michaelni
parents: 912
diff changeset
979 return acc;
75ee49a4a516 fixing 2pass assert failure
michaelni
parents: 912
diff changeset
980 }
75ee49a4a516 fixing 2pass assert failure
michaelni
parents: 912
diff changeset
981
75ee49a4a516 fixing 2pass assert failure
michaelni
parents: 912
diff changeset
982 static int get_intra_count(MpegEncContext *s, uint8_t *src, uint8_t *ref, int stride){
75ee49a4a516 fixing 2pass assert failure
michaelni
parents: 912
diff changeset
983 int x, y, w, h;
75ee49a4a516 fixing 2pass assert failure
michaelni
parents: 912
diff changeset
984 int acc=0;
75ee49a4a516 fixing 2pass assert failure
michaelni
parents: 912
diff changeset
985
75ee49a4a516 fixing 2pass assert failure
michaelni
parents: 912
diff changeset
986 w= s->width &~15;
75ee49a4a516 fixing 2pass assert failure
michaelni
parents: 912
diff changeset
987 h= s->height&~15;
75ee49a4a516 fixing 2pass assert failure
michaelni
parents: 912
diff changeset
988
75ee49a4a516 fixing 2pass assert failure
michaelni
parents: 912
diff changeset
989 for(y=0; y<h; y+=16){
75ee49a4a516 fixing 2pass assert failure
michaelni
parents: 912
diff changeset
990 for(x=0; x<w; x+=16){
75ee49a4a516 fixing 2pass assert failure
michaelni
parents: 912
diff changeset
991 int offset= x + y*stride;
75ee49a4a516 fixing 2pass assert failure
michaelni
parents: 912
diff changeset
992 int sad = s->dsp.pix_abs16x16(src + offset, ref + offset, stride);
75ee49a4a516 fixing 2pass assert failure
michaelni
parents: 912
diff changeset
993 int mean= (s->dsp.pix_sum(src + offset, stride) + 128)>>8;
75ee49a4a516 fixing 2pass assert failure
michaelni
parents: 912
diff changeset
994 int sae = get_sae(src + offset, mean, stride);
75ee49a4a516 fixing 2pass assert failure
michaelni
parents: 912
diff changeset
995
75ee49a4a516 fixing 2pass assert failure
michaelni
parents: 912
diff changeset
996 acc+= sae + 500 < sad;
75ee49a4a516 fixing 2pass assert failure
michaelni
parents: 912
diff changeset
997 }
75ee49a4a516 fixing 2pass assert failure
michaelni
parents: 912
diff changeset
998 }
75ee49a4a516 fixing 2pass assert failure
michaelni
parents: 912
diff changeset
999 return acc;
75ee49a4a516 fixing 2pass assert failure
michaelni
parents: 912
diff changeset
1000 }
75ee49a4a516 fixing 2pass assert failure
michaelni
parents: 912
diff changeset
1001
924
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
1002
925
7fccaa0d699d AVVideoFrame -> AVFrame
michaelni
parents: 924
diff changeset
1003 static int load_input_picture(MpegEncContext *s, AVFrame *pic_arg){
7fccaa0d699d AVVideoFrame -> AVFrame
michaelni
parents: 924
diff changeset
1004 AVFrame *pic;
924
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
1005 int i;
903
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
1006 const int encoding_delay= s->max_b_frames;
924
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
1007 int direct=1;
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
1008
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
1009 if(encoding_delay && !(s->flags&CODEC_FLAG_INPUT_PRESERVED)) direct=0;
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
1010 if(pic_arg->linesize[0] != s->linesize) direct=0;
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
1011 if(pic_arg->linesize[1] != s->uvlinesize) direct=0;
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
1012 if(pic_arg->linesize[2] != s->uvlinesize) direct=0;
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
1013
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
1014 // printf("%d %d %d %d\n",pic_arg->linesize[0], pic_arg->linesize[1], s->linesize, s->uvlinesize);
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
1015
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
1016 if(direct){
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
1017 i= find_unused_picture(s, 1);
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
1018
925
7fccaa0d699d AVVideoFrame -> AVFrame
michaelni
parents: 924
diff changeset
1019 pic= (AVFrame*)&s->picture[i];
924
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
1020 pic->reference= 1;
903
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
1021
924
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
1022 for(i=0; i<4; i++){
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
1023 pic->data[i]= pic_arg->data[i];
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
1024 pic->linesize[i]= pic_arg->linesize[i];
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
1025 }
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
1026 alloc_picture(s, (Picture*)pic, 1);
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
1027 }else{
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
1028 i= find_unused_picture(s, 0);
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
1029
925
7fccaa0d699d AVVideoFrame -> AVFrame
michaelni
parents: 924
diff changeset
1030 pic= (AVFrame*)&s->picture[i];
924
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
1031 pic->reference= 1;
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
1032
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
1033 alloc_picture(s, (Picture*)pic, 0);
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
1034
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
1035 if( pic->data[0] == pic_arg->data[0]
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
1036 && pic->data[1] == pic_arg->data[1]
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
1037 && pic->data[2] == pic_arg->data[2]){
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
1038 // empty
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
1039 }else{
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
1040 int h_chroma_shift, v_chroma_shift;
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
1041
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
1042 avcodec_get_chroma_sub_sample(s->avctx->pix_fmt, &h_chroma_shift, &v_chroma_shift);
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
1043
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
1044 for(i=0; i<3; i++){
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
1045 int src_stride= pic_arg->linesize[i];
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
1046 int dst_stride= i ? s->uvlinesize : s->linesize;
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
1047 int h_shift= i ? h_chroma_shift : 0;
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
1048 int v_shift= i ? v_chroma_shift : 0;
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
1049 int w= s->width >>h_shift;
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
1050 int h= s->height>>v_shift;
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
1051 uint8_t *src= pic_arg->data[i];
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
1052 uint8_t *dst= pic->data[i];
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
1053
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
1054 if(src_stride==dst_stride)
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
1055 memcpy(dst, src, src_stride*h);
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
1056 else{
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
1057 while(h--){
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
1058 memcpy(dst, src, w);
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
1059 dst += dst_stride;
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
1060 src += src_stride;
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
1061 }
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
1062 }
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
1063 }
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
1064 }
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
1065 }
924
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
1066 pic->quality= pic_arg->quality;
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
1067 pic->pict_type= pic_arg->pict_type;
955
8f5d4c666806 pts encoding fix patch by (Thomas Jarosch <tomj at simonv dot com>)
michaelni
parents: 954
diff changeset
1068 pic->pts = pic_arg->pts;
903
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
1069
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
1070 if(s->input_picture[encoding_delay])
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
1071 pic->display_picture_number= s->input_picture[encoding_delay]->display_picture_number + 1;
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
1072
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
1073 /* shift buffer entries */
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
1074 for(i=1; i<MAX_PICTURE_COUNT /*s->encoding_delay+1*/; i++)
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
1075 s->input_picture[i-1]= s->input_picture[i];
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
1076
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
1077 s->input_picture[encoding_delay]= (Picture*)pic;
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
1078
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
1079 return 0;
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
1080 }
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
1081
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
1082 static void select_input_picture(MpegEncContext *s){
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
1083 int i;
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
1084 const int encoding_delay= s->max_b_frames;
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
1085 int coded_pic_num=0;
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
1086
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
1087 if(s->reordered_input_picture[0])
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
1088 coded_pic_num= s->reordered_input_picture[0]->coded_picture_number + 1;
924
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
1089
903
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
1090 for(i=1; i<MAX_PICTURE_COUNT; i++)
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
1091 s->reordered_input_picture[i-1]= s->reordered_input_picture[i];
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
1092 s->reordered_input_picture[MAX_PICTURE_COUNT-1]= NULL;
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
1093
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
1094 /* set next picture types & ordering */
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
1095 if(s->reordered_input_picture[0]==NULL && s->input_picture[0]){
915
75ee49a4a516 fixing 2pass assert failure
michaelni
parents: 912
diff changeset
1096 if(/*s->picture_in_gop_number >= s->gop_size ||*/ s->next_picture.data[0]==NULL || s->intra_only){
75ee49a4a516 fixing 2pass assert failure
michaelni
parents: 912
diff changeset
1097 s->reordered_input_picture[0]= s->input_picture[0];
75ee49a4a516 fixing 2pass assert failure
michaelni
parents: 912
diff changeset
1098 s->reordered_input_picture[0]->pict_type= I_TYPE;
75ee49a4a516 fixing 2pass assert failure
michaelni
parents: 912
diff changeset
1099 s->reordered_input_picture[0]->coded_picture_number= coded_pic_num;
75ee49a4a516 fixing 2pass assert failure
michaelni
parents: 912
diff changeset
1100 }else{
75ee49a4a516 fixing 2pass assert failure
michaelni
parents: 912
diff changeset
1101 int b_frames;
75ee49a4a516 fixing 2pass assert failure
michaelni
parents: 912
diff changeset
1102
75ee49a4a516 fixing 2pass assert failure
michaelni
parents: 912
diff changeset
1103 if(s->flags&CODEC_FLAG_PASS2){
75ee49a4a516 fixing 2pass assert failure
michaelni
parents: 912
diff changeset
1104 for(i=0; i<s->max_b_frames+1; i++){
75ee49a4a516 fixing 2pass assert failure
michaelni
parents: 912
diff changeset
1105 int pict_num= s->input_picture[0]->display_picture_number + i;
75ee49a4a516 fixing 2pass assert failure
michaelni
parents: 912
diff changeset
1106 int pict_type= s->rc_context.entry[pict_num].new_pict_type;
75ee49a4a516 fixing 2pass assert failure
michaelni
parents: 912
diff changeset
1107 s->input_picture[i]->pict_type= pict_type;
75ee49a4a516 fixing 2pass assert failure
michaelni
parents: 912
diff changeset
1108
75ee49a4a516 fixing 2pass assert failure
michaelni
parents: 912
diff changeset
1109 if(i + 1 >= s->rc_context.num_entries) break;
75ee49a4a516 fixing 2pass assert failure
michaelni
parents: 912
diff changeset
1110 }
75ee49a4a516 fixing 2pass assert failure
michaelni
parents: 912
diff changeset
1111 }
924
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
1112
915
75ee49a4a516 fixing 2pass assert failure
michaelni
parents: 912
diff changeset
1113 if(s->input_picture[0]->pict_type){
75ee49a4a516 fixing 2pass assert failure
michaelni
parents: 912
diff changeset
1114 /* user selected pict_type */
909
8ae1e4c24e91 new PSNR code (now works with chroma, b frames, ...)
michaelni
parents: 903
diff changeset
1115 for(b_frames=0; b_frames<s->max_b_frames+1; b_frames++){
8ae1e4c24e91 new PSNR code (now works with chroma, b frames, ...)
michaelni
parents: 903
diff changeset
1116 if(s->input_picture[b_frames]->pict_type!=B_TYPE) break;
8ae1e4c24e91 new PSNR code (now works with chroma, b frames, ...)
michaelni
parents: 903
diff changeset
1117 }
915
75ee49a4a516 fixing 2pass assert failure
michaelni
parents: 912
diff changeset
1118
909
8ae1e4c24e91 new PSNR code (now works with chroma, b frames, ...)
michaelni
parents: 903
diff changeset
1119 if(b_frames > s->max_b_frames){
8ae1e4c24e91 new PSNR code (now works with chroma, b frames, ...)
michaelni
parents: 903
diff changeset
1120 fprintf(stderr, "warning, too many bframes in a row\n");
8ae1e4c24e91 new PSNR code (now works with chroma, b frames, ...)
michaelni
parents: 903
diff changeset
1121 b_frames = s->max_b_frames;
8ae1e4c24e91 new PSNR code (now works with chroma, b frames, ...)
michaelni
parents: 903
diff changeset
1122 }
915
75ee49a4a516 fixing 2pass assert failure
michaelni
parents: 912
diff changeset
1123 }else if(s->b_frame_strategy==0){
75ee49a4a516 fixing 2pass assert failure
michaelni
parents: 912
diff changeset
1124 b_frames= s->max_b_frames;
75ee49a4a516 fixing 2pass assert failure
michaelni
parents: 912
diff changeset
1125 }else if(s->b_frame_strategy==1){
75ee49a4a516 fixing 2pass assert failure
michaelni
parents: 912
diff changeset
1126 for(i=1; i<s->max_b_frames+1; i++){
75ee49a4a516 fixing 2pass assert failure
michaelni
parents: 912
diff changeset
1127 if(s->input_picture[i]->b_frame_score==0){
75ee49a4a516 fixing 2pass assert failure
michaelni
parents: 912
diff changeset
1128 s->input_picture[i]->b_frame_score=
924
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
1129 get_intra_count(s, s->input_picture[i ]->data[0],
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
1130 s->input_picture[i-1]->data[0], s->linesize) + 1;
915
75ee49a4a516 fixing 2pass assert failure
michaelni
parents: 912
diff changeset
1131 }
75ee49a4a516 fixing 2pass assert failure
michaelni
parents: 912
diff changeset
1132 }
75ee49a4a516 fixing 2pass assert failure
michaelni
parents: 912
diff changeset
1133 for(i=0; i<s->max_b_frames; i++){
75ee49a4a516 fixing 2pass assert failure
michaelni
parents: 912
diff changeset
1134 if(s->input_picture[i]->b_frame_score - 1 > s->mb_num/40) break;
75ee49a4a516 fixing 2pass assert failure
michaelni
parents: 912
diff changeset
1135 }
75ee49a4a516 fixing 2pass assert failure
michaelni
parents: 912
diff changeset
1136
75ee49a4a516 fixing 2pass assert failure
michaelni
parents: 912
diff changeset
1137 b_frames= FFMAX(0, i-1);
909
8ae1e4c24e91 new PSNR code (now works with chroma, b frames, ...)
michaelni
parents: 903
diff changeset
1138
915
75ee49a4a516 fixing 2pass assert failure
michaelni
parents: 912
diff changeset
1139 /* reset scores */
75ee49a4a516 fixing 2pass assert failure
michaelni
parents: 912
diff changeset
1140 for(i=0; i<b_frames+1; i++){
75ee49a4a516 fixing 2pass assert failure
michaelni
parents: 912
diff changeset
1141 s->input_picture[i]->b_frame_score=0;
75ee49a4a516 fixing 2pass assert failure
michaelni
parents: 912
diff changeset
1142 }
75ee49a4a516 fixing 2pass assert failure
michaelni
parents: 912
diff changeset
1143 }else{
75ee49a4a516 fixing 2pass assert failure
michaelni
parents: 912
diff changeset
1144 fprintf(stderr, "illegal b frame strategy\n");
75ee49a4a516 fixing 2pass assert failure
michaelni
parents: 912
diff changeset
1145 b_frames=0;
909
8ae1e4c24e91 new PSNR code (now works with chroma, b frames, ...)
michaelni
parents: 903
diff changeset
1146 }
915
75ee49a4a516 fixing 2pass assert failure
michaelni
parents: 912
diff changeset
1147
75ee49a4a516 fixing 2pass assert failure
michaelni
parents: 912
diff changeset
1148 emms_c();
75ee49a4a516 fixing 2pass assert failure
michaelni
parents: 912
diff changeset
1149 //static int b_count=0;
75ee49a4a516 fixing 2pass assert failure
michaelni
parents: 912
diff changeset
1150 //b_count+= b_frames;
75ee49a4a516 fixing 2pass assert failure
michaelni
parents: 912
diff changeset
1151 //printf("b_frames: %d\n", b_count);
75ee49a4a516 fixing 2pass assert failure
michaelni
parents: 912
diff changeset
1152
75ee49a4a516 fixing 2pass assert failure
michaelni
parents: 912
diff changeset
1153 s->reordered_input_picture[0]= s->input_picture[b_frames];
75ee49a4a516 fixing 2pass assert failure
michaelni
parents: 912
diff changeset
1154 if( s->picture_in_gop_number + b_frames >= s->gop_size
75ee49a4a516 fixing 2pass assert failure
michaelni
parents: 912
diff changeset
1155 || s->reordered_input_picture[0]->pict_type== I_TYPE)
903
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
1156 s->reordered_input_picture[0]->pict_type= I_TYPE;
915
75ee49a4a516 fixing 2pass assert failure
michaelni
parents: 912
diff changeset
1157 else
75ee49a4a516 fixing 2pass assert failure
michaelni
parents: 912
diff changeset
1158 s->reordered_input_picture[0]->pict_type= P_TYPE;
75ee49a4a516 fixing 2pass assert failure
michaelni
parents: 912
diff changeset
1159 s->reordered_input_picture[0]->coded_picture_number= coded_pic_num;
75ee49a4a516 fixing 2pass assert failure
michaelni
parents: 912
diff changeset
1160 for(i=0; i<b_frames; i++){
75ee49a4a516 fixing 2pass assert failure
michaelni
parents: 912
diff changeset
1161 coded_pic_num++;
75ee49a4a516 fixing 2pass assert failure
michaelni
parents: 912
diff changeset
1162 s->reordered_input_picture[i+1]= s->input_picture[i];
75ee49a4a516 fixing 2pass assert failure
michaelni
parents: 912
diff changeset
1163 s->reordered_input_picture[i+1]->pict_type= B_TYPE;
75ee49a4a516 fixing 2pass assert failure
michaelni
parents: 912
diff changeset
1164 s->reordered_input_picture[i+1]->coded_picture_number= coded_pic_num;
903
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
1165 }
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
1166 }
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
1167 }
903
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
1168
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
1169 if(s->reordered_input_picture[0]){
924
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
1170 s->reordered_input_picture[0]->reference= s->reordered_input_picture[0]->pict_type!=B_TYPE;
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
1171
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
1172 if(s->reordered_input_picture[0]->type == FF_BUFFER_TYPE_SHARED){
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
1173 int i= find_unused_picture(s, 0);
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
1174 Picture *pic= &s->picture[i];
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
1175
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
1176 s->new_picture= *s->reordered_input_picture[0];
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
1177
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
1178 /* mark us unused / free shared pic */
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
1179 for(i=0; i<4; i++)
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
1180 s->reordered_input_picture[0]->data[i]= NULL;
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
1181 s->reordered_input_picture[0]->type= 0;
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
1182
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
1183 pic->pict_type = s->reordered_input_picture[0]->pict_type;
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
1184 pic->quality = s->reordered_input_picture[0]->quality;
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
1185 pic->coded_picture_number = s->reordered_input_picture[0]->coded_picture_number;
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
1186 pic->reference = s->reordered_input_picture[0]->reference;
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
1187
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
1188 alloc_picture(s, pic, 0);
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
1189
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
1190 s->current_picture= *pic;
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
1191 }else{
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
1192 assert( s->reordered_input_picture[0]->type==FF_BUFFER_TYPE_USER
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
1193 || s->reordered_input_picture[0]->type==FF_BUFFER_TYPE_INTERNAL);
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
1194
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
1195 s->new_picture= *s->reordered_input_picture[0];
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
1196
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
1197 for(i=0; i<4; i++){
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
1198 s->reordered_input_picture[0]->data[i]-=16; //FIXME dirty
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
1199 }
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
1200 s->current_picture= *s->reordered_input_picture[0];
903
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
1201 }
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
1202
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
1203 s->picture_number= s->new_picture.display_picture_number;
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
1204 //printf("dpn:%d\n", s->picture_number);
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
1205 }else{
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
1206 memset(&s->new_picture, 0, sizeof(Picture));
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
1207 }
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
1208 }
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
1209
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1210 int MPV_encode_picture(AVCodecContext *avctx,
986e461dc072 Initial revision
glantau
parents:
diff changeset
1211 unsigned char *buf, int buf_size, void *data)
986e461dc072 Initial revision
glantau
parents:
diff changeset
1212 {
986e461dc072 Initial revision
glantau
parents:
diff changeset
1213 MpegEncContext *s = avctx->priv_data;
925
7fccaa0d699d AVVideoFrame -> AVFrame
michaelni
parents: 924
diff changeset
1214 AVFrame *pic_arg = data;
909
8ae1e4c24e91 new PSNR code (now works with chroma, b frames, ...)
michaelni
parents: 903
diff changeset
1215 int i;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1216
986e461dc072 Initial revision
glantau
parents:
diff changeset
1217 init_put_bits(&s->pb, buf, buf_size, NULL, NULL);
986e461dc072 Initial revision
glantau
parents:
diff changeset
1218
903
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
1219 s->picture_in_gop_number++;
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
1220
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
1221 load_input_picture(s, pic_arg);
329
5cc47d0ba53e fixed ratecontrol & b-frames
michaelni
parents: 327
diff changeset
1222
903
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
1223 select_input_picture(s);
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
1224
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
1225 /* output? */
903
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
1226 if(s->new_picture.data[0]){
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
1227
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
1228 s->pict_type= s->new_picture.pict_type;
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
1229 if (s->fixed_qscale){ /* the ratecontrol needs the last qscale so we dont touch it for CBR */
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
1230 s->qscale= (int)(s->new_picture.quality+0.5);
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
1231 assert(s->qscale);
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
1232 }
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
1233 //emms_c();
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
1234 //printf("qs:%f %f %d\n", s->new_picture.quality, s->current_picture.quality, s->qscale);
553
18ad513d92fe direct rendering method 1 support
michaelni
parents: 549
diff changeset
1235 MPV_frame_start(s, avctx);
286
91f7c38f5f37 statistics for 2-pass encoding
michaelni
parents: 281
diff changeset
1236
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
1237 encode_picture(s, s->picture_number);
652
c7647afc3ce5 set pict_type & key_frame on decoding too
michaelni
parents: 651
diff changeset
1238
376
ba9c3b8088c0 - pict_type exported to AVCodecContext
pulento
parents: 370
diff changeset
1239 avctx->real_pict_num = s->picture_number;
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
1240 avctx->header_bits = s->header_bits;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
1241 avctx->mv_bits = s->mv_bits;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
1242 avctx->misc_bits = s->misc_bits;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
1243 avctx->i_tex_bits = s->i_tex_bits;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
1244 avctx->p_tex_bits = s->p_tex_bits;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
1245 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
1246 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
1247 avctx->skip_count = s->skip_count;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1248
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
1249 MPV_frame_end(s);
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
1250
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
1251 if (s->out_format == FMT_MJPEG)
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
1252 mjpeg_picture_trailer(s);
329
5cc47d0ba53e fixed ratecontrol & b-frames
michaelni
parents: 327
diff changeset
1253
5cc47d0ba53e fixed ratecontrol & b-frames
michaelni
parents: 327
diff changeset
1254 if(s->flags&CODEC_FLAG_PASS1)
5cc47d0ba53e fixed ratecontrol & b-frames
michaelni
parents: 327
diff changeset
1255 ff_write_pass1_stats(s);
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
1256 }
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
1257
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
1258 s->input_picture_number++;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1259
986e461dc072 Initial revision
glantau
parents:
diff changeset
1260 flush_put_bits(&s->pb);
268
09ae29b27ed9 hopefully better bitrate controll
michaelni
parents: 266
diff changeset
1261 s->frame_bits = (pbBufPtr(&s->pb) - s->pb.buf) * 8;
612
c0005de2be59 new ratecontrol code
michaelni
parents: 611
diff changeset
1262
268
09ae29b27ed9 hopefully better bitrate controll
michaelni
parents: 266
diff changeset
1263 s->total_bits += s->frame_bits;
286
91f7c38f5f37 statistics for 2-pass encoding
michaelni
parents: 281
diff changeset
1264 avctx->frame_bits = s->frame_bits;
909
8ae1e4c24e91 new PSNR code (now works with chroma, b frames, ...)
michaelni
parents: 903
diff changeset
1265
8ae1e4c24e91 new PSNR code (now works with chroma, b frames, ...)
michaelni
parents: 903
diff changeset
1266 for(i=0; i<4; i++){
8ae1e4c24e91 new PSNR code (now works with chroma, b frames, ...)
michaelni
parents: 903
diff changeset
1267 avctx->error[i] += s->current_picture.error[i];
252
ddb1a0e94cf4 - Added PSNR feature to libavcodec and ffmpeg. By now just Y PSNR until I'm
pulento
parents: 251
diff changeset
1268 }
909
8ae1e4c24e91 new PSNR code (now works with chroma, b frames, ...)
michaelni
parents: 903
diff changeset
1269
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
1270 return pbBufPtr(&s->pb) - s->pb.buf;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1271 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
1272
1070
6da5ae9ee199 more #ifdef CONFIG_ENCODERS patch by (Wolfgang Hesseler <qv at multimediaware dot com>) with modifications by me (s/WOLFGANG/CONFIG_ENCODERS/ and some other fixes)
michaelni
parents: 1064
diff changeset
1273 #endif //CONFIG_ENCODERS
6da5ae9ee199 more #ifdef CONFIG_ENCODERS patch by (Wolfgang Hesseler <qv at multimediaware dot com>) with modifications by me (s/WOLFGANG/CONFIG_ENCODERS/ and some other fixes)
michaelni
parents: 1064
diff changeset
1274
255
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
1275 static inline void gmc1_motion(MpegEncContext *s,
1064
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1059
diff changeset
1276 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
255
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
1277 int dest_offset,
1064
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1059
diff changeset
1278 uint8_t **ref_picture, int src_offset)
255
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
1279 {
1064
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1059
diff changeset
1280 uint8_t *ptr;
556
762c67fd4078 uvlinesize
michaelni
parents: 554
diff changeset
1281 int offset, src_x, src_y, linesize, uvlinesize;
255
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
1282 int motion_x, motion_y;
566
c376a0b290cf fixing gmc with emu edges
michaelni
parents: 565
diff changeset
1283 int emu=0;
255
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
1284
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
1285 motion_x= s->sprite_offset[0][0];
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
1286 motion_y= s->sprite_offset[0][1];
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
1287 src_x = s->mb_x * 16 + (motion_x >> (s->sprite_warping_accuracy+1));
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
1288 src_y = s->mb_y * 16 + (motion_y >> (s->sprite_warping_accuracy+1));
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
1289 motion_x<<=(3-s->sprite_warping_accuracy);
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
1290 motion_y<<=(3-s->sprite_warping_accuracy);
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
1291 src_x = clip(src_x, -16, s->width);
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
1292 if (src_x == s->width)
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
1293 motion_x =0;
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
1294 src_y = clip(src_y, -16, s->height);
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
1295 if (src_y == s->height)
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
1296 motion_y =0;
753
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 745
diff changeset
1297
255
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
1298 linesize = s->linesize;
556
762c67fd4078 uvlinesize
michaelni
parents: 554
diff changeset
1299 uvlinesize = s->uvlinesize;
753
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 745
diff changeset
1300
255
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
1301 ptr = ref_picture[0] + (src_y * linesize) + src_x + src_offset;
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
1302
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
1303 dest_y+=dest_offset;
566
c376a0b290cf fixing gmc with emu edges
michaelni
parents: 565
diff changeset
1304 if(s->flags&CODEC_FLAG_EMU_EDGE){
1002
e89b11e07ee7 gmc1 segfault fix (found by kabi)
michaelni
parents: 998
diff changeset
1305 if(src_x<0 || src_y<0 || src_x + 17 >= s->h_edge_pos
e89b11e07ee7 gmc1 segfault fix (found by kabi)
michaelni
parents: 998
diff changeset
1306 || src_y + 17 >= s->v_edge_pos){
936
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
1307 ff_emulated_edge_mc(s, ptr, linesize, 17, 17, src_x, src_y, s->h_edge_pos, s->v_edge_pos);
566
c376a0b290cf fixing gmc with emu edges
michaelni
parents: 565
diff changeset
1308 ptr= s->edge_emu_buffer;
c376a0b290cf fixing gmc with emu edges
michaelni
parents: 565
diff changeset
1309 }
c376a0b290cf fixing gmc with emu edges
michaelni
parents: 565
diff changeset
1310 }
753
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 745
diff changeset
1311
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 745
diff changeset
1312 if((motion_x|motion_y)&7){
853
eacc2dd8fd9d * using DSPContext - so each codec could use its local (sub)set of CPU extension
kabi
parents: 847
diff changeset
1313 s->dsp.gmc1(dest_y , ptr , linesize, 16, motion_x&15, motion_y&15, 128 - s->no_rounding);
eacc2dd8fd9d * using DSPContext - so each codec could use its local (sub)set of CPU extension
kabi
parents: 847
diff changeset
1314 s->dsp.gmc1(dest_y+8, ptr+8, linesize, 16, motion_x&15, motion_y&15, 128 - s->no_rounding);
753
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 745
diff changeset
1315 }else{
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 745
diff changeset
1316 int dxy;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 745
diff changeset
1317
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 745
diff changeset
1318 dxy= ((motion_x>>3)&1) | ((motion_y>>2)&2);
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 745
diff changeset
1319 if (s->no_rounding){
853
eacc2dd8fd9d * using DSPContext - so each codec could use its local (sub)set of CPU extension
kabi
parents: 847
diff changeset
1320 s->dsp.put_no_rnd_pixels_tab[0][dxy](dest_y, ptr, linesize, 16);
753
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 745
diff changeset
1321 }else{
853
eacc2dd8fd9d * using DSPContext - so each codec could use its local (sub)set of CPU extension
kabi
parents: 847
diff changeset
1322 s->dsp.put_pixels_tab [0][dxy](dest_y, ptr, linesize, 16);
eacc2dd8fd9d * using DSPContext - so each codec could use its local (sub)set of CPU extension
kabi
parents: 847
diff changeset
1323 }
753
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 745
diff changeset
1324 }
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 745
diff changeset
1325
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 745
diff changeset
1326 if(s->flags&CODEC_FLAG_GRAY) return;
255
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
1327
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
1328 motion_x= s->sprite_offset[1][0];
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
1329 motion_y= s->sprite_offset[1][1];
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
1330 src_x = s->mb_x * 8 + (motion_x >> (s->sprite_warping_accuracy+1));
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
1331 src_y = s->mb_y * 8 + (motion_y >> (s->sprite_warping_accuracy+1));
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
1332 motion_x<<=(3-s->sprite_warping_accuracy);
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
1333 motion_y<<=(3-s->sprite_warping_accuracy);
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
1334 src_x = clip(src_x, -8, s->width>>1);
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
1335 if (src_x == s->width>>1)
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
1336 motion_x =0;
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
1337 src_y = clip(src_y, -8, s->height>>1);
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
1338 if (src_y == s->height>>1)
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
1339 motion_y =0;
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
1340
556
762c67fd4078 uvlinesize
michaelni
parents: 554
diff changeset
1341 offset = (src_y * uvlinesize) + src_x + (src_offset>>1);
255
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
1342 ptr = ref_picture[1] + offset;
1002
e89b11e07ee7 gmc1 segfault fix (found by kabi)
michaelni
parents: 998
diff changeset
1343 if(s->flags&CODEC_FLAG_EMU_EDGE){
e89b11e07ee7 gmc1 segfault fix (found by kabi)
michaelni
parents: 998
diff changeset
1344 if(src_x<0 || src_y<0 || src_x + 9 >= s->h_edge_pos>>1
e89b11e07ee7 gmc1 segfault fix (found by kabi)
michaelni
parents: 998
diff changeset
1345 || src_y + 9 >= s->v_edge_pos>>1){
e89b11e07ee7 gmc1 segfault fix (found by kabi)
michaelni
parents: 998
diff changeset
1346 ff_emulated_edge_mc(s, ptr, uvlinesize, 9, 9, src_x, src_y, s->h_edge_pos>>1, s->v_edge_pos>>1);
e89b11e07ee7 gmc1 segfault fix (found by kabi)
michaelni
parents: 998
diff changeset
1347 ptr= s->edge_emu_buffer;
e89b11e07ee7 gmc1 segfault fix (found by kabi)
michaelni
parents: 998
diff changeset
1348 emu=1;
e89b11e07ee7 gmc1 segfault fix (found by kabi)
michaelni
parents: 998
diff changeset
1349 }
566
c376a0b290cf fixing gmc with emu edges
michaelni
parents: 565
diff changeset
1350 }
853
eacc2dd8fd9d * using DSPContext - so each codec could use its local (sub)set of CPU extension
kabi
parents: 847
diff changeset
1351 s->dsp.gmc1(dest_cb + (dest_offset>>1), ptr, uvlinesize, 8, motion_x&15, motion_y&15, 128 - s->no_rounding);
566
c376a0b290cf fixing gmc with emu edges
michaelni
parents: 565
diff changeset
1352
255
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
1353 ptr = ref_picture[2] + offset;
566
c376a0b290cf fixing gmc with emu edges
michaelni
parents: 565
diff changeset
1354 if(emu){
936
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
1355 ff_emulated_edge_mc(s, ptr, uvlinesize, 9, 9, src_x, src_y, s->h_edge_pos>>1, s->v_edge_pos>>1);
566
c376a0b290cf fixing gmc with emu edges
michaelni
parents: 565
diff changeset
1356 ptr= s->edge_emu_buffer;
c376a0b290cf fixing gmc with emu edges
michaelni
parents: 565
diff changeset
1357 }
853
eacc2dd8fd9d * using DSPContext - so each codec could use its local (sub)set of CPU extension
kabi
parents: 847
diff changeset
1358 s->dsp.gmc1(dest_cr + (dest_offset>>1), ptr, uvlinesize, 8, motion_x&15, motion_y&15, 128 - s->no_rounding);
255
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
1359
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
1360 return;
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
1361 }
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
1362
753
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 745
diff changeset
1363 static inline void gmc_motion(MpegEncContext *s,
1064
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1059
diff changeset
1364 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
753
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 745
diff changeset
1365 int dest_offset,
1064
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1059
diff changeset
1366 uint8_t **ref_picture, int src_offset)
753
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 745
diff changeset
1367 {
1064
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1059
diff changeset
1368 uint8_t *ptr;
753
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 745
diff changeset
1369 int linesize, uvlinesize;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 745
diff changeset
1370 const int a= s->sprite_warping_accuracy;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 745
diff changeset
1371 int ox, oy;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 745
diff changeset
1372
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 745
diff changeset
1373 linesize = s->linesize;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 745
diff changeset
1374 uvlinesize = s->uvlinesize;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 745
diff changeset
1375
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 745
diff changeset
1376 ptr = ref_picture[0] + src_offset;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 745
diff changeset
1377
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 745
diff changeset
1378 dest_y+=dest_offset;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 745
diff changeset
1379
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 745
diff changeset
1380 ox= s->sprite_offset[0][0] + s->sprite_delta[0][0]*s->mb_x*16 + s->sprite_delta[0][1]*s->mb_y*16;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 745
diff changeset
1381 oy= s->sprite_offset[0][1] + s->sprite_delta[1][0]*s->mb_x*16 + s->sprite_delta[1][1]*s->mb_y*16;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 745
diff changeset
1382
853
eacc2dd8fd9d * using DSPContext - so each codec could use its local (sub)set of CPU extension
kabi
parents: 847
diff changeset
1383 s->dsp.gmc(dest_y, ptr, linesize, 16,
753
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 745
diff changeset
1384 ox,
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 745
diff changeset
1385 oy,
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 745
diff changeset
1386 s->sprite_delta[0][0], s->sprite_delta[0][1],
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 745
diff changeset
1387 s->sprite_delta[1][0], s->sprite_delta[1][1],
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 745
diff changeset
1388 a+1, (1<<(2*a+1)) - s->no_rounding,
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 745
diff changeset
1389 s->h_edge_pos, s->v_edge_pos);
853
eacc2dd8fd9d * using DSPContext - so each codec could use its local (sub)set of CPU extension
kabi
parents: 847
diff changeset
1390 s->dsp.gmc(dest_y+8, ptr, linesize, 16,
753
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 745
diff changeset
1391 ox + s->sprite_delta[0][0]*8,
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 745
diff changeset
1392 oy + s->sprite_delta[1][0]*8,
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 745
diff changeset
1393 s->sprite_delta[0][0], s->sprite_delta[0][1],
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 745
diff changeset
1394 s->sprite_delta[1][0], s->sprite_delta[1][1],
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 745
diff changeset
1395 a+1, (1<<(2*a+1)) - s->no_rounding,
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 745
diff changeset
1396 s->h_edge_pos, s->v_edge_pos);
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 745
diff changeset
1397
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 745
diff changeset
1398 if(s->flags&CODEC_FLAG_GRAY) return;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 745
diff changeset
1399
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 745
diff changeset
1400
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 745
diff changeset
1401 dest_cb+=dest_offset>>1;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 745
diff changeset
1402 dest_cr+=dest_offset>>1;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 745
diff changeset
1403
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 745
diff changeset
1404 ox= s->sprite_offset[1][0] + s->sprite_delta[0][0]*s->mb_x*8 + s->sprite_delta[0][1]*s->mb_y*8;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 745
diff changeset
1405 oy= s->sprite_offset[1][1] + s->sprite_delta[1][0]*s->mb_x*8 + s->sprite_delta[1][1]*s->mb_y*8;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 745
diff changeset
1406
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 745
diff changeset
1407 ptr = ref_picture[1] + (src_offset>>1);
853
eacc2dd8fd9d * using DSPContext - so each codec could use its local (sub)set of CPU extension
kabi
parents: 847
diff changeset
1408 s->dsp.gmc(dest_cb, ptr, uvlinesize, 8,
753
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 745
diff changeset
1409 ox,
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 745
diff changeset
1410 oy,
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 745
diff changeset
1411 s->sprite_delta[0][0], s->sprite_delta[0][1],
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 745
diff changeset
1412 s->sprite_delta[1][0], s->sprite_delta[1][1],
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 745
diff changeset
1413 a+1, (1<<(2*a+1)) - s->no_rounding,
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 745
diff changeset
1414 s->h_edge_pos>>1, s->v_edge_pos>>1);
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 745
diff changeset
1415
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 745
diff changeset
1416 ptr = ref_picture[2] + (src_offset>>1);
853
eacc2dd8fd9d * using DSPContext - so each codec could use its local (sub)set of CPU extension
kabi
parents: 847
diff changeset
1417 s->dsp.gmc(dest_cr, ptr, uvlinesize, 8,
753
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 745
diff changeset
1418 ox,
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 745
diff changeset
1419 oy,
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 745
diff changeset
1420 s->sprite_delta[0][0], s->sprite_delta[0][1],
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 745
diff changeset
1421 s->sprite_delta[1][0], s->sprite_delta[1][1],
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 745
diff changeset
1422 a+1, (1<<(2*a+1)) - s->no_rounding,
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 745
diff changeset
1423 s->h_edge_pos>>1, s->v_edge_pos>>1);
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 745
diff changeset
1424 }
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 745
diff changeset
1425
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 745
diff changeset
1426
1064
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1059
diff changeset
1427 void ff_emulated_edge_mc(MpegEncContext *s, uint8_t *src, int linesize, int block_w, int block_h,
553
18ad513d92fe direct rendering method 1 support
michaelni
parents: 549
diff changeset
1428 int src_x, int src_y, int w, int h){
18ad513d92fe direct rendering method 1 support
michaelni
parents: 549
diff changeset
1429 int x, y;
18ad513d92fe direct rendering method 1 support
michaelni
parents: 549
diff changeset
1430 int start_y, start_x, end_y, end_x;
1064
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1059
diff changeset
1431 uint8_t *buf= s->edge_emu_buffer;
853
eacc2dd8fd9d * using DSPContext - so each codec could use its local (sub)set of CPU extension
kabi
parents: 847
diff changeset
1432
553
18ad513d92fe direct rendering method 1 support
michaelni
parents: 549
diff changeset
1433 if(src_y>= h){
18ad513d92fe direct rendering method 1 support
michaelni
parents: 549
diff changeset
1434 src+= (h-1-src_y)*linesize;
18ad513d92fe direct rendering method 1 support
michaelni
parents: 549
diff changeset
1435 src_y=h-1;
554
3eb6fe38019a 4mv & qpel edge emu
michaelni
parents: 553
diff changeset
1436 }else if(src_y<=-block_h){
3eb6fe38019a 4mv & qpel edge emu
michaelni
parents: 553
diff changeset
1437 src+= (1-block_h-src_y)*linesize;
3eb6fe38019a 4mv & qpel edge emu
michaelni
parents: 553
diff changeset
1438 src_y=1-block_h;
553
18ad513d92fe direct rendering method 1 support
michaelni
parents: 549
diff changeset
1439 }
18ad513d92fe direct rendering method 1 support
michaelni
parents: 549
diff changeset
1440 if(src_x>= w){
18ad513d92fe direct rendering method 1 support
michaelni
parents: 549
diff changeset
1441 src+= (w-1-src_x);
18ad513d92fe direct rendering method 1 support
michaelni
parents: 549
diff changeset
1442 src_x=w-1;
554
3eb6fe38019a 4mv & qpel edge emu
michaelni
parents: 553
diff changeset
1443 }else if(src_x<=-block_w){
3eb6fe38019a 4mv & qpel edge emu
michaelni
parents: 553
diff changeset
1444 src+= (1-block_w-src_x);
3eb6fe38019a 4mv & qpel edge emu
michaelni
parents: 553
diff changeset
1445 src_x=1-block_w;
553
18ad513d92fe direct rendering method 1 support
michaelni
parents: 549
diff changeset
1446 }
18ad513d92fe direct rendering method 1 support
michaelni
parents: 549
diff changeset
1447
847
f3c369b8ddca reversing header game
michaelni
parents: 843
diff changeset
1448 start_y= FFMAX(0, -src_y);
f3c369b8ddca reversing header game
michaelni
parents: 843
diff changeset
1449 start_x= FFMAX(0, -src_x);
f3c369b8ddca reversing header game
michaelni
parents: 843
diff changeset
1450 end_y= FFMIN(block_h, h-src_y);
f3c369b8ddca reversing header game
michaelni
parents: 843
diff changeset
1451 end_x= FFMIN(block_w, w-src_x);
566
c376a0b290cf fixing gmc with emu edges
michaelni
parents: 565
diff changeset
1452
553
18ad513d92fe direct rendering method 1 support
michaelni
parents: 549
diff changeset
1453 // copy existing part
18ad513d92fe direct rendering method 1 support
michaelni
parents: 549
diff changeset
1454 for(y=start_y; y<end_y; y++){
18ad513d92fe direct rendering method 1 support
michaelni
parents: 549
diff changeset
1455 for(x=start_x; x<end_x; x++){
18ad513d92fe direct rendering method 1 support
michaelni
parents: 549
diff changeset
1456 buf[x + y*linesize]= src[x + y*linesize];
18ad513d92fe direct rendering method 1 support
michaelni
parents: 549
diff changeset
1457 }
18ad513d92fe direct rendering method 1 support
michaelni
parents: 549
diff changeset
1458 }
18ad513d92fe direct rendering method 1 support
michaelni
parents: 549
diff changeset
1459
18ad513d92fe direct rendering method 1 support
michaelni
parents: 549
diff changeset
1460 //top
18ad513d92fe direct rendering method 1 support
michaelni
parents: 549
diff changeset
1461 for(y=0; y<start_y; y++){
18ad513d92fe direct rendering method 1 support
michaelni
parents: 549
diff changeset
1462 for(x=start_x; x<end_x; x++){
18ad513d92fe direct rendering method 1 support
michaelni
parents: 549
diff changeset
1463 buf[x + y*linesize]= buf[x + start_y*linesize];
18ad513d92fe direct rendering method 1 support
michaelni
parents: 549
diff changeset
1464 }
18ad513d92fe direct rendering method 1 support
michaelni
parents: 549
diff changeset
1465 }
18ad513d92fe direct rendering method 1 support
michaelni
parents: 549
diff changeset
1466
18ad513d92fe direct rendering method 1 support
michaelni
parents: 549
diff changeset
1467 //bottom
18ad513d92fe direct rendering method 1 support
michaelni
parents: 549
diff changeset
1468 for(y=end_y; y<block_h; y++){
18ad513d92fe direct rendering method 1 support
michaelni
parents: 549
diff changeset
1469 for(x=start_x; x<end_x; x++){
18ad513d92fe direct rendering method 1 support
michaelni
parents: 549
diff changeset
1470 buf[x + y*linesize]= buf[x + (end_y-1)*linesize];
18ad513d92fe direct rendering method 1 support
michaelni
parents: 549
diff changeset
1471 }
18ad513d92fe direct rendering method 1 support
michaelni
parents: 549
diff changeset
1472 }
18ad513d92fe direct rendering method 1 support
michaelni
parents: 549
diff changeset
1473
18ad513d92fe direct rendering method 1 support
michaelni
parents: 549
diff changeset
1474 for(y=0; y<block_h; y++){
18ad513d92fe direct rendering method 1 support
michaelni
parents: 549
diff changeset
1475 //left
18ad513d92fe direct rendering method 1 support
michaelni
parents: 549
diff changeset
1476 for(x=0; x<start_x; x++){
18ad513d92fe direct rendering method 1 support
michaelni
parents: 549
diff changeset
1477 buf[x + y*linesize]= buf[start_x + y*linesize];
18ad513d92fe direct rendering method 1 support
michaelni
parents: 549
diff changeset
1478 }
18ad513d92fe direct rendering method 1 support
michaelni
parents: 549
diff changeset
1479
18ad513d92fe direct rendering method 1 support
michaelni
parents: 549
diff changeset
1480 //right
18ad513d92fe direct rendering method 1 support
michaelni
parents: 549
diff changeset
1481 for(x=end_x; x<block_w; x++){
18ad513d92fe direct rendering method 1 support
michaelni
parents: 549
diff changeset
1482 buf[x + y*linesize]= buf[end_x - 1 + y*linesize];
18ad513d92fe direct rendering method 1 support
michaelni
parents: 549
diff changeset
1483 }
18ad513d92fe direct rendering method 1 support
michaelni
parents: 549
diff changeset
1484 }
18ad513d92fe direct rendering method 1 support
michaelni
parents: 549
diff changeset
1485 }
18ad513d92fe direct rendering method 1 support
michaelni
parents: 549
diff changeset
1486
18ad513d92fe direct rendering method 1 support
michaelni
parents: 549
diff changeset
1487
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1488 /* apply one mpeg motion vector to the three components */
986e461dc072 Initial revision
glantau
parents:
diff changeset
1489 static inline void mpeg_motion(MpegEncContext *s,
1064
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1059
diff changeset
1490 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1491 int dest_offset,
1064
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1059
diff changeset
1492 uint8_t **ref_picture, int src_offset,
651
45e8f39fda50 put/avg_pixels16
michaelni
parents: 650
diff changeset
1493 int field_based, op_pixels_func (*pix_op)[4],
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1494 int motion_x, int motion_y, int h)
986e461dc072 Initial revision
glantau
parents:
diff changeset
1495 {
1064
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1059
diff changeset
1496 uint8_t *ptr;
582
5132a4ee50cd different edge positions fixed with edge emu / dr1
michaelni
parents: 575
diff changeset
1497 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
1498 int emu=0;
651
45e8f39fda50 put/avg_pixels16
michaelni
parents: 650
diff changeset
1499 #if 0
255
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
1500 if(s->quarter_sample)
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
1501 {
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
1502 motion_x>>=1;
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
1503 motion_y>>=1;
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
1504 }
651
45e8f39fda50 put/avg_pixels16
michaelni
parents: 650
diff changeset
1505 #endif
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1506 dxy = ((motion_y & 1) << 1) | (motion_x & 1);
986e461dc072 Initial revision
glantau
parents:
diff changeset
1507 src_x = s->mb_x * 16 + (motion_x >> 1);
986e461dc072 Initial revision
glantau
parents:
diff changeset
1508 src_y = s->mb_y * (16 >> field_based) + (motion_y >> 1);
986e461dc072 Initial revision
glantau
parents:
diff changeset
1509
986e461dc072 Initial revision
glantau
parents:
diff changeset
1510 /* WARNING: do no forget half pels */
986e461dc072 Initial revision
glantau
parents:
diff changeset
1511 height = s->height >> field_based;
582
5132a4ee50cd different edge positions fixed with edge emu / dr1
michaelni
parents: 575
diff changeset
1512 v_edge_pos = s->v_edge_pos >> field_based;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1513 src_x = clip(src_x, -16, s->width);
986e461dc072 Initial revision
glantau
parents:
diff changeset
1514 if (src_x == s->width)
986e461dc072 Initial revision
glantau
parents:
diff changeset
1515 dxy &= ~1;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1516 src_y = clip(src_y, -16, height);
986e461dc072 Initial revision
glantau
parents:
diff changeset
1517 if (src_y == height)
986e461dc072 Initial revision
glantau
parents:
diff changeset
1518 dxy &= ~2;
565
44d744901ded interlaced mpeg2 fix ... replacing linesize>>1 by uvlinesize brainlessly wasnt a good idea
michaelni
parents: 562
diff changeset
1519 linesize = s->linesize << field_based;
44d744901ded interlaced mpeg2 fix ... replacing linesize>>1 by uvlinesize brainlessly wasnt a good idea
michaelni
parents: 562
diff changeset
1520 uvlinesize = s->uvlinesize << field_based;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1521 ptr = ref_picture[0] + (src_y * linesize) + (src_x) + src_offset;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1522 dest_y += dest_offset;
553
18ad513d92fe direct rendering method 1 support
michaelni
parents: 549
diff changeset
1523
18ad513d92fe direct rendering method 1 support
michaelni
parents: 549
diff changeset
1524 if(s->flags&CODEC_FLAG_EMU_EDGE){
582
5132a4ee50cd different edge positions fixed with edge emu / dr1
michaelni
parents: 575
diff changeset
1525 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
1526 || src_y + (motion_y&1) + h > v_edge_pos){
936
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
1527 ff_emulated_edge_mc(s, ptr - src_offset, s->linesize, 17, 17+field_based,
763
339db642859d fixing interlaced MC & edge-emu
michaelni
parents: 760
diff changeset
1528 src_x, src_y<<field_based, s->h_edge_pos, s->v_edge_pos);
339db642859d fixing interlaced MC & edge-emu
michaelni
parents: 760
diff changeset
1529 ptr= s->edge_emu_buffer + src_offset;
553
18ad513d92fe direct rendering method 1 support
michaelni
parents: 549
diff changeset
1530 emu=1;
18ad513d92fe direct rendering method 1 support
michaelni
parents: 549
diff changeset
1531 }
18ad513d92fe direct rendering method 1 support
michaelni
parents: 549
diff changeset
1532 }
651
45e8f39fda50 put/avg_pixels16
michaelni
parents: 650
diff changeset
1533 pix_op[0][dxy](dest_y, ptr, linesize, h);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1534
485
20108840b0e5 grayscale only decoding
michaelni
parents: 481
diff changeset
1535 if(s->flags&CODEC_FLAG_GRAY) return;
20108840b0e5 grayscale only decoding
michaelni
parents: 481
diff changeset
1536
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1537 if (s->out_format == FMT_H263) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
1538 dxy = 0;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1539 if ((motion_x & 3) != 0)
986e461dc072 Initial revision
glantau
parents:
diff changeset
1540 dxy |= 1;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1541 if ((motion_y & 3) != 0)
986e461dc072 Initial revision
glantau
parents:
diff changeset
1542 dxy |= 2;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1543 mx = motion_x >> 2;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1544 my = motion_y >> 2;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1545 } else {
986e461dc072 Initial revision
glantau
parents:
diff changeset
1546 mx = motion_x / 2;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1547 my = motion_y / 2;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1548 dxy = ((my & 1) << 1) | (mx & 1);
986e461dc072 Initial revision
glantau
parents:
diff changeset
1549 mx >>= 1;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1550 my >>= 1;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1551 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
1552
986e461dc072 Initial revision
glantau
parents:
diff changeset
1553 src_x = s->mb_x * 8 + mx;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1554 src_y = s->mb_y * (8 >> field_based) + my;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1555 src_x = clip(src_x, -8, s->width >> 1);
986e461dc072 Initial revision
glantau
parents:
diff changeset
1556 if (src_x == (s->width >> 1))
986e461dc072 Initial revision
glantau
parents:
diff changeset
1557 dxy &= ~1;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1558 src_y = clip(src_y, -8, height >> 1);
986e461dc072 Initial revision
glantau
parents:
diff changeset
1559 if (src_y == (height >> 1))
986e461dc072 Initial revision
glantau
parents:
diff changeset
1560 dxy &= ~2;
565
44d744901ded interlaced mpeg2 fix ... replacing linesize>>1 by uvlinesize brainlessly wasnt a good idea
michaelni
parents: 562
diff changeset
1561 offset = (src_y * uvlinesize) + src_x + (src_offset >> 1);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1562 ptr = ref_picture[1] + offset;
553
18ad513d92fe direct rendering method 1 support
michaelni
parents: 549
diff changeset
1563 if(emu){
936
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
1564 ff_emulated_edge_mc(s, ptr - (src_offset >> 1), s->uvlinesize, 9, 9+field_based,
763
339db642859d fixing interlaced MC & edge-emu
michaelni
parents: 760
diff changeset
1565 src_x, src_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
339db642859d fixing interlaced MC & edge-emu
michaelni
parents: 760
diff changeset
1566 ptr= s->edge_emu_buffer + (src_offset >> 1);
553
18ad513d92fe direct rendering method 1 support
michaelni
parents: 549
diff changeset
1567 }
651
45e8f39fda50 put/avg_pixels16
michaelni
parents: 650
diff changeset
1568 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
1569
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1570 ptr = ref_picture[2] + offset;
553
18ad513d92fe direct rendering method 1 support
michaelni
parents: 549
diff changeset
1571 if(emu){
936
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
1572 ff_emulated_edge_mc(s, ptr - (src_offset >> 1), s->uvlinesize, 9, 9+field_based,
763
339db642859d fixing interlaced MC & edge-emu
michaelni
parents: 760
diff changeset
1573 src_x, src_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
339db642859d fixing interlaced MC & edge-emu
michaelni
parents: 760
diff changeset
1574 ptr= s->edge_emu_buffer + (src_offset >> 1);
553
18ad513d92fe direct rendering method 1 support
michaelni
parents: 549
diff changeset
1575 }
651
45e8f39fda50 put/avg_pixels16
michaelni
parents: 650
diff changeset
1576 pix_op[1][dxy](dest_cr + (dest_offset >> 1), ptr, uvlinesize, h >> 1);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1577 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
1578
255
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
1579 static inline void qpel_motion(MpegEncContext *s,
1064
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1059
diff changeset
1580 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
255
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
1581 int dest_offset,
1064
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1059
diff changeset
1582 uint8_t **ref_picture, int src_offset,
651
45e8f39fda50 put/avg_pixels16
michaelni
parents: 650
diff changeset
1583 int field_based, op_pixels_func (*pix_op)[4],
45e8f39fda50 put/avg_pixels16
michaelni
parents: 650
diff changeset
1584 qpel_mc_func (*qpix_op)[16],
255
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
1585 int motion_x, int motion_y, int h)
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
1586 {
1064
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1059
diff changeset
1587 uint8_t *ptr;
671
3f2e5a282f61 interlaced qpel mpeg4 fixed
michaelni
parents: 664
diff changeset
1588 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
1589 int emu=0;
255
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
1590
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
1591 dxy = ((motion_y & 3) << 2) | (motion_x & 3);
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
1592 src_x = s->mb_x * 16 + (motion_x >> 2);
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
1593 src_y = s->mb_y * (16 >> field_based) + (motion_y >> 2);
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
1594
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
1595 height = s->height >> field_based;
582
5132a4ee50cd different edge positions fixed with edge emu / dr1
michaelni
parents: 575
diff changeset
1596 v_edge_pos = s->v_edge_pos >> field_based;
255
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
1597 src_x = clip(src_x, -16, s->width);
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
1598 if (src_x == s->width)
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
1599 dxy &= ~3;
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
1600 src_y = clip(src_y, -16, height);
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
1601 if (src_y == height)
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
1602 dxy &= ~12;
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
1603 linesize = s->linesize << field_based;
671
3f2e5a282f61 interlaced qpel mpeg4 fixed
michaelni
parents: 664
diff changeset
1604 uvlinesize = s->uvlinesize << field_based;
255
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
1605 ptr = ref_picture[0] + (src_y * linesize) + src_x + src_offset;
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
1606 dest_y += dest_offset;
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
1607 //printf("%d %d %d\n", src_x, src_y, dxy);
554
3eb6fe38019a 4mv & qpel edge emu
michaelni
parents: 553
diff changeset
1608
3eb6fe38019a 4mv & qpel edge emu
michaelni
parents: 553
diff changeset
1609 if(s->flags&CODEC_FLAG_EMU_EDGE){
582
5132a4ee50cd different edge positions fixed with edge emu / dr1
michaelni
parents: 575
diff changeset
1610 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
1611 || src_y + (motion_y&3) + h > v_edge_pos){
936
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
1612 ff_emulated_edge_mc(s, ptr - src_offset, s->linesize, 17, 17+field_based,
763
339db642859d fixing interlaced MC & edge-emu
michaelni
parents: 760
diff changeset
1613 src_x, src_y<<field_based, s->h_edge_pos, s->v_edge_pos);
339db642859d fixing interlaced MC & edge-emu
michaelni
parents: 760
diff changeset
1614 ptr= s->edge_emu_buffer + src_offset;
554
3eb6fe38019a 4mv & qpel edge emu
michaelni
parents: 553
diff changeset
1615 emu=1;
3eb6fe38019a 4mv & qpel edge emu
michaelni
parents: 553
diff changeset
1616 }
3eb6fe38019a 4mv & qpel edge emu
michaelni
parents: 553
diff changeset
1617 }
671
3f2e5a282f61 interlaced qpel mpeg4 fixed
michaelni
parents: 664
diff changeset
1618 if(!field_based)
3f2e5a282f61 interlaced qpel mpeg4 fixed
michaelni
parents: 664
diff changeset
1619 qpix_op[0][dxy](dest_y, ptr, linesize);
3f2e5a282f61 interlaced qpel mpeg4 fixed
michaelni
parents: 664
diff changeset
1620 else{
3f2e5a282f61 interlaced qpel mpeg4 fixed
michaelni
parents: 664
diff changeset
1621 //damn interlaced mode
3f2e5a282f61 interlaced qpel mpeg4 fixed
michaelni
parents: 664
diff changeset
1622 //FIXME boundary mirroring is not exactly correct here
3f2e5a282f61 interlaced qpel mpeg4 fixed
michaelni
parents: 664
diff changeset
1623 qpix_op[1][dxy](dest_y , ptr , linesize);
3f2e5a282f61 interlaced qpel mpeg4 fixed
michaelni
parents: 664
diff changeset
1624 qpix_op[1][dxy](dest_y+8, ptr+8, linesize);
3f2e5a282f61 interlaced qpel mpeg4 fixed
michaelni
parents: 664
diff changeset
1625 }
651
45e8f39fda50 put/avg_pixels16
michaelni
parents: 650
diff changeset
1626
485
20108840b0e5 grayscale only decoding
michaelni
parents: 481
diff changeset
1627 if(s->flags&CODEC_FLAG_GRAY) return;
20108840b0e5 grayscale only decoding
michaelni
parents: 481
diff changeset
1628
671
3f2e5a282f61 interlaced qpel mpeg4 fixed
michaelni
parents: 664
diff changeset
1629 if(field_based){
3f2e5a282f61 interlaced qpel mpeg4 fixed
michaelni
parents: 664
diff changeset
1630 mx= motion_x/2;
3f2e5a282f61 interlaced qpel mpeg4 fixed
michaelni
parents: 664
diff changeset
1631 my= motion_y>>1;
1048
75a659fae7e0 divx503 decoding fix
michaelni
parents: 1042
diff changeset
1632 }else if(s->workaround_bugs&FF_BUG_QPEL_CHROMA2){
75a659fae7e0 divx503 decoding fix
michaelni
parents: 1042
diff changeset
1633 static const int rtab[8]= {0,0,1,1,0,0,0,1};
75a659fae7e0 divx503 decoding fix
michaelni
parents: 1042
diff changeset
1634 mx= (motion_x>>1) + rtab[motion_x&7];
75a659fae7e0 divx503 decoding fix
michaelni
parents: 1042
diff changeset
1635 my= (motion_y>>1) + rtab[motion_y&7];
760
e858fe220ce0 xvid qpel bug workaround
michaelni
parents: 756
diff changeset
1636 }else if(s->workaround_bugs&FF_BUG_QPEL_CHROMA){
671
3f2e5a282f61 interlaced qpel mpeg4 fixed
michaelni
parents: 664
diff changeset
1637 mx= (motion_x>>1)|(motion_x&1);
3f2e5a282f61 interlaced qpel mpeg4 fixed
michaelni
parents: 664
diff changeset
1638 my= (motion_y>>1)|(motion_y&1);
3f2e5a282f61 interlaced qpel mpeg4 fixed
michaelni
parents: 664
diff changeset
1639 }else{
3f2e5a282f61 interlaced qpel mpeg4 fixed
michaelni
parents: 664
diff changeset
1640 mx= motion_x/2;
3f2e5a282f61 interlaced qpel mpeg4 fixed
michaelni
parents: 664
diff changeset
1641 my= motion_y/2;
3f2e5a282f61 interlaced qpel mpeg4 fixed
michaelni
parents: 664
diff changeset
1642 }
3f2e5a282f61 interlaced qpel mpeg4 fixed
michaelni
parents: 664
diff changeset
1643 mx= (mx>>1)|(mx&1);
3f2e5a282f61 interlaced qpel mpeg4 fixed
michaelni
parents: 664
diff changeset
1644 my= (my>>1)|(my&1);
1048
75a659fae7e0 divx503 decoding fix
michaelni
parents: 1042
diff changeset
1645
671
3f2e5a282f61 interlaced qpel mpeg4 fixed
michaelni
parents: 664
diff changeset
1646 dxy= (mx&1) | ((my&1)<<1);
3f2e5a282f61 interlaced qpel mpeg4 fixed
michaelni
parents: 664
diff changeset
1647 mx>>=1;
3f2e5a282f61 interlaced qpel mpeg4 fixed
michaelni
parents: 664
diff changeset
1648 my>>=1;
255
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
1649
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
1650 src_x = s->mb_x * 8 + mx;
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
1651 src_y = s->mb_y * (8 >> field_based) + my;
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
1652 src_x = clip(src_x, -8, s->width >> 1);
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
1653 if (src_x == (s->width >> 1))
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
1654 dxy &= ~1;
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
1655 src_y = clip(src_y, -8, height >> 1);
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
1656 if (src_y == (height >> 1))
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
1657 dxy &= ~2;
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
1658
671
3f2e5a282f61 interlaced qpel mpeg4 fixed
michaelni
parents: 664
diff changeset
1659 offset = (src_y * uvlinesize) + src_x + (src_offset >> 1);
255
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
1660 ptr = ref_picture[1] + offset;
554
3eb6fe38019a 4mv & qpel edge emu
michaelni
parents: 553
diff changeset
1661 if(emu){
936
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
1662 ff_emulated_edge_mc(s, ptr - (src_offset >> 1), s->uvlinesize, 9, 9 + field_based,
763
339db642859d fixing interlaced MC & edge-emu
michaelni
parents: 760
diff changeset
1663 src_x, src_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
339db642859d fixing interlaced MC & edge-emu
michaelni
parents: 760
diff changeset
1664 ptr= s->edge_emu_buffer + (src_offset >> 1);
554
3eb6fe38019a 4mv & qpel edge emu
michaelni
parents: 553
diff changeset
1665 }
671
3f2e5a282f61 interlaced qpel mpeg4 fixed
michaelni
parents: 664
diff changeset
1666 pix_op[1][dxy](dest_cb + (dest_offset >> 1), ptr, uvlinesize, h >> 1);
554
3eb6fe38019a 4mv & qpel edge emu
michaelni
parents: 553
diff changeset
1667
255
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
1668 ptr = ref_picture[2] + offset;
554
3eb6fe38019a 4mv & qpel edge emu
michaelni
parents: 553
diff changeset
1669 if(emu){
936
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
1670 ff_emulated_edge_mc(s, ptr - (src_offset >> 1), s->uvlinesize, 9, 9 + field_based,
763
339db642859d fixing interlaced MC & edge-emu
michaelni
parents: 760
diff changeset
1671 src_x, src_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
339db642859d fixing interlaced MC & edge-emu
michaelni
parents: 760
diff changeset
1672 ptr= s->edge_emu_buffer + (src_offset >> 1);
554
3eb6fe38019a 4mv & qpel edge emu
michaelni
parents: 553
diff changeset
1673 }
671
3f2e5a282f61 interlaced qpel mpeg4 fixed
michaelni
parents: 664
diff changeset
1674 pix_op[1][dxy](dest_cr + (dest_offset >> 1), ptr, uvlinesize, h >> 1);
255
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
1675 }
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
1676
1013
5d4c95f323d0 finetuneing thresholds/factors
michaelni
parents: 1011
diff changeset
1677 inline int ff_h263_round_chroma(int x){
5d4c95f323d0 finetuneing thresholds/factors
michaelni
parents: 1011
diff changeset
1678 if (x >= 0)
5d4c95f323d0 finetuneing thresholds/factors
michaelni
parents: 1011
diff changeset
1679 return (h263_chroma_roundtab[x & 0xf] + ((x >> 3) & ~1));
5d4c95f323d0 finetuneing thresholds/factors
michaelni
parents: 1011
diff changeset
1680 else {
5d4c95f323d0 finetuneing thresholds/factors
michaelni
parents: 1011
diff changeset
1681 x = -x;
5d4c95f323d0 finetuneing thresholds/factors
michaelni
parents: 1011
diff changeset
1682 return -(h263_chroma_roundtab[x & 0xf] + ((x >> 3) & ~1));
5d4c95f323d0 finetuneing thresholds/factors
michaelni
parents: 1011
diff changeset
1683 }
5d4c95f323d0 finetuneing thresholds/factors
michaelni
parents: 1011
diff changeset
1684 }
255
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
1685
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1686 static inline void MPV_motion(MpegEncContext *s,
1064
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1059
diff changeset
1687 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1059
diff changeset
1688 int dir, uint8_t **ref_picture,
651
45e8f39fda50 put/avg_pixels16
michaelni
parents: 650
diff changeset
1689 op_pixels_func (*pix_op)[4], qpel_mc_func (*qpix_op)[16])
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1690 {
986e461dc072 Initial revision
glantau
parents:
diff changeset
1691 int dxy, offset, mx, my, src_x, src_y, motion_x, motion_y;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1692 int mb_x, mb_y, i;
1064
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1059
diff changeset
1693 uint8_t *ptr, *dest;
554
3eb6fe38019a 4mv & qpel edge emu
michaelni
parents: 553
diff changeset
1694 int emu=0;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1695
986e461dc072 Initial revision
glantau
parents:
diff changeset
1696 mb_x = s->mb_x;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1697 mb_y = s->mb_y;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1698
986e461dc072 Initial revision
glantau
parents:
diff changeset
1699 switch(s->mv_type) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
1700 case MV_TYPE_16X16:
1042
a78f6f72d54e --disable-risky support
michaelni
parents: 1026
diff changeset
1701 #ifdef CONFIG_RISKY
255
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
1702 if(s->mcsel){
753
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 745
diff changeset
1703 if(s->real_sprite_warping_points==1){
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 745
diff changeset
1704 gmc1_motion(s, dest_y, dest_cb, dest_cr, 0,
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 745
diff changeset
1705 ref_picture, 0);
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 745
diff changeset
1706 }else{
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 745
diff changeset
1707 gmc_motion(s, dest_y, dest_cb, dest_cr, 0,
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 745
diff changeset
1708 ref_picture, 0);
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 745
diff changeset
1709 }
651
45e8f39fda50 put/avg_pixels16
michaelni
parents: 650
diff changeset
1710 }else if(s->quarter_sample){
255
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
1711 qpel_motion(s, dest_y, dest_cb, dest_cr, 0,
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
1712 ref_picture, 0,
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
1713 0, pix_op, qpix_op,
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
1714 s->mv[dir][0][0], s->mv[dir][0][1], 16);
936
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
1715 }else if(s->mspel){
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
1716 ff_mspel_motion(s, dest_y, dest_cb, dest_cr,
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
1717 ref_picture, pix_op,
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
1718 s->mv[dir][0][0], s->mv[dir][0][1], 16);
1042
a78f6f72d54e --disable-risky support
michaelni
parents: 1026
diff changeset
1719 }else
a78f6f72d54e --disable-risky support
michaelni
parents: 1026
diff changeset
1720 #endif
a78f6f72d54e --disable-risky support
michaelni
parents: 1026
diff changeset
1721 {
255
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
1722 mpeg_motion(s, dest_y, dest_cb, dest_cr, 0,
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
1723 ref_picture, 0,
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
1724 0, pix_op,
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
1725 s->mv[dir][0][0], s->mv[dir][0][1], 16);
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
1726 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1727 break;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1728 case MV_TYPE_8X8:
673
242f0f7d8c15 fixing qpel 4mv
michaelni
parents: 671
diff changeset
1729 mx = 0;
242f0f7d8c15 fixing qpel 4mv
michaelni
parents: 671
diff changeset
1730 my = 0;
242f0f7d8c15 fixing qpel 4mv
michaelni
parents: 671
diff changeset
1731 if(s->quarter_sample){
242f0f7d8c15 fixing qpel 4mv
michaelni
parents: 671
diff changeset
1732 for(i=0;i<4;i++) {
242f0f7d8c15 fixing qpel 4mv
michaelni
parents: 671
diff changeset
1733 motion_x = s->mv[dir][i][0];
242f0f7d8c15 fixing qpel 4mv
michaelni
parents: 671
diff changeset
1734 motion_y = s->mv[dir][i][1];
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1735
673
242f0f7d8c15 fixing qpel 4mv
michaelni
parents: 671
diff changeset
1736 dxy = ((motion_y & 3) << 2) | (motion_x & 3);
242f0f7d8c15 fixing qpel 4mv
michaelni
parents: 671
diff changeset
1737 src_x = mb_x * 16 + (motion_x >> 2) + (i & 1) * 8;
242f0f7d8c15 fixing qpel 4mv
michaelni
parents: 671
diff changeset
1738 src_y = mb_y * 16 + (motion_y >> 2) + (i >>1) * 8;
242f0f7d8c15 fixing qpel 4mv
michaelni
parents: 671
diff changeset
1739
242f0f7d8c15 fixing qpel 4mv
michaelni
parents: 671
diff changeset
1740 /* WARNING: do no forget half pels */
242f0f7d8c15 fixing qpel 4mv
michaelni
parents: 671
diff changeset
1741 src_x = clip(src_x, -16, s->width);
242f0f7d8c15 fixing qpel 4mv
michaelni
parents: 671
diff changeset
1742 if (src_x == s->width)
242f0f7d8c15 fixing qpel 4mv
michaelni
parents: 671
diff changeset
1743 dxy &= ~3;
242f0f7d8c15 fixing qpel 4mv
michaelni
parents: 671
diff changeset
1744 src_y = clip(src_y, -16, s->height);
242f0f7d8c15 fixing qpel 4mv
michaelni
parents: 671
diff changeset
1745 if (src_y == s->height)
242f0f7d8c15 fixing qpel 4mv
michaelni
parents: 671
diff changeset
1746 dxy &= ~12;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1747
673
242f0f7d8c15 fixing qpel 4mv
michaelni
parents: 671
diff changeset
1748 ptr = ref_picture[0] + (src_y * s->linesize) + (src_x);
242f0f7d8c15 fixing qpel 4mv
michaelni
parents: 671
diff changeset
1749 if(s->flags&CODEC_FLAG_EMU_EDGE){
242f0f7d8c15 fixing qpel 4mv
michaelni
parents: 671
diff changeset
1750 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
1751 || src_y + (motion_y&3) + 8 > s->v_edge_pos){
936
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
1752 ff_emulated_edge_mc(s, ptr, s->linesize, 9, 9, src_x, src_y, s->h_edge_pos, s->v_edge_pos);
673
242f0f7d8c15 fixing qpel 4mv
michaelni
parents: 671
diff changeset
1753 ptr= s->edge_emu_buffer;
242f0f7d8c15 fixing qpel 4mv
michaelni
parents: 671
diff changeset
1754 }
242f0f7d8c15 fixing qpel 4mv
michaelni
parents: 671
diff changeset
1755 }
242f0f7d8c15 fixing qpel 4mv
michaelni
parents: 671
diff changeset
1756 dest = dest_y + ((i & 1) * 8) + (i >> 1) * 8 * s->linesize;
242f0f7d8c15 fixing qpel 4mv
michaelni
parents: 671
diff changeset
1757 qpix_op[1][dxy](dest, ptr, s->linesize);
242f0f7d8c15 fixing qpel 4mv
michaelni
parents: 671
diff changeset
1758
242f0f7d8c15 fixing qpel 4mv
michaelni
parents: 671
diff changeset
1759 mx += s->mv[dir][i][0]/2;
242f0f7d8c15 fixing qpel 4mv
michaelni
parents: 671
diff changeset
1760 my += s->mv[dir][i][1]/2;
242f0f7d8c15 fixing qpel 4mv
michaelni
parents: 671
diff changeset
1761 }
242f0f7d8c15 fixing qpel 4mv
michaelni
parents: 671
diff changeset
1762 }else{
242f0f7d8c15 fixing qpel 4mv
michaelni
parents: 671
diff changeset
1763 for(i=0;i<4;i++) {
242f0f7d8c15 fixing qpel 4mv
michaelni
parents: 671
diff changeset
1764 motion_x = s->mv[dir][i][0];
242f0f7d8c15 fixing qpel 4mv
michaelni
parents: 671
diff changeset
1765 motion_y = s->mv[dir][i][1];
242f0f7d8c15 fixing qpel 4mv
michaelni
parents: 671
diff changeset
1766
242f0f7d8c15 fixing qpel 4mv
michaelni
parents: 671
diff changeset
1767 dxy = ((motion_y & 1) << 1) | (motion_x & 1);
242f0f7d8c15 fixing qpel 4mv
michaelni
parents: 671
diff changeset
1768 src_x = mb_x * 16 + (motion_x >> 1) + (i & 1) * 8;
242f0f7d8c15 fixing qpel 4mv
michaelni
parents: 671
diff changeset
1769 src_y = mb_y * 16 + (motion_y >> 1) + (i >>1) * 8;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1770
673
242f0f7d8c15 fixing qpel 4mv
michaelni
parents: 671
diff changeset
1771 /* WARNING: do no forget half pels */
242f0f7d8c15 fixing qpel 4mv
michaelni
parents: 671
diff changeset
1772 src_x = clip(src_x, -16, s->width);
242f0f7d8c15 fixing qpel 4mv
michaelni
parents: 671
diff changeset
1773 if (src_x == s->width)
242f0f7d8c15 fixing qpel 4mv
michaelni
parents: 671
diff changeset
1774 dxy &= ~1;
242f0f7d8c15 fixing qpel 4mv
michaelni
parents: 671
diff changeset
1775 src_y = clip(src_y, -16, s->height);
242f0f7d8c15 fixing qpel 4mv
michaelni
parents: 671
diff changeset
1776 if (src_y == s->height)
242f0f7d8c15 fixing qpel 4mv
michaelni
parents: 671
diff changeset
1777 dxy &= ~2;
242f0f7d8c15 fixing qpel 4mv
michaelni
parents: 671
diff changeset
1778
242f0f7d8c15 fixing qpel 4mv
michaelni
parents: 671
diff changeset
1779 ptr = ref_picture[0] + (src_y * s->linesize) + (src_x);
242f0f7d8c15 fixing qpel 4mv
michaelni
parents: 671
diff changeset
1780 if(s->flags&CODEC_FLAG_EMU_EDGE){
242f0f7d8c15 fixing qpel 4mv
michaelni
parents: 671
diff changeset
1781 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
1782 || src_y + (motion_y&1) + 8 > s->v_edge_pos){
936
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
1783 ff_emulated_edge_mc(s, ptr, s->linesize, 9, 9, src_x, src_y, s->h_edge_pos, s->v_edge_pos);
673
242f0f7d8c15 fixing qpel 4mv
michaelni
parents: 671
diff changeset
1784 ptr= s->edge_emu_buffer;
242f0f7d8c15 fixing qpel 4mv
michaelni
parents: 671
diff changeset
1785 }
554
3eb6fe38019a 4mv & qpel edge emu
michaelni
parents: 553
diff changeset
1786 }
673
242f0f7d8c15 fixing qpel 4mv
michaelni
parents: 671
diff changeset
1787 dest = dest_y + ((i & 1) * 8) + (i >> 1) * 8 * s->linesize;
242f0f7d8c15 fixing qpel 4mv
michaelni
parents: 671
diff changeset
1788 pix_op[1][dxy](dest, ptr, s->linesize, 8);
242f0f7d8c15 fixing qpel 4mv
michaelni
parents: 671
diff changeset
1789
242f0f7d8c15 fixing qpel 4mv
michaelni
parents: 671
diff changeset
1790 mx += s->mv[dir][i][0];
242f0f7d8c15 fixing qpel 4mv
michaelni
parents: 671
diff changeset
1791 my += s->mv[dir][i][1];
554
3eb6fe38019a 4mv & qpel edge emu
michaelni
parents: 553
diff changeset
1792 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1793 }
673
242f0f7d8c15 fixing qpel 4mv
michaelni
parents: 671
diff changeset
1794
485
20108840b0e5 grayscale only decoding
michaelni
parents: 481
diff changeset
1795 if(s->flags&CODEC_FLAG_GRAY) break;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1796 /* In case of 8X8, we construct a single chroma motion vector
986e461dc072 Initial revision
glantau
parents:
diff changeset
1797 with a special rounding */
1013
5d4c95f323d0 finetuneing thresholds/factors
michaelni
parents: 1011
diff changeset
1798 mx= ff_h263_round_chroma(mx);
5d4c95f323d0 finetuneing thresholds/factors
michaelni
parents: 1011
diff changeset
1799 my= ff_h263_round_chroma(my);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1800 dxy = ((my & 1) << 1) | (mx & 1);
986e461dc072 Initial revision
glantau
parents:
diff changeset
1801 mx >>= 1;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1802 my >>= 1;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1803
986e461dc072 Initial revision
glantau
parents:
diff changeset
1804 src_x = mb_x * 8 + mx;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1805 src_y = mb_y * 8 + my;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1806 src_x = clip(src_x, -8, s->width/2);
986e461dc072 Initial revision
glantau
parents:
diff changeset
1807 if (src_x == s->width/2)
986e461dc072 Initial revision
glantau
parents:
diff changeset
1808 dxy &= ~1;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1809 src_y = clip(src_y, -8, s->height/2);
986e461dc072 Initial revision
glantau
parents:
diff changeset
1810 if (src_y == s->height/2)
986e461dc072 Initial revision
glantau
parents:
diff changeset
1811 dxy &= ~2;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1812
556
762c67fd4078 uvlinesize
michaelni
parents: 554
diff changeset
1813 offset = (src_y * (s->uvlinesize)) + src_x;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1814 ptr = ref_picture[1] + offset;
554
3eb6fe38019a 4mv & qpel edge emu
michaelni
parents: 553
diff changeset
1815 if(s->flags&CODEC_FLAG_EMU_EDGE){
582
5132a4ee50cd different edge positions fixed with edge emu / dr1
michaelni
parents: 575
diff changeset
1816 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
1817 || src_y + (dxy>>1) + 8 > s->v_edge_pos>>1){
936
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
1818 ff_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
1819 ptr= s->edge_emu_buffer;
3eb6fe38019a 4mv & qpel edge emu
michaelni
parents: 553
diff changeset
1820 emu=1;
3eb6fe38019a 4mv & qpel edge emu
michaelni
parents: 553
diff changeset
1821 }
3eb6fe38019a 4mv & qpel edge emu
michaelni
parents: 553
diff changeset
1822 }
651
45e8f39fda50 put/avg_pixels16
michaelni
parents: 650
diff changeset
1823 pix_op[1][dxy](dest_cb, ptr, s->uvlinesize, 8);
554
3eb6fe38019a 4mv & qpel edge emu
michaelni
parents: 553
diff changeset
1824
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1825 ptr = ref_picture[2] + offset;
554
3eb6fe38019a 4mv & qpel edge emu
michaelni
parents: 553
diff changeset
1826 if(emu){
936
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
1827 ff_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
1828 ptr= s->edge_emu_buffer;
3eb6fe38019a 4mv & qpel edge emu
michaelni
parents: 553
diff changeset
1829 }
651
45e8f39fda50 put/avg_pixels16
michaelni
parents: 650
diff changeset
1830 pix_op[1][dxy](dest_cr, ptr, s->uvlinesize, 8);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1831 break;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1832 case MV_TYPE_FIELD:
986e461dc072 Initial revision
glantau
parents:
diff changeset
1833 if (s->picture_structure == PICT_FRAME) {
671
3f2e5a282f61 interlaced qpel mpeg4 fixed
michaelni
parents: 664
diff changeset
1834 if(s->quarter_sample){
3f2e5a282f61 interlaced qpel mpeg4 fixed
michaelni
parents: 664
diff changeset
1835 /* top field */
3f2e5a282f61 interlaced qpel mpeg4 fixed
michaelni
parents: 664
diff changeset
1836 qpel_motion(s, dest_y, dest_cb, dest_cr, 0,
3f2e5a282f61 interlaced qpel mpeg4 fixed
michaelni
parents: 664
diff changeset
1837 ref_picture, s->field_select[dir][0] ? s->linesize : 0,
3f2e5a282f61 interlaced qpel mpeg4 fixed
michaelni
parents: 664
diff changeset
1838 1, pix_op, qpix_op,
3f2e5a282f61 interlaced qpel mpeg4 fixed
michaelni
parents: 664
diff changeset
1839 s->mv[dir][0][0], s->mv[dir][0][1], 8);
3f2e5a282f61 interlaced qpel mpeg4 fixed
michaelni
parents: 664
diff changeset
1840 /* bottom field */
3f2e5a282f61 interlaced qpel mpeg4 fixed
michaelni
parents: 664
diff changeset
1841 qpel_motion(s, dest_y, dest_cb, dest_cr, s->linesize,
3f2e5a282f61 interlaced qpel mpeg4 fixed
michaelni
parents: 664
diff changeset
1842 ref_picture, s->field_select[dir][1] ? s->linesize : 0,
3f2e5a282f61 interlaced qpel mpeg4 fixed
michaelni
parents: 664
diff changeset
1843 1, pix_op, qpix_op,
3f2e5a282f61 interlaced qpel mpeg4 fixed
michaelni
parents: 664
diff changeset
1844 s->mv[dir][1][0], s->mv[dir][1][1], 8);
3f2e5a282f61 interlaced qpel mpeg4 fixed
michaelni
parents: 664
diff changeset
1845 }else{
3f2e5a282f61 interlaced qpel mpeg4 fixed
michaelni
parents: 664
diff changeset
1846 /* top field */
3f2e5a282f61 interlaced qpel mpeg4 fixed
michaelni
parents: 664
diff changeset
1847 mpeg_motion(s, dest_y, dest_cb, dest_cr, 0,
3f2e5a282f61 interlaced qpel mpeg4 fixed
michaelni
parents: 664
diff changeset
1848 ref_picture, s->field_select[dir][0] ? s->linesize : 0,
3f2e5a282f61 interlaced qpel mpeg4 fixed
michaelni
parents: 664
diff changeset
1849 1, pix_op,
3f2e5a282f61 interlaced qpel mpeg4 fixed
michaelni
parents: 664
diff changeset
1850 s->mv[dir][0][0], s->mv[dir][0][1], 8);
3f2e5a282f61 interlaced qpel mpeg4 fixed
michaelni
parents: 664
diff changeset
1851 /* bottom field */
3f2e5a282f61 interlaced qpel mpeg4 fixed
michaelni
parents: 664
diff changeset
1852 mpeg_motion(s, dest_y, dest_cb, dest_cr, s->linesize,
3f2e5a282f61 interlaced qpel mpeg4 fixed
michaelni
parents: 664
diff changeset
1853 ref_picture, s->field_select[dir][1] ? s->linesize : 0,
3f2e5a282f61 interlaced qpel mpeg4 fixed
michaelni
parents: 664
diff changeset
1854 1, pix_op,
3f2e5a282f61 interlaced qpel mpeg4 fixed
michaelni
parents: 664
diff changeset
1855 s->mv[dir][1][0], s->mv[dir][1][1], 8);
3f2e5a282f61 interlaced qpel mpeg4 fixed
michaelni
parents: 664
diff changeset
1856 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1857 } else {
986e461dc072 Initial revision
glantau
parents:
diff changeset
1858
986e461dc072 Initial revision
glantau
parents:
diff changeset
1859
986e461dc072 Initial revision
glantau
parents:
diff changeset
1860 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
1861 break;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1862 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
1863 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
1864
986e461dc072 Initial revision
glantau
parents:
diff changeset
1865
986e461dc072 Initial revision
glantau
parents:
diff changeset
1866 /* put block[] to dest[] */
986e461dc072 Initial revision
glantau
parents:
diff changeset
1867 static inline void put_dct(MpegEncContext *s,
1064
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1059
diff changeset
1868 DCTELEM *block, int i, uint8_t *dest, int line_size)
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1869 {
711
dcbcf9676c9f optimizing mpeg1_decode_block()
michaelni
parents: 709
diff changeset
1870 s->dct_unquantize(s, block, i, s->qscale);
1092
f59c3f66363b MpegEncContext.(i)dct_* -> DspContext.(i)dct_*
michaelni
parents: 1089
diff changeset
1871 s->dsp.idct_put (dest, line_size, block);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1872 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
1873
986e461dc072 Initial revision
glantau
parents:
diff changeset
1874 /* add block[] to dest[] */
986e461dc072 Initial revision
glantau
parents:
diff changeset
1875 static inline void add_dct(MpegEncContext *s,
1064
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1059
diff changeset
1876 DCTELEM *block, int i, uint8_t *dest, int line_size)
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1877 {
986e461dc072 Initial revision
glantau
parents:
diff changeset
1878 if (s->block_last_index[i] >= 0) {
1092
f59c3f66363b MpegEncContext.(i)dct_* -> DspContext.(i)dct_*
michaelni
parents: 1089
diff changeset
1879 s->dsp.idct_add (dest, line_size, block);
481
29a7e17d19dd optimizing MPV_decode_mb
michaelni
parents: 478
diff changeset
1880 }
29a7e17d19dd optimizing MPV_decode_mb
michaelni
parents: 478
diff changeset
1881 }
29a7e17d19dd optimizing MPV_decode_mb
michaelni
parents: 478
diff changeset
1882
29a7e17d19dd optimizing MPV_decode_mb
michaelni
parents: 478
diff changeset
1883 static inline void add_dequant_dct(MpegEncContext *s,
1064
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1059
diff changeset
1884 DCTELEM *block, int i, uint8_t *dest, int line_size)
481
29a7e17d19dd optimizing MPV_decode_mb
michaelni
parents: 478
diff changeset
1885 {
29a7e17d19dd optimizing MPV_decode_mb
michaelni
parents: 478
diff changeset
1886 if (s->block_last_index[i] >= 0) {
29a7e17d19dd optimizing MPV_decode_mb
michaelni
parents: 478
diff changeset
1887 s->dct_unquantize(s, block, i, s->qscale);
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
1888
1092
f59c3f66363b MpegEncContext.(i)dct_* -> DspContext.(i)dct_*
michaelni
parents: 1089
diff changeset
1889 s->dsp.idct_add (dest, line_size, block);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1890 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
1891 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
1892
456
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
1893 /**
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
1894 * cleans dc, ac, coded_block for the current non intra MB
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
1895 */
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
1896 void ff_clean_intra_table_entries(MpegEncContext *s)
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
1897 {
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
1898 int wrap = s->block_wrap[0];
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
1899 int xy = s->block_index[0];
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
1900
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
1901 s->dc_val[0][xy ] =
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
1902 s->dc_val[0][xy + 1 ] =
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
1903 s->dc_val[0][xy + wrap] =
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
1904 s->dc_val[0][xy + 1 + wrap] = 1024;
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
1905 /* ac pred */
1064
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1059
diff changeset
1906 memset(s->ac_val[0][xy ], 0, 32 * sizeof(int16_t));
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1059
diff changeset
1907 memset(s->ac_val[0][xy + wrap], 0, 32 * sizeof(int16_t));
456
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
1908 if (s->msmpeg4_version>=3) {
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
1909 s->coded_block[xy ] =
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
1910 s->coded_block[xy + 1 ] =
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
1911 s->coded_block[xy + wrap] =
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
1912 s->coded_block[xy + 1 + wrap] = 0;
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
1913 }
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
1914 /* chroma */
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
1915 wrap = s->block_wrap[4];
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
1916 xy = s->mb_x + 1 + (s->mb_y + 1) * wrap;
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
1917 s->dc_val[1][xy] =
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
1918 s->dc_val[2][xy] = 1024;
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
1919 /* ac pred */
1064
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1059
diff changeset
1920 memset(s->ac_val[1][xy], 0, 16 * sizeof(int16_t));
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1059
diff changeset
1921 memset(s->ac_val[2][xy], 0, 16 * sizeof(int16_t));
456
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
1922
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
1923 s->mbintra_table[s->mb_x + s->mb_y*s->mb_width]= 0;
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
1924 }
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
1925
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1926 /* generic function called after a macroblock has been parsed by the
986e461dc072 Initial revision
glantau
parents:
diff changeset
1927 decoder or after it has been encoded by the encoder.
986e461dc072 Initial revision
glantau
parents:
diff changeset
1928
986e461dc072 Initial revision
glantau
parents:
diff changeset
1929 Important variables used:
986e461dc072 Initial revision
glantau
parents:
diff changeset
1930 s->mb_intra : true if intra macroblock
986e461dc072 Initial revision
glantau
parents:
diff changeset
1931 s->mv_dir : motion vector direction
986e461dc072 Initial revision
glantau
parents:
diff changeset
1932 s->mv_type : motion vector type
986e461dc072 Initial revision
glantau
parents:
diff changeset
1933 s->mv : motion vector
986e461dc072 Initial revision
glantau
parents:
diff changeset
1934 s->interlaced_dct : true if interlaced dct used (mpeg2)
986e461dc072 Initial revision
glantau
parents:
diff changeset
1935 */
986e461dc072 Initial revision
glantau
parents:
diff changeset
1936 void MPV_decode_mb(MpegEncContext *s, DCTELEM block[6][64])
986e461dc072 Initial revision
glantau
parents:
diff changeset
1937 {
244
3860331a1ecb * eliminating duplicated code from MPV_common_end
kabi
parents: 239
diff changeset
1938 int mb_x, mb_y;
481
29a7e17d19dd optimizing MPV_decode_mb
michaelni
parents: 478
diff changeset
1939 const int mb_xy = s->mb_y * s->mb_width + s->mb_x;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1940
986e461dc072 Initial revision
glantau
parents:
diff changeset
1941 mb_x = s->mb_x;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1942 mb_y = s->mb_y;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1943
903
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
1944 s->current_picture.qscale_table[mb_xy]= s->qscale;
108
1e4a4af694d1 exporting qscale data for postprocessing (for MPlayer)
arpi_esp
parents: 79
diff changeset
1945
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1946 /* update DC predictors for P macroblocks */
986e461dc072 Initial revision
glantau
parents:
diff changeset
1947 if (!s->mb_intra) {
249
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
1948 if (s->h263_pred || s->h263_aic) {
481
29a7e17d19dd optimizing MPV_decode_mb
michaelni
parents: 478
diff changeset
1949 if(s->mbintra_table[mb_xy])
456
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
1950 ff_clean_intra_table_entries(s);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1951 } else {
456
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
1952 s->last_dc[0] =
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
1953 s->last_dc[1] =
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1954 s->last_dc[2] = 128 << s->intra_dc_precision;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1955 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
1956 }
249
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
1957 else if (s->h263_pred || s->h263_aic)
481
29a7e17d19dd optimizing MPV_decode_mb
michaelni
parents: 478
diff changeset
1958 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
1959
280
3dc1ca4ba717 fixing epzs & mpeg1 (hopefully now really ...)
michaelni
parents: 279
diff changeset
1960 /* 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
1961 if (s->out_format == FMT_H263 && s->pict_type!=B_TYPE) { //FIXME move into h263.c if possible, format specific stuff shouldnt be here
936
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
1962 //FIXME a lot of thet is only needed for !low_delay
481
29a7e17d19dd optimizing MPV_decode_mb
michaelni
parents: 478
diff changeset
1963 const int wrap = s->block_wrap[0];
29a7e17d19dd optimizing MPV_decode_mb
michaelni
parents: 478
diff changeset
1964 const int xy = s->block_index[0];
664
00a882f626bd interlaced mpeg4 b frame decoding
michaelni
parents: 661
diff changeset
1965 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
1966 if(s->mv_type == MV_TYPE_8X8){
664
00a882f626bd interlaced mpeg4 b frame decoding
michaelni
parents: 661
diff changeset
1967 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
1968 } else {
2be2cc8fd0a1 mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents: 618
diff changeset
1969 int motion_x, motion_y;
2be2cc8fd0a1 mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents: 618
diff changeset
1970 if (s->mb_intra) {
2be2cc8fd0a1 mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents: 618
diff changeset
1971 motion_x = 0;
2be2cc8fd0a1 mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents: 618
diff changeset
1972 motion_y = 0;
664
00a882f626bd interlaced mpeg4 b frame decoding
michaelni
parents: 661
diff changeset
1973 if(s->co_located_type_table)
00a882f626bd interlaced mpeg4 b frame decoding
michaelni
parents: 661
diff changeset
1974 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
1975 } 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
1976 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
1977 motion_y = s->mv[0][0][1];
664
00a882f626bd interlaced mpeg4 b frame decoding
michaelni
parents: 661
diff changeset
1978 if(s->co_located_type_table)
00a882f626bd interlaced mpeg4 b frame decoding
michaelni
parents: 661
diff changeset
1979 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
1980 } else /*if (s->mv_type == MV_TYPE_FIELD)*/ {
664
00a882f626bd interlaced mpeg4 b frame decoding
michaelni
parents: 661
diff changeset
1981 int i;
619
2be2cc8fd0a1 mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents: 618
diff changeset
1982 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
1983 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
1984 motion_x = (motion_x>>1) | (motion_x&1);
664
00a882f626bd interlaced mpeg4 b frame decoding
michaelni
parents: 661
diff changeset
1985 for(i=0; i<2; i++){
00a882f626bd interlaced mpeg4 b frame decoding
michaelni
parents: 661
diff changeset
1986 s->field_mv_table[mb_index][i][0]= s->mv[0][i][0];
00a882f626bd interlaced mpeg4 b frame decoding
michaelni
parents: 661
diff changeset
1987 s->field_mv_table[mb_index][i][1]= s->mv[0][i][1];
00a882f626bd interlaced mpeg4 b frame decoding
michaelni
parents: 661
diff changeset
1988 s->field_select_table[mb_index][i]= s->field_select[0][i];
00a882f626bd interlaced mpeg4 b frame decoding
michaelni
parents: 661
diff changeset
1989 }
00a882f626bd interlaced mpeg4 b frame decoding
michaelni
parents: 661
diff changeset
1990 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
1991 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1992 /* 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
1993 s->motion_val[xy][0] = motion_x;
3860331a1ecb * eliminating duplicated code from MPV_common_end
kabi
parents: 239
diff changeset
1994 s->motion_val[xy][1] = motion_y;
3860331a1ecb * eliminating duplicated code from MPV_common_end
kabi
parents: 239
diff changeset
1995 s->motion_val[xy + 1][0] = motion_x;
3860331a1ecb * eliminating duplicated code from MPV_common_end
kabi
parents: 239
diff changeset
1996 s->motion_val[xy + 1][1] = motion_y;
3860331a1ecb * eliminating duplicated code from MPV_common_end
kabi
parents: 239
diff changeset
1997 s->motion_val[xy + wrap][0] = motion_x;
3860331a1ecb * eliminating duplicated code from MPV_common_end
kabi
parents: 239
diff changeset
1998 s->motion_val[xy + wrap][1] = motion_y;
3860331a1ecb * eliminating duplicated code from MPV_common_end
kabi
parents: 239
diff changeset
1999 s->motion_val[xy + 1 + wrap][0] = motion_x;
3860331a1ecb * eliminating duplicated code from MPV_common_end
kabi
parents: 239
diff changeset
2000 s->motion_val[xy + 1 + wrap][1] = motion_y;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2001 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
2002 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
2003
909
8ae1e4c24e91 new PSNR code (now works with chroma, b frames, ...)
michaelni
parents: 903
diff changeset
2004 if ((s->flags&CODEC_FLAG_PSNR) || !(s->encoding && (s->intra_only || s->pict_type==B_TYPE))) { //FIXME precalc
1064
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1059
diff changeset
2005 uint8_t *dest_y, *dest_cb, *dest_cr;
481
29a7e17d19dd optimizing MPV_decode_mb
michaelni
parents: 478
diff changeset
2006 int dct_linesize, dct_offset;
651
45e8f39fda50 put/avg_pixels16
michaelni
parents: 650
diff changeset
2007 op_pixels_func (*op_pix)[4];
45e8f39fda50 put/avg_pixels16
michaelni
parents: 650
diff changeset
2008 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
2009
903
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
2010 /* avoid copy if macroblock skipped in last frame too */
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
2011 if (s->pict_type != B_TYPE) {
903
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
2012 s->current_picture.mbskip_table[mb_xy]= s->mb_skiped;
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
2013 }
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
2014
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
2015 /* skip only during decoding as we might trash the buffers during encoding a bit */
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
2016 if(!s->encoding){
1064
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1059
diff changeset
2017 uint8_t *mbskip_ptr = &s->mbskip_table[mb_xy];
903
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
2018 const int age= s->current_picture.age;
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
2019
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
2020 assert(age);
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
2021
7
1d3ac9654178 added skip macroblock optimization (big perf win on black regions for example)
glantau
parents: 0
diff changeset
2022 if (s->mb_skiped) {
903
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
2023 s->mb_skiped= 0;
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
2024 assert(s->pict_type!=I_TYPE);
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
2025
556
762c67fd4078 uvlinesize
michaelni
parents: 554
diff changeset
2026 (*mbskip_ptr) ++; /* indicate that this time we skiped it */
762c67fd4078 uvlinesize
michaelni
parents: 554
diff changeset
2027 if(*mbskip_ptr >99) *mbskip_ptr= 99;
762c67fd4078 uvlinesize
michaelni
parents: 554
diff changeset
2028
903
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
2029 /* if previous was skipped too, then nothing to do ! */
1021
2d7c9f5738de trying to fix mb skip bug in mpeg1/2 if slices are not used
michaelni
parents: 1014
diff changeset
2030 if (*mbskip_ptr >= age && s->current_picture.reference){
2d7c9f5738de trying to fix mb skip bug in mpeg1/2 if slices are not used
michaelni
parents: 1014
diff changeset
2031 return;
903
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
2032 }
1021
2d7c9f5738de trying to fix mb skip bug in mpeg1/2 if slices are not used
michaelni
parents: 1014
diff changeset
2033 } else if(!s->current_picture.reference){
2d7c9f5738de trying to fix mb skip bug in mpeg1/2 if slices are not used
michaelni
parents: 1014
diff changeset
2034 (*mbskip_ptr) ++; /* increase counter so the age can be compared cleanly */
2d7c9f5738de trying to fix mb skip bug in mpeg1/2 if slices are not used
michaelni
parents: 1014
diff changeset
2035 if(*mbskip_ptr >99) *mbskip_ptr= 99;
2d7c9f5738de trying to fix mb skip bug in mpeg1/2 if slices are not used
michaelni
parents: 1014
diff changeset
2036 } else{
7
1d3ac9654178 added skip macroblock optimization (big perf win on black regions for example)
glantau
parents: 0
diff changeset
2037 *mbskip_ptr = 0; /* not skipped */
1d3ac9654178 added skip macroblock optimization (big perf win on black regions for example)
glantau
parents: 0
diff changeset
2038 }
903
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
2039 }else
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
2040 s->mb_skiped= 0;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2041
717
6cba3b6196f0 optimization
michaelni
parents: 711
diff changeset
2042 if(s->pict_type==B_TYPE && s->avctx->draw_horiz_band){
903
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
2043 dest_y = s->current_picture.data[0] + mb_x * 16;
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
2044 dest_cb = s->current_picture.data[1] + mb_x * 8;
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
2045 dest_cr = s->current_picture.data[2] + mb_x * 8;
717
6cba3b6196f0 optimization
michaelni
parents: 711
diff changeset
2046 }else{
903
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
2047 dest_y = s->current_picture.data[0] + (mb_y * 16* s->linesize ) + mb_x * 16;
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
2048 dest_cb = s->current_picture.data[1] + (mb_y * 8 * s->uvlinesize) + mb_x * 8;
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
2049 dest_cr = s->current_picture.data[2] + (mb_y * 8 * s->uvlinesize) + mb_x * 8;
717
6cba3b6196f0 optimization
michaelni
parents: 711
diff changeset
2050 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2051
986e461dc072 Initial revision
glantau
parents:
diff changeset
2052 if (s->interlaced_dct) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
2053 dct_linesize = s->linesize * 2;
986e461dc072 Initial revision
glantau
parents:
diff changeset
2054 dct_offset = s->linesize;
986e461dc072 Initial revision
glantau
parents:
diff changeset
2055 } else {
986e461dc072 Initial revision
glantau
parents:
diff changeset
2056 dct_linesize = s->linesize;
986e461dc072 Initial revision
glantau
parents:
diff changeset
2057 dct_offset = s->linesize * 8;
986e461dc072 Initial revision
glantau
parents:
diff changeset
2058 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
2059
986e461dc072 Initial revision
glantau
parents:
diff changeset
2060 if (!s->mb_intra) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
2061 /* motion handling */
456
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2062 /* decoding or more than one mb_type (MC was allready done otherwise) */
481
29a7e17d19dd optimizing MPV_decode_mb
michaelni
parents: 478
diff changeset
2063 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
2064 if ((!s->no_rounding) || s->pict_type==B_TYPE){
853
eacc2dd8fd9d * using DSPContext - so each codec could use its local (sub)set of CPU extension
kabi
parents: 847
diff changeset
2065 op_pix = s->dsp.put_pixels_tab;
eacc2dd8fd9d * using DSPContext - so each codec could use its local (sub)set of CPU extension
kabi
parents: 847
diff changeset
2066 op_qpix= s->dsp.put_qpel_pixels_tab;
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
2067 }else{
853
eacc2dd8fd9d * using DSPContext - so each codec could use its local (sub)set of CPU extension
kabi
parents: 847
diff changeset
2068 op_pix = s->dsp.put_no_rnd_pixels_tab;
eacc2dd8fd9d * using DSPContext - so each codec could use its local (sub)set of CPU extension
kabi
parents: 847
diff changeset
2069 op_qpix= s->dsp.put_no_rnd_qpel_pixels_tab;
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
2070 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2071
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
2072 if (s->mv_dir & MV_DIR_FORWARD) {
903
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
2073 MPV_motion(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.data, op_pix, op_qpix);
853
eacc2dd8fd9d * using DSPContext - so each codec could use its local (sub)set of CPU extension
kabi
parents: 847
diff changeset
2074 op_pix = s->dsp.avg_pixels_tab;
eacc2dd8fd9d * using DSPContext - so each codec could use its local (sub)set of CPU extension
kabi
parents: 847
diff changeset
2075 op_qpix= s->dsp.avg_qpel_pixels_tab;
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
2076 }
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
2077 if (s->mv_dir & MV_DIR_BACKWARD) {
903
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
2078 MPV_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.data, op_pix, op_qpix);
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
2079 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2080 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
2081
481
29a7e17d19dd optimizing MPV_decode_mb
michaelni
parents: 478
diff changeset
2082 /* skip dequant / idct if we are really late ;) */
814
8f31ed5bacd1 dont call emms_c() for each MB
michaelni
parents: 813
diff changeset
2083 if(s->hurry_up>1) return;
481
29a7e17d19dd optimizing MPV_decode_mb
michaelni
parents: 478
diff changeset
2084
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2085 /* add dct residue */
711
dcbcf9676c9f optimizing mpeg1_decode_block()
michaelni
parents: 709
diff changeset
2086 if(s->encoding || !( s->mpeg2 || s->h263_msmpeg4 || s->codec_id==CODEC_ID_MPEG1VIDEO
dcbcf9676c9f optimizing mpeg1_decode_block()
michaelni
parents: 709
diff changeset
2087 || (s->codec_id==CODEC_ID_MPEG4 && !s->mpeg_quant))){
481
29a7e17d19dd optimizing MPV_decode_mb
michaelni
parents: 478
diff changeset
2088 add_dequant_dct(s, block[0], 0, dest_y, dct_linesize);
29a7e17d19dd optimizing MPV_decode_mb
michaelni
parents: 478
diff changeset
2089 add_dequant_dct(s, block[1], 1, dest_y + 8, dct_linesize);
29a7e17d19dd optimizing MPV_decode_mb
michaelni
parents: 478
diff changeset
2090 add_dequant_dct(s, block[2], 2, dest_y + dct_offset, dct_linesize);
29a7e17d19dd optimizing MPV_decode_mb
michaelni
parents: 478
diff changeset
2091 add_dequant_dct(s, block[3], 3, dest_y + dct_offset + 8, dct_linesize);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2092
485
20108840b0e5 grayscale only decoding
michaelni
parents: 481
diff changeset
2093 if(!(s->flags&CODEC_FLAG_GRAY)){
556
762c67fd4078 uvlinesize
michaelni
parents: 554
diff changeset
2094 add_dequant_dct(s, block[4], 4, dest_cb, s->uvlinesize);
762c67fd4078 uvlinesize
michaelni
parents: 554
diff changeset
2095 add_dequant_dct(s, block[5], 5, dest_cr, s->uvlinesize);
485
20108840b0e5 grayscale only decoding
michaelni
parents: 481
diff changeset
2096 }
936
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2097 } else if(s->codec_id != CODEC_ID_WMV2){
481
29a7e17d19dd optimizing MPV_decode_mb
michaelni
parents: 478
diff changeset
2098 add_dct(s, block[0], 0, dest_y, dct_linesize);
29a7e17d19dd optimizing MPV_decode_mb
michaelni
parents: 478
diff changeset
2099 add_dct(s, block[1], 1, dest_y + 8, dct_linesize);
29a7e17d19dd optimizing MPV_decode_mb
michaelni
parents: 478
diff changeset
2100 add_dct(s, block[2], 2, dest_y + dct_offset, dct_linesize);
29a7e17d19dd optimizing MPV_decode_mb
michaelni
parents: 478
diff changeset
2101 add_dct(s, block[3], 3, dest_y + dct_offset + 8, dct_linesize);
29a7e17d19dd optimizing MPV_decode_mb
michaelni
parents: 478
diff changeset
2102
485
20108840b0e5 grayscale only decoding
michaelni
parents: 481
diff changeset
2103 if(!(s->flags&CODEC_FLAG_GRAY)){
556
762c67fd4078 uvlinesize
michaelni
parents: 554
diff changeset
2104 add_dct(s, block[4], 4, dest_cb, s->uvlinesize);
762c67fd4078 uvlinesize
michaelni
parents: 554
diff changeset
2105 add_dct(s, block[5], 5, dest_cr, s->uvlinesize);
485
20108840b0e5 grayscale only decoding
michaelni
parents: 481
diff changeset
2106 }
1042
a78f6f72d54e --disable-risky support
michaelni
parents: 1026
diff changeset
2107 }
a78f6f72d54e --disable-risky support
michaelni
parents: 1026
diff changeset
2108 #ifdef CONFIG_RISKY
a78f6f72d54e --disable-risky support
michaelni
parents: 1026
diff changeset
2109 else{
936
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2110 ff_wmv2_add_mb(s, block, dest_y, dest_cb, dest_cr);
481
29a7e17d19dd optimizing MPV_decode_mb
michaelni
parents: 478
diff changeset
2111 }
1042
a78f6f72d54e --disable-risky support
michaelni
parents: 1026
diff changeset
2112 #endif
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2113 } else {
986e461dc072 Initial revision
glantau
parents:
diff changeset
2114 /* dct only in intra block */
711
dcbcf9676c9f optimizing mpeg1_decode_block()
michaelni
parents: 709
diff changeset
2115 if(s->encoding || !(s->mpeg2 || s->codec_id==CODEC_ID_MPEG1VIDEO)){
dcbcf9676c9f optimizing mpeg1_decode_block()
michaelni
parents: 709
diff changeset
2116 put_dct(s, block[0], 0, dest_y, dct_linesize);
dcbcf9676c9f optimizing mpeg1_decode_block()
michaelni
parents: 709
diff changeset
2117 put_dct(s, block[1], 1, dest_y + 8, dct_linesize);
dcbcf9676c9f optimizing mpeg1_decode_block()
michaelni
parents: 709
diff changeset
2118 put_dct(s, block[2], 2, dest_y + dct_offset, dct_linesize);
dcbcf9676c9f optimizing mpeg1_decode_block()
michaelni
parents: 709
diff changeset
2119 put_dct(s, block[3], 3, dest_y + dct_offset + 8, dct_linesize);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2120
711
dcbcf9676c9f optimizing mpeg1_decode_block()
michaelni
parents: 709
diff changeset
2121 if(!(s->flags&CODEC_FLAG_GRAY)){
dcbcf9676c9f optimizing mpeg1_decode_block()
michaelni
parents: 709
diff changeset
2122 put_dct(s, block[4], 4, dest_cb, s->uvlinesize);
dcbcf9676c9f optimizing mpeg1_decode_block()
michaelni
parents: 709
diff changeset
2123 put_dct(s, block[5], 5, dest_cr, s->uvlinesize);
dcbcf9676c9f optimizing mpeg1_decode_block()
michaelni
parents: 709
diff changeset
2124 }
dcbcf9676c9f optimizing mpeg1_decode_block()
michaelni
parents: 709
diff changeset
2125 }else{
1092
f59c3f66363b MpegEncContext.(i)dct_* -> DspContext.(i)dct_*
michaelni
parents: 1089
diff changeset
2126 s->dsp.idct_put(dest_y , dct_linesize, block[0]);
f59c3f66363b MpegEncContext.(i)dct_* -> DspContext.(i)dct_*
michaelni
parents: 1089
diff changeset
2127 s->dsp.idct_put(dest_y + 8, dct_linesize, block[1]);
f59c3f66363b MpegEncContext.(i)dct_* -> DspContext.(i)dct_*
michaelni
parents: 1089
diff changeset
2128 s->dsp.idct_put(dest_y + dct_offset , dct_linesize, block[2]);
f59c3f66363b MpegEncContext.(i)dct_* -> DspContext.(i)dct_*
michaelni
parents: 1089
diff changeset
2129 s->dsp.idct_put(dest_y + dct_offset + 8, dct_linesize, block[3]);
711
dcbcf9676c9f optimizing mpeg1_decode_block()
michaelni
parents: 709
diff changeset
2130
dcbcf9676c9f optimizing mpeg1_decode_block()
michaelni
parents: 709
diff changeset
2131 if(!(s->flags&CODEC_FLAG_GRAY)){
1092
f59c3f66363b MpegEncContext.(i)dct_* -> DspContext.(i)dct_*
michaelni
parents: 1089
diff changeset
2132 s->dsp.idct_put(dest_cb, s->uvlinesize, block[4]);
f59c3f66363b MpegEncContext.(i)dct_* -> DspContext.(i)dct_*
michaelni
parents: 1089
diff changeset
2133 s->dsp.idct_put(dest_cr, s->uvlinesize, block[5]);
711
dcbcf9676c9f optimizing mpeg1_decode_block()
michaelni
parents: 709
diff changeset
2134 }
485
20108840b0e5 grayscale only decoding
michaelni
parents: 481
diff changeset
2135 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2136 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
2137 }
294
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 292
diff changeset
2138 }
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 292
diff changeset
2139
1070
6da5ae9ee199 more #ifdef CONFIG_ENCODERS patch by (Wolfgang Hesseler <qv at multimediaware dot com>) with modifications by me (s/WOLFGANG/CONFIG_ENCODERS/ and some other fixes)
michaelni
parents: 1064
diff changeset
2140 #ifdef CONFIG_ENCODERS
6da5ae9ee199 more #ifdef CONFIG_ENCODERS patch by (Wolfgang Hesseler <qv at multimediaware dot com>) with modifications by me (s/WOLFGANG/CONFIG_ENCODERS/ and some other fixes)
michaelni
parents: 1064
diff changeset
2141
605
40874804a5af same dc skip behavior for chroma & luma elimination, its confusing otherwise imho
michaelni
parents: 604
diff changeset
2142 static inline void dct_single_coeff_elimination(MpegEncContext *s, int n, int threshold)
456
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2143 {
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2144 static const char tab[64]=
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2145 {3,2,2,1,1,1,1,1,
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2146 1,1,1,1,1,1,1,1,
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2147 1,1,1,1,1,1,1,1,
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2148 0,0,0,0,0,0,0,0,
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2149 0,0,0,0,0,0,0,0,
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2150 0,0,0,0,0,0,0,0,
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2151 0,0,0,0,0,0,0,0,
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2152 0,0,0,0,0,0,0,0};
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2153 int score=0;
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2154 int run=0;
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2155 int i;
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2156 DCTELEM *block= s->block[n];
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2157 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
2158 int skip_dc;
456
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2159
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
2160 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
2161 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
2162 threshold= -threshold;
605
40874804a5af same dc skip behavior for chroma & luma elimination, its confusing otherwise imho
michaelni
parents: 604
diff changeset
2163 }else
40874804a5af same dc skip behavior for chroma & luma elimination, its confusing otherwise imho
michaelni
parents: 604
diff changeset
2164 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
2165
456
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2166 /* are all which we could set to zero are allready zero? */
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2167 if(last_index<=skip_dc - 1) return;
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2168
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2169 for(i=0; i<=last_index; i++){
706
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 704
diff changeset
2170 const int j = s->intra_scantable.permutated[i];
456
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2171 const int level = ABS(block[j]);
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2172 if(level==1){
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2173 if(skip_dc && i==0) continue;
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2174 score+= tab[run];
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2175 run=0;
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2176 }else if(level>1){
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2177 return;
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2178 }else{
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2179 run++;
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2180 }
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2181 }
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2182 if(score >= threshold) return;
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2183 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
2184 const int j = s->intra_scantable.permutated[i];
456
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2185 block[j]=0;
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2186 }
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2187 if(block[0]) s->block_last_index[n]= 0;
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2188 else s->block_last_index[n]= -1;
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2189 }
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2190
344
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
2191 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
2192 {
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
2193 int i;
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
2194 const int maxlevel= s->max_qcoeff;
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
2195 const int minlevel= s->min_qcoeff;
706
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 704
diff changeset
2196
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 704
diff changeset
2197 if(s->mb_intra){
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 704
diff changeset
2198 i=1; //skip clipping of intra dc
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 704
diff changeset
2199 }else
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 704
diff changeset
2200 i=0;
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 704
diff changeset
2201
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 704
diff changeset
2202 for(;i<=last_index; i++){
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 704
diff changeset
2203 const int j= s->intra_scantable.permutated[i];
344
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
2204 int level = block[j];
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
2205
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
2206 if (level>maxlevel) level=maxlevel;
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
2207 else if(level<minlevel) level=minlevel;
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
2208 block[j]= level;
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
2209 }
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
2210 }
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
2211
697
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2212 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
2213 {
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2214 int i;
706
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 704
diff changeset
2215
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 704
diff changeset
2216 if(s->mb_intra){
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 704
diff changeset
2217 i=1; //skip clipping of intra dc
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 704
diff changeset
2218 //FIXME requantize, note (mpeg1/h263/h263p-aic dont need it,...)
697
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2219 }else
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2220 i=0;
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2221
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2222 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
2223 const int j = s->intra_scantable.permutated[i];
697
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2224 int level = block[j];
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2225
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2226 block[j]= ROUNDED_DIV(level*oldq, newq);
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2227 }
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2228
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2229 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
2230 const int j = s->intra_scantable.permutated[i];
697
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2231 if(block[j]) break;
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2232 }
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2233 s->block_last_index[n]= i;
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2234 }
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2235
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2236 static inline void auto_requantize_coeffs(MpegEncContext *s, DCTELEM block[6][64])
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2237 {
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2238 int i,n, newq;
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2239 const int maxlevel= s->max_qcoeff;
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2240 const int minlevel= s->min_qcoeff;
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2241 int largest=0, smallest=0;
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2242
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2243 assert(s->adaptive_quant);
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2244
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2245 for(n=0; n<6; n++){
706
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 704
diff changeset
2246 if(s->mb_intra){
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 704
diff changeset
2247 i=1; //skip clipping of intra dc
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 704
diff changeset
2248 //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
2249 }else
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 704
diff changeset
2250 i=0;
697
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2251
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2252 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
2253 const int j = s->intra_scantable.permutated[i];
697
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2254 int level = block[n][j];
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2255 if(largest < level) largest = level;
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2256 if(smallest > level) smallest= level;
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2257 }
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2258 }
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2259
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2260 for(newq=s->qscale+1; newq<32; newq++){
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2261 if( ROUNDED_DIV(smallest*s->qscale, newq) >= minlevel
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2262 && ROUNDED_DIV(largest *s->qscale, newq) <= maxlevel)
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2263 break;
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2264 }
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2265
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2266 if(s->out_format==FMT_H263){
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2267 /* h263 like formats cannot change qscale by more than 2 easiely */
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2268 if(s->avctx->qmin + 2 < newq)
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2269 newq= s->avctx->qmin + 2;
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2270 }
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2271
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2272 for(n=0; n<6; n++){
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2273 requantize_coeffs(s, block[n], s->qscale, newq, n);
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2274 clip_coeffs(s, block[n], s->block_last_index[n]);
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2275 }
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2276
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2277 s->dquant+= newq - s->qscale;
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2278 s->qscale= newq;
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2279 }
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2280 #if 0
1064
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1059
diff changeset
2281 static int pix_vcmp16x8(uint8_t *s, int stride){ //FIXME move to dsputil & optimize
697
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2282 int score=0;
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2283 int x,y;
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2284
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2285 for(y=0; y<7; y++){
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2286 for(x=0; x<16; x+=4){
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2287 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
2288 +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
2289 }
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2290 s+= stride;
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2291 }
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2292
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2293 return score;
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2294 }
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2295
1064
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1059
diff changeset
2296 static int pix_diff_vcmp16x8(uint8_t *s1, uint8_t*s2, int stride){ //FIXME move to dsputil & optimize
697
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2297 int score=0;
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2298 int x,y;
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2299
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2300 for(y=0; y<7; y++){
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2301 for(x=0; x<16; x++){
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2302 score+= ABS(s1[x ] - s2[x ] - s1[x +stride] + s2[x +stride]);
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2303 }
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2304 s1+= stride;
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2305 s2+= stride;
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2306 }
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2307
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2308 return score;
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2309 }
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2310 #else
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2311 #define SQ(a) ((a)*(a))
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2312
1064
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1059
diff changeset
2313 static int pix_vcmp16x8(uint8_t *s, int stride){ //FIXME move to dsputil & optimize
697
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2314 int score=0;
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2315 int x,y;
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2316
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2317 for(y=0; y<7; y++){
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2318 for(x=0; x<16; x+=4){
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2319 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
2320 +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
2321 }
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2322 s+= stride;
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2323 }
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2324
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2325 return score;
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2326 }
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2327
1064
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1059
diff changeset
2328 static int pix_diff_vcmp16x8(uint8_t *s1, uint8_t*s2, int stride){ //FIXME move to dsputil & optimize
697
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2329 int score=0;
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2330 int x,y;
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2331
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2332 for(y=0; y<7; y++){
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2333 for(x=0; x<16; x++){
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2334 score+= SQ(s1[x ] - s2[x ] - s1[x +stride] + s2[x +stride]);
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2335 }
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2336 s1+= stride;
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2337 s2+= stride;
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2338 }
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2339
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2340 return score;
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2341 }
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2342
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2343 #endif
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 731
diff changeset
2344
1070
6da5ae9ee199 more #ifdef CONFIG_ENCODERS patch by (Wolfgang Hesseler <qv at multimediaware dot com>) with modifications by me (s/WOLFGANG/CONFIG_ENCODERS/ and some other fixes)
michaelni
parents: 1064
diff changeset
2345 #endif //CONFIG_ENCODERS
6da5ae9ee199 more #ifdef CONFIG_ENCODERS patch by (Wolfgang Hesseler <qv at multimediaware dot com>) with modifications by me (s/WOLFGANG/CONFIG_ENCODERS/ and some other fixes)
michaelni
parents: 1064
diff changeset
2346
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 731
diff changeset
2347 void ff_draw_horiz_band(MpegEncContext *s){
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 731
diff changeset
2348 if ( s->avctx->draw_horiz_band
924
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
2349 && (s->last_picture.data[0] || s->low_delay) ) {
1064
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1059
diff changeset
2350 uint8_t *src_ptr[3];
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 731
diff changeset
2351 int y, h, offset;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 731
diff changeset
2352 y = s->mb_y * 16;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 731
diff changeset
2353 h = s->height - y;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 731
diff changeset
2354 if (h > 16)
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 731
diff changeset
2355 h = 16;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 731
diff changeset
2356
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 731
diff changeset
2357 if(s->pict_type==B_TYPE)
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 731
diff changeset
2358 offset = 0;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 731
diff changeset
2359 else
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 731
diff changeset
2360 offset = y * s->linesize;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 731
diff changeset
2361
924
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
2362 if(s->pict_type==B_TYPE || s->low_delay){
903
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
2363 src_ptr[0] = s->current_picture.data[0] + offset;
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
2364 src_ptr[1] = s->current_picture.data[1] + (offset >> 2);
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
2365 src_ptr[2] = s->current_picture.data[2] + (offset >> 2);
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 731
diff changeset
2366 } else {
903
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
2367 src_ptr[0] = s->last_picture.data[0] + offset;
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
2368 src_ptr[1] = s->last_picture.data[1] + (offset >> 2);
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
2369 src_ptr[2] = s->last_picture.data[2] + (offset >> 2);
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 731
diff changeset
2370 }
813
dfaa1c45bd27 cleanup
michaelni
parents: 809
diff changeset
2371 emms_c();
dfaa1c45bd27 cleanup
michaelni
parents: 809
diff changeset
2372
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 731
diff changeset
2373 s->avctx->draw_horiz_band(s->avctx, src_ptr, s->linesize,
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 731
diff changeset
2374 y, s->width, h);
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 731
diff changeset
2375 }
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 731
diff changeset
2376 }
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 731
diff changeset
2377
1070
6da5ae9ee199 more #ifdef CONFIG_ENCODERS patch by (Wolfgang Hesseler <qv at multimediaware dot com>) with modifications by me (s/WOLFGANG/CONFIG_ENCODERS/ and some other fixes)
michaelni
parents: 1064
diff changeset
2378 #ifdef CONFIG_ENCODERS
6da5ae9ee199 more #ifdef CONFIG_ENCODERS patch by (Wolfgang Hesseler <qv at multimediaware dot com>) with modifications by me (s/WOLFGANG/CONFIG_ENCODERS/ and some other fixes)
michaelni
parents: 1064
diff changeset
2379
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
2380 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
2381 {
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 292
diff changeset
2382 const int mb_x= s->mb_x;
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 292
diff changeset
2383 const int mb_y= s->mb_y;
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 292
diff changeset
2384 int i;
456
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2385 int skip_dct[6];
697
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2386 int dct_offset = s->linesize*8; //default for progressive frames
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2387
456
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2388 for(i=0; i<6; i++) skip_dct[i]=0;
690
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 673
diff changeset
2389
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 673
diff changeset
2390 if(s->adaptive_quant){
903
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
2391 s->dquant= s->current_picture.qscale_table[mb_x + mb_y*s->mb_width] - s->qscale;
697
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2392
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2393 if(s->out_format==FMT_H263){
690
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 673
diff changeset
2394 if (s->dquant> 2) s->dquant= 2;
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 673
diff changeset
2395 else if(s->dquant<-2) s->dquant=-2;
697
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2396 }
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2397
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2398 if(s->codec_id==CODEC_ID_MPEG4){
690
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 673
diff changeset
2399 if(!s->mb_intra){
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 673
diff changeset
2400 assert(s->dquant==0 || s->mv_type!=MV_TYPE_8X8);
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 673
diff changeset
2401
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 673
diff changeset
2402 if(s->mv_dir&MV_DIRECT)
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 673
diff changeset
2403 s->dquant=0;
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 673
diff changeset
2404 }
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 673
diff changeset
2405 }
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 673
diff changeset
2406 s->qscale+= s->dquant;
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 673
diff changeset
2407 s->y_dc_scale= s->y_dc_scale_table[ s->qscale ];
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 673
diff changeset
2408 s->c_dc_scale= s->c_dc_scale_table[ s->qscale ];
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 673
diff changeset
2409 }
294
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 292
diff changeset
2410
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
2411 if (s->mb_intra) {
1064
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1059
diff changeset
2412 uint8_t *ptr;
697
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2413 int wrap_y;
570
274d9c5a75ee use edge emu for encoding of width or height %16!=0 files
michaelni
parents: 569
diff changeset
2414 int emu=0;
294
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 292
diff changeset
2415
697
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2416 wrap_y = s->linesize;
903
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
2417 ptr = s->new_picture.data[0] + (mb_y * 16 * wrap_y) + mb_x * 16;
697
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2418
570
274d9c5a75ee use edge emu for encoding of width or height %16!=0 files
michaelni
parents: 569
diff changeset
2419 if(mb_x*16+16 > s->width || mb_y*16+16 > s->height){
936
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2420 ff_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
2421 ptr= s->edge_emu_buffer;
274d9c5a75ee use edge emu for encoding of width or height %16!=0 files
michaelni
parents: 569
diff changeset
2422 emu=1;
274d9c5a75ee use edge emu for encoding of width or height %16!=0 files
michaelni
parents: 569
diff changeset
2423 }
697
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2424
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2425 if(s->flags&CODEC_FLAG_INTERLACED_DCT){
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2426 int progressive_score, interlaced_score;
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2427
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2428 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
2429 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
2430
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2431 if(progressive_score > interlaced_score + 100){
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2432 s->interlaced_dct=1;
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2433
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2434 dct_offset= wrap_y;
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2435 wrap_y<<=1;
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2436 }else
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2437 s->interlaced_dct=0;
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2438 }
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2439
853
eacc2dd8fd9d * using DSPContext - so each codec could use its local (sub)set of CPU extension
kabi
parents: 847
diff changeset
2440 s->dsp.get_pixels(s->block[0], ptr , wrap_y);
eacc2dd8fd9d * using DSPContext - so each codec could use its local (sub)set of CPU extension
kabi
parents: 847
diff changeset
2441 s->dsp.get_pixels(s->block[1], ptr + 8, wrap_y);
eacc2dd8fd9d * using DSPContext - so each codec could use its local (sub)set of CPU extension
kabi
parents: 847
diff changeset
2442 s->dsp.get_pixels(s->block[2], ptr + dct_offset , wrap_y);
eacc2dd8fd9d * using DSPContext - so each codec could use its local (sub)set of CPU extension
kabi
parents: 847
diff changeset
2443 s->dsp.get_pixels(s->block[3], ptr + dct_offset + 8, wrap_y);
294
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 292
diff changeset
2444
487
cee02f2f4a5a grayscale only encoding
michaelni
parents: 485
diff changeset
2445 if(s->flags&CODEC_FLAG_GRAY){
cee02f2f4a5a grayscale only encoding
michaelni
parents: 485
diff changeset
2446 skip_dct[4]= 1;
cee02f2f4a5a grayscale only encoding
michaelni
parents: 485
diff changeset
2447 skip_dct[5]= 1;
cee02f2f4a5a grayscale only encoding
michaelni
parents: 485
diff changeset
2448 }else{
697
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2449 int wrap_c = s->uvlinesize;
903
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
2450 ptr = s->new_picture.data[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
2451 if(emu){
936
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2452 ff_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
2453 ptr= s->edge_emu_buffer;
274d9c5a75ee use edge emu for encoding of width or height %16!=0 files
michaelni
parents: 569
diff changeset
2454 }
853
eacc2dd8fd9d * using DSPContext - so each codec could use its local (sub)set of CPU extension
kabi
parents: 847
diff changeset
2455 s->dsp.get_pixels(s->block[4], ptr, wrap_c);
294
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 292
diff changeset
2456
903
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
2457 ptr = s->new_picture.data[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
2458 if(emu){
936
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2459 ff_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
2460 ptr= s->edge_emu_buffer;
274d9c5a75ee use edge emu for encoding of width or height %16!=0 files
michaelni
parents: 569
diff changeset
2461 }
853
eacc2dd8fd9d * using DSPContext - so each codec could use its local (sub)set of CPU extension
kabi
parents: 847
diff changeset
2462 s->dsp.get_pixels(s->block[5], ptr, wrap_c);
487
cee02f2f4a5a grayscale only encoding
michaelni
parents: 485
diff changeset
2463 }
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
2464 }else{
651
45e8f39fda50 put/avg_pixels16
michaelni
parents: 650
diff changeset
2465 op_pixels_func (*op_pix)[4];
45e8f39fda50 put/avg_pixels16
michaelni
parents: 650
diff changeset
2466 qpel_mc_func (*op_qpix)[16];
1064
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1059
diff changeset
2467 uint8_t *dest_y, *dest_cb, *dest_cr;
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1059
diff changeset
2468 uint8_t *ptr_y, *ptr_cb, *ptr_cr;
456
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2469 int wrap_y, wrap_c;
570
274d9c5a75ee use edge emu for encoding of width or height %16!=0 files
michaelni
parents: 569
diff changeset
2470 int emu=0;
294
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 292
diff changeset
2471
903
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
2472 dest_y = s->current_picture.data[0] + (mb_y * 16 * s->linesize ) + mb_x * 16;
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
2473 dest_cb = s->current_picture.data[1] + (mb_y * 8 * (s->uvlinesize)) + mb_x * 8;
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
2474 dest_cr = s->current_picture.data[2] + (mb_y * 8 * (s->uvlinesize)) + mb_x * 8;
456
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2475 wrap_y = s->linesize;
697
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2476 wrap_c = s->uvlinesize;
903
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
2477 ptr_y = s->new_picture.data[0] + (mb_y * 16 * wrap_y) + mb_x * 16;
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
2478 ptr_cb = s->new_picture.data[1] + (mb_y * 8 * wrap_c) + mb_x * 8;
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
2479 ptr_cr = s->new_picture.data[2] + (mb_y * 8 * wrap_c) + mb_x * 8;
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
2480
327
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 326
diff changeset
2481 if ((!s->no_rounding) || s->pict_type==B_TYPE){
853
eacc2dd8fd9d * using DSPContext - so each codec could use its local (sub)set of CPU extension
kabi
parents: 847
diff changeset
2482 op_pix = s->dsp.put_pixels_tab;
eacc2dd8fd9d * using DSPContext - so each codec could use its local (sub)set of CPU extension
kabi
parents: 847
diff changeset
2483 op_qpix= s->dsp.put_qpel_pixels_tab;
295
6622b0fd036c mpeg4 4MV encoding
michaelni
parents: 294
diff changeset
2484 }else{
853
eacc2dd8fd9d * using DSPContext - so each codec could use its local (sub)set of CPU extension
kabi
parents: 847
diff changeset
2485 op_pix = s->dsp.put_no_rnd_pixels_tab;
eacc2dd8fd9d * using DSPContext - so each codec could use its local (sub)set of CPU extension
kabi
parents: 847
diff changeset
2486 op_qpix= s->dsp.put_no_rnd_qpel_pixels_tab;
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
2487 }
295
6622b0fd036c mpeg4 4MV encoding
michaelni
parents: 294
diff changeset
2488
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
2489 if (s->mv_dir & MV_DIR_FORWARD) {
903
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
2490 MPV_motion(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.data, op_pix, op_qpix);
853
eacc2dd8fd9d * using DSPContext - so each codec could use its local (sub)set of CPU extension
kabi
parents: 847
diff changeset
2491 op_pix = s->dsp.avg_pixels_tab;
eacc2dd8fd9d * using DSPContext - so each codec could use its local (sub)set of CPU extension
kabi
parents: 847
diff changeset
2492 op_qpix= s->dsp.avg_qpel_pixels_tab;
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
2493 }
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
2494 if (s->mv_dir & MV_DIR_BACKWARD) {
903
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
2495 MPV_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.data, op_pix, op_qpix);
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
2496 }
295
6622b0fd036c mpeg4 4MV encoding
michaelni
parents: 294
diff changeset
2497
570
274d9c5a75ee use edge emu for encoding of width or height %16!=0 files
michaelni
parents: 569
diff changeset
2498 if(mb_x*16+16 > s->width || mb_y*16+16 > s->height){
936
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2499 ff_emulated_edge_mc(s, ptr_y, 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
2500 ptr_y= s->edge_emu_buffer;
274d9c5a75ee use edge emu for encoding of width or height %16!=0 files
michaelni
parents: 569
diff changeset
2501 emu=1;
274d9c5a75ee use edge emu for encoding of width or height %16!=0 files
michaelni
parents: 569
diff changeset
2502 }
697
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2503
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2504 if(s->flags&CODEC_FLAG_INTERLACED_DCT){
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2505 int progressive_score, interlaced_score;
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2506
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2507 progressive_score= pix_diff_vcmp16x8(ptr_y , dest_y , wrap_y )
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2508 + 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
2509 interlaced_score = pix_diff_vcmp16x8(ptr_y , dest_y , wrap_y*2)
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2510 + pix_diff_vcmp16x8(ptr_y + wrap_y , dest_y + wrap_y , wrap_y*2);
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2511
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2512 if(progressive_score > interlaced_score + 600){
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2513 s->interlaced_dct=1;
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2514
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2515 dct_offset= wrap_y;
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2516 wrap_y<<=1;
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2517 }else
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2518 s->interlaced_dct=0;
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2519 }
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2520
853
eacc2dd8fd9d * using DSPContext - so each codec could use its local (sub)set of CPU extension
kabi
parents: 847
diff changeset
2521 s->dsp.diff_pixels(s->block[0], ptr_y , dest_y , wrap_y);
eacc2dd8fd9d * using DSPContext - so each codec could use its local (sub)set of CPU extension
kabi
parents: 847
diff changeset
2522 s->dsp.diff_pixels(s->block[1], ptr_y + 8, dest_y + 8, wrap_y);
eacc2dd8fd9d * using DSPContext - so each codec could use its local (sub)set of CPU extension
kabi
parents: 847
diff changeset
2523 s->dsp.diff_pixels(s->block[2], ptr_y + dct_offset , dest_y + dct_offset , wrap_y);
eacc2dd8fd9d * using DSPContext - so each codec could use its local (sub)set of CPU extension
kabi
parents: 847
diff changeset
2524 s->dsp.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
2525
cee02f2f4a5a grayscale only encoding
michaelni
parents: 485
diff changeset
2526 if(s->flags&CODEC_FLAG_GRAY){
cee02f2f4a5a grayscale only encoding
michaelni
parents: 485
diff changeset
2527 skip_dct[4]= 1;
cee02f2f4a5a grayscale only encoding
michaelni
parents: 485
diff changeset
2528 skip_dct[5]= 1;
cee02f2f4a5a grayscale only encoding
michaelni
parents: 485
diff changeset
2529 }else{
570
274d9c5a75ee use edge emu for encoding of width or height %16!=0 files
michaelni
parents: 569
diff changeset
2530 if(emu){
936
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2531 ff_emulated_edge_mc(s, ptr_cb, 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
2532 ptr_cb= s->edge_emu_buffer;
274d9c5a75ee use edge emu for encoding of width or height %16!=0 files
michaelni
parents: 569
diff changeset
2533 }
853
eacc2dd8fd9d * using DSPContext - so each codec could use its local (sub)set of CPU extension
kabi
parents: 847
diff changeset
2534 s->dsp.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
2535 if(emu){
936
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2536 ff_emulated_edge_mc(s, ptr_cr, 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
2537 ptr_cr= s->edge_emu_buffer;
274d9c5a75ee use edge emu for encoding of width or height %16!=0 files
michaelni
parents: 569
diff changeset
2538 }
853
eacc2dd8fd9d * using DSPContext - so each codec could use its local (sub)set of CPU extension
kabi
parents: 847
diff changeset
2539 s->dsp.diff_pixels(s->block[5], ptr_cr, dest_cr, wrap_c);
487
cee02f2f4a5a grayscale only encoding
michaelni
parents: 485
diff changeset
2540 }
456
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2541 /* pre quantization */
903
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
2542 if(s->current_picture.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
2543 //FIXME optimize
853
eacc2dd8fd9d * using DSPContext - so each codec could use its local (sub)set of CPU extension
kabi
parents: 847
diff changeset
2544 if(s->dsp.pix_abs8x8(ptr_y , dest_y , wrap_y) < 20*s->qscale) skip_dct[0]= 1;
eacc2dd8fd9d * using DSPContext - so each codec could use its local (sub)set of CPU extension
kabi
parents: 847
diff changeset
2545 if(s->dsp.pix_abs8x8(ptr_y + 8, dest_y + 8, wrap_y) < 20*s->qscale) skip_dct[1]= 1;
eacc2dd8fd9d * using DSPContext - so each codec could use its local (sub)set of CPU extension
kabi
parents: 847
diff changeset
2546 if(s->dsp.pix_abs8x8(ptr_y +dct_offset , dest_y +dct_offset , wrap_y) < 20*s->qscale) skip_dct[2]= 1;
eacc2dd8fd9d * using DSPContext - so each codec could use its local (sub)set of CPU extension
kabi
parents: 847
diff changeset
2547 if(s->dsp.pix_abs8x8(ptr_y +dct_offset+ 8, dest_y +dct_offset+ 8, wrap_y) < 20*s->qscale) skip_dct[3]= 1;
899
9d9a415e3dd9 100l (mixing chroma & luma linesize)
michaelni
parents: 885
diff changeset
2548 if(s->dsp.pix_abs8x8(ptr_cb , dest_cb , wrap_c) < 20*s->qscale) skip_dct[4]= 1;
9d9a415e3dd9 100l (mixing chroma & luma linesize)
michaelni
parents: 885
diff changeset
2549 if(s->dsp.pix_abs8x8(ptr_cr , dest_cr , wrap_c) < 20*s->qscale) skip_dct[5]= 1;
456
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2550 #if 0
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2551 {
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2552 static int stat[7];
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2553 int num=0;
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2554 for(i=0; i<6; i++)
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2555 if(skip_dct[i]) num++;
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2556 stat[num]++;
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2557
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2558 if(s->mb_x==0 && s->mb_y==0){
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2559 for(i=0; i<7; i++){
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2560 printf("%6d %1d\n", stat[i], i);
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2561 }
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2562 }
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2563 }
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2564 #endif
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2565 }
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
2566
294
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 292
diff changeset
2567 }
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 292
diff changeset
2568
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 292
diff changeset
2569 #if 0
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 292
diff changeset
2570 {
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 292
diff changeset
2571 float adap_parm;
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 292
diff changeset
2572
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 292
diff changeset
2573 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
2574 ((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
2575
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 292
diff changeset
2576 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
2577 (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
2578 s->qscale, adap_parm, s->qscale*adap_parm,
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 292
diff changeset
2579 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
2580 }
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 292
diff changeset
2581 #endif
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 292
diff changeset
2582 /* DCT & quantize */
344
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
2583 if(s->out_format==FMT_MJPEG){
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
2584 for(i=0;i<6;i++) {
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
2585 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
2586 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
2587 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
2588 }
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
2589 }else{
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
2590 for(i=0;i<6;i++) {
456
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2591 if(!skip_dct[i]){
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2592 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
2593 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
2594 // 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
2595 // 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
2596 // of improve it. Just INTRADC clipping deserves changes in quantizer
456
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2597 if (overflow) clip_coeffs(s, s->block[i], s->block_last_index[i]);
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2598 }else
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2599 s->block_last_index[i]= -1;
344
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
2600 }
456
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2601 if(s->luma_elim_threshold && !s->mb_intra)
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2602 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
2603 dct_single_coeff_elimination(s, i, s->luma_elim_threshold);
456
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2604 if(s->chroma_elim_threshold && !s->mb_intra)
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2605 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
2606 dct_single_coeff_elimination(s, i, s->chroma_elim_threshold);
294
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 292
diff changeset
2607 }
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 292
diff changeset
2608
487
cee02f2f4a5a grayscale only encoding
michaelni
parents: 485
diff changeset
2609 if((s->flags&CODEC_FLAG_GRAY) && s->mb_intra){
cee02f2f4a5a grayscale only encoding
michaelni
parents: 485
diff changeset
2610 s->block_last_index[4]=
cee02f2f4a5a grayscale only encoding
michaelni
parents: 485
diff changeset
2611 s->block_last_index[5]= 0;
cee02f2f4a5a grayscale only encoding
michaelni
parents: 485
diff changeset
2612 s->block[4][0]=
1011
michaelni
parents: 1007
diff changeset
2613 s->block[5][0]= (1024 + s->c_dc_scale/2)/ s->c_dc_scale;
487
cee02f2f4a5a grayscale only encoding
michaelni
parents: 485
diff changeset
2614 }
cee02f2f4a5a grayscale only encoding
michaelni
parents: 485
diff changeset
2615
294
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 292
diff changeset
2616 /* huffman encode */
936
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2617 switch(s->codec_id){ //FIXME funct ptr could be slightly faster
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2618 case CODEC_ID_MPEG1VIDEO:
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2619 mpeg1_encode_mb(s, s->block, motion_x, motion_y); break;
1042
a78f6f72d54e --disable-risky support
michaelni
parents: 1026
diff changeset
2620 #ifdef CONFIG_RISKY
936
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2621 case CODEC_ID_MPEG4:
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2622 mpeg4_encode_mb(s, s->block, motion_x, motion_y); break;
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2623 case CODEC_ID_MSMPEG4V2:
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2624 case CODEC_ID_MSMPEG4V3:
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2625 case CODEC_ID_WMV1:
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2626 msmpeg4_encode_mb(s, s->block, motion_x, motion_y); break;
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2627 case CODEC_ID_WMV2:
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2628 ff_wmv2_encode_mb(s, s->block, motion_x, motion_y); break;
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2629 case CODEC_ID_H263:
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2630 case CODEC_ID_H263P:
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2631 case CODEC_ID_RV10:
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2632 h263_encode_mb(s, s->block, motion_x, motion_y); break;
1042
a78f6f72d54e --disable-risky support
michaelni
parents: 1026
diff changeset
2633 #endif
a78f6f72d54e --disable-risky support
michaelni
parents: 1026
diff changeset
2634 case CODEC_ID_MJPEG:
a78f6f72d54e --disable-risky support
michaelni
parents: 1026
diff changeset
2635 mjpeg_encode_mb(s, s->block); break;
936
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2636 default:
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2637 assert(0);
294
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 292
diff changeset
2638 }
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 292
diff changeset
2639 }
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 292
diff changeset
2640
1070
6da5ae9ee199 more #ifdef CONFIG_ENCODERS patch by (Wolfgang Hesseler <qv at multimediaware dot com>) with modifications by me (s/WOLFGANG/CONFIG_ENCODERS/ and some other fixes)
michaelni
parents: 1064
diff changeset
2641 #endif //CONFIG_ENCODERS
6da5ae9ee199 more #ifdef CONFIG_ENCODERS patch by (Wolfgang Hesseler <qv at multimediaware dot com>) with modifications by me (s/WOLFGANG/CONFIG_ENCODERS/ and some other fixes)
michaelni
parents: 1064
diff changeset
2642
1026
d6ba0641cc36 cleanup
michaelni
parents: 1021
diff changeset
2643 /**
d6ba0641cc36 cleanup
michaelni
parents: 1021
diff changeset
2644 * combines the (truncated) bitstream to a complete frame
d6ba0641cc36 cleanup
michaelni
parents: 1021
diff changeset
2645 * @returns -1 if no complete frame could be created
d6ba0641cc36 cleanup
michaelni
parents: 1021
diff changeset
2646 */
d6ba0641cc36 cleanup
michaelni
parents: 1021
diff changeset
2647 int ff_combine_frame( MpegEncContext *s, int next, uint8_t **buf, int *buf_size){
d6ba0641cc36 cleanup
michaelni
parents: 1021
diff changeset
2648 ParseContext *pc= &s->parse_context;
d6ba0641cc36 cleanup
michaelni
parents: 1021
diff changeset
2649
d6ba0641cc36 cleanup
michaelni
parents: 1021
diff changeset
2650 pc->last_index= pc->index;
d6ba0641cc36 cleanup
michaelni
parents: 1021
diff changeset
2651
d6ba0641cc36 cleanup
michaelni
parents: 1021
diff changeset
2652 if(next==-1){
d6ba0641cc36 cleanup
michaelni
parents: 1021
diff changeset
2653 pc->buffer= av_fast_realloc(pc->buffer, &pc->buffer_size, (*buf_size) + pc->index + FF_INPUT_BUFFER_PADDING_SIZE);
d6ba0641cc36 cleanup
michaelni
parents: 1021
diff changeset
2654
d6ba0641cc36 cleanup
michaelni
parents: 1021
diff changeset
2655 memcpy(&pc->buffer[pc->index], *buf, *buf_size);
d6ba0641cc36 cleanup
michaelni
parents: 1021
diff changeset
2656 pc->index += *buf_size;
d6ba0641cc36 cleanup
michaelni
parents: 1021
diff changeset
2657 return -1;
d6ba0641cc36 cleanup
michaelni
parents: 1021
diff changeset
2658 }
d6ba0641cc36 cleanup
michaelni
parents: 1021
diff changeset
2659
d6ba0641cc36 cleanup
michaelni
parents: 1021
diff changeset
2660 if(pc->index){
d6ba0641cc36 cleanup
michaelni
parents: 1021
diff changeset
2661 pc->buffer= av_fast_realloc(pc->buffer, &pc->buffer_size, next + pc->index + FF_INPUT_BUFFER_PADDING_SIZE);
d6ba0641cc36 cleanup
michaelni
parents: 1021
diff changeset
2662
d6ba0641cc36 cleanup
michaelni
parents: 1021
diff changeset
2663 memcpy(&pc->buffer[pc->index], *buf, next + FF_INPUT_BUFFER_PADDING_SIZE );
d6ba0641cc36 cleanup
michaelni
parents: 1021
diff changeset
2664 pc->index = 0;
d6ba0641cc36 cleanup
michaelni
parents: 1021
diff changeset
2665 *buf= pc->buffer;
d6ba0641cc36 cleanup
michaelni
parents: 1021
diff changeset
2666 *buf_size= pc->last_index + next;
d6ba0641cc36 cleanup
michaelni
parents: 1021
diff changeset
2667 }
d6ba0641cc36 cleanup
michaelni
parents: 1021
diff changeset
2668
d6ba0641cc36 cleanup
michaelni
parents: 1021
diff changeset
2669 return 0;
d6ba0641cc36 cleanup
michaelni
parents: 1021
diff changeset
2670 }
d6ba0641cc36 cleanup
michaelni
parents: 1021
diff changeset
2671
1070
6da5ae9ee199 more #ifdef CONFIG_ENCODERS patch by (Wolfgang Hesseler <qv at multimediaware dot com>) with modifications by me (s/WOLFGANG/CONFIG_ENCODERS/ and some other fixes)
michaelni
parents: 1064
diff changeset
2672 #ifdef CONFIG_ENCODERS
1064
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1059
diff changeset
2673 void ff_copy_bits(PutBitContext *pb, uint8_t *src, int length)
294
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 292
diff changeset
2674 {
326
6ebb8680885d fixing hq mode with mpeg1 and 2-pass
michaelni
parents: 325
diff changeset
2675 int bytes= length>>4;
6ebb8680885d fixing hq mode with mpeg1 and 2-pass
michaelni
parents: 325
diff changeset
2676 int bits= length&15;
6ebb8680885d fixing hq mode with mpeg1 and 2-pass
michaelni
parents: 325
diff changeset
2677 int i;
6ebb8680885d fixing hq mode with mpeg1 and 2-pass
michaelni
parents: 325
diff changeset
2678
456
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2679 if(length==0) return;
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2680
326
6ebb8680885d fixing hq mode with mpeg1 and 2-pass
michaelni
parents: 325
diff changeset
2681 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
2682 put_bits(pb, bits, be2me_16(((uint16_t*)src)[i])>>(16-bits));
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2683 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
2684
456
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2685 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
2686 int i;
6ebb8680885d fixing hq mode with mpeg1 and 2-pass
michaelni
parents: 325
diff changeset
2687
6ebb8680885d fixing hq mode with mpeg1 and 2-pass
michaelni
parents: 325
diff changeset
2688 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
2689
6ebb8680885d fixing hq mode with mpeg1 and 2-pass
michaelni
parents: 325
diff changeset
2690 /* mpeg1 */
6ebb8680885d fixing hq mode with mpeg1 and 2-pass
michaelni
parents: 325
diff changeset
2691 d->mb_incr= s->mb_incr;
6ebb8680885d fixing hq mode with mpeg1 and 2-pass
michaelni
parents: 325
diff changeset
2692 for(i=0; i<3; i++)
6ebb8680885d fixing hq mode with mpeg1 and 2-pass
michaelni
parents: 325
diff changeset
2693 d->last_dc[i]= s->last_dc[i];
6ebb8680885d fixing hq mode with mpeg1 and 2-pass
michaelni
parents: 325
diff changeset
2694
6ebb8680885d fixing hq mode with mpeg1 and 2-pass
michaelni
parents: 325
diff changeset
2695 /* statistics */
6ebb8680885d fixing hq mode with mpeg1 and 2-pass
michaelni
parents: 325
diff changeset
2696 d->mv_bits= s->mv_bits;
6ebb8680885d fixing hq mode with mpeg1 and 2-pass
michaelni
parents: 325
diff changeset
2697 d->i_tex_bits= s->i_tex_bits;
6ebb8680885d fixing hq mode with mpeg1 and 2-pass
michaelni
parents: 325
diff changeset
2698 d->p_tex_bits= s->p_tex_bits;
6ebb8680885d fixing hq mode with mpeg1 and 2-pass
michaelni
parents: 325
diff changeset
2699 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
2700 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
2701 d->b_count= s->b_count;
326
6ebb8680885d fixing hq mode with mpeg1 and 2-pass
michaelni
parents: 325
diff changeset
2702 d->skip_count= s->skip_count;
6ebb8680885d fixing hq mode with mpeg1 and 2-pass
michaelni
parents: 325
diff changeset
2703 d->misc_bits= s->misc_bits;
329
5cc47d0ba53e fixed ratecontrol & b-frames
michaelni
parents: 327
diff changeset
2704 d->last_bits= 0;
327
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 326
diff changeset
2705
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 326
diff changeset
2706 d->mb_skiped= s->mb_skiped;
912
4a1e6bb1f41c fixing hq + adaptive quant
michaelni
parents: 910
diff changeset
2707 d->qscale= s->qscale;
326
6ebb8680885d fixing hq mode with mpeg1 and 2-pass
michaelni
parents: 325
diff changeset
2708 }
6ebb8680885d fixing hq mode with mpeg1 and 2-pass
michaelni
parents: 325
diff changeset
2709
456
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2710 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
2711 int i;
6ebb8680885d fixing hq mode with mpeg1 and 2-pass
michaelni
parents: 325
diff changeset
2712
6ebb8680885d fixing hq mode with mpeg1 and 2-pass
michaelni
parents: 325
diff changeset
2713 memcpy(d->mv, s->mv, 2*4*2*sizeof(int));
6ebb8680885d fixing hq mode with mpeg1 and 2-pass
michaelni
parents: 325
diff changeset
2714 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
2715
6ebb8680885d fixing hq mode with mpeg1 and 2-pass
michaelni
parents: 325
diff changeset
2716 /* mpeg1 */
6ebb8680885d fixing hq mode with mpeg1 and 2-pass
michaelni
parents: 325
diff changeset
2717 d->mb_incr= s->mb_incr;
6ebb8680885d fixing hq mode with mpeg1 and 2-pass
michaelni
parents: 325
diff changeset
2718 for(i=0; i<3; i++)
6ebb8680885d fixing hq mode with mpeg1 and 2-pass
michaelni
parents: 325
diff changeset
2719 d->last_dc[i]= s->last_dc[i];
6ebb8680885d fixing hq mode with mpeg1 and 2-pass
michaelni
parents: 325
diff changeset
2720
6ebb8680885d fixing hq mode with mpeg1 and 2-pass
michaelni
parents: 325
diff changeset
2721 /* statistics */
6ebb8680885d fixing hq mode with mpeg1 and 2-pass
michaelni
parents: 325
diff changeset
2722 d->mv_bits= s->mv_bits;
6ebb8680885d fixing hq mode with mpeg1 and 2-pass
michaelni
parents: 325
diff changeset
2723 d->i_tex_bits= s->i_tex_bits;
6ebb8680885d fixing hq mode with mpeg1 and 2-pass
michaelni
parents: 325
diff changeset
2724 d->p_tex_bits= s->p_tex_bits;
6ebb8680885d fixing hq mode with mpeg1 and 2-pass
michaelni
parents: 325
diff changeset
2725 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
2726 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
2727 d->b_count= s->b_count;
326
6ebb8680885d fixing hq mode with mpeg1 and 2-pass
michaelni
parents: 325
diff changeset
2728 d->skip_count= s->skip_count;
6ebb8680885d fixing hq mode with mpeg1 and 2-pass
michaelni
parents: 325
diff changeset
2729 d->misc_bits= s->misc_bits;
6ebb8680885d fixing hq mode with mpeg1 and 2-pass
michaelni
parents: 325
diff changeset
2730
6ebb8680885d fixing hq mode with mpeg1 and 2-pass
michaelni
parents: 325
diff changeset
2731 d->mb_intra= s->mb_intra;
327
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 326
diff changeset
2732 d->mb_skiped= s->mb_skiped;
326
6ebb8680885d fixing hq mode with mpeg1 and 2-pass
michaelni
parents: 325
diff changeset
2733 d->mv_type= s->mv_type;
6ebb8680885d fixing hq mode with mpeg1 and 2-pass
michaelni
parents: 325
diff changeset
2734 d->mv_dir= s->mv_dir;
6ebb8680885d fixing hq mode with mpeg1 and 2-pass
michaelni
parents: 325
diff changeset
2735 d->pb= s->pb;
456
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2736 if(s->data_partitioning){
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2737 d->pb2= s->pb2;
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2738 d->tex_pb= s->tex_pb;
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2739 }
326
6ebb8680885d fixing hq mode with mpeg1 and 2-pass
michaelni
parents: 325
diff changeset
2740 d->block= s->block;
6ebb8680885d fixing hq mode with mpeg1 and 2-pass
michaelni
parents: 325
diff changeset
2741 for(i=0; i<6; i++)
6ebb8680885d fixing hq mode with mpeg1 and 2-pass
michaelni
parents: 325
diff changeset
2742 d->block_last_index[i]= s->block_last_index[i];
755
d17846a6c164 fixing interlaced dct + hq mode
michaelni
parents: 754
diff changeset
2743 d->interlaced_dct= s->interlaced_dct;
912
4a1e6bb1f41c fixing hq + adaptive quant
michaelni
parents: 910
diff changeset
2744 d->qscale= s->qscale;
326
6ebb8680885d fixing hq mode with mpeg1 and 2-pass
michaelni
parents: 325
diff changeset
2745 }
6ebb8680885d fixing hq mode with mpeg1 and 2-pass
michaelni
parents: 325
diff changeset
2746
456
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2747 static inline void encode_mb_hq(MpegEncContext *s, MpegEncContext *backup, MpegEncContext *best, int type,
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2748 PutBitContext pb[2], PutBitContext pb2[2], PutBitContext tex_pb[2],
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2749 int *dmin, int *next_block, int motion_x, int motion_y)
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2750 {
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2751 int bits_count;
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2752
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2753 copy_context_before_encode(s, backup, type);
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2754
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2755 s->block= s->blocks[*next_block];
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2756 s->pb= pb[*next_block];
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2757 if(s->data_partitioning){
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2758 s->pb2 = pb2 [*next_block];
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2759 s->tex_pb= tex_pb[*next_block];
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2760 }
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2761
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2762 encode_mb(s, motion_x, motion_y);
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2763
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2764 bits_count= get_bit_count(&s->pb);
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2765 if(s->data_partitioning){
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2766 bits_count+= get_bit_count(&s->pb2);
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2767 bits_count+= get_bit_count(&s->tex_pb);
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2768 }
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2769
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2770 if(bits_count<*dmin){
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2771 *dmin= bits_count;
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2772 *next_block^=1;
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2773
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2774 copy_context_after_encode(best, s, type);
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2775 }
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2776 }
909
8ae1e4c24e91 new PSNR code (now works with chroma, b frames, ...)
michaelni
parents: 903
diff changeset
2777
8ae1e4c24e91 new PSNR code (now works with chroma, b frames, ...)
michaelni
parents: 903
diff changeset
2778 static inline int sse(MpegEncContext *s, uint8_t *src1, uint8_t *src2, int w, int h, int stride){
8ae1e4c24e91 new PSNR code (now works with chroma, b frames, ...)
michaelni
parents: 903
diff changeset
2779 uint32_t *sq = squareTbl + 256;
8ae1e4c24e91 new PSNR code (now works with chroma, b frames, ...)
michaelni
parents: 903
diff changeset
2780 int acc=0;
8ae1e4c24e91 new PSNR code (now works with chroma, b frames, ...)
michaelni
parents: 903
diff changeset
2781 int x,y;
8ae1e4c24e91 new PSNR code (now works with chroma, b frames, ...)
michaelni
parents: 903
diff changeset
2782
8ae1e4c24e91 new PSNR code (now works with chroma, b frames, ...)
michaelni
parents: 903
diff changeset
2783 if(w==16 && h==16)
936
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2784 return s->dsp.sse[0](NULL, src1, src2, stride);
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2785 else if(w==8 && h==8)
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2786 return s->dsp.sse[1](NULL, src1, src2, stride);
909
8ae1e4c24e91 new PSNR code (now works with chroma, b frames, ...)
michaelni
parents: 903
diff changeset
2787
8ae1e4c24e91 new PSNR code (now works with chroma, b frames, ...)
michaelni
parents: 903
diff changeset
2788 for(y=0; y<h; y++){
8ae1e4c24e91 new PSNR code (now works with chroma, b frames, ...)
michaelni
parents: 903
diff changeset
2789 for(x=0; x<w; x++){
8ae1e4c24e91 new PSNR code (now works with chroma, b frames, ...)
michaelni
parents: 903
diff changeset
2790 acc+= sq[src1[x + y*stride] - src2[x + y*stride]];
8ae1e4c24e91 new PSNR code (now works with chroma, b frames, ...)
michaelni
parents: 903
diff changeset
2791 }
8ae1e4c24e91 new PSNR code (now works with chroma, b frames, ...)
michaelni
parents: 903
diff changeset
2792 }
936
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2793
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2794 assert(acc>=0);
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2795
909
8ae1e4c24e91 new PSNR code (now works with chroma, b frames, ...)
michaelni
parents: 903
diff changeset
2796 return acc;
8ae1e4c24e91 new PSNR code (now works with chroma, b frames, ...)
michaelni
parents: 903
diff changeset
2797 }
326
6ebb8680885d fixing hq mode with mpeg1 and 2-pass
michaelni
parents: 325
diff changeset
2798
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2799 static void encode_picture(MpegEncContext *s, int picture_number)
986e461dc072 Initial revision
glantau
parents:
diff changeset
2800 {
766
8d36b35a7e6e slice encoding cleanup
michaelni
parents: 764
diff changeset
2801 int mb_x, mb_y, pdif = 0;
294
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 292
diff changeset
2802 int i;
286
91f7c38f5f37 statistics for 2-pass encoding
michaelni
parents: 281
diff changeset
2803 int bits;
326
6ebb8680885d fixing hq mode with mpeg1 and 2-pass
michaelni
parents: 325
diff changeset
2804 MpegEncContext best_s, backup_s;
1064
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1059
diff changeset
2805 uint8_t bit_buf[2][3000];
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1059
diff changeset
2806 uint8_t bit_buf2[2][3000];
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1059
diff changeset
2807 uint8_t bit_buf_tex[2][3000];
456
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2808 PutBitContext pb[2], pb2[2], tex_pb[2];
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2809
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2810 for(i=0; i<2; i++){
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2811 init_put_bits(&pb [i], bit_buf [i], 3000, NULL, NULL);
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2812 init_put_bits(&pb2 [i], bit_buf2 [i], 3000, NULL, NULL);
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2813 init_put_bits(&tex_pb[i], bit_buf_tex[i], 3000, NULL, NULL);
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2814 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2815
986e461dc072 Initial revision
glantau
parents:
diff changeset
2816 s->picture_number = picture_number;
268
09ae29b27ed9 hopefully better bitrate controll
michaelni
parents: 266
diff changeset
2817
294
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 292
diff changeset
2818 s->block_wrap[0]=
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 292
diff changeset
2819 s->block_wrap[1]=
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 292
diff changeset
2820 s->block_wrap[2]=
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 292
diff changeset
2821 s->block_wrap[3]= s->mb_width*2 + 2;
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 292
diff changeset
2822 s->block_wrap[4]=
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 292
diff changeset
2823 s->block_wrap[5]= s->mb_width + 2;
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 292
diff changeset
2824
268
09ae29b27ed9 hopefully better bitrate controll
michaelni
parents: 266
diff changeset
2825 /* Reset the average MB variance */
903
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
2826 s->current_picture.mb_var_sum = 0;
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
2827 s->current_picture.mc_mb_var_sum = 0;
327
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 326
diff changeset
2828
1042
a78f6f72d54e --disable-risky support
michaelni
parents: 1026
diff changeset
2829 #ifdef CONFIG_RISKY
327
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 326
diff changeset
2830 /* we need to initialize some time vars before we can encode b-frames */
1051
e5a9dbf597d4 mpeg1 bframe encoding patch by (Rapha«³l LEGRAND) with some modifications by me
michaelni
parents: 1048
diff changeset
2831 // RAL: Condition added for MPEG1VIDEO
e5a9dbf597d4 mpeg1 bframe encoding patch by (Rapha«³l LEGRAND) with some modifications by me
michaelni
parents: 1048
diff changeset
2832 if (s->codec_id == CODEC_ID_MPEG1VIDEO || (s->h263_pred && !s->h263_msmpeg4))
327
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 326
diff changeset
2833 ff_set_mpeg4_time(s, s->picture_number);
1042
a78f6f72d54e --disable-risky support
michaelni
parents: 1026
diff changeset
2834 #endif
a78f6f72d54e --disable-risky support
michaelni
parents: 1026
diff changeset
2835
608
98e39397636b better scene change detection
michaelni
parents: 605
diff changeset
2836 s->scene_change_score=0;
690
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 673
diff changeset
2837
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 673
diff changeset
2838 s->qscale= (int)(s->frame_qscale + 0.5); //FIXME qscale / ... stuff for ME ratedistoration
936
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2839
1089
7e79a58954b1 h263(+) clenaup & bugfixes
michaelni
parents: 1086
diff changeset
2840 if(s->pict_type==I_TYPE){
7e79a58954b1 h263(+) clenaup & bugfixes
michaelni
parents: 1086
diff changeset
2841 if(s->msmpeg4_version) s->no_rounding=1;
7e79a58954b1 h263(+) clenaup & bugfixes
michaelni
parents: 1086
diff changeset
2842 else s->no_rounding=0;
7e79a58954b1 h263(+) clenaup & bugfixes
michaelni
parents: 1086
diff changeset
2843 }else if(s->pict_type!=B_TYPE){
7e79a58954b1 h263(+) clenaup & bugfixes
michaelni
parents: 1086
diff changeset
2844 if(s->flipflop_rounding || s->codec_id == CODEC_ID_H263P || s->codec_id == CODEC_ID_MPEG4)
936
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2845 s->no_rounding ^= 1;
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2846 }
1089
7e79a58954b1 h263(+) clenaup & bugfixes
michaelni
parents: 1086
diff changeset
2847
268
09ae29b27ed9 hopefully better bitrate controll
michaelni
parents: 266
diff changeset
2848 /* Estimate motion for every MB */
1013
5d4c95f323d0 finetuneing thresholds/factors
michaelni
parents: 1011
diff changeset
2849 s->mb_intra=0; //for the rate distoration & bit compare functions
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
2850 if(s->pict_type != I_TYPE){
951
ad264a7d4f94 motion estimation pre pass
michaelni
parents: 947
diff changeset
2851 if(s->pict_type != B_TYPE){
ad264a7d4f94 motion estimation pre pass
michaelni
parents: 947
diff changeset
2852 if((s->avctx->pre_me && s->last_non_b_pict_type==I_TYPE) || s->avctx->pre_me==2){
952
f348d302a51e pre motion estimation cleanup/bugfix
michaelni
parents: 951
diff changeset
2853 s->me.pre_pass=1;
954
13aec7e50c52 qpel in mmx2/3dnow
michaelni
parents: 952
diff changeset
2854 s->me.dia_size= s->avctx->pre_dia_size;
952
f348d302a51e pre motion estimation cleanup/bugfix
michaelni
parents: 951
diff changeset
2855
951
ad264a7d4f94 motion estimation pre pass
michaelni
parents: 947
diff changeset
2856 for(mb_y=s->mb_height-1; mb_y >=0 ; mb_y--) {
ad264a7d4f94 motion estimation pre pass
michaelni
parents: 947
diff changeset
2857 for(mb_x=s->mb_width-1; mb_x >=0 ; mb_x--) {
ad264a7d4f94 motion estimation pre pass
michaelni
parents: 947
diff changeset
2858 s->mb_x = mb_x;
ad264a7d4f94 motion estimation pre pass
michaelni
parents: 947
diff changeset
2859 s->mb_y = mb_y;
ad264a7d4f94 motion estimation pre pass
michaelni
parents: 947
diff changeset
2860 ff_pre_estimate_p_frame_motion(s, mb_x, mb_y);
ad264a7d4f94 motion estimation pre pass
michaelni
parents: 947
diff changeset
2861 }
ad264a7d4f94 motion estimation pre pass
michaelni
parents: 947
diff changeset
2862 }
952
f348d302a51e pre motion estimation cleanup/bugfix
michaelni
parents: 951
diff changeset
2863 s->me.pre_pass=0;
951
ad264a7d4f94 motion estimation pre pass
michaelni
parents: 947
diff changeset
2864 }
ad264a7d4f94 motion estimation pre pass
michaelni
parents: 947
diff changeset
2865 }
ad264a7d4f94 motion estimation pre pass
michaelni
parents: 947
diff changeset
2866
954
13aec7e50c52 qpel in mmx2/3dnow
michaelni
parents: 952
diff changeset
2867 s->me.dia_size= s->avctx->dia_size;
294
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 292
diff changeset
2868 for(mb_y=0; mb_y < s->mb_height; mb_y++) {
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 292
diff changeset
2869 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
2870 s->block_index[1]= s->block_wrap[0]*(mb_y*2 + 1);
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 292
diff changeset
2871 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
2872 s->block_index[3]= s->block_wrap[0]*(mb_y*2 + 2);
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 292
diff changeset
2873 for(mb_x=0; mb_x < s->mb_width; mb_x++) {
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 292
diff changeset
2874 s->mb_x = mb_x;
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 292
diff changeset
2875 s->mb_y = mb_y;
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 292
diff changeset
2876 s->block_index[0]+=2;
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 292
diff changeset
2877 s->block_index[1]+=2;
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 292
diff changeset
2878 s->block_index[2]+=2;
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 292
diff changeset
2879 s->block_index[3]+=2;
954
13aec7e50c52 qpel in mmx2/3dnow
michaelni
parents: 952
diff changeset
2880
294
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 292
diff changeset
2881 /* compute motion vector & mb_type and store in context */
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
2882 if(s->pict_type==B_TYPE)
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
2883 ff_estimate_b_frame_motion(s, mb_x, mb_y);
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
2884 else
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
2885 ff_estimate_p_frame_motion(s, mb_x, mb_y);
268
09ae29b27ed9 hopefully better bitrate controll
michaelni
parents: 266
diff changeset
2886 }
09ae29b27ed9 hopefully better bitrate controll
michaelni
parents: 266
diff changeset
2887 }
456
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
2888 }else /* if(s->pict_type == I_TYPE) */{
294
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 292
diff changeset
2889 /* I-Frame */
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 292
diff changeset
2890 //FIXME do we need to zero them?
1064
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1059
diff changeset
2891 memset(s->motion_val[0], 0, sizeof(int16_t)*(s->mb_width*2 + 2)*(s->mb_height*2 + 2)*2);
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1059
diff changeset
2892 memset(s->p_mv_table , 0, sizeof(int16_t)*(s->mb_width+2)*(s->mb_height+2)*2);
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1059
diff changeset
2893 memset(s->mb_type , MB_TYPE_INTRA, sizeof(uint8_t)*s->mb_width*s->mb_height);
612
c0005de2be59 new ratecontrol code
michaelni
parents: 611
diff changeset
2894
c0005de2be59 new ratecontrol code
michaelni
parents: 611
diff changeset
2895 if(!s->fixed_qscale){
c0005de2be59 new ratecontrol code
michaelni
parents: 611
diff changeset
2896 /* finding spatial complexity for I-frame rate control */
c0005de2be59 new ratecontrol code
michaelni
parents: 611
diff changeset
2897 for(mb_y=0; mb_y < s->mb_height; mb_y++) {
c0005de2be59 new ratecontrol code
michaelni
parents: 611
diff changeset
2898 for(mb_x=0; mb_x < s->mb_width; mb_x++) {
c0005de2be59 new ratecontrol code
michaelni
parents: 611
diff changeset
2899 int xx = mb_x * 16;
c0005de2be59 new ratecontrol code
michaelni
parents: 611
diff changeset
2900 int yy = mb_y * 16;
903
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
2901 uint8_t *pix = s->new_picture.data[0] + (yy * s->linesize) + xx;
612
c0005de2be59 new ratecontrol code
michaelni
parents: 611
diff changeset
2902 int varc;
853
eacc2dd8fd9d * using DSPContext - so each codec could use its local (sub)set of CPU extension
kabi
parents: 847
diff changeset
2903 int sum = s->dsp.pix_sum(pix, s->linesize);
612
c0005de2be59 new ratecontrol code
michaelni
parents: 611
diff changeset
2904
853
eacc2dd8fd9d * using DSPContext - so each codec could use its local (sub)set of CPU extension
kabi
parents: 847
diff changeset
2905 varc = (s->dsp.pix_norm1(pix, s->linesize) - (((unsigned)(sum*sum))>>8) + 500 + 128)>>8;
612
c0005de2be59 new ratecontrol code
michaelni
parents: 611
diff changeset
2906
903
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
2907 s->current_picture.mb_var [s->mb_width * mb_y + mb_x] = varc;
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
2908 s->current_picture.mb_mean[s->mb_width * mb_y + mb_x] = (sum+128)>>8;
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
2909 s->current_picture.mb_var_sum += varc;
612
c0005de2be59 new ratecontrol code
michaelni
parents: 611
diff changeset
2910 }
c0005de2be59 new ratecontrol code
michaelni
parents: 611
diff changeset
2911 }
c0005de2be59 new ratecontrol code
michaelni
parents: 611
diff changeset
2912 }
268
09ae29b27ed9 hopefully better bitrate controll
michaelni
parents: 266
diff changeset
2913 }
814
8f31ed5bacd1 dont call emms_c() for each MB
michaelni
parents: 813
diff changeset
2914 emms_c();
8f31ed5bacd1 dont call emms_c() for each MB
michaelni
parents: 813
diff changeset
2915
608
98e39397636b better scene change detection
michaelni
parents: 605
diff changeset
2916 if(s->scene_change_score > 0 && s->pict_type == P_TYPE){
271
997aac7d4e3e scene change detection
michaelni
parents: 270
diff changeset
2917 s->pict_type= I_TYPE;
1064
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1059
diff changeset
2918 memset(s->mb_type , MB_TYPE_INTRA, sizeof(uint8_t)*s->mb_width*s->mb_height);
903
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
2919 //printf("Scene change detected, encoding as I Frame %d %d\n", s->current_picture.mb_var_sum, s->current_picture.mc_mb_var_sum);
271
997aac7d4e3e scene change detection
michaelni
parents: 270
diff changeset
2920 }
903
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
2921
1089
7e79a58954b1 h263(+) clenaup & bugfixes
michaelni
parents: 1086
diff changeset
2922 if(!s->umvplus){
1086
d3b93dc997a3 user specified motion estimation range limit
michaelni
parents: 1070
diff changeset
2923 if(s->pict_type==P_TYPE || s->pict_type==S_TYPE) {
d3b93dc997a3 user specified motion estimation range limit
michaelni
parents: 1070
diff changeset
2924 s->f_code= ff_get_best_fcode(s, s->p_mv_table, MB_TYPE_INTER);
1051
e5a9dbf597d4 mpeg1 bframe encoding patch by (Rapha«³l LEGRAND) with some modifications by me
michaelni
parents: 1048
diff changeset
2925
1086
d3b93dc997a3 user specified motion estimation range limit
michaelni
parents: 1070
diff changeset
2926 ff_fix_long_p_mvs(s);
d3b93dc997a3 user specified motion estimation range limit
michaelni
parents: 1070
diff changeset
2927 }
d3b93dc997a3 user specified motion estimation range limit
michaelni
parents: 1070
diff changeset
2928
d3b93dc997a3 user specified motion estimation range limit
michaelni
parents: 1070
diff changeset
2929 if(s->pict_type==B_TYPE){
d3b93dc997a3 user specified motion estimation range limit
michaelni
parents: 1070
diff changeset
2930 int a, b;
d3b93dc997a3 user specified motion estimation range limit
michaelni
parents: 1070
diff changeset
2931
d3b93dc997a3 user specified motion estimation range limit
michaelni
parents: 1070
diff changeset
2932 a = ff_get_best_fcode(s, s->b_forw_mv_table, MB_TYPE_FORWARD);
d3b93dc997a3 user specified motion estimation range limit
michaelni
parents: 1070
diff changeset
2933 b = ff_get_best_fcode(s, s->b_bidir_forw_mv_table, MB_TYPE_BIDIR);
d3b93dc997a3 user specified motion estimation range limit
michaelni
parents: 1070
diff changeset
2934 s->f_code = FFMAX(a, b);
d3b93dc997a3 user specified motion estimation range limit
michaelni
parents: 1070
diff changeset
2935
d3b93dc997a3 user specified motion estimation range limit
michaelni
parents: 1070
diff changeset
2936 a = ff_get_best_fcode(s, s->b_back_mv_table, MB_TYPE_BACKWARD);
d3b93dc997a3 user specified motion estimation range limit
michaelni
parents: 1070
diff changeset
2937 b = ff_get_best_fcode(s, s->b_bidir_back_mv_table, MB_TYPE_BIDIR);
d3b93dc997a3 user specified motion estimation range limit
michaelni
parents: 1070
diff changeset
2938 s->b_code = FFMAX(a, b);
d3b93dc997a3 user specified motion estimation range limit
michaelni
parents: 1070
diff changeset
2939
d3b93dc997a3 user specified motion estimation range limit
michaelni
parents: 1070
diff changeset
2940 ff_fix_long_b_mvs(s, s->b_forw_mv_table, s->f_code, MB_TYPE_FORWARD);
d3b93dc997a3 user specified motion estimation range limit
michaelni
parents: 1070
diff changeset
2941 ff_fix_long_b_mvs(s, s->b_back_mv_table, s->b_code, MB_TYPE_BACKWARD);
d3b93dc997a3 user specified motion estimation range limit
michaelni
parents: 1070
diff changeset
2942 ff_fix_long_b_mvs(s, s->b_bidir_forw_mv_table, s->f_code, MB_TYPE_BIDIR);
d3b93dc997a3 user specified motion estimation range limit
michaelni
parents: 1070
diff changeset
2943 ff_fix_long_b_mvs(s, s->b_bidir_back_mv_table, s->b_code, MB_TYPE_BIDIR);
d3b93dc997a3 user specified motion estimation range limit
michaelni
parents: 1070
diff changeset
2944 }
277
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 271
diff changeset
2945 }
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
2946
690
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 673
diff changeset
2947 if (s->fixed_qscale)
903
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
2948 s->frame_qscale = s->current_picture.quality;
690
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 673
diff changeset
2949 else
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 673
diff changeset
2950 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
2951
695
3525da287ee2 adaptive quantization for h263
michaelni
parents: 693
diff changeset
2952 if(s->adaptive_quant){
1042
a78f6f72d54e --disable-risky support
michaelni
parents: 1026
diff changeset
2953 #ifdef CONFIG_RISKY
695
3525da287ee2 adaptive quantization for h263
michaelni
parents: 693
diff changeset
2954 switch(s->codec_id){
3525da287ee2 adaptive quantization for h263
michaelni
parents: 693
diff changeset
2955 case CODEC_ID_MPEG4:
3525da287ee2 adaptive quantization for h263
michaelni
parents: 693
diff changeset
2956 ff_clean_mpeg4_qscales(s);
3525da287ee2 adaptive quantization for h263
michaelni
parents: 693
diff changeset
2957 break;
3525da287ee2 adaptive quantization for h263
michaelni
parents: 693
diff changeset
2958 case CODEC_ID_H263:
3525da287ee2 adaptive quantization for h263
michaelni
parents: 693
diff changeset
2959 case CODEC_ID_H263P:
3525da287ee2 adaptive quantization for h263
michaelni
parents: 693
diff changeset
2960 ff_clean_h263_qscales(s);
3525da287ee2 adaptive quantization for h263
michaelni
parents: 693
diff changeset
2961 break;
3525da287ee2 adaptive quantization for h263
michaelni
parents: 693
diff changeset
2962 }
1042
a78f6f72d54e --disable-risky support
michaelni
parents: 1026
diff changeset
2963 #endif
695
3525da287ee2 adaptive quantization for h263
michaelni
parents: 693
diff changeset
2964
903
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
2965 s->qscale= s->current_picture.qscale_table[0];
695
3525da287ee2 adaptive quantization for h263
michaelni
parents: 693
diff changeset
2966 }else
690
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 673
diff changeset
2967 s->qscale= (int)(s->frame_qscale + 0.5);
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 673
diff changeset
2968
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2969 if (s->out_format == FMT_MJPEG) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
2970 /* 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
2971 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
2972 for(i=1;i<64;i++){
1092
f59c3f66363b MpegEncContext.(i)dct_* -> DspContext.(i)dct_*
michaelni
parents: 1089
diff changeset
2973 int j= s->dsp.idct_permutation[i];
706
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 704
diff changeset
2974
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 704
diff changeset
2975 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
2976 }
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
2977 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
2978 s->q_intra_matrix16_bias, s->intra_matrix, s->intra_quant_bias, 8, 8);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2979 }
903
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
2980
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
2981 //FIXME var duplication
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
2982 s->current_picture.key_frame= s->pict_type == I_TYPE;
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
2983 s->current_picture.pict_type= s->pict_type;
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
2984
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
2985 if(s->current_picture.key_frame)
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
2986 s->picture_in_gop_number=0;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2987
286
91f7c38f5f37 statistics for 2-pass encoding
michaelni
parents: 281
diff changeset
2988 s->last_bits= get_bit_count(&s->pb);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2989 switch(s->out_format) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
2990 case FMT_MJPEG:
986e461dc072 Initial revision
glantau
parents:
diff changeset
2991 mjpeg_picture_header(s);
986e461dc072 Initial revision
glantau
parents:
diff changeset
2992 break;
1042
a78f6f72d54e --disable-risky support
michaelni
parents: 1026
diff changeset
2993 #ifdef CONFIG_RISKY
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2994 case FMT_H263:
936
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2995 if (s->codec_id == CODEC_ID_WMV2)
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2996 ff_wmv2_encode_picture_header(s, picture_number);
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2997 else if (s->h263_msmpeg4)
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2998 msmpeg4_encode_picture_header(s, picture_number);
986e461dc072 Initial revision
glantau
parents:
diff changeset
2999 else if (s->h263_pred)
986e461dc072 Initial revision
glantau
parents:
diff changeset
3000 mpeg4_encode_picture_header(s, picture_number);
986e461dc072 Initial revision
glantau
parents:
diff changeset
3001 else if (s->h263_rv10)
986e461dc072 Initial revision
glantau
parents:
diff changeset
3002 rv10_encode_picture_header(s, picture_number);
986e461dc072 Initial revision
glantau
parents:
diff changeset
3003 else
986e461dc072 Initial revision
glantau
parents:
diff changeset
3004 h263_encode_picture_header(s, picture_number);
986e461dc072 Initial revision
glantau
parents:
diff changeset
3005 break;
1042
a78f6f72d54e --disable-risky support
michaelni
parents: 1026
diff changeset
3006 #endif
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3007 case FMT_MPEG1:
986e461dc072 Initial revision
glantau
parents:
diff changeset
3008 mpeg1_encode_picture_header(s, picture_number);
986e461dc072 Initial revision
glantau
parents:
diff changeset
3009 break;
986e461dc072 Initial revision
glantau
parents:
diff changeset
3010 }
286
91f7c38f5f37 statistics for 2-pass encoding
michaelni
parents: 281
diff changeset
3011 bits= get_bit_count(&s->pb);
91f7c38f5f37 statistics for 2-pass encoding
michaelni
parents: 281
diff changeset
3012 s->header_bits= bits - s->last_bits;
91f7c38f5f37 statistics for 2-pass encoding
michaelni
parents: 281
diff changeset
3013 s->last_bits= bits;
91f7c38f5f37 statistics for 2-pass encoding
michaelni
parents: 281
diff changeset
3014 s->mv_bits=0;
91f7c38f5f37 statistics for 2-pass encoding
michaelni
parents: 281
diff changeset
3015 s->misc_bits=0;
91f7c38f5f37 statistics for 2-pass encoding
michaelni
parents: 281
diff changeset
3016 s->i_tex_bits=0;
91f7c38f5f37 statistics for 2-pass encoding
michaelni
parents: 281
diff changeset
3017 s->p_tex_bits=0;
91f7c38f5f37 statistics for 2-pass encoding
michaelni
parents: 281
diff changeset
3018 s->i_count=0;
656
e47fa3e3f2d5 statistics for forw & back p-MBs instead of just one counter for both
michaelni
parents: 652
diff changeset
3019 s->f_count=0;
e47fa3e3f2d5 statistics for forw & back p-MBs instead of just one counter for both
michaelni
parents: 652
diff changeset
3020 s->b_count=0;
286
91f7c38f5f37 statistics for 2-pass encoding
michaelni
parents: 281
diff changeset
3021 s->skip_count=0;
91f7c38f5f37 statistics for 2-pass encoding
michaelni
parents: 281
diff changeset
3022
909
8ae1e4c24e91 new PSNR code (now works with chroma, b frames, ...)
michaelni
parents: 903
diff changeset
3023 for(i=0; i<3; i++){
8ae1e4c24e91 new PSNR code (now works with chroma, b frames, ...)
michaelni
parents: 903
diff changeset
3024 /* init last dc values */
8ae1e4c24e91 new PSNR code (now works with chroma, b frames, ...)
michaelni
parents: 903
diff changeset
3025 /* note: quant matrix value (8) is implied here */
8ae1e4c24e91 new PSNR code (now works with chroma, b frames, ...)
michaelni
parents: 903
diff changeset
3026 s->last_dc[i] = 128;
8ae1e4c24e91 new PSNR code (now works with chroma, b frames, ...)
michaelni
parents: 903
diff changeset
3027
8ae1e4c24e91 new PSNR code (now works with chroma, b frames, ...)
michaelni
parents: 903
diff changeset
3028 s->current_picture.error[i] = 0;
8ae1e4c24e91 new PSNR code (now works with chroma, b frames, ...)
michaelni
parents: 903
diff changeset
3029 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3030 s->mb_incr = 1;
986e461dc072 Initial revision
glantau
parents:
diff changeset
3031 s->last_mv[0][0][0] = 0;
986e461dc072 Initial revision
glantau
parents:
diff changeset
3032 s->last_mv[0][0][1] = 0;
1051
e5a9dbf597d4 mpeg1 bframe encoding patch by (Rapha«³l LEGRAND) with some modifications by me
michaelni
parents: 1048
diff changeset
3033 s->last_mv[1][0][0] = 0;
e5a9dbf597d4 mpeg1 bframe encoding patch by (Rapha«³l LEGRAND) with some modifications by me
michaelni
parents: 1048
diff changeset
3034 s->last_mv[1][0][1] = 0;
e5a9dbf597d4 mpeg1 bframe encoding patch by (Rapha«³l LEGRAND) with some modifications by me
michaelni
parents: 1048
diff changeset
3035
e5a9dbf597d4 mpeg1 bframe encoding patch by (Rapha«³l LEGRAND) with some modifications by me
michaelni
parents: 1048
diff changeset
3036 s->last_mv_dir = 0;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3037
1042
a78f6f72d54e --disable-risky support
michaelni
parents: 1026
diff changeset
3038 #ifdef CONFIG_RISKY
766
8d36b35a7e6e slice encoding cleanup
michaelni
parents: 764
diff changeset
3039 if (s->codec_id==CODEC_ID_H263 || s->codec_id==CODEC_ID_H263P)
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 731
diff changeset
3040 s->gob_index = ff_h263_get_gob_height(s);
456
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
3041
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 731
diff changeset
3042 if(s->codec_id==CODEC_ID_MPEG4 && s->partitioned_frame)
456
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
3043 ff_mpeg4_init_partitions(s);
1042
a78f6f72d54e --disable-risky support
michaelni
parents: 1026
diff changeset
3044 #endif
456
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
3045
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
3046 s->resync_mb_x=0;
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
3047 s->resync_mb_y=0;
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 731
diff changeset
3048 s->first_slice_line = 1;
766
8d36b35a7e6e slice encoding cleanup
michaelni
parents: 764
diff changeset
3049 s->ptr_lastgob = s->pb.buf;
8d36b35a7e6e slice encoding cleanup
michaelni
parents: 764
diff changeset
3050 s->ptr_last_mb_line = s->pb.buf;
233
3f5b72726118 - More work on preliminary bit rate control, just to be able to get an
pulento
parents: 232
diff changeset
3051 for(mb_y=0; mb_y < s->mb_height; mb_y++) {
499
8b7a54d58549 wmv1 support
michaelni
parents: 487
diff changeset
3052 s->y_dc_scale= s->y_dc_scale_table[ s->qscale ];
8b7a54d58549 wmv1 support
michaelni
parents: 487
diff changeset
3053 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
3054
266
252444e5259b optimization
michaelni
parents: 265
diff changeset
3055 s->block_index[0]= s->block_wrap[0]*(mb_y*2 + 1) - 1;
252444e5259b optimization
michaelni
parents: 265
diff changeset
3056 s->block_index[1]= s->block_wrap[0]*(mb_y*2 + 1);
252444e5259b optimization
michaelni
parents: 265
diff changeset
3057 s->block_index[2]= s->block_wrap[0]*(mb_y*2 + 2) - 1;
252444e5259b optimization
michaelni
parents: 265
diff changeset
3058 s->block_index[3]= s->block_wrap[0]*(mb_y*2 + 2);
252444e5259b optimization
michaelni
parents: 265
diff changeset
3059 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
3060 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
3061 for(mb_x=0; mb_x < s->mb_width; mb_x++) {
1013
5d4c95f323d0 finetuneing thresholds/factors
michaelni
parents: 1011
diff changeset
3062 int mb_type= s->mb_type[mb_y * s->mb_width + mb_x];
327
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 326
diff changeset
3063 const int xy= (mb_y+1) * (s->mb_width+2) + mb_x + 1;
456
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
3064 // int d;
294
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 292
diff changeset
3065 int dmin=10000000;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3066
232
b640ec5948b0 - Now the ME is done for the entire picture when enconding, the
pulento
parents: 231
diff changeset
3067 s->mb_x = mb_x;
b640ec5948b0 - Now the ME is done for the entire picture when enconding, the
pulento
parents: 231
diff changeset
3068 s->mb_y = mb_y;
266
252444e5259b optimization
michaelni
parents: 265
diff changeset
3069 s->block_index[0]+=2;
252444e5259b optimization
michaelni
parents: 265
diff changeset
3070 s->block_index[1]+=2;
252444e5259b optimization
michaelni
parents: 265
diff changeset
3071 s->block_index[2]+=2;
252444e5259b optimization
michaelni
parents: 265
diff changeset
3072 s->block_index[3]+=2;
252444e5259b optimization
michaelni
parents: 265
diff changeset
3073 s->block_index[4]++;
252444e5259b optimization
michaelni
parents: 265
diff changeset
3074 s->block_index[5]++;
456
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
3075
766
8d36b35a7e6e slice encoding cleanup
michaelni
parents: 764
diff changeset
3076 /* write gob / video packet header */
1042
a78f6f72d54e --disable-risky support
michaelni
parents: 1026
diff changeset
3077 #ifdef CONFIG_RISKY
766
8d36b35a7e6e slice encoding cleanup
michaelni
parents: 764
diff changeset
3078 if(s->rtp_mode){
8d36b35a7e6e slice encoding cleanup
michaelni
parents: 764
diff changeset
3079 int current_packet_size, is_gob_start;
8d36b35a7e6e slice encoding cleanup
michaelni
parents: 764
diff changeset
3080
8d36b35a7e6e slice encoding cleanup
michaelni
parents: 764
diff changeset
3081 current_packet_size= pbBufPtr(&s->pb) - s->ptr_lastgob;
8d36b35a7e6e slice encoding cleanup
michaelni
parents: 764
diff changeset
3082 is_gob_start=0;
8d36b35a7e6e slice encoding cleanup
michaelni
parents: 764
diff changeset
3083
8d36b35a7e6e slice encoding cleanup
michaelni
parents: 764
diff changeset
3084 if(s->codec_id==CODEC_ID_MPEG4){
8d36b35a7e6e slice encoding cleanup
michaelni
parents: 764
diff changeset
3085 if(current_packet_size + s->mb_line_avgsize/s->mb_width >= s->rtp_payload_size
8d36b35a7e6e slice encoding cleanup
michaelni
parents: 764
diff changeset
3086 && s->mb_y + s->mb_x>0){
8d36b35a7e6e slice encoding cleanup
michaelni
parents: 764
diff changeset
3087
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 731
diff changeset
3088 if(s->partitioned_frame){
456
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
3089 ff_mpeg4_merge_partitions(s);
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
3090 ff_mpeg4_init_partitions(s);
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
3091 }
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
3092 ff_mpeg4_encode_video_packet_header(s);
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
3093
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
3094 if(s->flags&CODEC_FLAG_PASS1){
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
3095 int bits= get_bit_count(&s->pb);
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
3096 s->misc_bits+= bits - s->last_bits;
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
3097 s->last_bits= bits;
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
3098 }
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
3099 ff_mpeg4_clean_buffers(s);
766
8d36b35a7e6e slice encoding cleanup
michaelni
parents: 764
diff changeset
3100 is_gob_start=1;
456
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
3101 }
766
8d36b35a7e6e slice encoding cleanup
michaelni
parents: 764
diff changeset
3102 }else{
8d36b35a7e6e slice encoding cleanup
michaelni
parents: 764
diff changeset
3103 if(current_packet_size + s->mb_line_avgsize*s->gob_index >= s->rtp_payload_size
8d36b35a7e6e slice encoding cleanup
michaelni
parents: 764
diff changeset
3104 && s->mb_x==0 && s->mb_y>0 && s->mb_y%s->gob_index==0){
8d36b35a7e6e slice encoding cleanup
michaelni
parents: 764
diff changeset
3105
8d36b35a7e6e slice encoding cleanup
michaelni
parents: 764
diff changeset
3106 h263_encode_gob_header(s, mb_y);
8d36b35a7e6e slice encoding cleanup
michaelni
parents: 764
diff changeset
3107 is_gob_start=1;
8d36b35a7e6e slice encoding cleanup
michaelni
parents: 764
diff changeset
3108 }
8d36b35a7e6e slice encoding cleanup
michaelni
parents: 764
diff changeset
3109 }
8d36b35a7e6e slice encoding cleanup
michaelni
parents: 764
diff changeset
3110
8d36b35a7e6e slice encoding cleanup
michaelni
parents: 764
diff changeset
3111 if(is_gob_start){
456
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
3112 s->ptr_lastgob = pbBufPtr(&s->pb);
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
3113 s->first_slice_line=1;
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
3114 s->resync_mb_x=mb_x;
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
3115 s->resync_mb_y=mb_y;
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
3116 }
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 731
diff changeset
3117 }
1042
a78f6f72d54e --disable-risky support
michaelni
parents: 1026
diff changeset
3118 #endif
456
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
3119
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 731
diff changeset
3120 if( (s->resync_mb_x == s->mb_x)
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 731
diff changeset
3121 && s->resync_mb_y+1 == s->mb_y){
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 731
diff changeset
3122 s->first_slice_line=0;
456
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
3123 }
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
3124
294
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 292
diff changeset
3125 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
3126 int next_block=0;
456
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
3127 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
3128
6ebb8680885d fixing hq mode with mpeg1 and 2-pass
michaelni
parents: 325
diff changeset
3129 copy_context_before_encode(&backup_s, s, -1);
456
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
3130 backup_s.pb= s->pb;
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
3131 best_s.data_partitioning= s->data_partitioning;
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 731
diff changeset
3132 best_s.partitioned_frame= s->partitioned_frame;
456
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
3133 if(s->data_partitioning){
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
3134 backup_s.pb2= s->pb2;
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
3135 backup_s.tex_pb= s->tex_pb;
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
3136 }
326
6ebb8680885d fixing hq mode with mpeg1 and 2-pass
michaelni
parents: 325
diff changeset
3137
294
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 292
diff changeset
3138 if(mb_type&MB_TYPE_INTER){
327
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 326
diff changeset
3139 s->mv_dir = MV_DIR_FORWARD;
295
6622b0fd036c mpeg4 4MV encoding
michaelni
parents: 294
diff changeset
3140 s->mv_type = MV_TYPE_16X16;
294
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 292
diff changeset
3141 s->mb_intra= 0;
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
3142 s->mv[0][0][0] = s->p_mv_table[xy][0];
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
3143 s->mv[0][0][1] = s->p_mv_table[xy][1];
456
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
3144 encode_mb_hq(s, &backup_s, &best_s, MB_TYPE_INTER, pb, pb2, tex_pb,
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
3145 &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3146 }
326
6ebb8680885d fixing hq mode with mpeg1 and 2-pass
michaelni
parents: 325
diff changeset
3147 if(mb_type&MB_TYPE_INTER4V){
327
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 326
diff changeset
3148 s->mv_dir = MV_DIR_FORWARD;
295
6622b0fd036c mpeg4 4MV encoding
michaelni
parents: 294
diff changeset
3149 s->mv_type = MV_TYPE_8X8;
6622b0fd036c mpeg4 4MV encoding
michaelni
parents: 294
diff changeset
3150 s->mb_intra= 0;
6622b0fd036c mpeg4 4MV encoding
michaelni
parents: 294
diff changeset
3151 for(i=0; i<4; i++){
6622b0fd036c mpeg4 4MV encoding
michaelni
parents: 294
diff changeset
3152 s->mv[0][i][0] = s->motion_val[s->block_index[i]][0];
6622b0fd036c mpeg4 4MV encoding
michaelni
parents: 294
diff changeset
3153 s->mv[0][i][1] = s->motion_val[s->block_index[i]][1];
6622b0fd036c mpeg4 4MV encoding
michaelni
parents: 294
diff changeset
3154 }
456
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
3155 encode_mb_hq(s, &backup_s, &best_s, MB_TYPE_INTER4V, pb, pb2, tex_pb,
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
3156 &dmin, &next_block, 0, 0);
327
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 326
diff changeset
3157 }
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 326
diff changeset
3158 if(mb_type&MB_TYPE_FORWARD){
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 326
diff changeset
3159 s->mv_dir = MV_DIR_FORWARD;
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 326
diff changeset
3160 s->mv_type = MV_TYPE_16X16;
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 326
diff changeset
3161 s->mb_intra= 0;
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 326
diff changeset
3162 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
3163 s->mv[0][0][1] = s->b_forw_mv_table[xy][1];
456
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
3164 encode_mb_hq(s, &backup_s, &best_s, MB_TYPE_FORWARD, pb, pb2, tex_pb,
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
3165 &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
3166 }
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 326
diff changeset
3167 if(mb_type&MB_TYPE_BACKWARD){
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 326
diff changeset
3168 s->mv_dir = MV_DIR_BACKWARD;
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 326
diff changeset
3169 s->mv_type = MV_TYPE_16X16;
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 326
diff changeset
3170 s->mb_intra= 0;
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 326
diff changeset
3171 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
3172 s->mv[1][0][1] = s->b_back_mv_table[xy][1];
456
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
3173 encode_mb_hq(s, &backup_s, &best_s, MB_TYPE_BACKWARD, pb, pb2, tex_pb,
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
3174 &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
3175 }
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 326
diff changeset
3176 if(mb_type&MB_TYPE_BIDIR){
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 326
diff changeset
3177 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
3178 s->mv_type = MV_TYPE_16X16;
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 326
diff changeset
3179 s->mb_intra= 0;
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 326
diff changeset
3180 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
3181 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
3182 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
3183 s->mv[1][0][1] = s->b_bidir_back_mv_table[xy][1];
456
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
3184 encode_mb_hq(s, &backup_s, &best_s, MB_TYPE_BIDIR, pb, pb2, tex_pb,
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
3185 &dmin, &next_block, 0, 0);
327
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 326
diff changeset
3186 }
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 326
diff changeset
3187 if(mb_type&MB_TYPE_DIRECT){
936
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
3188 int mx= s->b_direct_mv_table[xy][0];
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
3189 int my= s->b_direct_mv_table[xy][1];
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
3190
327
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 326
diff changeset
3191 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
3192 s->mb_intra= 0;
1042
a78f6f72d54e --disable-risky support
michaelni
parents: 1026
diff changeset
3193 #ifdef CONFIG_RISKY
936
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
3194 ff_mpeg4_set_direct_mv(s, mx, my);
1042
a78f6f72d54e --disable-risky support
michaelni
parents: 1026
diff changeset
3195 #endif
456
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
3196 encode_mb_hq(s, &backup_s, &best_s, MB_TYPE_DIRECT, pb, pb2, tex_pb,
936
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
3197 &dmin, &next_block, mx, my);
295
6622b0fd036c mpeg4 4MV encoding
michaelni
parents: 294
diff changeset
3198 }
294
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 292
diff changeset
3199 if(mb_type&MB_TYPE_INTRA){
1051
e5a9dbf597d4 mpeg1 bframe encoding patch by (Rapha«³l LEGRAND) with some modifications by me
michaelni
parents: 1048
diff changeset
3200 s->mv_dir = 0;
295
6622b0fd036c mpeg4 4MV encoding
michaelni
parents: 294
diff changeset
3201 s->mv_type = MV_TYPE_16X16;
294
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 292
diff changeset
3202 s->mb_intra= 1;
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 292
diff changeset
3203 s->mv[0][0][0] = 0;
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 292
diff changeset
3204 s->mv[0][0][1] = 0;
456
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
3205 encode_mb_hq(s, &backup_s, &best_s, MB_TYPE_INTRA, pb, pb2, tex_pb,
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
3206 &dmin, &next_block, 0, 0);
326
6ebb8680885d fixing hq mode with mpeg1 and 2-pass
michaelni
parents: 325
diff changeset
3207 /* force cleaning of ac/dc pred stuff if needed ... */
6ebb8680885d fixing hq mode with mpeg1 and 2-pass
michaelni
parents: 325
diff changeset
3208 if(s->h263_pred || s->h263_aic)
6ebb8680885d fixing hq mode with mpeg1 and 2-pass
michaelni
parents: 325
diff changeset
3209 s->mbintra_table[mb_x + mb_y*s->mb_width]=1;
295
6622b0fd036c mpeg4 4MV encoding
michaelni
parents: 294
diff changeset
3210 }
326
6ebb8680885d fixing hq mode with mpeg1 and 2-pass
michaelni
parents: 325
diff changeset
3211 copy_context_after_encode(s, &best_s, -1);
456
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
3212
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
3213 pb_bits_count= get_bit_count(&s->pb);
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
3214 flush_put_bits(&s->pb);
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
3215 ff_copy_bits(&backup_s.pb, bit_buf[next_block^1], pb_bits_count);
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
3216 s->pb= backup_s.pb;
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
3217
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
3218 if(s->data_partitioning){
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
3219 pb2_bits_count= get_bit_count(&s->pb2);
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
3220 flush_put_bits(&s->pb2);
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
3221 ff_copy_bits(&backup_s.pb2, bit_buf2[next_block^1], pb2_bits_count);
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
3222 s->pb2= backup_s.pb2;
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
3223
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
3224 tex_pb_bits_count= get_bit_count(&s->tex_pb);
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
3225 flush_put_bits(&s->tex_pb);
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
3226 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
3227 s->tex_pb= backup_s.tex_pb;
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
3228 }
329
5cc47d0ba53e fixed ratecontrol & b-frames
michaelni
parents: 327
diff changeset
3229 s->last_bits= get_bit_count(&s->pb);
294
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 292
diff changeset
3230 } else {
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
3231 int motion_x, motion_y;
1013
5d4c95f323d0 finetuneing thresholds/factors
michaelni
parents: 1011
diff changeset
3232 int intra_score;
5d4c95f323d0 finetuneing thresholds/factors
michaelni
parents: 1011
diff changeset
3233 int inter_score= s->current_picture.mb_cmp_score[mb_x + mb_y*s->mb_width];
5d4c95f323d0 finetuneing thresholds/factors
michaelni
parents: 1011
diff changeset
3234
5d4c95f323d0 finetuneing thresholds/factors
michaelni
parents: 1011
diff changeset
3235 if(!(s->flags&CODEC_FLAG_HQ) && s->pict_type==P_TYPE){
5d4c95f323d0 finetuneing thresholds/factors
michaelni
parents: 1011
diff changeset
3236 /* get luma score */
5d4c95f323d0 finetuneing thresholds/factors
michaelni
parents: 1011
diff changeset
3237 if((s->avctx->mb_cmp&0xFF)==FF_CMP_SSE){
5d4c95f323d0 finetuneing thresholds/factors
michaelni
parents: 1011
diff changeset
3238 intra_score= (s->current_picture.mb_var[mb_x + mb_y*s->mb_width]<<8) - 500; //FIXME dont scale it down so we dont have to fix it
5d4c95f323d0 finetuneing thresholds/factors
michaelni
parents: 1011
diff changeset
3239 }else{
5d4c95f323d0 finetuneing thresholds/factors
michaelni
parents: 1011
diff changeset
3240 uint8_t *dest_y;
5d4c95f323d0 finetuneing thresholds/factors
michaelni
parents: 1011
diff changeset
3241
5d4c95f323d0 finetuneing thresholds/factors
michaelni
parents: 1011
diff changeset
3242 int mean= s->current_picture.mb_mean[mb_x + mb_y*s->mb_width]; //FIXME
5d4c95f323d0 finetuneing thresholds/factors
michaelni
parents: 1011
diff changeset
3243 mean*= 0x01010101;
5d4c95f323d0 finetuneing thresholds/factors
michaelni
parents: 1011
diff changeset
3244
5d4c95f323d0 finetuneing thresholds/factors
michaelni
parents: 1011
diff changeset
3245 dest_y = s->new_picture.data[0] + (mb_y * 16 * s->linesize ) + mb_x * 16;
5d4c95f323d0 finetuneing thresholds/factors
michaelni
parents: 1011
diff changeset
3246
5d4c95f323d0 finetuneing thresholds/factors
michaelni
parents: 1011
diff changeset
3247 for(i=0; i<16; i++){
5d4c95f323d0 finetuneing thresholds/factors
michaelni
parents: 1011
diff changeset
3248 *(uint32_t*)(&s->me.scratchpad[i*s->linesize+ 0]) = mean;
5d4c95f323d0 finetuneing thresholds/factors
michaelni
parents: 1011
diff changeset
3249 *(uint32_t*)(&s->me.scratchpad[i*s->linesize+ 4]) = mean;
5d4c95f323d0 finetuneing thresholds/factors
michaelni
parents: 1011
diff changeset
3250 *(uint32_t*)(&s->me.scratchpad[i*s->linesize+ 8]) = mean;
5d4c95f323d0 finetuneing thresholds/factors
michaelni
parents: 1011
diff changeset
3251 *(uint32_t*)(&s->me.scratchpad[i*s->linesize+12]) = mean;
5d4c95f323d0 finetuneing thresholds/factors
michaelni
parents: 1011
diff changeset
3252 }
5d4c95f323d0 finetuneing thresholds/factors
michaelni
parents: 1011
diff changeset
3253
5d4c95f323d0 finetuneing thresholds/factors
michaelni
parents: 1011
diff changeset
3254 s->mb_intra=1;
5d4c95f323d0 finetuneing thresholds/factors
michaelni
parents: 1011
diff changeset
3255 intra_score= s->dsp.mb_cmp[0](s, s->me.scratchpad, dest_y, s->linesize);
5d4c95f323d0 finetuneing thresholds/factors
michaelni
parents: 1011
diff changeset
3256
5d4c95f323d0 finetuneing thresholds/factors
michaelni
parents: 1011
diff changeset
3257 /* printf("intra:%7d inter:%7d var:%7d mc_var.%7d\n", intra_score>>8, inter_score>>8,
5d4c95f323d0 finetuneing thresholds/factors
michaelni
parents: 1011
diff changeset
3258 s->current_picture.mb_var[mb_x + mb_y*s->mb_width],
5d4c95f323d0 finetuneing thresholds/factors
michaelni
parents: 1011
diff changeset
3259 s->current_picture.mc_mb_var[mb_x + mb_y*s->mb_width]);*/
5d4c95f323d0 finetuneing thresholds/factors
michaelni
parents: 1011
diff changeset
3260 }
5d4c95f323d0 finetuneing thresholds/factors
michaelni
parents: 1011
diff changeset
3261
5d4c95f323d0 finetuneing thresholds/factors
michaelni
parents: 1011
diff changeset
3262 /* get chroma score */
5d4c95f323d0 finetuneing thresholds/factors
michaelni
parents: 1011
diff changeset
3263 if(s->avctx->mb_cmp&FF_CMP_CHROMA){
5d4c95f323d0 finetuneing thresholds/factors
michaelni
parents: 1011
diff changeset
3264 int i;
5d4c95f323d0 finetuneing thresholds/factors
michaelni
parents: 1011
diff changeset
3265
5d4c95f323d0 finetuneing thresholds/factors
michaelni
parents: 1011
diff changeset
3266 s->mb_intra=1;
5d4c95f323d0 finetuneing thresholds/factors
michaelni
parents: 1011
diff changeset
3267 for(i=1; i<3; i++){
5d4c95f323d0 finetuneing thresholds/factors
michaelni
parents: 1011
diff changeset
3268 uint8_t *dest_c;
5d4c95f323d0 finetuneing thresholds/factors
michaelni
parents: 1011
diff changeset
3269 int mean;
5d4c95f323d0 finetuneing thresholds/factors
michaelni
parents: 1011
diff changeset
3270
5d4c95f323d0 finetuneing thresholds/factors
michaelni
parents: 1011
diff changeset
3271 if(s->out_format == FMT_H263){
5d4c95f323d0 finetuneing thresholds/factors
michaelni
parents: 1011
diff changeset
3272 mean= (s->dc_val[i][mb_x + (mb_y+1)*(s->mb_width+2)] + 4)>>3; //FIXME not exact but simple ;)
5d4c95f323d0 finetuneing thresholds/factors
michaelni
parents: 1011
diff changeset
3273 }else{
5d4c95f323d0 finetuneing thresholds/factors
michaelni
parents: 1011
diff changeset
3274 mean= (s->last_dc[i] + 4)>>3;
5d4c95f323d0 finetuneing thresholds/factors
michaelni
parents: 1011
diff changeset
3275 }
5d4c95f323d0 finetuneing thresholds/factors
michaelni
parents: 1011
diff changeset
3276 dest_c = s->new_picture.data[i] + (mb_y * 8 * (s->uvlinesize)) + mb_x * 8;
5d4c95f323d0 finetuneing thresholds/factors
michaelni
parents: 1011
diff changeset
3277
5d4c95f323d0 finetuneing thresholds/factors
michaelni
parents: 1011
diff changeset
3278 mean*= 0x01010101;
5d4c95f323d0 finetuneing thresholds/factors
michaelni
parents: 1011
diff changeset
3279 for(i=0; i<8; i++){
5d4c95f323d0 finetuneing thresholds/factors
michaelni
parents: 1011
diff changeset
3280 *(uint32_t*)(&s->me.scratchpad[i*s->uvlinesize+ 0]) = mean;
5d4c95f323d0 finetuneing thresholds/factors
michaelni
parents: 1011
diff changeset
3281 *(uint32_t*)(&s->me.scratchpad[i*s->uvlinesize+ 4]) = mean;
5d4c95f323d0 finetuneing thresholds/factors
michaelni
parents: 1011
diff changeset
3282 }
5d4c95f323d0 finetuneing thresholds/factors
michaelni
parents: 1011
diff changeset
3283
5d4c95f323d0 finetuneing thresholds/factors
michaelni
parents: 1011
diff changeset
3284 intra_score+= s->dsp.mb_cmp[1](s, s->me.scratchpad, dest_c, s->uvlinesize);
5d4c95f323d0 finetuneing thresholds/factors
michaelni
parents: 1011
diff changeset
3285 }
5d4c95f323d0 finetuneing thresholds/factors
michaelni
parents: 1011
diff changeset
3286 }
5d4c95f323d0 finetuneing thresholds/factors
michaelni
parents: 1011
diff changeset
3287
5d4c95f323d0 finetuneing thresholds/factors
michaelni
parents: 1011
diff changeset
3288 /* bias */
5d4c95f323d0 finetuneing thresholds/factors
michaelni
parents: 1011
diff changeset
3289 switch(s->avctx->mb_cmp&0xFF){
5d4c95f323d0 finetuneing thresholds/factors
michaelni
parents: 1011
diff changeset
3290 default:
5d4c95f323d0 finetuneing thresholds/factors
michaelni
parents: 1011
diff changeset
3291 case FF_CMP_SAD:
5d4c95f323d0 finetuneing thresholds/factors
michaelni
parents: 1011
diff changeset
3292 intra_score+= 32*s->qscale;
5d4c95f323d0 finetuneing thresholds/factors
michaelni
parents: 1011
diff changeset
3293 break;
5d4c95f323d0 finetuneing thresholds/factors
michaelni
parents: 1011
diff changeset
3294 case FF_CMP_SSE:
5d4c95f323d0 finetuneing thresholds/factors
michaelni
parents: 1011
diff changeset
3295 intra_score+= 24*s->qscale*s->qscale;
5d4c95f323d0 finetuneing thresholds/factors
michaelni
parents: 1011
diff changeset
3296 break;
5d4c95f323d0 finetuneing thresholds/factors
michaelni
parents: 1011
diff changeset
3297 case FF_CMP_SATD:
5d4c95f323d0 finetuneing thresholds/factors
michaelni
parents: 1011
diff changeset
3298 intra_score+= 96*s->qscale;
5d4c95f323d0 finetuneing thresholds/factors
michaelni
parents: 1011
diff changeset
3299 break;
5d4c95f323d0 finetuneing thresholds/factors
michaelni
parents: 1011
diff changeset
3300 case FF_CMP_DCT:
5d4c95f323d0 finetuneing thresholds/factors
michaelni
parents: 1011
diff changeset
3301 intra_score+= 48*s->qscale;
5d4c95f323d0 finetuneing thresholds/factors
michaelni
parents: 1011
diff changeset
3302 break;
5d4c95f323d0 finetuneing thresholds/factors
michaelni
parents: 1011
diff changeset
3303 case FF_CMP_BIT:
5d4c95f323d0 finetuneing thresholds/factors
michaelni
parents: 1011
diff changeset
3304 intra_score+= 16;
5d4c95f323d0 finetuneing thresholds/factors
michaelni
parents: 1011
diff changeset
3305 break;
5d4c95f323d0 finetuneing thresholds/factors
michaelni
parents: 1011
diff changeset
3306 case FF_CMP_PSNR:
5d4c95f323d0 finetuneing thresholds/factors
michaelni
parents: 1011
diff changeset
3307 case FF_CMP_RD:
5d4c95f323d0 finetuneing thresholds/factors
michaelni
parents: 1011
diff changeset
3308 intra_score+= (s->qscale*s->qscale*109*8 + 64)>>7;
5d4c95f323d0 finetuneing thresholds/factors
michaelni
parents: 1011
diff changeset
3309 break;
5d4c95f323d0 finetuneing thresholds/factors
michaelni
parents: 1011
diff changeset
3310 }
5d4c95f323d0 finetuneing thresholds/factors
michaelni
parents: 1011
diff changeset
3311
5d4c95f323d0 finetuneing thresholds/factors
michaelni
parents: 1011
diff changeset
3312 if(intra_score < inter_score)
5d4c95f323d0 finetuneing thresholds/factors
michaelni
parents: 1011
diff changeset
3313 mb_type= MB_TYPE_INTRA;
5d4c95f323d0 finetuneing thresholds/factors
michaelni
parents: 1011
diff changeset
3314 }
5d4c95f323d0 finetuneing thresholds/factors
michaelni
parents: 1011
diff changeset
3315
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
3316 s->mv_type=MV_TYPE_16X16;
294
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 292
diff changeset
3317 // only one MB-Type possible
1013
5d4c95f323d0 finetuneing thresholds/factors
michaelni
parents: 1011
diff changeset
3318
327
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 326
diff changeset
3319 switch(mb_type){
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 326
diff changeset
3320 case MB_TYPE_INTRA:
1051
e5a9dbf597d4 mpeg1 bframe encoding patch by (Rapha«³l LEGRAND) with some modifications by me
michaelni
parents: 1048
diff changeset
3321 s->mv_dir = 0;
294
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 292
diff changeset
3322 s->mb_intra= 1;
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
3323 motion_x= s->mv[0][0][0] = 0;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
3324 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
3325 break;
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 326
diff changeset
3326 case MB_TYPE_INTER:
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
3327 s->mv_dir = MV_DIR_FORWARD;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
3328 s->mb_intra= 0;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
3329 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
3330 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
3331 break;
456
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
3332 case MB_TYPE_INTER4V:
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
3333 s->mv_dir = MV_DIR_FORWARD;
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
3334 s->mv_type = MV_TYPE_8X8;
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
3335 s->mb_intra= 0;
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
3336 for(i=0; i<4; i++){
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
3337 s->mv[0][i][0] = s->motion_val[s->block_index[i]][0];
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
3338 s->mv[0][i][1] = s->motion_val[s->block_index[i]][1];
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
3339 }
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
3340 motion_x= motion_y= 0;
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
3341 break;
327
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 326
diff changeset
3342 case MB_TYPE_DIRECT:
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
3343 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
3344 s->mb_intra= 0;
327
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 326
diff changeset
3345 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
3346 motion_y=s->b_direct_mv_table[xy][1];
1042
a78f6f72d54e --disable-risky support
michaelni
parents: 1026
diff changeset
3347 #ifdef CONFIG_RISKY
936
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
3348 ff_mpeg4_set_direct_mv(s, motion_x, motion_y);
1042
a78f6f72d54e --disable-risky support
michaelni
parents: 1026
diff changeset
3349 #endif
327
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 326
diff changeset
3350 break;
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 326
diff changeset
3351 case MB_TYPE_BIDIR:
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
3352 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
294
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 292
diff changeset
3353 s->mb_intra= 0;
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
3354 motion_x=0;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
3355 motion_y=0;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
3356 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
3357 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
3358 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
3359 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
3360 break;
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 326
diff changeset
3361 case MB_TYPE_BACKWARD:
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
3362 s->mv_dir = MV_DIR_BACKWARD;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
3363 s->mb_intra= 0;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
3364 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
3365 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
3366 break;
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 326
diff changeset
3367 case MB_TYPE_FORWARD:
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
3368 s->mv_dir = MV_DIR_FORWARD;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
3369 s->mb_intra= 0;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
3370 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
3371 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
3372 // printf(" %d %d ", motion_x, motion_y);
327
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 326
diff changeset
3373 break;
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 326
diff changeset
3374 default:
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
3375 motion_x=motion_y=0; //gcc warning fix
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
3376 printf("illegal MB type\n");
294
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 292
diff changeset
3377 }
1051
e5a9dbf597d4 mpeg1 bframe encoding patch by (Rapha«³l LEGRAND) with some modifications by me
michaelni
parents: 1048
diff changeset
3378
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
3379 encode_mb(s, motion_x, motion_y);
1051
e5a9dbf597d4 mpeg1 bframe encoding patch by (Rapha«³l LEGRAND) with some modifications by me
michaelni
parents: 1048
diff changeset
3380
e5a9dbf597d4 mpeg1 bframe encoding patch by (Rapha«³l LEGRAND) with some modifications by me
michaelni
parents: 1048
diff changeset
3381 // RAL: Update last macrobloc type
e5a9dbf597d4 mpeg1 bframe encoding patch by (Rapha«³l LEGRAND) with some modifications by me
michaelni
parents: 1048
diff changeset
3382 s->last_mv_dir = s->mv_dir;
248
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 244
diff changeset
3383 }
1051
e5a9dbf597d4 mpeg1 bframe encoding patch by (Rapha«³l LEGRAND) with some modifications by me
michaelni
parents: 1048
diff changeset
3384
327
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 326
diff changeset
3385 /* 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
3386 if(s->mb_intra /* && I,P,S_TYPE */){
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 326
diff changeset
3387 s->p_mv_table[xy][0]=0;
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 326
diff changeset
3388 s->p_mv_table[xy][1]=0;
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 326
diff changeset
3389 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3390
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
3391 MPV_decode_mb(s, s->block);
909
8ae1e4c24e91 new PSNR code (now works with chroma, b frames, ...)
michaelni
parents: 903
diff changeset
3392
8ae1e4c24e91 new PSNR code (now works with chroma, b frames, ...)
michaelni
parents: 903
diff changeset
3393 if(s->flags&CODEC_FLAG_PSNR){
8ae1e4c24e91 new PSNR code (now works with chroma, b frames, ...)
michaelni
parents: 903
diff changeset
3394 int w= 16;
8ae1e4c24e91 new PSNR code (now works with chroma, b frames, ...)
michaelni
parents: 903
diff changeset
3395 int h= 16;
8ae1e4c24e91 new PSNR code (now works with chroma, b frames, ...)
michaelni
parents: 903
diff changeset
3396
8ae1e4c24e91 new PSNR code (now works with chroma, b frames, ...)
michaelni
parents: 903
diff changeset
3397 if(s->mb_x*16 + 16 > s->width ) w= s->width - s->mb_x*16;
8ae1e4c24e91 new PSNR code (now works with chroma, b frames, ...)
michaelni
parents: 903
diff changeset
3398 if(s->mb_y*16 + 16 > s->height) h= s->height- s->mb_y*16;
936
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
3399
909
8ae1e4c24e91 new PSNR code (now works with chroma, b frames, ...)
michaelni
parents: 903
diff changeset
3400 s->current_picture.error[0] += sse(
8ae1e4c24e91 new PSNR code (now works with chroma, b frames, ...)
michaelni
parents: 903
diff changeset
3401 s,
8ae1e4c24e91 new PSNR code (now works with chroma, b frames, ...)
michaelni
parents: 903
diff changeset
3402 s->new_picture .data[0] + s->mb_x*16 + s->mb_y*s->linesize*16,
8ae1e4c24e91 new PSNR code (now works with chroma, b frames, ...)
michaelni
parents: 903
diff changeset
3403 s->current_picture.data[0] + s->mb_x*16 + s->mb_y*s->linesize*16,
8ae1e4c24e91 new PSNR code (now works with chroma, b frames, ...)
michaelni
parents: 903
diff changeset
3404 w, h, s->linesize);
8ae1e4c24e91 new PSNR code (now works with chroma, b frames, ...)
michaelni
parents: 903
diff changeset
3405 s->current_picture.error[1] += sse(
8ae1e4c24e91 new PSNR code (now works with chroma, b frames, ...)
michaelni
parents: 903
diff changeset
3406 s,
8ae1e4c24e91 new PSNR code (now works with chroma, b frames, ...)
michaelni
parents: 903
diff changeset
3407 s->new_picture .data[1] + s->mb_x*8 + s->mb_y*s->uvlinesize*8,
8ae1e4c24e91 new PSNR code (now works with chroma, b frames, ...)
michaelni
parents: 903
diff changeset
3408 s->current_picture.data[1] + s->mb_x*8 + s->mb_y*s->uvlinesize*8,
8ae1e4c24e91 new PSNR code (now works with chroma, b frames, ...)
michaelni
parents: 903
diff changeset
3409 w>>1, h>>1, s->uvlinesize);
8ae1e4c24e91 new PSNR code (now works with chroma, b frames, ...)
michaelni
parents: 903
diff changeset
3410 s->current_picture.error[2] += sse(
8ae1e4c24e91 new PSNR code (now works with chroma, b frames, ...)
michaelni
parents: 903
diff changeset
3411 s,
8ae1e4c24e91 new PSNR code (now works with chroma, b frames, ...)
michaelni
parents: 903
diff changeset
3412 s->new_picture .data[2] + s->mb_x*8 + s->mb_y*s->uvlinesize*8,
8ae1e4c24e91 new PSNR code (now works with chroma, b frames, ...)
michaelni
parents: 903
diff changeset
3413 s->current_picture.data[2] + s->mb_x*8 + s->mb_y*s->uvlinesize*8,
8ae1e4c24e91 new PSNR code (now works with chroma, b frames, ...)
michaelni
parents: 903
diff changeset
3414 w>>1, h>>1, s->uvlinesize);
8ae1e4c24e91 new PSNR code (now works with chroma, b frames, ...)
michaelni
parents: 903
diff changeset
3415 }
456
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
3416 //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
3417 }
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
3418
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
3419
766
8d36b35a7e6e slice encoding cleanup
michaelni
parents: 764
diff changeset
3420 /* Obtain average mb_row size for RTP */
231
840cd25bf259 - Fixes on RTP and GOB headers for H.263.
pulento
parents: 230
diff changeset
3421 if (s->rtp_mode) {
766
8d36b35a7e6e slice encoding cleanup
michaelni
parents: 764
diff changeset
3422 if (mb_y==0)
234
5fc0c3af3fe4 alternative bitstream writer (disabled by default, uncomment #define ALT_BISTREAM_WRITER in common.h if u want to try it)
michaelni
parents: 233
diff changeset
3423 s->mb_line_avgsize = pbBufPtr(&s->pb) - s->ptr_last_mb_line;
766
8d36b35a7e6e slice encoding cleanup
michaelni
parents: 764
diff changeset
3424 else {
234
5fc0c3af3fe4 alternative bitstream writer (disabled by default, uncomment #define ALT_BISTREAM_WRITER in common.h if u want to try it)
michaelni
parents: 233
diff changeset
3425 s->mb_line_avgsize = (s->mb_line_avgsize + pbBufPtr(&s->pb) - s->ptr_last_mb_line) >> 1;
231
840cd25bf259 - Fixes on RTP and GOB headers for H.263.
pulento
parents: 230
diff changeset
3426 }
766
8d36b35a7e6e slice encoding cleanup
michaelni
parents: 764
diff changeset
3427 s->ptr_last_mb_line = pbBufPtr(&s->pb);
231
840cd25bf259 - Fixes on RTP and GOB headers for H.263.
pulento
parents: 230
diff changeset
3428 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3429 }
294
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 292
diff changeset
3430 emms_c();
286
91f7c38f5f37 statistics for 2-pass encoding
michaelni
parents: 281
diff changeset
3431
1042
a78f6f72d54e --disable-risky support
michaelni
parents: 1026
diff changeset
3432 #ifdef CONFIG_RISKY
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 731
diff changeset
3433 if(s->codec_id==CODEC_ID_MPEG4 && s->partitioned_frame)
456
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
3434 ff_mpeg4_merge_partitions(s);
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
3435
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
3436 if (s->msmpeg4_version && s->msmpeg4_version<4 && s->pict_type == I_TYPE)
208
2eb04d6be309 (commit by michael)
arpi_esp
parents: 207
diff changeset
3437 msmpeg4_encode_ext_header(s);
2eb04d6be309 (commit by michael)
arpi_esp
parents: 207
diff changeset
3438
456
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
3439 if(s->codec_id==CODEC_ID_MPEG4)
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
3440 ff_mpeg4_stuffing(&s->pb);
1042
a78f6f72d54e --disable-risky support
michaelni
parents: 1026
diff changeset
3441 #endif
456
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
3442
162
de80712db90b - Preliminary RTP friendly mode for H.263.
pulento
parents: 108
diff changeset
3443 //if (s->gob_number)
de80712db90b - Preliminary RTP friendly mode for H.263.
pulento
parents: 108
diff changeset
3444 // 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
3445
840cd25bf259 - Fixes on RTP and GOB headers for H.263.
pulento
parents: 230
diff changeset
3446 /* Send the last GOB if RTP */
840cd25bf259 - Fixes on RTP and GOB headers for H.263.
pulento
parents: 230
diff changeset
3447 if (s->rtp_mode) {
840cd25bf259 - Fixes on RTP and GOB headers for H.263.
pulento
parents: 230
diff changeset
3448 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
3449 pdif = pbBufPtr(&s->pb) - s->ptr_lastgob;
231
840cd25bf259 - Fixes on RTP and GOB headers for H.263.
pulento
parents: 230
diff changeset
3450 /* Call the RTP callback to send the last GOB */
840cd25bf259 - Fixes on RTP and GOB headers for H.263.
pulento
parents: 230
diff changeset
3451 if (s->rtp_callback)
840cd25bf259 - Fixes on RTP and GOB headers for H.263.
pulento
parents: 230
diff changeset
3452 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
3453 s->ptr_lastgob = pbBufPtr(&s->pb);
231
840cd25bf259 - Fixes on RTP and GOB headers for H.263.
pulento
parents: 230
diff changeset
3454 //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
3455 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3456 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
3457
945
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
3458 static int dct_quantize_trellis_c(MpegEncContext *s,
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
3459 DCTELEM *block, int n,
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
3460 int qscale, int *overflow){
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
3461 const int *qmat;
1064
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1059
diff changeset
3462 const uint8_t *scantable= s->intra_scantable.scantable;
945
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
3463 int max=0;
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
3464 unsigned int threshold1, threshold2;
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
3465 int bias=0;
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
3466 int run_tab[65];
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
3467 int level_tab[65];
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
3468 int score_tab[65];
946
4f522c9e6099 more optimized trellis quantizer
michaelni
parents: 945
diff changeset
3469 int last_run=0;
4f522c9e6099 more optimized trellis quantizer
michaelni
parents: 945
diff changeset
3470 int last_level=0;
4f522c9e6099 more optimized trellis quantizer
michaelni
parents: 945
diff changeset
3471 int last_score= 0;
4f522c9e6099 more optimized trellis quantizer
michaelni
parents: 945
diff changeset
3472 int last_i= 0;
4f522c9e6099 more optimized trellis quantizer
michaelni
parents: 945
diff changeset
3473 int coeff[3][64];
945
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
3474 int coeff_count[64];
946
4f522c9e6099 more optimized trellis quantizer
michaelni
parents: 945
diff changeset
3475 int lambda, qmul, qadd, start_i, last_non_zero, i;
945
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
3476 const int esc_length= s->ac_esc_length;
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
3477 uint8_t * length;
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
3478 uint8_t * last_length;
946
4f522c9e6099 more optimized trellis quantizer
michaelni
parents: 945
diff changeset
3479 int score_limit=0;
4f522c9e6099 more optimized trellis quantizer
michaelni
parents: 945
diff changeset
3480 int left_limit= 0;
945
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
3481
1092
f59c3f66363b MpegEncContext.(i)dct_* -> DspContext.(i)dct_*
michaelni
parents: 1089
diff changeset
3482 s->dsp.fdct (block);
945
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
3483
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
3484 qmul= qscale*16;
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
3485 qadd= ((qscale-1)|1)*8;
946
4f522c9e6099 more optimized trellis quantizer
michaelni
parents: 945
diff changeset
3486
945
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
3487 if (s->mb_intra) {
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
3488 int q;
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
3489 if (!s->h263_aic) {
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
3490 if (n < 4)
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
3491 q = s->y_dc_scale;
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
3492 else
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
3493 q = s->c_dc_scale;
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
3494 q = q << 3;
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
3495 } else{
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
3496 /* For AIC we skip quant/dequant of INTRADC */
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
3497 q = 1 << 3;
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
3498 qadd=0;
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
3499 }
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
3500
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
3501 /* note: block[0] is assumed to be positive */
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
3502 block[0] = (block[0] + (q >> 1)) / q;
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
3503 start_i = 1;
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
3504 last_non_zero = 0;
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
3505 qmat = s->q_intra_matrix[qscale];
947
9be53be2d1a9 trellis quantization for mpeg1
michaelni
parents: 946
diff changeset
3506 if(s->mpeg_quant || s->codec_id== CODEC_ID_MPEG1VIDEO)
945
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
3507 bias= 1<<(QMAT_SHIFT-1);
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
3508 length = s->intra_ac_vlc_length;
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
3509 last_length= s->intra_ac_vlc_last_length;
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
3510 } else {
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
3511 start_i = 0;
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
3512 last_non_zero = -1;
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
3513 qmat = s->q_inter_matrix[qscale];
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
3514 length = s->inter_ac_vlc_length;
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
3515 last_length= s->inter_ac_vlc_last_length;
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
3516 }
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
3517
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
3518 threshold1= (1<<QMAT_SHIFT) - bias - 1;
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
3519 threshold2= (threshold1<<1);
946
4f522c9e6099 more optimized trellis quantizer
michaelni
parents: 945
diff changeset
3520
945
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
3521 for(i=start_i; i<64; i++) {
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
3522 const int j = scantable[i];
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
3523 const int k= i-start_i;
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
3524 int level = block[j];
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
3525 level = level * qmat[j];
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
3526
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
3527 // if( bias+level >= (1<<(QMAT_SHIFT - 3))
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
3528 // || bias-level >= (1<<(QMAT_SHIFT - 3))){
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
3529 if(((unsigned)(level+threshold1))>threshold2){
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
3530 if(level>0){
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
3531 level= (bias + level)>>QMAT_SHIFT;
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
3532 coeff[0][k]= level;
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
3533 coeff[1][k]= level-1;
946
4f522c9e6099 more optimized trellis quantizer
michaelni
parents: 945
diff changeset
3534 // coeff[2][k]= level-2;
945
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
3535 }else{
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
3536 level= (bias - level)>>QMAT_SHIFT;
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
3537 coeff[0][k]= -level;
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
3538 coeff[1][k]= -level+1;
946
4f522c9e6099 more optimized trellis quantizer
michaelni
parents: 945
diff changeset
3539 // coeff[2][k]= -level+2;
945
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
3540 }
946
4f522c9e6099 more optimized trellis quantizer
michaelni
parents: 945
diff changeset
3541 coeff_count[k]= FFMIN(level, 2);
945
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
3542 max |=level;
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
3543 last_non_zero = i;
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
3544 }else{
946
4f522c9e6099 more optimized trellis quantizer
michaelni
parents: 945
diff changeset
3545 coeff[0][k]= (level>>31)|1;
945
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
3546 coeff_count[k]= 1;
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
3547 }
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
3548 }
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
3549
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
3550 *overflow= s->max_qcoeff < max; //overflow might have happend
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
3551
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
3552 if(last_non_zero < start_i){
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
3553 memset(block + start_i, 0, (64-start_i)*sizeof(DCTELEM));
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
3554 return last_non_zero;
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
3555 }
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
3556
1013
5d4c95f323d0 finetuneing thresholds/factors
michaelni
parents: 1011
diff changeset
3557 lambda= (qscale*qscale*64*105 + 64)>>7; //FIXME finetune
945
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
3558
946
4f522c9e6099 more optimized trellis quantizer
michaelni
parents: 945
diff changeset
3559 score_tab[0]= 0;
945
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
3560 for(i=0; i<=last_non_zero - start_i; i++){
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
3561 int level_index, run, j;
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
3562 const int dct_coeff= block[ scantable[i + start_i] ];
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
3563 const int zero_distoration= dct_coeff*dct_coeff;
946
4f522c9e6099 more optimized trellis quantizer
michaelni
parents: 945
diff changeset
3564 int best_score=256*256*256*120;
4f522c9e6099 more optimized trellis quantizer
michaelni
parents: 945
diff changeset
3565
4f522c9e6099 more optimized trellis quantizer
michaelni
parents: 945
diff changeset
3566 last_score += zero_distoration;
945
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
3567 for(level_index=0; level_index < coeff_count[i]; level_index++){
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
3568 int distoration;
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
3569 int level= coeff[level_index][i];
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
3570 int unquant_coeff;
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
3571
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
3572 assert(level);
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
3573
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
3574 if(s->out_format == FMT_H263){
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
3575 if(level>0){
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
3576 unquant_coeff= level*qmul + qadd;
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
3577 }else{
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
3578 unquant_coeff= level*qmul - qadd;
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
3579 }
947
9be53be2d1a9 trellis quantization for mpeg1
michaelni
parents: 946
diff changeset
3580 }else{ //MPEG1
1092
f59c3f66363b MpegEncContext.(i)dct_* -> DspContext.(i)dct_*
michaelni
parents: 1089
diff changeset
3581 j= s->dsp.idct_permutation[ scantable[i + start_i] ]; //FIXME optimize
947
9be53be2d1a9 trellis quantization for mpeg1
michaelni
parents: 946
diff changeset
3582 if(s->mb_intra){
9be53be2d1a9 trellis quantization for mpeg1
michaelni
parents: 946
diff changeset
3583 if (level < 0) {
9be53be2d1a9 trellis quantization for mpeg1
michaelni
parents: 946
diff changeset
3584 unquant_coeff = (int)((-level) * qscale * s->intra_matrix[j]) >> 3;
9be53be2d1a9 trellis quantization for mpeg1
michaelni
parents: 946
diff changeset
3585 unquant_coeff = -((unquant_coeff - 1) | 1);
9be53be2d1a9 trellis quantization for mpeg1
michaelni
parents: 946
diff changeset
3586 } else {
9be53be2d1a9 trellis quantization for mpeg1
michaelni
parents: 946
diff changeset
3587 unquant_coeff = (int)( level * qscale * s->intra_matrix[j]) >> 3;
9be53be2d1a9 trellis quantization for mpeg1
michaelni
parents: 946
diff changeset
3588 unquant_coeff = (unquant_coeff - 1) | 1;
9be53be2d1a9 trellis quantization for mpeg1
michaelni
parents: 946
diff changeset
3589 }
9be53be2d1a9 trellis quantization for mpeg1
michaelni
parents: 946
diff changeset
3590 }else{
9be53be2d1a9 trellis quantization for mpeg1
michaelni
parents: 946
diff changeset
3591 if (level < 0) {
9be53be2d1a9 trellis quantization for mpeg1
michaelni
parents: 946
diff changeset
3592 unquant_coeff = ((((-level) << 1) + 1) * qscale * ((int) s->inter_matrix[j])) >> 4;
9be53be2d1a9 trellis quantization for mpeg1
michaelni
parents: 946
diff changeset
3593 unquant_coeff = -((unquant_coeff - 1) | 1);
9be53be2d1a9 trellis quantization for mpeg1
michaelni
parents: 946
diff changeset
3594 } else {
9be53be2d1a9 trellis quantization for mpeg1
michaelni
parents: 946
diff changeset
3595 unquant_coeff = ((( level << 1) + 1) * qscale * ((int) s->inter_matrix[j])) >> 4;
9be53be2d1a9 trellis quantization for mpeg1
michaelni
parents: 946
diff changeset
3596 unquant_coeff = (unquant_coeff - 1) | 1;
9be53be2d1a9 trellis quantization for mpeg1
michaelni
parents: 946
diff changeset
3597 }
9be53be2d1a9 trellis quantization for mpeg1
michaelni
parents: 946
diff changeset
3598 }
9be53be2d1a9 trellis quantization for mpeg1
michaelni
parents: 946
diff changeset
3599 unquant_coeff<<= 3;
9be53be2d1a9 trellis quantization for mpeg1
michaelni
parents: 946
diff changeset
3600 }
946
4f522c9e6099 more optimized trellis quantizer
michaelni
parents: 945
diff changeset
3601
945
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
3602 distoration= (unquant_coeff - dct_coeff) * (unquant_coeff - dct_coeff);
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
3603 level+=64;
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
3604 if((level&(~127)) == 0){
946
4f522c9e6099 more optimized trellis quantizer
michaelni
parents: 945
diff changeset
3605 for(run=0; run<=i - left_limit; run++){
947
9be53be2d1a9 trellis quantization for mpeg1
michaelni
parents: 946
diff changeset
3606 int score= distoration + length[UNI_AC_ENC_INDEX(run, level)]*lambda;
945
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
3607 score += score_tab[i-run];
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
3608
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
3609 if(score < best_score){
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
3610 best_score=
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
3611 score_tab[i+1]= score;
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
3612 run_tab[i+1]= run;
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
3613 level_tab[i+1]= level-64;
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
3614 }
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
3615 }
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
3616
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
3617 if(s->out_format == FMT_H263){
946
4f522c9e6099 more optimized trellis quantizer
michaelni
parents: 945
diff changeset
3618 for(run=0; run<=i - left_limit; run++){
947
9be53be2d1a9 trellis quantization for mpeg1
michaelni
parents: 946
diff changeset
3619 int score= distoration + last_length[UNI_AC_ENC_INDEX(run, level)]*lambda;
945
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
3620 score += score_tab[i-run];
946
4f522c9e6099 more optimized trellis quantizer
michaelni
parents: 945
diff changeset
3621 if(score < last_score){
4f522c9e6099 more optimized trellis quantizer
michaelni
parents: 945
diff changeset
3622 last_score= score;
4f522c9e6099 more optimized trellis quantizer
michaelni
parents: 945
diff changeset
3623 last_run= run;
4f522c9e6099 more optimized trellis quantizer
michaelni
parents: 945
diff changeset
3624 last_level= level-64;
4f522c9e6099 more optimized trellis quantizer
michaelni
parents: 945
diff changeset
3625 last_i= i+1;
945
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
3626 }
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
3627 }
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
3628 }
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
3629 }else{
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
3630 distoration += esc_length*lambda;
946
4f522c9e6099 more optimized trellis quantizer
michaelni
parents: 945
diff changeset
3631 for(run=0; run<=i - left_limit; run++){
945
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
3632 int score= distoration + score_tab[i-run];
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
3633
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
3634 if(score < best_score){
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
3635 best_score=
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
3636 score_tab[i+1]= score;
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
3637 run_tab[i+1]= run;
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
3638 level_tab[i+1]= level-64;
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
3639 }
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
3640 }
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
3641
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
3642 if(s->out_format == FMT_H263){
946
4f522c9e6099 more optimized trellis quantizer
michaelni
parents: 945
diff changeset
3643 for(run=0; run<=i - left_limit; run++){
945
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
3644 int score= distoration + score_tab[i-run];
946
4f522c9e6099 more optimized trellis quantizer
michaelni
parents: 945
diff changeset
3645 if(score < last_score){
4f522c9e6099 more optimized trellis quantizer
michaelni
parents: 945
diff changeset
3646 last_score= score;
4f522c9e6099 more optimized trellis quantizer
michaelni
parents: 945
diff changeset
3647 last_run= run;
4f522c9e6099 more optimized trellis quantizer
michaelni
parents: 945
diff changeset
3648 last_level= level-64;
4f522c9e6099 more optimized trellis quantizer
michaelni
parents: 945
diff changeset
3649 last_i= i+1;
945
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
3650 }
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
3651 }
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
3652 }
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
3653 }
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
3654 }
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
3655
946
4f522c9e6099 more optimized trellis quantizer
michaelni
parents: 945
diff changeset
3656 for(j=left_limit; j<=i; j++){
945
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
3657 score_tab[j] += zero_distoration;
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
3658 }
946
4f522c9e6099 more optimized trellis quantizer
michaelni
parents: 945
diff changeset
3659 score_limit+= zero_distoration;
4f522c9e6099 more optimized trellis quantizer
michaelni
parents: 945
diff changeset
3660 if(score_tab[i+1] < score_limit)
4f522c9e6099 more optimized trellis quantizer
michaelni
parents: 945
diff changeset
3661 score_limit= score_tab[i+1];
4f522c9e6099 more optimized trellis quantizer
michaelni
parents: 945
diff changeset
3662
4f522c9e6099 more optimized trellis quantizer
michaelni
parents: 945
diff changeset
3663 //Note: there is a vlc code in mpeg4 which is 1 bit shorter then another one with a shorter run and the same level
4f522c9e6099 more optimized trellis quantizer
michaelni
parents: 945
diff changeset
3664 while(score_tab[ left_limit ] > score_limit + lambda) left_limit++;
945
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
3665 }
946
4f522c9e6099 more optimized trellis quantizer
michaelni
parents: 945
diff changeset
3666
4f522c9e6099 more optimized trellis quantizer
michaelni
parents: 945
diff changeset
3667 //FIXME add some cbp penalty
4f522c9e6099 more optimized trellis quantizer
michaelni
parents: 945
diff changeset
3668
945
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
3669 if(s->out_format != FMT_H263){
946
4f522c9e6099 more optimized trellis quantizer
michaelni
parents: 945
diff changeset
3670 last_score= 256*256*256*120;
947
9be53be2d1a9 trellis quantization for mpeg1
michaelni
parents: 946
diff changeset
3671 for(i= left_limit; i<=last_non_zero - start_i + 1; i++){
946
4f522c9e6099 more optimized trellis quantizer
michaelni
parents: 945
diff changeset
3672 int score= score_tab[i];
947
9be53be2d1a9 trellis quantization for mpeg1
michaelni
parents: 946
diff changeset
3673 if(i) score += lambda*2; //FIXME exacter?
9be53be2d1a9 trellis quantization for mpeg1
michaelni
parents: 946
diff changeset
3674
946
4f522c9e6099 more optimized trellis quantizer
michaelni
parents: 945
diff changeset
3675 if(score < last_score){
4f522c9e6099 more optimized trellis quantizer
michaelni
parents: 945
diff changeset
3676 last_score= score;
4f522c9e6099 more optimized trellis quantizer
michaelni
parents: 945
diff changeset
3677 last_i= i;
4f522c9e6099 more optimized trellis quantizer
michaelni
parents: 945
diff changeset
3678 last_level= level_tab[i];
4f522c9e6099 more optimized trellis quantizer
michaelni
parents: 945
diff changeset
3679 last_run= run_tab[i];
4f522c9e6099 more optimized trellis quantizer
michaelni
parents: 945
diff changeset
3680 }
945
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
3681 }
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
3682 }
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
3683
946
4f522c9e6099 more optimized trellis quantizer
michaelni
parents: 945
diff changeset
3684 last_non_zero= last_i - 1 + start_i;
945
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
3685 memset(block + start_i, 0, (64-start_i)*sizeof(DCTELEM));
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
3686
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
3687 if(last_non_zero < start_i)
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
3688 return last_non_zero;
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
3689
946
4f522c9e6099 more optimized trellis quantizer
michaelni
parents: 945
diff changeset
3690 i= last_i;
4f522c9e6099 more optimized trellis quantizer
michaelni
parents: 945
diff changeset
3691 assert(last_level);
945
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
3692 //FIXME use permutated scantable
1092
f59c3f66363b MpegEncContext.(i)dct_* -> DspContext.(i)dct_*
michaelni
parents: 1089
diff changeset
3693 block[ s->dsp.idct_permutation[ scantable[last_non_zero] ] ]= last_level;
946
4f522c9e6099 more optimized trellis quantizer
michaelni
parents: 945
diff changeset
3694 i -= last_run + 1;
945
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
3695
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
3696 for(;i>0 ; i -= run_tab[i] + 1){
1092
f59c3f66363b MpegEncContext.(i)dct_* -> DspContext.(i)dct_*
michaelni
parents: 1089
diff changeset
3697 const int j= s->dsp.idct_permutation[ scantable[i - 1 + start_i] ];
945
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
3698
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
3699 block[j]= level_tab[i];
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
3700 assert(block[j]);
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
3701 }
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
3702
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
3703 return last_non_zero;
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
3704 }
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
3705
220
0b234715e205 (commit by michael)
arpi_esp
parents: 217
diff changeset
3706 static int dct_quantize_c(MpegEncContext *s,
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3707 DCTELEM *block, int n,
344
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
3708 int qscale, int *overflow)
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3709 {
986e461dc072 Initial revision
glantau
parents:
diff changeset
3710 int i, j, level, last_non_zero, q;
986e461dc072 Initial revision
glantau
parents:
diff changeset
3711 const int *qmat;
1064
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1059
diff changeset
3712 const uint8_t *scantable= s->intra_scantable.scantable;
344
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
3713 int bias;
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
3714 int max=0;
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
3715 unsigned int threshold1, threshold2;
828
ace3ccd18dd2 Altivec Patch (Mark III) by (Dieter Shirley <dieters at schemasoft dot com>)
michaelni
parents: 815
diff changeset
3716
1092
f59c3f66363b MpegEncContext.(i)dct_* -> DspContext.(i)dct_*
michaelni
parents: 1089
diff changeset
3717 s->dsp.fdct (block);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3718
986e461dc072 Initial revision
glantau
parents:
diff changeset
3719 if (s->mb_intra) {
350
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 347
diff changeset
3720 if (!s->h263_aic) {
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 347
diff changeset
3721 if (n < 4)
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 347
diff changeset
3722 q = s->y_dc_scale;
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 347
diff changeset
3723 else
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 347
diff changeset
3724 q = s->c_dc_scale;
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 347
diff changeset
3725 q = q << 3;
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 347
diff changeset
3726 } else
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 347
diff changeset
3727 /* 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
3728 q = 1 << 3;
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 347
diff changeset
3729
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3730 /* note: block[0] is assumed to be positive */
986e461dc072 Initial revision
glantau
parents:
diff changeset
3731 block[0] = (block[0] + (q >> 1)) / q;
986e461dc072 Initial revision
glantau
parents:
diff changeset
3732 i = 1;
986e461dc072 Initial revision
glantau
parents:
diff changeset
3733 last_non_zero = 0;
344
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
3734 qmat = s->q_intra_matrix[qscale];
635
3e0f62e5eed6 dct cleanup
michaelni
parents: 628
diff changeset
3735 bias= s->intra_quant_bias<<(QMAT_SHIFT - QUANT_BIAS_SHIFT);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3736 } else {
986e461dc072 Initial revision
glantau
parents:
diff changeset
3737 i = 0;
986e461dc072 Initial revision
glantau
parents:
diff changeset
3738 last_non_zero = -1;
344
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
3739 qmat = s->q_inter_matrix[qscale];
635
3e0f62e5eed6 dct cleanup
michaelni
parents: 628
diff changeset
3740 bias= s->inter_quant_bias<<(QMAT_SHIFT - QUANT_BIAS_SHIFT);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3741 }
635
3e0f62e5eed6 dct cleanup
michaelni
parents: 628
diff changeset
3742 threshold1= (1<<QMAT_SHIFT) - bias - 1;
3e0f62e5eed6 dct cleanup
michaelni
parents: 628
diff changeset
3743 threshold2= (threshold1<<1);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3744
986e461dc072 Initial revision
glantau
parents:
diff changeset
3745 for(;i<64;i++) {
764
d4726182dfd2 optimize block_permute()
michaelni
parents: 763
diff changeset
3746 j = scantable[i];
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3747 level = block[j];
986e461dc072 Initial revision
glantau
parents:
diff changeset
3748 level = level * qmat[j];
344
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
3749
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
3750 // if( bias+level >= (1<<(QMAT_SHIFT - 3))
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
3751 // || bias-level >= (1<<(QMAT_SHIFT - 3))){
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
3752 if(((unsigned)(level+threshold1))>threshold2){
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
3753 if(level>0){
635
3e0f62e5eed6 dct cleanup
michaelni
parents: 628
diff changeset
3754 level= (bias + level)>>QMAT_SHIFT;
344
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
3755 block[j]= level;
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
3756 }else{
635
3e0f62e5eed6 dct cleanup
michaelni
parents: 628
diff changeset
3757 level= (bias - level)>>QMAT_SHIFT;
344
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
3758 block[j]= -level;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3759 }
344
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
3760 max |=level;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3761 last_non_zero = i;
344
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
3762 }else{
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
3763 block[j]=0;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3764 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
3765 }
344
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
3766 *overflow= s->max_qcoeff < max; //overflow might have happend
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
3767
764
d4726182dfd2 optimize block_permute()
michaelni
parents: 763
diff changeset
3768 /* we need this permutation so that we correct the IDCT, we only permute the !=0 elements */
1092
f59c3f66363b MpegEncContext.(i)dct_* -> DspContext.(i)dct_*
michaelni
parents: 1089
diff changeset
3769 if (s->dsp.idct_permutation_type != FF_NO_IDCT_PERM)
f59c3f66363b MpegEncContext.(i)dct_* -> DspContext.(i)dct_*
michaelni
parents: 1089
diff changeset
3770 ff_block_permute(block, s->dsp.idct_permutation, scantable, last_non_zero);
764
d4726182dfd2 optimize block_permute()
michaelni
parents: 763
diff changeset
3771
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3772 return last_non_zero;
986e461dc072 Initial revision
glantau
parents:
diff changeset
3773 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
3774
1070
6da5ae9ee199 more #ifdef CONFIG_ENCODERS patch by (Wolfgang Hesseler <qv at multimediaware dot com>) with modifications by me (s/WOLFGANG/CONFIG_ENCODERS/ and some other fixes)
michaelni
parents: 1064
diff changeset
3775 #endif //CONFIG_ENCODERS
6da5ae9ee199 more #ifdef CONFIG_ENCODERS patch by (Wolfgang Hesseler <qv at multimediaware dot com>) with modifications by me (s/WOLFGANG/CONFIG_ENCODERS/ and some other fixes)
michaelni
parents: 1064
diff changeset
3776
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
3777 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
3778 DCTELEM *block, int n, int qscale)
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3779 {
200
6ab301aaa652 (commit by michael)
arpi_esp
parents: 198
diff changeset
3780 int i, level, nCoeffs;
1064
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1059
diff changeset
3781 const uint16_t *quant_matrix;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3782
706
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 704
diff changeset
3783 nCoeffs= s->block_last_index[n];
200
6ab301aaa652 (commit by michael)
arpi_esp
parents: 198
diff changeset
3784
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3785 if (s->mb_intra) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
3786 if (n < 4)
986e461dc072 Initial revision
glantau
parents:
diff changeset
3787 block[0] = block[0] * s->y_dc_scale;
986e461dc072 Initial revision
glantau
parents:
diff changeset
3788 else
986e461dc072 Initial revision
glantau
parents:
diff changeset
3789 block[0] = block[0] * s->c_dc_scale;
986e461dc072 Initial revision
glantau
parents:
diff changeset
3790 /* XXX: only mpeg1 */
986e461dc072 Initial revision
glantau
parents:
diff changeset
3791 quant_matrix = s->intra_matrix;
706
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 704
diff changeset
3792 for(i=1;i<=nCoeffs;i++) {
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 704
diff changeset
3793 int j= s->intra_scantable.permutated[i];
200
6ab301aaa652 (commit by michael)
arpi_esp
parents: 198
diff changeset
3794 level = block[j];
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3795 if (level) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
3796 if (level < 0) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
3797 level = -level;
200
6ab301aaa652 (commit by michael)
arpi_esp
parents: 198
diff changeset
3798 level = (int)(level * qscale * quant_matrix[j]) >> 3;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3799 level = (level - 1) | 1;
986e461dc072 Initial revision
glantau
parents:
diff changeset
3800 level = -level;
986e461dc072 Initial revision
glantau
parents:
diff changeset
3801 } else {
200
6ab301aaa652 (commit by michael)
arpi_esp
parents: 198
diff changeset
3802 level = (int)(level * qscale * quant_matrix[j]) >> 3;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3803 level = (level - 1) | 1;
986e461dc072 Initial revision
glantau
parents:
diff changeset
3804 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
3805 #ifdef PARANOID
986e461dc072 Initial revision
glantau
parents:
diff changeset
3806 if (level < -2048 || level > 2047)
986e461dc072 Initial revision
glantau
parents:
diff changeset
3807 fprintf(stderr, "unquant error %d %d\n", i, level);
986e461dc072 Initial revision
glantau
parents:
diff changeset
3808 #endif
200
6ab301aaa652 (commit by michael)
arpi_esp
parents: 198
diff changeset
3809 block[j] = level;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3810 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
3811 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
3812 } else {
986e461dc072 Initial revision
glantau
parents:
diff changeset
3813 i = 0;
344
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
3814 quant_matrix = s->inter_matrix;
706
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 704
diff changeset
3815 for(;i<=nCoeffs;i++) {
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 704
diff changeset
3816 int j= s->intra_scantable.permutated[i];
200
6ab301aaa652 (commit by michael)
arpi_esp
parents: 198
diff changeset
3817 level = block[j];
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3818 if (level) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
3819 if (level < 0) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
3820 level = -level;
986e461dc072 Initial revision
glantau
parents:
diff changeset
3821 level = (((level << 1) + 1) * qscale *
200
6ab301aaa652 (commit by michael)
arpi_esp
parents: 198
diff changeset
3822 ((int) (quant_matrix[j]))) >> 4;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3823 level = (level - 1) | 1;
986e461dc072 Initial revision
glantau
parents:
diff changeset
3824 level = -level;
986e461dc072 Initial revision
glantau
parents:
diff changeset
3825 } else {
986e461dc072 Initial revision
glantau
parents:
diff changeset
3826 level = (((level << 1) + 1) * qscale *
200
6ab301aaa652 (commit by michael)
arpi_esp
parents: 198
diff changeset
3827 ((int) (quant_matrix[j]))) >> 4;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3828 level = (level - 1) | 1;
986e461dc072 Initial revision
glantau
parents:
diff changeset
3829 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
3830 #ifdef PARANOID
986e461dc072 Initial revision
glantau
parents:
diff changeset
3831 if (level < -2048 || level > 2047)
986e461dc072 Initial revision
glantau
parents:
diff changeset
3832 fprintf(stderr, "unquant error %d %d\n", i, level);
986e461dc072 Initial revision
glantau
parents:
diff changeset
3833 #endif
200
6ab301aaa652 (commit by michael)
arpi_esp
parents: 198
diff changeset
3834 block[j] = level;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3835 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
3836 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
3837 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
3838 }
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
3839
325
15efd80cf51e mpeg2/mpeg4 dequantizer support (c & mmx)
michaelni
parents: 324
diff changeset
3840 static void dct_unquantize_mpeg2_c(MpegEncContext *s,
15efd80cf51e mpeg2/mpeg4 dequantizer support (c & mmx)
michaelni
parents: 324
diff changeset
3841 DCTELEM *block, int n, int qscale)
15efd80cf51e mpeg2/mpeg4 dequantizer support (c & mmx)
michaelni
parents: 324
diff changeset
3842 {
15efd80cf51e mpeg2/mpeg4 dequantizer support (c & mmx)
michaelni
parents: 324
diff changeset
3843 int i, level, nCoeffs;
1064
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1059
diff changeset
3844 const uint16_t *quant_matrix;
325
15efd80cf51e mpeg2/mpeg4 dequantizer support (c & mmx)
michaelni
parents: 324
diff changeset
3845
706
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 704
diff changeset
3846 if(s->alternate_scan) nCoeffs= 63;
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 704
diff changeset
3847 else nCoeffs= s->block_last_index[n];
325
15efd80cf51e mpeg2/mpeg4 dequantizer support (c & mmx)
michaelni
parents: 324
diff changeset
3848
15efd80cf51e mpeg2/mpeg4 dequantizer support (c & mmx)
michaelni
parents: 324
diff changeset
3849 if (s->mb_intra) {
15efd80cf51e mpeg2/mpeg4 dequantizer support (c & mmx)
michaelni
parents: 324
diff changeset
3850 if (n < 4)
15efd80cf51e mpeg2/mpeg4 dequantizer support (c & mmx)
michaelni
parents: 324
diff changeset
3851 block[0] = block[0] * s->y_dc_scale;
15efd80cf51e mpeg2/mpeg4 dequantizer support (c & mmx)
michaelni
parents: 324
diff changeset
3852 else
15efd80cf51e mpeg2/mpeg4 dequantizer support (c & mmx)
michaelni
parents: 324
diff changeset
3853 block[0] = block[0] * s->c_dc_scale;
15efd80cf51e mpeg2/mpeg4 dequantizer support (c & mmx)
michaelni
parents: 324
diff changeset
3854 quant_matrix = s->intra_matrix;
706
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 704
diff changeset
3855 for(i=1;i<=nCoeffs;i++) {
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 704
diff changeset
3856 int j= s->intra_scantable.permutated[i];
325
15efd80cf51e mpeg2/mpeg4 dequantizer support (c & mmx)
michaelni
parents: 324
diff changeset
3857 level = block[j];
15efd80cf51e mpeg2/mpeg4 dequantizer support (c & mmx)
michaelni
parents: 324
diff changeset
3858 if (level) {
15efd80cf51e mpeg2/mpeg4 dequantizer support (c & mmx)
michaelni
parents: 324
diff changeset
3859 if (level < 0) {
15efd80cf51e mpeg2/mpeg4 dequantizer support (c & mmx)
michaelni
parents: 324
diff changeset
3860 level = -level;
15efd80cf51e mpeg2/mpeg4 dequantizer support (c & mmx)
michaelni
parents: 324
diff changeset
3861 level = (int)(level * qscale * quant_matrix[j]) >> 3;
15efd80cf51e mpeg2/mpeg4 dequantizer support (c & mmx)
michaelni
parents: 324
diff changeset
3862 level = -level;
15efd80cf51e mpeg2/mpeg4 dequantizer support (c & mmx)
michaelni
parents: 324
diff changeset
3863 } else {
15efd80cf51e mpeg2/mpeg4 dequantizer support (c & mmx)
michaelni
parents: 324
diff changeset
3864 level = (int)(level * qscale * quant_matrix[j]) >> 3;
15efd80cf51e mpeg2/mpeg4 dequantizer support (c & mmx)
michaelni
parents: 324
diff changeset
3865 }
15efd80cf51e mpeg2/mpeg4 dequantizer support (c & mmx)
michaelni
parents: 324
diff changeset
3866 #ifdef PARANOID
15efd80cf51e mpeg2/mpeg4 dequantizer support (c & mmx)
michaelni
parents: 324
diff changeset
3867 if (level < -2048 || level > 2047)
15efd80cf51e mpeg2/mpeg4 dequantizer support (c & mmx)
michaelni
parents: 324
diff changeset
3868 fprintf(stderr, "unquant error %d %d\n", i, level);
15efd80cf51e mpeg2/mpeg4 dequantizer support (c & mmx)
michaelni
parents: 324
diff changeset
3869 #endif
15efd80cf51e mpeg2/mpeg4 dequantizer support (c & mmx)
michaelni
parents: 324
diff changeset
3870 block[j] = level;
15efd80cf51e mpeg2/mpeg4 dequantizer support (c & mmx)
michaelni
parents: 324
diff changeset
3871 }
15efd80cf51e mpeg2/mpeg4 dequantizer support (c & mmx)
michaelni
parents: 324
diff changeset
3872 }
15efd80cf51e mpeg2/mpeg4 dequantizer support (c & mmx)
michaelni
parents: 324
diff changeset
3873 } else {
15efd80cf51e mpeg2/mpeg4 dequantizer support (c & mmx)
michaelni
parents: 324
diff changeset
3874 int sum=-1;
15efd80cf51e mpeg2/mpeg4 dequantizer support (c & mmx)
michaelni
parents: 324
diff changeset
3875 i = 0;
344
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
3876 quant_matrix = s->inter_matrix;
706
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 704
diff changeset
3877 for(;i<=nCoeffs;i++) {
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 704
diff changeset
3878 int j= s->intra_scantable.permutated[i];
325
15efd80cf51e mpeg2/mpeg4 dequantizer support (c & mmx)
michaelni
parents: 324
diff changeset
3879 level = block[j];
15efd80cf51e mpeg2/mpeg4 dequantizer support (c & mmx)
michaelni
parents: 324
diff changeset
3880 if (level) {
15efd80cf51e mpeg2/mpeg4 dequantizer support (c & mmx)
michaelni
parents: 324
diff changeset
3881 if (level < 0) {
15efd80cf51e mpeg2/mpeg4 dequantizer support (c & mmx)
michaelni
parents: 324
diff changeset
3882 level = -level;
15efd80cf51e mpeg2/mpeg4 dequantizer support (c & mmx)
michaelni
parents: 324
diff changeset
3883 level = (((level << 1) + 1) * qscale *
15efd80cf51e mpeg2/mpeg4 dequantizer support (c & mmx)
michaelni
parents: 324
diff changeset
3884 ((int) (quant_matrix[j]))) >> 4;
15efd80cf51e mpeg2/mpeg4 dequantizer support (c & mmx)
michaelni
parents: 324
diff changeset
3885 level = -level;
15efd80cf51e mpeg2/mpeg4 dequantizer support (c & mmx)
michaelni
parents: 324
diff changeset
3886 } else {
15efd80cf51e mpeg2/mpeg4 dequantizer support (c & mmx)
michaelni
parents: 324
diff changeset
3887 level = (((level << 1) + 1) * qscale *
15efd80cf51e mpeg2/mpeg4 dequantizer support (c & mmx)
michaelni
parents: 324
diff changeset
3888 ((int) (quant_matrix[j]))) >> 4;
15efd80cf51e mpeg2/mpeg4 dequantizer support (c & mmx)
michaelni
parents: 324
diff changeset
3889 }
15efd80cf51e mpeg2/mpeg4 dequantizer support (c & mmx)
michaelni
parents: 324
diff changeset
3890 #ifdef PARANOID
15efd80cf51e mpeg2/mpeg4 dequantizer support (c & mmx)
michaelni
parents: 324
diff changeset
3891 if (level < -2048 || level > 2047)
15efd80cf51e mpeg2/mpeg4 dequantizer support (c & mmx)
michaelni
parents: 324
diff changeset
3892 fprintf(stderr, "unquant error %d %d\n", i, level);
15efd80cf51e mpeg2/mpeg4 dequantizer support (c & mmx)
michaelni
parents: 324
diff changeset
3893 #endif
15efd80cf51e mpeg2/mpeg4 dequantizer support (c & mmx)
michaelni
parents: 324
diff changeset
3894 block[j] = level;
15efd80cf51e mpeg2/mpeg4 dequantizer support (c & mmx)
michaelni
parents: 324
diff changeset
3895 sum+=level;
15efd80cf51e mpeg2/mpeg4 dequantizer support (c & mmx)
michaelni
parents: 324
diff changeset
3896 }
15efd80cf51e mpeg2/mpeg4 dequantizer support (c & mmx)
michaelni
parents: 324
diff changeset
3897 }
15efd80cf51e mpeg2/mpeg4 dequantizer support (c & mmx)
michaelni
parents: 324
diff changeset
3898 block[63]^=sum&1;
15efd80cf51e mpeg2/mpeg4 dequantizer support (c & mmx)
michaelni
parents: 324
diff changeset
3899 }
15efd80cf51e mpeg2/mpeg4 dequantizer support (c & mmx)
michaelni
parents: 324
diff changeset
3900 }
15efd80cf51e mpeg2/mpeg4 dequantizer support (c & mmx)
michaelni
parents: 324
diff changeset
3901
15efd80cf51e mpeg2/mpeg4 dequantizer support (c & mmx)
michaelni
parents: 324
diff changeset
3902
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
3903 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
3904 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
3905 {
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
3906 int i, level, qmul, qadd;
200
6ab301aaa652 (commit by michael)
arpi_esp
parents: 198
diff changeset
3907 int nCoeffs;
249
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
3908
706
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 704
diff changeset
3909 assert(s->block_last_index[n]>=0);
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 704
diff changeset
3910
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 704
diff changeset
3911 qadd = (qscale - 1) | 1;
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 704
diff changeset
3912 qmul = qscale << 1;
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 704
diff changeset
3913
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
3914 if (s->mb_intra) {
249
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
3915 if (!s->h263_aic) {
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
3916 if (n < 4)
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
3917 block[0] = block[0] * s->y_dc_scale;
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
3918 else
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
3919 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
3920 }else
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 704
diff changeset
3921 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
3922 i = 1;
706
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 704
diff changeset
3923 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
3924 } 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
3925 i = 0;
1094
0ed00edd4d74 typo (fixes wmv1 regression test in c)
michaelni
parents: 1092
diff changeset
3926 nCoeffs= s->inter_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
3927 }
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
3928
706
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 704
diff changeset
3929 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
3930 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
3931 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
3932 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
3933 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
3934 } 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
3935 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
3936 }
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
3937 #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
3938 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
3939 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
3940 #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
3941 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
3942 }
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
3943 }
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
3944 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3945
1070
6da5ae9ee199 more #ifdef CONFIG_ENCODERS patch by (Wolfgang Hesseler <qv at multimediaware dot com>) with modifications by me (s/WOLFGANG/CONFIG_ENCODERS/ and some other fixes)
michaelni
parents: 1064
diff changeset
3946
930
6bcb214d6a17 more debug output
michaelni
parents: 925
diff changeset
3947 char ff_get_pict_type_char(int pict_type){
6bcb214d6a17 more debug output
michaelni
parents: 925
diff changeset
3948 switch(pict_type){
6bcb214d6a17 more debug output
michaelni
parents: 925
diff changeset
3949 case I_TYPE: return 'I';
6bcb214d6a17 more debug output
michaelni
parents: 925
diff changeset
3950 case P_TYPE: return 'P';
6bcb214d6a17 more debug output
michaelni
parents: 925
diff changeset
3951 case B_TYPE: return 'B';
6bcb214d6a17 more debug output
michaelni
parents: 925
diff changeset
3952 case S_TYPE: return 'S';
936
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
3953 default: return '?';
930
6bcb214d6a17 more debug output
michaelni
parents: 925
diff changeset
3954 }
6bcb214d6a17 more debug output
michaelni
parents: 925
diff changeset
3955 }
6bcb214d6a17 more debug output
michaelni
parents: 925
diff changeset
3956
1059
890b9fb44e84 * still unfinished code for Options
kabi
parents: 1051
diff changeset
3957 extern const AVOption common_options[2];
890b9fb44e84 * still unfinished code for Options
kabi
parents: 1051
diff changeset
3958 static const AVOption mpeg4_options[] =
890b9fb44e84 * still unfinished code for Options
kabi
parents: 1051
diff changeset
3959 {
890b9fb44e84 * still unfinished code for Options
kabi
parents: 1051
diff changeset
3960 AVOPTION_CODEC_INT("bitrate", "desired video bitrate", bit_rate, 4, 240000000, 800000),
890b9fb44e84 * still unfinished code for Options
kabi
parents: 1051
diff changeset
3961 AVOPTION_CODEC_FLAG("vhq", "very high quality", flags, CODEC_FLAG_HQ, 0),
890b9fb44e84 * still unfinished code for Options
kabi
parents: 1051
diff changeset
3962 AVOPTION_CODEC_INT("ratetol", "number of bits the bitstream is allowed to diverge from the reference"
890b9fb44e84 * still unfinished code for Options
kabi
parents: 1051
diff changeset
3963 "the reference can be CBR (for CBR pass1) or VBR (for pass2)",
890b9fb44e84 * still unfinished code for Options
kabi
parents: 1051
diff changeset
3964 bit_rate_tolerance, 4, 240000000, 8000),
890b9fb44e84 * still unfinished code for Options
kabi
parents: 1051
diff changeset
3965 AVOPTION_CODEC_INT("qmin", "minimum quantizer", qmin, 1, 31, 2),
890b9fb44e84 * still unfinished code for Options
kabi
parents: 1051
diff changeset
3966 AVOPTION_CODEC_INT("qmax", "maximum quantizer", qmax, 1, 31, 31),
890b9fb44e84 * still unfinished code for Options
kabi
parents: 1051
diff changeset
3967 AVOPTION_CODEC_STRING("rc_eq", "rate control equation",
890b9fb44e84 * still unfinished code for Options
kabi
parents: 1051
diff changeset
3968 rc_eq, "tex^qComp,option1,options2", 0),
890b9fb44e84 * still unfinished code for Options
kabi
parents: 1051
diff changeset
3969 AVOPTION_CODEC_INT("rc_minrate", "rate control minimum bitrate",
890b9fb44e84 * still unfinished code for Options
kabi
parents: 1051
diff changeset
3970 rc_min_rate, 4, 24000000, 0),
890b9fb44e84 * still unfinished code for Options
kabi
parents: 1051
diff changeset
3971 AVOPTION_CODEC_INT("rc_maxrate", "rate control maximum bitrate",
890b9fb44e84 * still unfinished code for Options
kabi
parents: 1051
diff changeset
3972 rc_max_rate, 4, 24000000, 0),
890b9fb44e84 * still unfinished code for Options
kabi
parents: 1051
diff changeset
3973 AVOPTION_CODEC_FLAG("psnr", "calculate PSNR of compressed frames",
890b9fb44e84 * still unfinished code for Options
kabi
parents: 1051
diff changeset
3974 flags, CODEC_FLAG_PSNR, 0),
890b9fb44e84 * still unfinished code for Options
kabi
parents: 1051
diff changeset
3975 AVOPTION_CODEC_RCOVERRIDE("rc_override", "ratecontrol override (=startframe,endframe,qscale,quality_factor)",
890b9fb44e84 * still unfinished code for Options
kabi
parents: 1051
diff changeset
3976 rc_override),
890b9fb44e84 * still unfinished code for Options
kabi
parents: 1051
diff changeset
3977 AVOPTION_SUB(common_options),
890b9fb44e84 * still unfinished code for Options
kabi
parents: 1051
diff changeset
3978 AVOPTION_END()
890b9fb44e84 * still unfinished code for Options
kabi
parents: 1051
diff changeset
3979 };
890b9fb44e84 * still unfinished code for Options
kabi
parents: 1051
diff changeset
3980
1070
6da5ae9ee199 more #ifdef CONFIG_ENCODERS patch by (Wolfgang Hesseler <qv at multimediaware dot com>) with modifications by me (s/WOLFGANG/CONFIG_ENCODERS/ and some other fixes)
michaelni
parents: 1064
diff changeset
3981 #ifdef CONFIG_ENCODERS
6da5ae9ee199 more #ifdef CONFIG_ENCODERS patch by (Wolfgang Hesseler <qv at multimediaware dot com>) with modifications by me (s/WOLFGANG/CONFIG_ENCODERS/ and some other fixes)
michaelni
parents: 1064
diff changeset
3982
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3983 AVCodec mpeg1video_encoder = {
986e461dc072 Initial revision
glantau
parents:
diff changeset
3984 "mpeg1video",
986e461dc072 Initial revision
glantau
parents:
diff changeset
3985 CODEC_TYPE_VIDEO,
986e461dc072 Initial revision
glantau
parents:
diff changeset
3986 CODEC_ID_MPEG1VIDEO,
986e461dc072 Initial revision
glantau
parents:
diff changeset
3987 sizeof(MpegEncContext),
986e461dc072 Initial revision
glantau
parents:
diff changeset
3988 MPV_encode_init,
986e461dc072 Initial revision
glantau
parents:
diff changeset
3989 MPV_encode_picture,
986e461dc072 Initial revision
glantau
parents:
diff changeset
3990 MPV_encode_end,
986e461dc072 Initial revision
glantau
parents:
diff changeset
3991 };
986e461dc072 Initial revision
glantau
parents:
diff changeset
3992
1042
a78f6f72d54e --disable-risky support
michaelni
parents: 1026
diff changeset
3993 #ifdef CONFIG_RISKY
a78f6f72d54e --disable-risky support
michaelni
parents: 1026
diff changeset
3994
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3995 AVCodec h263_encoder = {
986e461dc072 Initial revision
glantau
parents:
diff changeset
3996 "h263",
986e461dc072 Initial revision
glantau
parents:
diff changeset
3997 CODEC_TYPE_VIDEO,
986e461dc072 Initial revision
glantau
parents:
diff changeset
3998 CODEC_ID_H263,
986e461dc072 Initial revision
glantau
parents:
diff changeset
3999 sizeof(MpegEncContext),
986e461dc072 Initial revision
glantau
parents:
diff changeset
4000 MPV_encode_init,
986e461dc072 Initial revision
glantau
parents:
diff changeset
4001 MPV_encode_picture,
986e461dc072 Initial revision
glantau
parents:
diff changeset
4002 MPV_encode_end,
986e461dc072 Initial revision
glantau
parents:
diff changeset
4003 };
986e461dc072 Initial revision
glantau
parents:
diff changeset
4004
986e461dc072 Initial revision
glantau
parents:
diff changeset
4005 AVCodec h263p_encoder = {
986e461dc072 Initial revision
glantau
parents:
diff changeset
4006 "h263p",
986e461dc072 Initial revision
glantau
parents:
diff changeset
4007 CODEC_TYPE_VIDEO,
986e461dc072 Initial revision
glantau
parents:
diff changeset
4008 CODEC_ID_H263P,
986e461dc072 Initial revision
glantau
parents:
diff changeset
4009 sizeof(MpegEncContext),
986e461dc072 Initial revision
glantau
parents:
diff changeset
4010 MPV_encode_init,
986e461dc072 Initial revision
glantau
parents:
diff changeset
4011 MPV_encode_picture,
986e461dc072 Initial revision
glantau
parents:
diff changeset
4012 MPV_encode_end,
986e461dc072 Initial revision
glantau
parents:
diff changeset
4013 };
986e461dc072 Initial revision
glantau
parents:
diff changeset
4014
986e461dc072 Initial revision
glantau
parents:
diff changeset
4015 AVCodec rv10_encoder = {
986e461dc072 Initial revision
glantau
parents:
diff changeset
4016 "rv10",
986e461dc072 Initial revision
glantau
parents:
diff changeset
4017 CODEC_TYPE_VIDEO,
986e461dc072 Initial revision
glantau
parents:
diff changeset
4018 CODEC_ID_RV10,
986e461dc072 Initial revision
glantau
parents:
diff changeset
4019 sizeof(MpegEncContext),
986e461dc072 Initial revision
glantau
parents:
diff changeset
4020 MPV_encode_init,
986e461dc072 Initial revision
glantau
parents:
diff changeset
4021 MPV_encode_picture,
986e461dc072 Initial revision
glantau
parents:
diff changeset
4022 MPV_encode_end,
986e461dc072 Initial revision
glantau
parents:
diff changeset
4023 };
986e461dc072 Initial revision
glantau
parents:
diff changeset
4024
71
79be2c581c01 changed opendivx to mpeg4
glantau
parents: 64
diff changeset
4025 AVCodec mpeg4_encoder = {
79be2c581c01 changed opendivx to mpeg4
glantau
parents: 64
diff changeset
4026 "mpeg4",
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4027 CODEC_TYPE_VIDEO,
71
79be2c581c01 changed opendivx to mpeg4
glantau
parents: 64
diff changeset
4028 CODEC_ID_MPEG4,
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4029 sizeof(MpegEncContext),
986e461dc072 Initial revision
glantau
parents:
diff changeset
4030 MPV_encode_init,
986e461dc072 Initial revision
glantau
parents:
diff changeset
4031 MPV_encode_picture,
986e461dc072 Initial revision
glantau
parents:
diff changeset
4032 MPV_encode_end,
1059
890b9fb44e84 * still unfinished code for Options
kabi
parents: 1051
diff changeset
4033 .options = mpeg4_options,
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4034 };
986e461dc072 Initial revision
glantau
parents:
diff changeset
4035
307
764aeec1320e msmpeg4v2 decoding (no encoding yet)
michaelni
parents: 302
diff changeset
4036 AVCodec msmpeg4v1_encoder = {
764aeec1320e msmpeg4v2 decoding (no encoding yet)
michaelni
parents: 302
diff changeset
4037 "msmpeg4v1",
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4038 CODEC_TYPE_VIDEO,
307
764aeec1320e msmpeg4v2 decoding (no encoding yet)
michaelni
parents: 302
diff changeset
4039 CODEC_ID_MSMPEG4V1,
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4040 sizeof(MpegEncContext),
986e461dc072 Initial revision
glantau
parents:
diff changeset
4041 MPV_encode_init,
986e461dc072 Initial revision
glantau
parents:
diff changeset
4042 MPV_encode_picture,
986e461dc072 Initial revision
glantau
parents:
diff changeset
4043 MPV_encode_end,
986e461dc072 Initial revision
glantau
parents:
diff changeset
4044 };
307
764aeec1320e msmpeg4v2 decoding (no encoding yet)
michaelni
parents: 302
diff changeset
4045
764aeec1320e msmpeg4v2 decoding (no encoding yet)
michaelni
parents: 302
diff changeset
4046 AVCodec msmpeg4v2_encoder = {
764aeec1320e msmpeg4v2 decoding (no encoding yet)
michaelni
parents: 302
diff changeset
4047 "msmpeg4v2",
764aeec1320e msmpeg4v2 decoding (no encoding yet)
michaelni
parents: 302
diff changeset
4048 CODEC_TYPE_VIDEO,
764aeec1320e msmpeg4v2 decoding (no encoding yet)
michaelni
parents: 302
diff changeset
4049 CODEC_ID_MSMPEG4V2,
764aeec1320e msmpeg4v2 decoding (no encoding yet)
michaelni
parents: 302
diff changeset
4050 sizeof(MpegEncContext),
764aeec1320e msmpeg4v2 decoding (no encoding yet)
michaelni
parents: 302
diff changeset
4051 MPV_encode_init,
764aeec1320e msmpeg4v2 decoding (no encoding yet)
michaelni
parents: 302
diff changeset
4052 MPV_encode_picture,
764aeec1320e msmpeg4v2 decoding (no encoding yet)
michaelni
parents: 302
diff changeset
4053 MPV_encode_end,
764aeec1320e msmpeg4v2 decoding (no encoding yet)
michaelni
parents: 302
diff changeset
4054 };
764aeec1320e msmpeg4v2 decoding (no encoding yet)
michaelni
parents: 302
diff changeset
4055
764aeec1320e msmpeg4v2 decoding (no encoding yet)
michaelni
parents: 302
diff changeset
4056 AVCodec msmpeg4v3_encoder = {
764aeec1320e msmpeg4v2 decoding (no encoding yet)
michaelni
parents: 302
diff changeset
4057 "msmpeg4",
764aeec1320e msmpeg4v2 decoding (no encoding yet)
michaelni
parents: 302
diff changeset
4058 CODEC_TYPE_VIDEO,
764aeec1320e msmpeg4v2 decoding (no encoding yet)
michaelni
parents: 302
diff changeset
4059 CODEC_ID_MSMPEG4V3,
764aeec1320e msmpeg4v2 decoding (no encoding yet)
michaelni
parents: 302
diff changeset
4060 sizeof(MpegEncContext),
764aeec1320e msmpeg4v2 decoding (no encoding yet)
michaelni
parents: 302
diff changeset
4061 MPV_encode_init,
764aeec1320e msmpeg4v2 decoding (no encoding yet)
michaelni
parents: 302
diff changeset
4062 MPV_encode_picture,
764aeec1320e msmpeg4v2 decoding (no encoding yet)
michaelni
parents: 302
diff changeset
4063 MPV_encode_end,
764aeec1320e msmpeg4v2 decoding (no encoding yet)
michaelni
parents: 302
diff changeset
4064 };
499
8b7a54d58549 wmv1 support
michaelni
parents: 487
diff changeset
4065
8b7a54d58549 wmv1 support
michaelni
parents: 487
diff changeset
4066 AVCodec wmv1_encoder = {
8b7a54d58549 wmv1 support
michaelni
parents: 487
diff changeset
4067 "wmv1",
8b7a54d58549 wmv1 support
michaelni
parents: 487
diff changeset
4068 CODEC_TYPE_VIDEO,
8b7a54d58549 wmv1 support
michaelni
parents: 487
diff changeset
4069 CODEC_ID_WMV1,
8b7a54d58549 wmv1 support
michaelni
parents: 487
diff changeset
4070 sizeof(MpegEncContext),
8b7a54d58549 wmv1 support
michaelni
parents: 487
diff changeset
4071 MPV_encode_init,
8b7a54d58549 wmv1 support
michaelni
parents: 487
diff changeset
4072 MPV_encode_picture,
8b7a54d58549 wmv1 support
michaelni
parents: 487
diff changeset
4073 MPV_encode_end,
8b7a54d58549 wmv1 support
michaelni
parents: 487
diff changeset
4074 };
8b7a54d58549 wmv1 support
michaelni
parents: 487
diff changeset
4075
1042
a78f6f72d54e --disable-risky support
michaelni
parents: 1026
diff changeset
4076 #endif
a78f6f72d54e --disable-risky support
michaelni
parents: 1026
diff changeset
4077
a78f6f72d54e --disable-risky support
michaelni
parents: 1026
diff changeset
4078 AVCodec mjpeg_encoder = {
a78f6f72d54e --disable-risky support
michaelni
parents: 1026
diff changeset
4079 "mjpeg",
a78f6f72d54e --disable-risky support
michaelni
parents: 1026
diff changeset
4080 CODEC_TYPE_VIDEO,
a78f6f72d54e --disable-risky support
michaelni
parents: 1026
diff changeset
4081 CODEC_ID_MJPEG,
a78f6f72d54e --disable-risky support
michaelni
parents: 1026
diff changeset
4082 sizeof(MpegEncContext),
a78f6f72d54e --disable-risky support
michaelni
parents: 1026
diff changeset
4083 MPV_encode_init,
a78f6f72d54e --disable-risky support
michaelni
parents: 1026
diff changeset
4084 MPV_encode_picture,
a78f6f72d54e --disable-risky support
michaelni
parents: 1026
diff changeset
4085 MPV_encode_end,
a78f6f72d54e --disable-risky support
michaelni
parents: 1026
diff changeset
4086 };
1070
6da5ae9ee199 more #ifdef CONFIG_ENCODERS patch by (Wolfgang Hesseler <qv at multimediaware dot com>) with modifications by me (s/WOLFGANG/CONFIG_ENCODERS/ and some other fixes)
michaelni
parents: 1064
diff changeset
4087
6da5ae9ee199 more #ifdef CONFIG_ENCODERS patch by (Wolfgang Hesseler <qv at multimediaware dot com>) with modifications by me (s/WOLFGANG/CONFIG_ENCODERS/ and some other fixes)
michaelni
parents: 1064
diff changeset
4088 #endif //CONFIG_ENCODERS
6da5ae9ee199 more #ifdef CONFIG_ENCODERS patch by (Wolfgang Hesseler <qv at multimediaware dot com>) with modifications by me (s/WOLFGANG/CONFIG_ENCODERS/ and some other fixes)
michaelni
parents: 1064
diff changeset
4089