Mercurial > libavcodec.hg
annotate mpegvideo.c @ 5129:0244bba24b43 libavcodec
misc typo fixes
author | diego |
---|---|
date | Tue, 12 Jun 2007 18:50:50 +0000 |
parents | 4dbe6578f811 |
children | a3b82ca01e68 |
rev | line source |
---|---|
0 | 1 /* |
2 * The simplest mpeg encoder (well, it was the simplest!) | |
429 | 3 * Copyright (c) 2000,2001 Fabrice Bellard. |
1739
07a484280a82
copyright year update of the files i touched and remembered, things look annoyingly unmaintained otherwise
michael
parents:
1729
diff
changeset
|
4 * Copyright (c) 2002-2004 Michael Niedermayer <michaelni@gmx.at> |
0 | 5 * |
3947
c8c591fe26f8
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
3939
diff
changeset
|
6 * This file is part of FFmpeg. |
c8c591fe26f8
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
3939
diff
changeset
|
7 * |
c8c591fe26f8
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
3939
diff
changeset
|
8 * FFmpeg is free software; you can redistribute it and/or |
429 | 9 * modify it under the terms of the GNU Lesser General Public |
10 * License as published by the Free Software Foundation; either | |
3947
c8c591fe26f8
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
3939
diff
changeset
|
11 * version 2.1 of the License, or (at your option) any later version. |
0 | 12 * |
3947
c8c591fe26f8
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
3939
diff
changeset
|
13 * FFmpeg is distributed in the hope that it will be useful, |
0 | 14 * but WITHOUT ANY WARRANTY; without even the implied warranty of |
429 | 15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
16 * Lesser General Public License for more details. | |
0 | 17 * |
429 | 18 * You should have received a copy of the GNU Lesser General Public |
3947
c8c591fe26f8
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
3939
diff
changeset
|
19 * License along with FFmpeg; if not, write to the Free Software |
3036
0b546eab515d
Update licensing information: The FSF changed postal address.
diego
parents:
3011
diff
changeset
|
20 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA |
295 | 21 * |
325 | 22 * 4MV & hq & b-frame encoding stuff by Michael Niedermayer <michaelni@gmx.at> |
0 | 23 */ |
2967 | 24 |
1106 | 25 /** |
26 * @file mpegvideo.c | |
27 * The simplest mpeg encoder (well, it was the simplest!). | |
2967 | 28 */ |
29 | |
0 | 30 #include "avcodec.h" |
31 #include "dsputil.h" | |
32 #include "mpegvideo.h" | |
5028 | 33 #include "mjpegenc.h" |
4967
6d45158e0249
disable reference to msmpeg4 and wmv2 code when those codecs are not compiled in
aurel
parents:
4668
diff
changeset
|
34 #include "msmpeg4.h" |
1557 | 35 #include "faandct.h" |
2024
f65d87bfdd5a
some of the warning fixes by (Michael Roitzsch <mroi at users dot sourceforge dot net>)
michael
parents:
2015
diff
changeset
|
36 #include <limits.h> |
0 | 37 |
1422
efeed6e29f9b
oooooops, having 2 Eterms open and doing cvs diff in one and cvs commit in the other sucks, especially if they are in different directories (MPlayer/main/libavcodec vs. ffmpeg/libavcodec)
michaelni
parents:
1421
diff
changeset
|
38 //#undef NDEBUG |
efeed6e29f9b
oooooops, having 2 Eterms open and doing cvs diff in one and cvs commit in the other sucks, especially if they are in different directories (MPlayer/main/libavcodec vs. ffmpeg/libavcodec)
michaelni
parents:
1421
diff
changeset
|
39 //#include <assert.h> |
706
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
40 |
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
|
41 #ifdef CONFIG_ENCODERS |
3766 | 42 static int 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
|
43 #endif //CONFIG_ENCODERS |
2967 | 44 static void dct_unquantize_mpeg1_intra_c(MpegEncContext *s, |
1689 | 45 DCTELEM *block, int n, int qscale); |
2967 | 46 static void dct_unquantize_mpeg1_inter_c(MpegEncContext *s, |
1689 | 47 DCTELEM *block, int n, int qscale); |
48 static void dct_unquantize_mpeg2_intra_c(MpegEncContext *s, | |
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
|
49 DCTELEM *block, int n, int qscale); |
3281
7fac25904a8b
missmatch control for mpeg2 intra dequantization if bitexact=1
michael
parents:
3268
diff
changeset
|
50 static void dct_unquantize_mpeg2_intra_bitexact(MpegEncContext *s, |
7fac25904a8b
missmatch control for mpeg2 intra dequantization if bitexact=1
michael
parents:
3268
diff
changeset
|
51 DCTELEM *block, int n, int qscale); |
1689 | 52 static void dct_unquantize_mpeg2_inter_c(MpegEncContext *s, |
325 | 53 DCTELEM *block, int n, int qscale); |
2967 | 54 static void dct_unquantize_h263_intra_c(MpegEncContext *s, |
1689 | 55 DCTELEM *block, int n, int qscale); |
2967 | 56 static void dct_unquantize_h263_inter_c(MpegEncContext *s, |
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
|
57 DCTELEM *block, int n, int qscale); |
1064 | 58 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
|
59 #ifdef CONFIG_ENCODERS |
344 | 60 static int dct_quantize_c(MpegEncContext *s, DCTELEM *block, int n, int qscale, int *overflow); |
945 | 61 static int dct_quantize_trellis_c(MpegEncContext *s, DCTELEM *block, int n, int qscale, int *overflow); |
1777 | 62 static int dct_quantize_refine(MpegEncContext *s, DCTELEM *block, int16_t *weight, DCTELEM *orig, int n, int qscale); |
1389 | 63 static int sse_mb(MpegEncContext *s); |
1719 | 64 static void denoise_dct_c(MpegEncContext *s, DCTELEM *block); |
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
|
65 #endif //CONFIG_ENCODERS |
206 | 66 |
1381 | 67 #ifdef HAVE_XVMC |
68 extern int XVMC_field_start(MpegEncContext*s, AVCodecContext *avctx); | |
69 extern void XVMC_field_end(MpegEncContext *s); | |
1580
628bf341e099
XvMC speedup by removing one memcpy and doing MB packing
iive
parents:
1579
diff
changeset
|
70 extern void XVMC_decode_mb(MpegEncContext *s); |
1381 | 71 #endif |
72 | |
1064 | 73 void (*draw_edges)(uint8_t *buf, int wrap, int width, int height, int w)= draw_edges_c; |
206 | 74 |
0 | 75 |
76 /* enable all paranoid tests for rounding, overflows, etc... */ | |
77 //#define PARANOID | |
78 | |
79 //#define DEBUG | |
80 | |
321 | 81 |
0 | 82 /* for jpeg fast DCT */ |
83 #define CONST_BITS 14 | |
84 | |
853
eacc2dd8fd9d
* using DSPContext - so each codec could use its local (sub)set of CPU extension
kabi
parents:
847
diff
changeset
|
85 static const uint16_t aanscales[64] = { |
0 | 86 /* precomputed values scaled up by 14 bits */ |
87 16384, 22725, 21407, 19266, 16384, 12873, 8867, 4520, | |
88 22725, 31521, 29692, 26722, 22725, 17855, 12299, 6270, | |
89 21407, 29692, 27969, 25172, 21407, 16819, 11585, 5906, | |
90 19266, 26722, 25172, 22654, 19266, 15137, 10426, 5315, | |
91 16384, 22725, 21407, 19266, 16384, 12873, 8867, 4520, | |
92 12873, 17855, 16819, 15137, 12873, 10114, 6967, 3552, | |
936 | 93 8867 , 12299, 11585, 10426, 8867, 6967, 4799, 2446, |
94 4520 , 6270, 5906, 5315, 4520, 3552, 2446, 1247 | |
0 | 95 }; |
96 | |
853
eacc2dd8fd9d
* using DSPContext - so each codec could use its local (sub)set of CPU extension
kabi
parents:
847
diff
changeset
|
97 static const uint8_t h263_chroma_roundtab[16] = { |
1013 | 98 // 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
0 | 99 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, |
100 }; | |
101 | |
1644 | 102 static const uint8_t ff_default_chroma_qscale_table[32]={ |
103 // 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 | |
104 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31 | |
105 }; | |
106 | |
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
|
107 #ifdef CONFIG_ENCODERS |
4655 | 108 static uint8_t default_mv_penalty[MAX_FCODE+1][MAX_MV*2+1]; |
1064 | 109 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
|
110 |
998 | 111 enum PixelFormat ff_yuv420p_list[2]= {PIX_FMT_YUV420P, -1}; |
112 | |
1579
039cb2296de2
make convert_matrix() independant of MpegEncContext
michael
parents:
1573
diff
changeset
|
113 static void convert_matrix(DSPContext *dsp, int (*qmat)[64], uint16_t (*qmat16)[2][64], |
2385
4605a8b188c3
warn the user if the quantization code could overflow with the selected custom matrix and qp limits
michael
parents:
2382
diff
changeset
|
114 const uint16_t *quant_matrix, int bias, int qmin, int qmax, int intra) |
0 | 115 { |
344 | 116 int qscale; |
2385
4605a8b188c3
warn the user if the quantization code could overflow with the selected custom matrix and qp limits
michael
parents:
2382
diff
changeset
|
117 int shift=0; |
0 | 118 |
709
afeff6ccb7f5
convert only needed matrixes in convert_matrix() (mjpeg calls it for every frame)
michaelni
parents:
706
diff
changeset
|
119 for(qscale=qmin; qscale<=qmax; qscale++){ |
344 | 120 int i; |
2967 | 121 if (dsp->fdct == ff_jpeg_fdct_islow |
1562
bf452704100f
optionally merge postscale into quantization table for the float aan dct
michael
parents:
1557
diff
changeset
|
122 #ifdef FAAN_POSTSCALE |
1579
039cb2296de2
make convert_matrix() independant of MpegEncContext
michael
parents:
1573
diff
changeset
|
123 || dsp->fdct == ff_faandct |
1562
bf452704100f
optionally merge postscale into quantization table for the float aan dct
michael
parents:
1557
diff
changeset
|
124 #endif |
bf452704100f
optionally merge postscale into quantization table for the float aan dct
michael
parents:
1557
diff
changeset
|
125 ) { |
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
|
126 for(i=0;i<64;i++) { |
1579
039cb2296de2
make convert_matrix() independant of MpegEncContext
michael
parents:
1573
diff
changeset
|
127 const int j= 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
|
128 /* 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
|
129 /* 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
|
130 /* (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
|
131 /* 3444240 >= (1<<36)/(aanscales[i] * qscale * quant_matrix[i]) >= 275 */ |
2967 | 132 |
4274 | 133 qmat[qscale][i] = (int)((UINT64_C(1) << QMAT_SHIFT) / |
625
bb6a69f9d409
slow but accurate integer dct from IJG (should be ok with the LGPL as the old DCT is the fast integer DCT from IJG)
michaelni
parents:
619
diff
changeset
|
134 (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
|
135 } |
1579
039cb2296de2
make convert_matrix() independant of MpegEncContext
michael
parents:
1573
diff
changeset
|
136 } else if (dsp->fdct == fdct_ifast |
1562
bf452704100f
optionally merge postscale into quantization table for the float aan dct
michael
parents:
1557
diff
changeset
|
137 #ifndef FAAN_POSTSCALE |
1579
039cb2296de2
make convert_matrix() independant of MpegEncContext
michael
parents:
1573
diff
changeset
|
138 || dsp->fdct == ff_faandct |
1562
bf452704100f
optionally merge postscale into quantization table for the float aan dct
michael
parents:
1557
diff
changeset
|
139 #endif |
bf452704100f
optionally merge postscale into quantization table for the float aan dct
michael
parents:
1557
diff
changeset
|
140 ) { |
344 | 141 for(i=0;i<64;i++) { |
1579
039cb2296de2
make convert_matrix() independant of MpegEncContext
michael
parents:
1573
diff
changeset
|
142 const int j= dsp->idct_permutation[i]; |
344 | 143 /* 16 <= qscale * quant_matrix[i] <= 7905 */ |
144 /* 19952 <= aanscales[i] * qscale * quant_matrix[i] <= 249205026 */ | |
145 /* (1<<36)/19952 >= (1<<36)/(aanscales[i] * qscale * quant_matrix[i]) >= (1<<36)/249205026 */ | |
146 /* 3444240 >= (1<<36)/(aanscales[i] * qscale * quant_matrix[i]) >= 275 */ | |
2967 | 147 |
4274 | 148 qmat[qscale][i] = (int)((UINT64_C(1) << (QMAT_SHIFT + 14)) / |
344 | 149 (aanscales[i] * qscale * quant_matrix[j])); |
150 } | |
151 } else { | |
152 for(i=0;i<64;i++) { | |
1579
039cb2296de2
make convert_matrix() independant of MpegEncContext
michael
parents:
1573
diff
changeset
|
153 const int j= dsp->idct_permutation[i]; |
344 | 154 /* We can safely suppose that 16 <= quant_matrix[i] <= 255 |
155 So 16 <= qscale * quant_matrix[i] <= 7905 | |
156 so (1<<19) / 16 >= (1<<19) / (qscale * quant_matrix[i]) >= (1<<19) / 7905 | |
157 so 32768 >= (1<<19) / (qscale * quant_matrix[i]) >= 67 | |
158 */ | |
4274 | 159 qmat[qscale][i] = (int)((UINT64_C(1) << QMAT_SHIFT) / (qscale * quant_matrix[j])); |
945 | 160 // qmat [qscale][i] = (1 << QMAT_SHIFT_MMX) / (qscale * quant_matrix[i]); |
1554
d736e24bf303
move mmx quantizer matrixes out of MpegEncContext (23k -> 7k) (no meassureable slowdown)
michael
parents:
1553
diff
changeset
|
161 qmat16[qscale][0][i] = (1 << QMAT_SHIFT_MMX) / (qscale * quant_matrix[j]); |
d736e24bf303
move mmx quantizer matrixes out of MpegEncContext (23k -> 7k) (no meassureable slowdown)
michael
parents:
1553
diff
changeset
|
162 |
d736e24bf303
move mmx quantizer matrixes out of MpegEncContext (23k -> 7k) (no meassureable slowdown)
michael
parents:
1553
diff
changeset
|
163 if(qmat16[qscale][0][i]==0 || qmat16[qscale][0][i]==128*256) qmat16[qscale][0][i]=128*256-1; |
d736e24bf303
move mmx quantizer matrixes out of MpegEncContext (23k -> 7k) (no meassureable slowdown)
michael
parents:
1553
diff
changeset
|
164 qmat16[qscale][1][i]= ROUNDED_DIV(bias<<(16-QUANT_BIAS_SHIFT), qmat16[qscale][0][i]); |
344 | 165 } |
0 | 166 } |
2967 | 167 |
2385
4605a8b188c3
warn the user if the quantization code could overflow with the selected custom matrix and qp limits
michael
parents:
2382
diff
changeset
|
168 for(i=intra; i<64; i++){ |
2390 | 169 int64_t max= 8191; |
170 if (dsp->fdct == fdct_ifast | |
171 #ifndef FAAN_POSTSCALE | |
172 || dsp->fdct == ff_faandct | |
173 #endif | |
174 ) { | |
175 max= (8191LL*aanscales[i]) >> 14; | |
176 } | |
2967 | 177 while(((max * qmat[qscale][i]) >> shift) > INT_MAX){ |
2385
4605a8b188c3
warn the user if the quantization code could overflow with the selected custom matrix and qp limits
michael
parents:
2382
diff
changeset
|
178 shift++; |
4605a8b188c3
warn the user if the quantization code could overflow with the selected custom matrix and qp limits
michael
parents:
2382
diff
changeset
|
179 } |
4605a8b188c3
warn the user if the quantization code could overflow with the selected custom matrix and qp limits
michael
parents:
2382
diff
changeset
|
180 } |
4605a8b188c3
warn the user if the quantization code could overflow with the selected custom matrix and qp limits
michael
parents:
2382
diff
changeset
|
181 } |
4605a8b188c3
warn the user if the quantization code could overflow with the selected custom matrix and qp limits
michael
parents:
2382
diff
changeset
|
182 if(shift){ |
4525 | 183 av_log(NULL, AV_LOG_INFO, "Warning, QMAT_SHIFT is larger than %d, overflows possible\n", QMAT_SHIFT - shift); |
0 | 184 } |
185 } | |
1505
010f76d07a27
use lagrange multipler instead of qp for ratecontrol, this may break some things, tell me ASAP if u notice anything broken
michaelni
parents:
1497
diff
changeset
|
186 |
010f76d07a27
use lagrange multipler instead of qp for ratecontrol, this may break some things, tell me ASAP if u notice anything broken
michaelni
parents:
1497
diff
changeset
|
187 static inline void update_qscale(MpegEncContext *s){ |
010f76d07a27
use lagrange multipler instead of qp for ratecontrol, this may break some things, tell me ASAP if u notice anything broken
michaelni
parents:
1497
diff
changeset
|
188 s->qscale= (s->lambda*139 + FF_LAMBDA_SCALE*64) >> (FF_LAMBDA_SHIFT + 7); |
4594 | 189 s->qscale= av_clip(s->qscale, s->avctx->qmin, s->avctx->qmax); |
2967 | 190 |
1505
010f76d07a27
use lagrange multipler instead of qp for ratecontrol, this may break some things, tell me ASAP if u notice anything broken
michaelni
parents:
1497
diff
changeset
|
191 s->lambda2= (s->lambda*s->lambda + FF_LAMBDA_SCALE/2) >> FF_LAMBDA_SHIFT; |
010f76d07a27
use lagrange multipler instead of qp for ratecontrol, this may break some things, tell me ASAP if u notice anything broken
michaelni
parents:
1497
diff
changeset
|
192 } |
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
|
193 #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
|
194 |
1273 | 195 void ff_init_scantable(uint8_t *permutation, ScanTable *st, const uint8_t *src_scantable){ |
706
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
196 int i; |
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
197 int end; |
2967 | 198 |
764 | 199 st->scantable= src_scantable; |
706
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
200 |
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
201 for(i=0; i<64; i++){ |
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
202 int j; |
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
203 j = src_scantable[i]; |
1273 | 204 st->permutated[i] = permutation[j]; |
828
ace3ccd18dd2
Altivec Patch (Mark III) by (Dieter Shirley <dieters at schemasoft dot com>)
michaelni
parents:
815
diff
changeset
|
205 #ifdef ARCH_POWERPC |
ace3ccd18dd2
Altivec Patch (Mark III) by (Dieter Shirley <dieters at schemasoft dot com>)
michaelni
parents:
815
diff
changeset
|
206 st->inverse[j] = i; |
ace3ccd18dd2
Altivec Patch (Mark III) by (Dieter Shirley <dieters at schemasoft dot com>)
michaelni
parents:
815
diff
changeset
|
207 #endif |
706
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
208 } |
2967 | 209 |
706
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
210 end=-1; |
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
211 for(i=0; i<64; i++){ |
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
212 int j; |
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
213 j = st->permutated[i]; |
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
214 if(j>end) end=j; |
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
215 st->raster_end[i]= end; |
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
216 } |
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
217 } |
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
218 |
1530
3b31998fe22f
disable encoders where appropriate (patch courtesy of BERO
melanson
parents:
1523
diff
changeset
|
219 #ifdef CONFIG_ENCODERS |
3776 | 220 void ff_write_quant_matrix(PutBitContext *pb, uint16_t *matrix){ |
1411 | 221 int i; |
222 | |
223 if(matrix){ | |
224 put_bits(pb, 1, 1); | |
225 for(i=0;i<64;i++) { | |
226 put_bits(pb, 8, matrix[ ff_zigzag_direct[i] ]); | |
227 } | |
228 }else | |
229 put_bits(pb, 1, 0); | |
230 } | |
1530
3b31998fe22f
disable encoders where appropriate (patch courtesy of BERO
melanson
parents:
1523
diff
changeset
|
231 #endif //CONFIG_ENCODERS |
1411 | 232 |
3086 | 233 const uint8_t *ff_find_start_code(const uint8_t * restrict p, const uint8_t *end, uint32_t * restrict state){ |
234 int i; | |
235 | |
3092 | 236 assert(p<=end); |
237 if(p>=end) | |
238 return end; | |
239 | |
3086 | 240 for(i=0; i<3; i++){ |
241 uint32_t tmp= *state << 8; | |
242 *state= tmp + *(p++); | |
243 if(tmp == 0x100 || p==end) | |
244 return p; | |
245 } | |
246 | |
247 while(p<end){ | |
3087 | 248 if (p[-1] > 1 ) p+= 3; |
249 else if(p[-2] ) p+= 2; | |
250 else if(p[-3]|(p[-1]-1)) p++; | |
3086 | 251 else{ |
252 p++; | |
253 break; | |
254 } | |
255 } | |
256 | |
3087 | 257 p= FFMIN(p, end)-4; |
3086 | 258 *state= be2me_32(unaligned32(p)); |
259 | |
260 return p+4; | |
261 } | |
262 | |
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
|
263 /* 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
|
264 int DCT_common_init(MpegEncContext *s) |
0 | 265 { |
1689 | 266 s->dct_unquantize_h263_intra = dct_unquantize_h263_intra_c; |
267 s->dct_unquantize_h263_inter = dct_unquantize_h263_inter_c; | |
268 s->dct_unquantize_mpeg1_intra = dct_unquantize_mpeg1_intra_c; | |
269 s->dct_unquantize_mpeg1_inter = dct_unquantize_mpeg1_inter_c; | |
270 s->dct_unquantize_mpeg2_intra = dct_unquantize_mpeg2_intra_c; | |
3281
7fac25904a8b
missmatch control for mpeg2 intra dequantization if bitexact=1
michael
parents:
3268
diff
changeset
|
271 if(s->flags & CODEC_FLAG_BITEXACT) |
7fac25904a8b
missmatch control for mpeg2 intra dequantization if bitexact=1
michael
parents:
3268
diff
changeset
|
272 s->dct_unquantize_mpeg2_intra = dct_unquantize_mpeg2_intra_bitexact; |
1689 | 273 s->dct_unquantize_mpeg2_inter = dct_unquantize_mpeg2_inter_c; |
1092 | 274 |
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
|
275 #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
|
276 s->dct_quantize= dct_quantize_c; |
1719 | 277 s->denoise_dct= denoise_dct_c; |
2616
ba6530ae8e34
remove superfluous CONFIG_ENCODERS (entire function is already wrapped)
melanson
parents:
2584
diff
changeset
|
278 #endif //CONFIG_ENCODERS |
2967 | 279 |
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
|
280 #ifdef HAVE_MMX |
1422
efeed6e29f9b
oooooops, having 2 Eterms open and doing cvs diff in one and cvs commit in the other sucks, especially if they are in different directories (MPlayer/main/libavcodec vs. ffmpeg/libavcodec)
michaelni
parents:
1421
diff
changeset
|
281 MPV_common_init_mmx(s); |
8 | 282 #endif |
514
c9f724e3a797
Update and activate dct_unquantize_h263_mvi. Thanks to M«©ns Rullg«©rd
mellum
parents:
506
diff
changeset
|
283 #ifdef ARCH_ALPHA |
c9f724e3a797
Update and activate dct_unquantize_h263_mvi. Thanks to M«©ns Rullg«©rd
mellum
parents:
506
diff
changeset
|
284 MPV_common_init_axp(s); |
c9f724e3a797
Update and activate dct_unquantize_h263_mvi. Thanks to M«©ns Rullg«©rd
mellum
parents:
506
diff
changeset
|
285 #endif |
628
f596db4aa871
sun solaris compilation bugfix, patch by (Martin Olschewski <olschewski at zpr dot uni-koeln dot de>)
michaelni
parents:
625
diff
changeset
|
286 #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
|
287 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
|
288 #endif |
721
71f669e9f633
ps2 optimizations update patch by (Leon van Stuivenberg <leonvs at iae dot nl>)
michaelni
parents:
717
diff
changeset
|
289 #ifdef HAVE_MMI |
71f669e9f633
ps2 optimizations update patch by (Leon van Stuivenberg <leonvs at iae dot nl>)
michaelni
parents:
717
diff
changeset
|
290 MPV_common_init_mmi(s); |
71f669e9f633
ps2 optimizations update patch by (Leon van Stuivenberg <leonvs at iae dot nl>)
michaelni
parents:
717
diff
changeset
|
291 #endif |
730 | 292 #ifdef ARCH_ARMV4L |
874 | 293 MPV_common_init_armv4l(s); |
730 | 294 #endif |
828
ace3ccd18dd2
Altivec Patch (Mark III) by (Dieter Shirley <dieters at schemasoft dot com>)
michaelni
parents:
815
diff
changeset
|
295 #ifdef ARCH_POWERPC |
ace3ccd18dd2
Altivec Patch (Mark III) by (Dieter Shirley <dieters at schemasoft dot com>)
michaelni
parents:
815
diff
changeset
|
296 MPV_common_init_ppc(s); |
ace3ccd18dd2
Altivec Patch (Mark III) by (Dieter Shirley <dieters at schemasoft dot com>)
michaelni
parents:
815
diff
changeset
|
297 #endif |
730 | 298 |
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
|
299 #ifdef CONFIG_ENCODERS |
1007 | 300 s->fast_dct_quantize= s->dct_quantize; |
301 | |
945 | 302 if(s->flags&CODEC_FLAG_TRELLIS_QUANT){ |
303 s->dct_quantize= dct_quantize_trellis_c; //move before MPV_common_init_* | |
304 } | |
305 | |
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
|
306 #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
|
307 |
706
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
308 /* load & permutate scantables |
2967 | 309 note: only wmv uses different ones |
706
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
310 */ |
1708 | 311 if(s->alternate_scan){ |
312 ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable , ff_alternate_vertical_scan); | |
313 ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable , ff_alternate_vertical_scan); | |
314 }else{ | |
315 ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable , ff_zigzag_direct); | |
316 ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable , ff_zigzag_direct); | |
317 } | |
1273 | 318 ff_init_scantable(s->dsp.idct_permutation, &s->intra_h_scantable, ff_alternate_horizontal_scan); |
319 ff_init_scantable(s->dsp.idct_permutation, &s->intra_v_scantable, ff_alternate_vertical_scan); | |
591 | 320 |
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
|
321 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
|
322 } |
a91203b34e71
moved dct init out from mpv_common_init to dct_common_init (for less-uglier way for dv)
al3x
parents:
721
diff
changeset
|
323 |
1539
14d01ccc0081
picture buffer cleanup, this fixes a assertion failure (if assertion checking was manualy enabled for utils.c) and a memleak at least
michael
parents:
1530
diff
changeset
|
324 static void copy_picture(Picture *dst, Picture *src){ |
14d01ccc0081
picture buffer cleanup, this fixes a assertion failure (if assertion checking was manualy enabled for utils.c) and a memleak at least
michael
parents:
1530
diff
changeset
|
325 *dst = *src; |
14d01ccc0081
picture buffer cleanup, this fixes a assertion failure (if assertion checking was manualy enabled for utils.c) and a memleak at least
michael
parents:
1530
diff
changeset
|
326 dst->type= FF_BUFFER_TYPE_COPY; |
14d01ccc0081
picture buffer cleanup, this fixes a assertion failure (if assertion checking was manualy enabled for utils.c) and a memleak at least
michael
parents:
1530
diff
changeset
|
327 } |
14d01ccc0081
picture buffer cleanup, this fixes a assertion failure (if assertion checking was manualy enabled for utils.c) and a memleak at least
michael
parents:
1530
diff
changeset
|
328 |
3777 | 329 #ifdef CONFIG_ENCODERS |
1938
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1918
diff
changeset
|
330 static void copy_picture_attributes(MpegEncContext *s, AVFrame *dst, AVFrame *src){ |
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1918
diff
changeset
|
331 int i; |
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1918
diff
changeset
|
332 |
1702 | 333 dst->pict_type = src->pict_type; |
334 dst->quality = src->quality; | |
335 dst->coded_picture_number = src->coded_picture_number; | |
336 dst->display_picture_number = src->display_picture_number; | |
337 // dst->reference = src->reference; | |
338 dst->pts = src->pts; | |
339 dst->interlaced_frame = src->interlaced_frame; | |
340 dst->top_field_first = src->top_field_first; | |
1938
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1918
diff
changeset
|
341 |
1945
32f68745c431
passing AVFrame instead of AVPicture around in ffmpeg, that way stuff like motion vectors can be passed from the decoder to the encoder
michael
parents:
1944
diff
changeset
|
342 if(s->avctx->me_threshold){ |
32f68745c431
passing AVFrame instead of AVPicture around in ffmpeg, that way stuff like motion vectors can be passed from the decoder to the encoder
michael
parents:
1944
diff
changeset
|
343 if(!src->motion_val[0]) |
32f68745c431
passing AVFrame instead of AVPicture around in ffmpeg, that way stuff like motion vectors can be passed from the decoder to the encoder
michael
parents:
1944
diff
changeset
|
344 av_log(s->avctx, AV_LOG_ERROR, "AVFrame.motion_val not set!\n"); |
32f68745c431
passing AVFrame instead of AVPicture around in ffmpeg, that way stuff like motion vectors can be passed from the decoder to the encoder
michael
parents:
1944
diff
changeset
|
345 if(!src->mb_type) |
32f68745c431
passing AVFrame instead of AVPicture around in ffmpeg, that way stuff like motion vectors can be passed from the decoder to the encoder
michael
parents:
1944
diff
changeset
|
346 av_log(s->avctx, AV_LOG_ERROR, "AVFrame.mb_type not set!\n"); |
32f68745c431
passing AVFrame instead of AVPicture around in ffmpeg, that way stuff like motion vectors can be passed from the decoder to the encoder
michael
parents:
1944
diff
changeset
|
347 if(!src->ref_index[0]) |
32f68745c431
passing AVFrame instead of AVPicture around in ffmpeg, that way stuff like motion vectors can be passed from the decoder to the encoder
michael
parents:
1944
diff
changeset
|
348 av_log(s->avctx, AV_LOG_ERROR, "AVFrame.ref_index not set!\n"); |
1938
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1918
diff
changeset
|
349 if(src->motion_subsample_log2 != dst->motion_subsample_log2) |
2627
bf158d23bbcc
Spelling errors patch by (Kevin Baragona | kevinmb500 gawab com)
michael
parents:
2620
diff
changeset
|
350 av_log(s->avctx, AV_LOG_ERROR, "AVFrame.motion_subsample_log2 doesn't match! (%d!=%d)\n", |
1955
5dafb10e0252
reuse motion vectors/mb types/field select values of the source video, if the SSE for a macroblock which is predicted with these values is below me_threshold
michael
parents:
1948
diff
changeset
|
351 src->motion_subsample_log2, dst->motion_subsample_log2); |
1945
32f68745c431
passing AVFrame instead of AVPicture around in ffmpeg, that way stuff like motion vectors can be passed from the decoder to the encoder
michael
parents:
1944
diff
changeset
|
352 |
32f68745c431
passing AVFrame instead of AVPicture around in ffmpeg, that way stuff like motion vectors can be passed from the decoder to the encoder
michael
parents:
1944
diff
changeset
|
353 memcpy(dst->mb_type, src->mb_type, s->mb_stride * s->mb_height * sizeof(dst->mb_type[0])); |
2967 | 354 |
1945
32f68745c431
passing AVFrame instead of AVPicture around in ffmpeg, that way stuff like motion vectors can be passed from the decoder to the encoder
michael
parents:
1944
diff
changeset
|
355 for(i=0; i<2; i++){ |
1938
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1918
diff
changeset
|
356 int stride= ((16*s->mb_width )>>src->motion_subsample_log2) + 1; |
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1918
diff
changeset
|
357 int height= ((16*s->mb_height)>>src->motion_subsample_log2); |
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1918
diff
changeset
|
358 |
1945
32f68745c431
passing AVFrame instead of AVPicture around in ffmpeg, that way stuff like motion vectors can be passed from the decoder to the encoder
michael
parents:
1944
diff
changeset
|
359 if(src->motion_val[i] && src->motion_val[i] != dst->motion_val[i]){ |
32f68745c431
passing AVFrame instead of AVPicture around in ffmpeg, that way stuff like motion vectors can be passed from the decoder to the encoder
michael
parents:
1944
diff
changeset
|
360 memcpy(dst->motion_val[i], src->motion_val[i], 2*stride*height*sizeof(int16_t)); |
32f68745c431
passing AVFrame instead of AVPicture around in ffmpeg, that way stuff like motion vectors can be passed from the decoder to the encoder
michael
parents:
1944
diff
changeset
|
361 } |
32f68745c431
passing AVFrame instead of AVPicture around in ffmpeg, that way stuff like motion vectors can be passed from the decoder to the encoder
michael
parents:
1944
diff
changeset
|
362 if(src->ref_index[i] && src->ref_index[i] != dst->ref_index[i]){ |
1948 | 363 memcpy(dst->ref_index[i], src->ref_index[i], s->b8_stride*2*s->mb_height*sizeof(int8_t)); |
1945
32f68745c431
passing AVFrame instead of AVPicture around in ffmpeg, that way stuff like motion vectors can be passed from the decoder to the encoder
michael
parents:
1944
diff
changeset
|
364 } |
1938
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1918
diff
changeset
|
365 } |
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1918
diff
changeset
|
366 } |
1702 | 367 } |
3777 | 368 #endif |
1702 | 369 |
903 | 370 /** |
924 | 371 * allocates a Picture |
372 * The pixels are allocated/set by calling get_buffer() if shared=0 | |
903 | 373 */ |
924 | 374 static int alloc_picture(MpegEncContext *s, Picture *pic, int shared){ |
5127 | 375 const int big_mb_num= s->mb_stride*(s->mb_height+1) + 1; //the +1 is needed so memset(,,stride*height) does not sig11 |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1173
diff
changeset
|
376 const int mb_array_size= s->mb_stride*s->mb_height; |
1655 | 377 const int b8_array_size= s->b8_stride*s->mb_height*2; |
378 const int b4_array_size= s->b4_stride*s->mb_height*4; | |
1168 | 379 int i; |
2967 | 380 |
924 | 381 if(shared){ |
382 assert(pic->data[0]); | |
383 assert(pic->type == 0 || pic->type == FF_BUFFER_TYPE_SHARED); | |
384 pic->type= FF_BUFFER_TYPE_SHARED; | |
385 }else{ | |
386 int r; | |
2967 | 387 |
924 | 388 assert(!pic->data[0]); |
2967 | 389 |
925 | 390 r= s->avctx->get_buffer(s->avctx, (AVFrame*)pic); |
2967 | 391 |
924 | 392 if(r<0 || !pic->age || !pic->type || !pic->data[0]){ |
2979 | 393 av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed (%d %d %d %p)\n", r, pic->age, pic->type, pic->data[0]); |
924 | 394 return -1; |
395 } | |
396 | |
397 if(s->linesize && (s->linesize != pic->linesize[0] || s->uvlinesize != pic->linesize[1])){ | |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1597
diff
changeset
|
398 av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed (stride changed)\n"); |
924 | 399 return -1; |
400 } | |
401 | |
402 if(pic->linesize[1] != pic->linesize[2]){ | |
2764 | 403 av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed (uv stride mismatch)\n"); |
924 | 404 return -1; |
405 } | |
406 | |
407 s->linesize = pic->linesize[0]; | |
408 s->uvlinesize= pic->linesize[1]; | |
903 | 409 } |
2967 | 410 |
924 | 411 if(pic->qscale_table==NULL){ |
2967 | 412 if (s->encoding) { |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1173
diff
changeset
|
413 CHECKED_ALLOCZ(pic->mb_var , mb_array_size * sizeof(int16_t)) |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1173
diff
changeset
|
414 CHECKED_ALLOCZ(pic->mc_mb_var, mb_array_size * sizeof(int16_t)) |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1173
diff
changeset
|
415 CHECKED_ALLOCZ(pic->mb_mean , mb_array_size * sizeof(int8_t)) |
924 | 416 } |
417 | |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1173
diff
changeset
|
418 CHECKED_ALLOCZ(pic->mbskip_table , mb_array_size * sizeof(uint8_t)+2) //the +2 is for the slice end check |
1422
efeed6e29f9b
oooooops, having 2 Eterms open and doing cvs diff in one and cvs commit in the other sucks, especially if they are in different directories (MPlayer/main/libavcodec vs. ffmpeg/libavcodec)
michaelni
parents:
1421
diff
changeset
|
419 CHECKED_ALLOCZ(pic->qscale_table , mb_array_size * sizeof(uint8_t)) |
1742 | 420 CHECKED_ALLOCZ(pic->mb_type_base , big_mb_num * sizeof(uint32_t)) |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1173
diff
changeset
|
421 pic->mb_type= pic->mb_type_base + s->mb_stride+1; |
1168 | 422 if(s->out_format == FMT_H264){ |
423 for(i=0; i<2; i++){ | |
2570 | 424 CHECKED_ALLOCZ(pic->motion_val_base[i], 2 * (b4_array_size+4) * sizeof(int16_t)) |
425 pic->motion_val[i]= pic->motion_val_base[i]+4; | |
1948 | 426 CHECKED_ALLOCZ(pic->ref_index[i], b8_array_size * sizeof(uint8_t)) |
1655 | 427 } |
1669 | 428 pic->motion_subsample_log2= 2; |
1706
3ba5c493db6f
motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1705
diff
changeset
|
429 }else if(s->out_format == FMT_H263 || s->encoding || (s->avctx->debug&FF_DEBUG_MV) || (s->avctx->debug_mv)){ |
1655 | 430 for(i=0; i<2; i++){ |
2570 | 431 CHECKED_ALLOCZ(pic->motion_val_base[i], 2 * (b8_array_size+4) * sizeof(int16_t)) |
432 pic->motion_val[i]= pic->motion_val_base[i]+4; | |
1948 | 433 CHECKED_ALLOCZ(pic->ref_index[i], b8_array_size * sizeof(uint8_t)) |
1168 | 434 } |
1669 | 435 pic->motion_subsample_log2= 3; |
1168 | 436 } |
1833
ba27ce284d07
export DCT coefficients patch by (Wolfgang Hesseler <wolfgang.hesseler at imk dot fraunhofer dot de>)
michael
parents:
1831
diff
changeset
|
437 if(s->avctx->debug&FF_DEBUG_DCT_COEFF) { |
ba27ce284d07
export DCT coefficients patch by (Wolfgang Hesseler <wolfgang.hesseler at imk dot fraunhofer dot de>)
michael
parents:
1831
diff
changeset
|
438 CHECKED_ALLOCZ(pic->dct_coeff, 64 * mb_array_size * sizeof(DCTELEM)*6) |
ba27ce284d07
export DCT coefficients patch by (Wolfgang Hesseler <wolfgang.hesseler at imk dot fraunhofer dot de>)
michael
parents:
1831
diff
changeset
|
439 } |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1173
diff
changeset
|
440 pic->qstride= s->mb_stride; |
1546 | 441 CHECKED_ALLOCZ(pic->pan_scan , 1 * sizeof(AVPanScan)) |
924 | 442 } |
1168 | 443 |
5129 | 444 /* It might be nicer if the application would keep track of these |
445 * but it would require an API change. */ | |
1021
2d7c9f5738de
trying to fix mb skip bug in mpeg1/2 if slices are not used
michaelni
parents:
1014
diff
changeset
|
446 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
|
447 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
|
448 if(pic->age < PREV_PICT_TYPES_BUFFER_SIZE && s->prev_pict_types[pic->age] == B_TYPE) |
5129 | 449 pic->age= INT_MAX; // Skipped MBs in B-frames are quite rare in MPEG-1/2 and it is a bit tricky to skip them anyway. |
2967 | 450 |
903 | 451 return 0; |
452 fail: //for the CHECKED_ALLOCZ macro | |
453 return -1; | |
454 } | |
455 | |
924 | 456 /** |
457 * deallocates a picture | |
458 */ | |
903 | 459 static void free_picture(MpegEncContext *s, Picture *pic){ |
460 int i; | |
924 | 461 |
462 if(pic->data[0] && pic->type!=FF_BUFFER_TYPE_SHARED){ | |
925 | 463 s->avctx->release_buffer(s->avctx, (AVFrame*)pic); |
924 | 464 } |
465 | |
903 | 466 av_freep(&pic->mb_var); |
467 av_freep(&pic->mc_mb_var); | |
468 av_freep(&pic->mb_mean); | |
469 av_freep(&pic->mbskip_table); | |
470 av_freep(&pic->qscale_table); | |
1168 | 471 av_freep(&pic->mb_type_base); |
1833
ba27ce284d07
export DCT coefficients patch by (Wolfgang Hesseler <wolfgang.hesseler at imk dot fraunhofer dot de>)
michael
parents:
1831
diff
changeset
|
472 av_freep(&pic->dct_coeff); |
1546 | 473 av_freep(&pic->pan_scan); |
1168 | 474 pic->mb_type= NULL; |
475 for(i=0; i<2; i++){ | |
1655 | 476 av_freep(&pic->motion_val_base[i]); |
1168 | 477 av_freep(&pic->ref_index[i]); |
478 } | |
2967 | 479 |
1214 | 480 if(pic->type == FF_BUFFER_TYPE_SHARED){ |
924 | 481 for(i=0; i<4; i++){ |
482 pic->base[i]= | |
483 pic->data[i]= NULL; | |
484 } | |
2967 | 485 pic->type= 0; |
903 | 486 } |
487 } | |
488 | |
1799 | 489 static int init_duplicate_context(MpegEncContext *s, MpegEncContext *base){ |
490 int i; | |
491 | |
2967 | 492 // edge emu needs blocksize + filter length - 1 (=17x17 for halfpel / 21x21 for h264) |
3316 | 493 CHECKED_ALLOCZ(s->allocated_edge_emu_buffer, (s->width+64)*2*21*2); //(width + edge + align)*interlaced*MBsize*tolerance |
494 s->edge_emu_buffer= s->allocated_edge_emu_buffer + (s->width+64)*2*21; | |
1799 | 495 |
5127 | 496 //FIXME should be linesize instead of s->width*2 but that is not known before get_buffer() |
2967 | 497 CHECKED_ALLOCZ(s->me.scratchpad, (s->width+64)*4*16*2*sizeof(uint8_t)) |
1799 | 498 s->rd_scratchpad= s->me.scratchpad; |
499 s->b_scratchpad= s->me.scratchpad; | |
500 s->obmc_scratchpad= s->me.scratchpad + 16; | |
501 if (s->encoding) { | |
502 CHECKED_ALLOCZ(s->me.map , ME_MAP_SIZE*sizeof(uint32_t)) | |
503 CHECKED_ALLOCZ(s->me.score_map, ME_MAP_SIZE*sizeof(uint32_t)) | |
504 if(s->avctx->noise_reduction){ | |
505 CHECKED_ALLOCZ(s->dct_error_sum, 2 * 64 * sizeof(int)) | |
506 } | |
2967 | 507 } |
1848
c72589baee53
initial chroma_format changes,xvmc tweaks and codec_cap
iive
parents:
1846
diff
changeset
|
508 CHECKED_ALLOCZ(s->blocks, 64*12*2 * sizeof(DCTELEM)) |
1799 | 509 s->block= s->blocks[0]; |
510 | |
511 for(i=0;i<12;i++){ | |
512 s->pblocks[i] = (short *)(&s->block[i]); | |
513 } | |
514 return 0; | |
515 fail: | |
516 return -1; //free() through MPV_common_end() | |
517 } | |
518 | |
519 static void free_duplicate_context(MpegEncContext *s){ | |
520 if(s==NULL) return; | |
521 | |
522 av_freep(&s->allocated_edge_emu_buffer); s->edge_emu_buffer= NULL; | |
523 av_freep(&s->me.scratchpad); | |
2967 | 524 s->rd_scratchpad= |
525 s->b_scratchpad= | |
1799 | 526 s->obmc_scratchpad= NULL; |
2967 | 527 |
1799 | 528 av_freep(&s->dct_error_sum); |
529 av_freep(&s->me.map); | |
530 av_freep(&s->me.score_map); | |
531 av_freep(&s->blocks); | |
532 s->block= NULL; | |
533 } | |
534 | |
535 static void backup_duplicate_context(MpegEncContext *bak, MpegEncContext *src){ | |
536 #define COPY(a) bak->a= src->a | |
537 COPY(allocated_edge_emu_buffer); | |
538 COPY(edge_emu_buffer); | |
539 COPY(me.scratchpad); | |
540 COPY(rd_scratchpad); | |
541 COPY(b_scratchpad); | |
542 COPY(obmc_scratchpad); | |
543 COPY(me.map); | |
544 COPY(me.score_map); | |
545 COPY(blocks); | |
546 COPY(block); | |
547 COPY(start_mb_y); | |
548 COPY(end_mb_y); | |
549 COPY(me.map_generation); | |
550 COPY(pb); | |
551 COPY(dct_error_sum); | |
1810 | 552 COPY(dct_count[0]); |
553 COPY(dct_count[1]); | |
1799 | 554 #undef COPY |
555 } | |
556 | |
1827 | 557 void ff_update_duplicate_context(MpegEncContext *dst, MpegEncContext *src){ |
1799 | 558 MpegEncContext bak; |
1827 | 559 int i; |
1799 | 560 //FIXME copy only needed parts |
561 //START_TIMER | |
562 backup_duplicate_context(&bak, dst); | |
563 memcpy(dst, src, sizeof(MpegEncContext)); | |
564 backup_duplicate_context(dst, &bak); | |
1827 | 565 for(i=0;i<12;i++){ |
566 dst->pblocks[i] = (short *)(&dst->block[i]); | |
567 } | |
1799 | 568 //STOP_TIMER("update_duplicate_context") //about 10k cycles / 0.01 sec for 1000frames on 1ghz with 2 threads |
569 } | |
570 | |
3777 | 571 #ifdef CONFIG_ENCODERS |
1799 | 572 static void update_duplicate_context_after_me(MpegEncContext *dst, MpegEncContext *src){ |
573 #define COPY(a) dst->a= src->a | |
574 COPY(pict_type); | |
575 COPY(current_picture); | |
576 COPY(f_code); | |
577 COPY(b_code); | |
578 COPY(qscale); | |
579 COPY(lambda); | |
580 COPY(lambda2); | |
581 COPY(picture_in_gop_number); | |
582 COPY(gop_picture_number); | |
2764 | 583 COPY(frame_pred_frame_dct); //FIXME don't set in encode_header |
584 COPY(progressive_frame); //FIXME don't set in encode_header | |
585 COPY(partitioned_frame); //FIXME don't set in encode_header | |
1799 | 586 #undef COPY |
587 } | |
3777 | 588 #endif |
1799 | 589 |
1892 | 590 /** |
591 * sets the given MpegEncContext to common defaults (same for encoding and decoding). | |
592 * the changed fields will not depend upon the prior state of the MpegEncContext. | |
593 */ | |
594 static void MPV_common_defaults(MpegEncContext *s){ | |
595 s->y_dc_scale_table= | |
596 s->c_dc_scale_table= ff_mpeg1_dc_scale_table; | |
597 s->chroma_qscale_table= ff_default_chroma_qscale_table; | |
598 s->progressive_frame= 1; | |
599 s->progressive_sequence= 1; | |
600 s->picture_structure= PICT_FRAME; | |
601 | |
602 s->coded_picture_number = 0; | |
603 s->picture_number = 0; | |
604 s->input_picture_number = 0; | |
605 | |
606 s->picture_in_gop_number = 0; | |
1894 | 607 |
608 s->f_code = 1; | |
609 s->b_code = 1; | |
1892 | 610 } |
611 | |
612 /** | |
613 * sets the given MpegEncContext to defaults for decoding. | |
614 * the changed fields will not depend upon the prior state of the MpegEncContext. | |
615 */ | |
616 void MPV_decode_defaults(MpegEncContext *s){ | |
617 MPV_common_defaults(s); | |
618 } | |
619 | |
620 /** | |
621 * sets the given MpegEncContext to defaults for encoding. | |
622 * the changed fields will not depend upon the prior state of the MpegEncContext. | |
623 */ | |
1902
a5588762c4fa
Compile fix by (Chip <szarlada at freemail dot hu>)
michael
parents:
1894
diff
changeset
|
624 |
a5588762c4fa
Compile fix by (Chip <szarlada at freemail dot hu>)
michael
parents:
1894
diff
changeset
|
625 #ifdef CONFIG_ENCODERS |
2024
f65d87bfdd5a
some of the warning fixes by (Michael Roitzsch <mroi at users dot sourceforge dot net>)
michael
parents:
2015
diff
changeset
|
626 static void MPV_encode_defaults(MpegEncContext *s){ |
4658 | 627 int i; |
1892 | 628 MPV_common_defaults(s); |
2967 | 629 |
4658 | 630 for(i=-16; i<16; i++){ |
631 default_fcode_tab[i + MAX_MV]= 1; | |
1892 | 632 } |
633 s->me.mv_penalty= default_mv_penalty; | |
634 s->fcode_tab= default_fcode_tab; | |
635 } | |
1902
a5588762c4fa
Compile fix by (Chip <szarlada at freemail dot hu>)
michael
parents:
1894
diff
changeset
|
636 #endif //CONFIG_ENCODERS |
1892 | 637 |
2967 | 638 /** |
1892 | 639 * init common structure for both encoder and decoder. |
640 * this assumes that some variables like width/height are already set | |
641 */ | |
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
|
642 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
|
643 { |
1708 | 644 int y_size, c_size, yc_size, i, mb_array_size, mv_table_size, x, y; |
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
|
645 |
3070 | 646 s->mb_height = (s->height + 15) / 16; |
647 | |
648 if(s->avctx->thread_count > MAX_THREADS || (s->avctx->thread_count > s->mb_height && s->mb_height)){ | |
1989 | 649 av_log(s->avctx, AV_LOG_ERROR, "too many threads\n"); |
650 return -1; | |
651 } | |
652 | |
2422 | 653 if((s->width || s->height) && avcodec_check_dimensions(s->avctx, s->width, s->height)) |
654 return -1; | |
655 | |
1092 | 656 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
|
657 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
|
658 |
754 | 659 s->flags= s->avctx->flags; |
1754
bdf3927bf8c5
closed gop support & flags2 as all bits in flags are used
michael
parents:
1751
diff
changeset
|
660 s->flags2= s->avctx->flags2; |
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
|
661 |
903 | 662 s->mb_width = (s->width + 15) / 16; |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1173
diff
changeset
|
663 s->mb_stride = s->mb_width + 1; |
1655 | 664 s->b8_stride = s->mb_width*2 + 1; |
665 s->b4_stride = s->mb_width*4 + 1; | |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1173
diff
changeset
|
666 mb_array_size= s->mb_height * s->mb_stride; |
1708 | 667 mv_table_size= (s->mb_height+2) * s->mb_stride + 1; |
853
eacc2dd8fd9d
* using DSPContext - so each codec could use its local (sub)set of CPU extension
kabi
parents:
847
diff
changeset
|
668 |
2074
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
669 /* set chroma shifts */ |
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
670 avcodec_get_chroma_sub_sample(s->avctx->pix_fmt,&(s->chroma_x_shift), |
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
671 &(s->chroma_y_shift) ); |
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
672 |
853
eacc2dd8fd9d
* using DSPContext - so each codec could use its local (sub)set of CPU extension
kabi
parents:
847
diff
changeset
|
673 /* 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
|
674 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
|
675 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
|
676 |
eacc2dd8fd9d
* using DSPContext - so each codec could use its local (sub)set of CPU extension
kabi
parents:
847
diff
changeset
|
677 s->mb_num = s->mb_width * s->mb_height; |
2967 | 678 |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1173
diff
changeset
|
679 s->block_wrap[0]= |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1173
diff
changeset
|
680 s->block_wrap[1]= |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1173
diff
changeset
|
681 s->block_wrap[2]= |
1938
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1918
diff
changeset
|
682 s->block_wrap[3]= s->b8_stride; |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1173
diff
changeset
|
683 s->block_wrap[4]= |
1938
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1918
diff
changeset
|
684 s->block_wrap[5]= s->mb_stride; |
2967 | 685 |
1938
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1918
diff
changeset
|
686 y_size = s->b8_stride * (2 * s->mb_height + 1); |
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1918
diff
changeset
|
687 c_size = s->mb_stride * (s->mb_height + 1); |
756 | 688 yc_size = y_size + 2 * c_size; |
2967 | 689 |
701 | 690 /* convert fourcc to upper case */ |
4155
0f28fc219799
add codec_tag and codec_stream_tag to MpegEncContext to not alter avctx values
bcoudurier
parents:
4122
diff
changeset
|
691 s->codec_tag= toupper( s->avctx->codec_tag &0xFF) |
1116 | 692 + (toupper((s->avctx->codec_tag>>8 )&0xFF)<<8 ) |
2967 | 693 + (toupper((s->avctx->codec_tag>>16)&0xFF)<<16) |
1116 | 694 + (toupper((s->avctx->codec_tag>>24)&0xFF)<<24); |
582
5132a4ee50cd
different edge positions fixed with edge emu / dr1
michaelni
parents:
575
diff
changeset
|
695 |
4155
0f28fc219799
add codec_tag and codec_stream_tag to MpegEncContext to not alter avctx values
bcoudurier
parents:
4122
diff
changeset
|
696 s->stream_codec_tag= toupper( s->avctx->stream_codec_tag &0xFF) |
1458
40b69d238beb
AVI stream header FCC / more reliable detection of old xvid files
michaelni
parents:
1451
diff
changeset
|
697 + (toupper((s->avctx->stream_codec_tag>>8 )&0xFF)<<8 ) |
2967 | 698 + (toupper((s->avctx->stream_codec_tag>>16)&0xFF)<<16) |
1458
40b69d238beb
AVI stream header FCC / more reliable detection of old xvid files
michaelni
parents:
1451
diff
changeset
|
699 + (toupper((s->avctx->stream_codec_tag>>24)&0xFF)<<24); |
40b69d238beb
AVI stream header FCC / more reliable detection of old xvid files
michaelni
parents:
1451
diff
changeset
|
700 |
925 | 701 s->avctx->coded_frame= (AVFrame*)&s->current_picture; |
903 | 702 |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1173
diff
changeset
|
703 CHECKED_ALLOCZ(s->mb_index2xy, (s->mb_num+1)*sizeof(int)) //error ressilience code looks cleaner with this |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1173
diff
changeset
|
704 for(y=0; y<s->mb_height; y++){ |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1173
diff
changeset
|
705 for(x=0; x<s->mb_width; x++){ |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1173
diff
changeset
|
706 s->mb_index2xy[ x + y*s->mb_width ] = x + y*s->mb_stride; |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1173
diff
changeset
|
707 } |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1173
diff
changeset
|
708 } |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1173
diff
changeset
|
709 s->mb_index2xy[ s->mb_height*s->mb_width ] = (s->mb_height-1)*s->mb_stride + s->mb_width; //FIXME really needed? |
2967 | 710 |
232
b640ec5948b0
- Now the ME is done for the entire picture when enconding, the
pulento
parents:
231
diff
changeset
|
711 if (s->encoding) { |
324 | 712 /* Allocate MV tables */ |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1173
diff
changeset
|
713 CHECKED_ALLOCZ(s->p_mv_table_base , mv_table_size * 2 * sizeof(int16_t)) |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1173
diff
changeset
|
714 CHECKED_ALLOCZ(s->b_forw_mv_table_base , mv_table_size * 2 * sizeof(int16_t)) |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1173
diff
changeset
|
715 CHECKED_ALLOCZ(s->b_back_mv_table_base , mv_table_size * 2 * sizeof(int16_t)) |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1173
diff
changeset
|
716 CHECKED_ALLOCZ(s->b_bidir_forw_mv_table_base , mv_table_size * 2 * sizeof(int16_t)) |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1173
diff
changeset
|
717 CHECKED_ALLOCZ(s->b_bidir_back_mv_table_base , mv_table_size * 2 * sizeof(int16_t)) |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1173
diff
changeset
|
718 CHECKED_ALLOCZ(s->b_direct_mv_table_base , mv_table_size * 2 * sizeof(int16_t)) |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1173
diff
changeset
|
719 s->p_mv_table = s->p_mv_table_base + s->mb_stride + 1; |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1173
diff
changeset
|
720 s->b_forw_mv_table = s->b_forw_mv_table_base + s->mb_stride + 1; |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1173
diff
changeset
|
721 s->b_back_mv_table = s->b_back_mv_table_base + s->mb_stride + 1; |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1173
diff
changeset
|
722 s->b_bidir_forw_mv_table= s->b_bidir_forw_mv_table_base + s->mb_stride + 1; |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1173
diff
changeset
|
723 s->b_bidir_back_mv_table= s->b_bidir_back_mv_table_base + s->mb_stride + 1; |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1173
diff
changeset
|
724 s->b_direct_mv_table = s->b_direct_mv_table_base + s->mb_stride + 1; |
324 | 725 |
650
ef4a33aad86e
reducing sizeof MpegEncContext to avoid stack overflow on crap M$ windo$
michaelni
parents:
635
diff
changeset
|
726 if(s->msmpeg4_version){ |
ef4a33aad86e
reducing sizeof MpegEncContext to avoid stack overflow on crap M$ windo$
michaelni
parents:
635
diff
changeset
|
727 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
|
728 } |
612 | 729 CHECKED_ALLOCZ(s->avctx->stats_out, 256); |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1173
diff
changeset
|
730 |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1173
diff
changeset
|
731 /* Allocate MB type table */ |
1708 | 732 CHECKED_ALLOCZ(s->mb_type , mb_array_size * sizeof(uint16_t)) //needed for encoding |
2967 | 733 |
1505
010f76d07a27
use lagrange multipler instead of qp for ratecontrol, this may break some things, tell me ASAP if u notice anything broken
michaelni
parents:
1497
diff
changeset
|
734 CHECKED_ALLOCZ(s->lambda_table, mb_array_size * sizeof(int)) |
2967 | 735 |
1553
541681146f83
move q_*_matrix out of MpegEncContext (40k ->23k) dct_quantize() is even slightly faster now, dont ask my why ...
michael
parents:
1552
diff
changeset
|
736 CHECKED_ALLOCZ(s->q_intra_matrix, 64*32 * sizeof(int)) |
541681146f83
move q_*_matrix out of MpegEncContext (40k ->23k) dct_quantize() is even slightly faster now, dont ask my why ...
michael
parents:
1552
diff
changeset
|
737 CHECKED_ALLOCZ(s->q_inter_matrix, 64*32 * sizeof(int)) |
1554
d736e24bf303
move mmx quantizer matrixes out of MpegEncContext (23k -> 7k) (no meassureable slowdown)
michael
parents:
1553
diff
changeset
|
738 CHECKED_ALLOCZ(s->q_intra_matrix16, 64*32*2 * sizeof(uint16_t)) |
d736e24bf303
move mmx quantizer matrixes out of MpegEncContext (23k -> 7k) (no meassureable slowdown)
michael
parents:
1553
diff
changeset
|
739 CHECKED_ALLOCZ(s->q_inter_matrix16, 64*32*2 * sizeof(uint16_t)) |
1556 | 740 CHECKED_ALLOCZ(s->input_picture, MAX_PICTURE_COUNT * sizeof(Picture*)) |
741 CHECKED_ALLOCZ(s->reordered_input_picture, MAX_PICTURE_COUNT * sizeof(Picture*)) | |
2967 | 742 |
1597 | 743 if(s->avctx->noise_reduction){ |
744 CHECKED_ALLOCZ(s->dct_offset, 2 * 64 * sizeof(uint16_t)) | |
745 } | |
232
b640ec5948b0
- Now the ME is done for the entire picture when enconding, the
pulento
parents:
231
diff
changeset
|
746 } |
1552
26c6ecba99a1
dynamic alloc of picture structs instead of putting them in MpegEncContext
michael
parents:
1546
diff
changeset
|
747 CHECKED_ALLOCZ(s->picture, MAX_PICTURE_COUNT * sizeof(Picture)) |
26c6ecba99a1
dynamic alloc of picture structs instead of putting them in MpegEncContext
michael
parents:
1546
diff
changeset
|
748 |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1173
diff
changeset
|
749 CHECKED_ALLOCZ(s->error_status_table, mb_array_size*sizeof(uint8_t)) |
2967 | 750 |
1708 | 751 if(s->codec_id==CODEC_ID_MPEG4 || (s->flags & CODEC_FLAG_INTERLACED_ME)){ |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
731
diff
changeset
|
752 /* interlaced direct mode decoding tables */ |
1708 | 753 for(i=0; i<2; i++){ |
754 int j, k; | |
755 for(j=0; j<2; j++){ | |
756 for(k=0; k<2; k++){ | |
757 CHECKED_ALLOCZ(s->b_field_mv_table_base[i][j][k] , mv_table_size * 2 * sizeof(int16_t)) | |
758 s->b_field_mv_table[i][j][k] = s->b_field_mv_table_base[i][j][k] + s->mb_stride + 1; | |
759 } | |
760 CHECKED_ALLOCZ(s->b_field_select_table[i][j] , mb_array_size * 2 * sizeof(uint8_t)) | |
761 CHECKED_ALLOCZ(s->p_field_mv_table_base[i][j] , mv_table_size * 2 * sizeof(int16_t)) | |
762 s->p_field_mv_table[i][j] = s->p_field_mv_table_base[i][j] + s->mb_stride + 1; | |
763 } | |
764 CHECKED_ALLOCZ(s->p_field_select_table[i] , mb_array_size * 2 * sizeof(uint8_t)) | |
765 } | |
0 | 766 } |
767 | 767 if (s->out_format == FMT_H263) { |
0 | 768 /* ac values */ |
1938
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1918
diff
changeset
|
769 CHECKED_ALLOCZ(s->ac_val_base, yc_size * sizeof(int16_t) * 16); |
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1918
diff
changeset
|
770 s->ac_val[0] = s->ac_val_base + s->b8_stride + 1; |
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1918
diff
changeset
|
771 s->ac_val[1] = s->ac_val_base + y_size + s->mb_stride + 1; |
0 | 772 s->ac_val[2] = s->ac_val[1] + c_size; |
2967 | 773 |
0 | 774 /* cbp values */ |
1938
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1918
diff
changeset
|
775 CHECKED_ALLOCZ(s->coded_block_base, y_size); |
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1918
diff
changeset
|
776 s->coded_block= s->coded_block_base + s->b8_stride + 1; |
2967 | 777 |
456 | 778 /* cbp, ac_pred, pred_dir */ |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1173
diff
changeset
|
779 CHECKED_ALLOCZ(s->cbp_table , mb_array_size * sizeof(uint8_t)) |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1173
diff
changeset
|
780 CHECKED_ALLOCZ(s->pred_dir_table, mb_array_size * 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
|
781 } |
2967 | 782 |
756 | 783 if (s->h263_pred || s->h263_plus || !s->encoding) { |
784 /* dc values */ | |
785 //MN: we need these for error resilience of intra-frames | |
1938
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1918
diff
changeset
|
786 CHECKED_ALLOCZ(s->dc_val_base, yc_size * sizeof(int16_t)); |
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1918
diff
changeset
|
787 s->dc_val[0] = s->dc_val_base + s->b8_stride + 1; |
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1918
diff
changeset
|
788 s->dc_val[1] = s->dc_val_base + y_size + s->mb_stride + 1; |
756 | 789 s->dc_val[2] = s->dc_val[1] + c_size; |
790 for(i=0;i<yc_size;i++) | |
1938
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1918
diff
changeset
|
791 s->dc_val_base[i] = 1024; |
756 | 792 } |
793 | |
611
3214d3f4519e
error concealment needs the mbintra_table so it should allways be allocated
michaelni
parents:
608
diff
changeset
|
794 /* which mb is a intra block */ |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1173
diff
changeset
|
795 CHECKED_ALLOCZ(s->mbintra_table, mb_array_size); |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1173
diff
changeset
|
796 memset(s->mbintra_table, 1, mb_array_size); |
2967 | 797 |
7
1d3ac9654178
added skip macroblock optimization (big perf win on black regions for example)
glantau
parents:
0
diff
changeset
|
798 /* init macroblock skip table */ |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1173
diff
changeset
|
799 CHECKED_ALLOCZ(s->mbskip_table, mb_array_size+2); |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
731
diff
changeset
|
800 //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
|
801 CHECKED_ALLOCZ(s->prev_pict_types, PREV_PICT_TYPES_BUFFER_SIZE); |
2967 | 802 |
842
e460775adb38
cleanup (breaks compatibility, requested by fabrice)
michaelni
parents:
828
diff
changeset
|
803 s->parse_context.state= -1; |
1706
3ba5c493db6f
motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1705
diff
changeset
|
804 if((s->avctx->debug&(FF_DEBUG_VIS_QP|FF_DEBUG_VIS_MB_TYPE)) || (s->avctx->debug_mv)){ |
3ba5c493db6f
motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1705
diff
changeset
|
805 s->visualization_buffer[0] = av_malloc((s->mb_width*16 + 2*EDGE_WIDTH) * s->mb_height*16 + 2*EDGE_WIDTH); |
3ba5c493db6f
motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1705
diff
changeset
|
806 s->visualization_buffer[1] = av_malloc((s->mb_width*8 + EDGE_WIDTH) * s->mb_height*8 + EDGE_WIDTH); |
3ba5c493db6f
motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1705
diff
changeset
|
807 s->visualization_buffer[2] = av_malloc((s->mb_width*8 + EDGE_WIDTH) * s->mb_height*8 + EDGE_WIDTH); |
3ba5c493db6f
motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1705
diff
changeset
|
808 } |
842
e460775adb38
cleanup (breaks compatibility, requested by fabrice)
michaelni
parents:
828
diff
changeset
|
809 |
0 | 810 s->context_initialized = 1; |
1799 | 811 |
812 s->thread_context[0]= s; | |
813 for(i=1; i<s->avctx->thread_count; i++){ | |
814 s->thread_context[i]= av_malloc(sizeof(MpegEncContext)); | |
815 memcpy(s->thread_context[i], s, sizeof(MpegEncContext)); | |
816 } | |
817 | |
818 for(i=0; i<s->avctx->thread_count; i++){ | |
819 if(init_duplicate_context(s->thread_context[i], s) < 0) | |
820 goto fail; | |
821 s->thread_context[i]->start_mb_y= (s->mb_height*(i ) + s->avctx->thread_count/2) / s->avctx->thread_count; | |
822 s->thread_context[i]->end_mb_y = (s->mb_height*(i+1) + s->avctx->thread_count/2) / s->avctx->thread_count; | |
823 } | |
824 | |
0 | 825 return 0; |
826 fail: | |
244 | 827 MPV_common_end(s); |
828 return -1; | |
829 } | |
830 | |
831 /* init common structure for both encoder and decoder */ | |
832 void MPV_common_end(MpegEncContext *s) | |
833 { | |
1708 | 834 int i, j, k; |
244 | 835 |
1799 | 836 for(i=0; i<s->avctx->thread_count; i++){ |
837 free_duplicate_context(s->thread_context[i]); | |
838 } | |
839 for(i=1; i<s->avctx->thread_count; i++){ | |
840 av_freep(&s->thread_context[i]); | |
841 } | |
842 | |
1344
447b88b784ee
memleak fix by (Jake Page <jake at CS dot Stanford dot EDU>)
michaelni
parents:
1339
diff
changeset
|
843 av_freep(&s->parse_context.buffer); |
447b88b784ee
memleak fix by (Jake Page <jake at CS dot Stanford dot EDU>)
michaelni
parents:
1339
diff
changeset
|
844 s->parse_context.buffer_size=0; |
447b88b784ee
memleak fix by (Jake Page <jake at CS dot Stanford dot EDU>)
michaelni
parents:
1339
diff
changeset
|
845 |
396
fce0a2520551
removed useless header includes - use av memory functions
glantau
parents:
376
diff
changeset
|
846 av_freep(&s->mb_type); |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1173
diff
changeset
|
847 av_freep(&s->p_mv_table_base); |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1173
diff
changeset
|
848 av_freep(&s->b_forw_mv_table_base); |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1173
diff
changeset
|
849 av_freep(&s->b_back_mv_table_base); |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1173
diff
changeset
|
850 av_freep(&s->b_bidir_forw_mv_table_base); |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1173
diff
changeset
|
851 av_freep(&s->b_bidir_back_mv_table_base); |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1173
diff
changeset
|
852 av_freep(&s->b_direct_mv_table_base); |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1173
diff
changeset
|
853 s->p_mv_table= NULL; |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1173
diff
changeset
|
854 s->b_forw_mv_table= NULL; |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1173
diff
changeset
|
855 s->b_back_mv_table= NULL; |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1173
diff
changeset
|
856 s->b_bidir_forw_mv_table= NULL; |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1173
diff
changeset
|
857 s->b_bidir_back_mv_table= NULL; |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1173
diff
changeset
|
858 s->b_direct_mv_table= NULL; |
1708 | 859 for(i=0; i<2; i++){ |
860 for(j=0; j<2; j++){ | |
861 for(k=0; k<2; k++){ | |
862 av_freep(&s->b_field_mv_table_base[i][j][k]); | |
863 s->b_field_mv_table[i][j][k]=NULL; | |
864 } | |
865 av_freep(&s->b_field_select_table[i][j]); | |
866 av_freep(&s->p_field_mv_table_base[i][j]); | |
867 s->p_field_mv_table[i][j]=NULL; | |
868 } | |
869 av_freep(&s->p_field_select_table[i]); | |
870 } | |
2967 | 871 |
1938
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1918
diff
changeset
|
872 av_freep(&s->dc_val_base); |
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1918
diff
changeset
|
873 av_freep(&s->ac_val_base); |
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1918
diff
changeset
|
874 av_freep(&s->coded_block_base); |
396
fce0a2520551
removed useless header includes - use av memory functions
glantau
parents:
376
diff
changeset
|
875 av_freep(&s->mbintra_table); |
456 | 876 av_freep(&s->cbp_table); |
877 av_freep(&s->pred_dir_table); | |
2967 | 878 |
396
fce0a2520551
removed useless header includes - use av memory functions
glantau
parents:
376
diff
changeset
|
879 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
|
880 av_freep(&s->prev_pict_types); |
396
fce0a2520551
removed useless header includes - use av memory functions
glantau
parents:
376
diff
changeset
|
881 av_freep(&s->bitstream_buffer); |
2422 | 882 s->allocated_bitstream_buffer_size=0; |
883 | |
612 | 884 av_freep(&s->avctx->stats_out); |
650
ef4a33aad86e
reducing sizeof MpegEncContext to avoid stack overflow on crap M$ windo$
michaelni
parents:
635
diff
changeset
|
885 av_freep(&s->ac_stats); |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
731
diff
changeset
|
886 av_freep(&s->error_status_table); |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1173
diff
changeset
|
887 av_freep(&s->mb_index2xy); |
1505
010f76d07a27
use lagrange multipler instead of qp for ratecontrol, this may break some things, tell me ASAP if u notice anything broken
michaelni
parents:
1497
diff
changeset
|
888 av_freep(&s->lambda_table); |
1553
541681146f83
move q_*_matrix out of MpegEncContext (40k ->23k) dct_quantize() is even slightly faster now, dont ask my why ...
michael
parents:
1552
diff
changeset
|
889 av_freep(&s->q_intra_matrix); |
541681146f83
move q_*_matrix out of MpegEncContext (40k ->23k) dct_quantize() is even slightly faster now, dont ask my why ...
michael
parents:
1552
diff
changeset
|
890 av_freep(&s->q_inter_matrix); |
1554
d736e24bf303
move mmx quantizer matrixes out of MpegEncContext (23k -> 7k) (no meassureable slowdown)
michael
parents:
1553
diff
changeset
|
891 av_freep(&s->q_intra_matrix16); |
d736e24bf303
move mmx quantizer matrixes out of MpegEncContext (23k -> 7k) (no meassureable slowdown)
michael
parents:
1553
diff
changeset
|
892 av_freep(&s->q_inter_matrix16); |
1556 | 893 av_freep(&s->input_picture); |
894 av_freep(&s->reordered_input_picture); | |
1597 | 895 av_freep(&s->dct_offset); |
903 | 896 |
1573 | 897 if(s->picture){ |
898 for(i=0; i<MAX_PICTURE_COUNT; i++){ | |
899 free_picture(s, &s->picture[i]); | |
900 } | |
0 | 901 } |
1552
26c6ecba99a1
dynamic alloc of picture structs instead of putting them in MpegEncContext
michael
parents:
1546
diff
changeset
|
902 av_freep(&s->picture); |
0 | 903 s->context_initialized = 0; |
1523 | 904 s->last_picture_ptr= |
905 s->next_picture_ptr= | |
906 s->current_picture_ptr= NULL; | |
2231 | 907 s->linesize= s->uvlinesize= 0; |
1918
ea20f38b8d57
nicer looking arrows for the motion vector vissualization
michael
parents:
1916
diff
changeset
|
908 |
1706
3ba5c493db6f
motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1705
diff
changeset
|
909 for(i=0; i<3; i++) |
1918
ea20f38b8d57
nicer looking arrows for the motion vector vissualization
michael
parents:
1916
diff
changeset
|
910 av_freep(&s->visualization_buffer[i]); |
2231 | 911 |
912 avcodec_default_free_buffers(s->avctx); | |
0 | 913 } |
914 | |
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
|
915 #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
|
916 |
0 | 917 /* init video encoder */ |
918 int MPV_encode_init(AVCodecContext *avctx) | |
919 { | |
920 MpegEncContext *s = avctx->priv_data; | |
2834 | 921 int i; |
1315
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1288
diff
changeset
|
922 int chroma_h_shift, chroma_v_shift; |
2967 | 923 |
1892 | 924 MPV_encode_defaults(s); |
315 | 925 |
3309 | 926 switch (avctx->codec_id) { |
927 case CODEC_ID_MPEG2VIDEO: | |
928 if(avctx->pix_fmt != PIX_FMT_YUV420P && avctx->pix_fmt != PIX_FMT_YUV422P){ | |
929 av_log(avctx, AV_LOG_ERROR, "only YUV420 and YUV422 are supported\n"); | |
930 return -1; | |
931 } | |
932 break; | |
933 case CODEC_ID_LJPEG: | |
934 case CODEC_ID_MJPEG: | |
3929 | 935 if(avctx->pix_fmt != PIX_FMT_YUVJ420P && avctx->pix_fmt != PIX_FMT_YUVJ422P && |
936 ((avctx->pix_fmt != PIX_FMT_YUV420P && avctx->pix_fmt != PIX_FMT_YUV422P) || avctx->strict_std_compliance>FF_COMPLIANCE_INOFFICIAL)){ | |
2442 | 937 av_log(avctx, AV_LOG_ERROR, "colorspace not supported in jpeg\n"); |
938 return -1; | |
939 } | |
3309 | 940 break; |
941 default: | |
942 if(avctx->pix_fmt != PIX_FMT_YUV420P){ | |
943 av_log(avctx, AV_LOG_ERROR, "only YUV420 is supported\n"); | |
2442 | 944 return -1; |
945 } | |
946 } | |
1402
f662e9c86cf2
* fixing a regression in mpeg encoder (not setting pix_fmt),
romansh
parents:
1397
diff
changeset
|
947 |
3309 | 948 switch (avctx->pix_fmt) { |
949 case PIX_FMT_YUVJ422P: | |
950 case PIX_FMT_YUV422P: | |
951 s->chroma_format = CHROMA_422; | |
952 break; | |
953 case PIX_FMT_YUVJ420P: | |
954 case PIX_FMT_YUV420P: | |
955 default: | |
956 s->chroma_format = CHROMA_420; | |
957 break; | |
958 } | |
959 | |
0 | 960 s->bit_rate = avctx->bit_rate; |
961 s->width = avctx->width; | |
962 s->height = avctx->height; | |
3296
d185908c71cb
allow insane gop sizes if the user doesnt care about playable streams (doesnt want compliance to any standard)
michael
parents:
3286
diff
changeset
|
963 if(avctx->gop_size > 600 && avctx->strict_std_compliance>FF_COMPLIANCE_EXPERIMENTAL){ |
2979 | 964 av_log(avctx, AV_LOG_ERROR, "Warning keyframe interval too large! reducing it ...\n"); |
456 | 965 avctx->gop_size=600; |
966 } | |
0 | 967 s->gop_size = avctx->gop_size; |
194
27d1773552c9
mpeg4 encoder fix by Michael Niedermayer <michaelni@gmx.at>
arpi_esp
parents:
191
diff
changeset
|
968 s->avctx = avctx; |
294 | 969 s->flags= avctx->flags; |
1754
bdf3927bf8c5
closed gop support & flags2 as all bits in flags are used
michael
parents:
1751
diff
changeset
|
970 s->flags2= avctx->flags2; |
324 | 971 s->max_b_frames= avctx->max_b_frames; |
344 | 972 s->codec_id= avctx->codec->id; |
456 | 973 s->luma_elim_threshold = avctx->luma_elim_threshold; |
974 s->chroma_elim_threshold= avctx->chroma_elim_threshold; | |
975 s->strict_std_compliance= avctx->strict_std_compliance; | |
976 s->data_partitioning= avctx->flags & CODEC_FLAG_PART; | |
936 | 977 s->quarter_sample= (avctx->flags & CODEC_FLAG_QPEL)!=0; |
599 | 978 s->mpeg_quant= avctx->mpeg_quant; |
1661 | 979 s->rtp_mode= !!avctx->rtp_payload_size; |
1992 | 980 s->intra_dc_precision= avctx->intra_dc_precision; |
2243
b8bad8bbbc64
check if the user specified timestamps are strictly monotone
michael
parents:
2235
diff
changeset
|
981 s->user_specified_pts = AV_NOPTS_VALUE; |
1422
efeed6e29f9b
oooooops, having 2 Eterms open and doing cvs diff in one and cvs commit in the other sucks, especially if they are in different directories (MPlayer/main/libavcodec vs. ffmpeg/libavcodec)
michaelni
parents:
1421
diff
changeset
|
982 |
0 | 983 if (s->gop_size <= 1) { |
984 s->intra_only = 1; | |
985 s->gop_size = 12; | |
986 } else { | |
987 s->intra_only = 0; | |
988 } | |
693
b6a7ff92df57
darkness masking (lumi masking does only bright stuff now)
michaelni
parents:
690
diff
changeset
|
989 |
936 | 990 s->me_method = avctx->me_method; |
693
b6a7ff92df57
darkness masking (lumi masking does only bright stuff now)
michaelni
parents:
690
diff
changeset
|
991 |
320
cda7d0857baf
- ME setting moved to AVCodecContext/MpegEncContext, no longer a global.
pulento
parents:
315
diff
changeset
|
992 /* Fixed QSCALE */ |
1708 | 993 s->fixed_qscale = !!(avctx->flags & CODEC_FLAG_QSCALE); |
2967 | 994 |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
673
diff
changeset
|
995 s->adaptive_quant= ( s->avctx->lumi_masking |
693
b6a7ff92df57
darkness masking (lumi masking does only bright stuff now)
michaelni
parents:
690
diff
changeset
|
996 || s->avctx->dark_masking |
2967 | 997 || s->avctx->temporal_cplx_masking |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
673
diff
changeset
|
998 || s->avctx->spatial_cplx_masking |
1616 | 999 || s->avctx->p_masking |
2493
258120c61eea
Border processing adaptive quant patch by (Christophe Massiot |cmassiot freebox fr)
michael
parents:
2492
diff
changeset
|
1000 || s->avctx->border_masking |
1616 | 1001 || (s->flags&CODEC_FLAG_QP_RD)) |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
673
diff
changeset
|
1002 && !s->fixed_qscale; |
2967 | 1003 |
1708 | 1004 s->obmc= !!(s->flags & CODEC_FLAG_OBMC); |
1005 s->loop_filter= !!(s->flags & CODEC_FLAG_LOOP_FILTER); | |
1006 s->alternate_scan= !!(s->flags & CODEC_FLAG_ALT_SCAN); | |
3305 | 1007 s->intra_vlc_format= !!(s->flags2 & CODEC_FLAG2_INTRA_VLC); |
4621 | 1008 s->q_scale_type= !!(s->flags2 & CODEC_FLAG2_NON_LINEAR_QUANT); |
1633 | 1009 |
1711 | 1010 if(avctx->rc_max_rate && !avctx->rc_buffer_size){ |
1011 av_log(avctx, AV_LOG_ERROR, "a vbv buffer size is needed, for encoding with a maximum bitrate\n"); | |
1012 return -1; | |
2967 | 1013 } |
1711 | 1014 |
1015 if(avctx->rc_min_rate && avctx->rc_max_rate != avctx->rc_min_rate){ | |
2627
bf158d23bbcc
Spelling errors patch by (Kevin Baragona | kevinmb500 gawab com)
michael
parents:
2620
diff
changeset
|
1016 av_log(avctx, AV_LOG_INFO, "Warning min_rate > 0 but min_rate != max_rate isn't recommended!\n"); |
1907 | 1017 } |
2967 | 1018 |
2063 | 1019 if(avctx->rc_min_rate && avctx->rc_min_rate > avctx->bit_rate){ |
5048 | 1020 av_log(avctx, AV_LOG_ERROR, "bitrate below min bitrate\n"); |
2063 | 1021 return -1; |
1022 } | |
2967 | 1023 |
2063 | 1024 if(avctx->rc_max_rate && avctx->rc_max_rate < avctx->bit_rate){ |
1025 av_log(avctx, AV_LOG_INFO, "bitrate above max bitrate\n"); | |
1026 return -1; | |
1027 } | |
2967 | 1028 |
5047
460a12052adf
sanity checks for bitrate tolerance and buffer size (= fail if a single frame at the
michael
parents:
5030
diff
changeset
|
1029 if(avctx->rc_buffer_size && avctx->bit_rate*av_q2d(avctx->time_base) > avctx->rc_buffer_size){ |
5048 | 1030 av_log(avctx, AV_LOG_ERROR, "VBV buffer too small for bitrate\n"); |
5047
460a12052adf
sanity checks for bitrate tolerance and buffer size (= fail if a single frame at the
michael
parents:
5030
diff
changeset
|
1031 return -1; |
460a12052adf
sanity checks for bitrate tolerance and buffer size (= fail if a single frame at the
michael
parents:
5030
diff
changeset
|
1032 } |
460a12052adf
sanity checks for bitrate tolerance and buffer size (= fail if a single frame at the
michael
parents:
5030
diff
changeset
|
1033 |
460a12052adf
sanity checks for bitrate tolerance and buffer size (= fail if a single frame at the
michael
parents:
5030
diff
changeset
|
1034 if(avctx->bit_rate*av_q2d(avctx->time_base) > avctx->bit_rate_tolerance){ |
5048 | 1035 av_log(avctx, AV_LOG_ERROR, "bitrate tolerance too small for bitrate\n"); |
5047
460a12052adf
sanity checks for bitrate tolerance and buffer size (= fail if a single frame at the
michael
parents:
5030
diff
changeset
|
1036 return -1; |
460a12052adf
sanity checks for bitrate tolerance and buffer size (= fail if a single frame at the
michael
parents:
5030
diff
changeset
|
1037 } |
460a12052adf
sanity checks for bitrate tolerance and buffer size (= fail if a single frame at the
michael
parents:
5030
diff
changeset
|
1038 |
2967 | 1039 if( s->avctx->rc_max_rate && s->avctx->rc_min_rate == s->avctx->rc_max_rate |
1907 | 1040 && (s->codec_id == CODEC_ID_MPEG1VIDEO || s->codec_id == CODEC_ID_MPEG2VIDEO) |
1041 && 90000LL * (avctx->rc_buffer_size-1) > s->avctx->rc_max_rate*0xFFFFLL){ | |
2967 | 1042 |
1907 | 1043 av_log(avctx, AV_LOG_INFO, "Warning vbv_delay will be set to 0xFFFF (=VBR) as the specified vbv buffer is too large for the given bitrate!\n"); |
1044 } | |
2967 | 1045 |
1046 if((s->flags & CODEC_FLAG_4MV) && s->codec_id != CODEC_ID_MPEG4 | |
1790 | 1047 && s->codec_id != CODEC_ID_H263 && s->codec_id != CODEC_ID_H263P && s->codec_id != CODEC_ID_FLV1){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1597
diff
changeset
|
1048 av_log(avctx, AV_LOG_ERROR, "4MV not supported by codec\n"); |
1188 | 1049 return -1; |
1050 } | |
2967 | 1051 |
1633 | 1052 if(s->obmc && s->avctx->mb_decision != FF_MB_DECISION_SIMPLE){ |
2627
bf158d23bbcc
Spelling errors patch by (Kevin Baragona | kevinmb500 gawab com)
michael
parents:
2620
diff
changeset
|
1053 av_log(avctx, AV_LOG_ERROR, "OBMC is only supported with simple mb decision\n"); |
1633 | 1054 return -1; |
1055 } | |
2967 | 1056 |
1644 | 1057 if(s->obmc && s->codec_id != CODEC_ID_H263 && s->codec_id != CODEC_ID_H263P){ |
1058 av_log(avctx, AV_LOG_ERROR, "OBMC is only supported with H263(+)\n"); | |
1059 return -1; | |
1060 } | |
2967 | 1061 |
1188 | 1062 if(s->quarter_sample && s->codec_id != CODEC_ID_MPEG4){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1597
diff
changeset
|
1063 av_log(avctx, AV_LOG_ERROR, "qpel not supported by codec\n"); |
1188 | 1064 return -1; |
1065 } | |
1066 | |
1067 if(s->data_partitioning && s->codec_id != CODEC_ID_MPEG4){ | |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1597
diff
changeset
|
1068 av_log(avctx, AV_LOG_ERROR, "data partitioning not supported by codec\n"); |
1188 | 1069 return -1; |
1070 } | |
2967 | 1071 |
1421 | 1072 if(s->max_b_frames && s->codec_id != CODEC_ID_MPEG4 && s->codec_id != CODEC_ID_MPEG1VIDEO && s->codec_id != CODEC_ID_MPEG2VIDEO){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1597
diff
changeset
|
1073 av_log(avctx, AV_LOG_ERROR, "b frames not supported by codec\n"); |
1188 | 1074 return -1; |
1075 } | |
1958 | 1076 |
2967 | 1077 if((s->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME|CODEC_FLAG_ALT_SCAN)) |
1958 | 1078 && s->codec_id != CODEC_ID_MPEG4 && s->codec_id != CODEC_ID_MPEG2VIDEO){ |
1079 av_log(avctx, AV_LOG_ERROR, "interlacing not supported by codec\n"); | |
1080 return -1; | |
1081 } | |
2967 | 1082 |
1188 | 1083 if(s->mpeg_quant && s->codec_id != CODEC_ID_MPEG4){ //FIXME mpeg2 uses that too |
2627
bf158d23bbcc
Spelling errors patch by (Kevin Baragona | kevinmb500 gawab com)
michael
parents:
2620
diff
changeset
|
1084 av_log(avctx, AV_LOG_ERROR, "mpeg2 style quantization not supported by codec\n"); |
1188 | 1085 return -1; |
1086 } | |
2967 | 1087 |
1490
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1480
diff
changeset
|
1088 if((s->flags & CODEC_FLAG_CBP_RD) && !(s->flags & CODEC_FLAG_TRELLIS_QUANT)){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1597
diff
changeset
|
1089 av_log(avctx, AV_LOG_ERROR, "CBP RD needs trellis quant\n"); |
1490
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1480
diff
changeset
|
1090 return -1; |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1480
diff
changeset
|
1091 } |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1480
diff
changeset
|
1092 |
1622 | 1093 if((s->flags & CODEC_FLAG_QP_RD) && s->avctx->mb_decision != FF_MB_DECISION_RD){ |
1094 av_log(avctx, AV_LOG_ERROR, "QP RD needs mbd=2\n"); | |
1095 return -1; | |
1096 } | |
2967 | 1097 |
1754
bdf3927bf8c5
closed gop support & flags2 as all bits in flags are used
michael
parents:
1751
diff
changeset
|
1098 if(s->avctx->scenechange_threshold < 1000000000 && (s->flags & CODEC_FLAG_CLOSED_GOP)){ |
4399
daa2a095181d
add hint for closed gop and sc threshold error message
bcoudurier
parents:
4396
diff
changeset
|
1099 av_log(avctx, AV_LOG_ERROR, "closed gop with scene change detection arent supported yet, set threshold to 1000000000\n"); |
1754
bdf3927bf8c5
closed gop support & flags2 as all bits in flags are used
michael
parents:
1751
diff
changeset
|
1100 return -1; |
bdf3927bf8c5
closed gop support & flags2 as all bits in flags are used
michael
parents:
1751
diff
changeset
|
1101 } |
2967 | 1102 |
3305 | 1103 if((s->flags2 & CODEC_FLAG2_INTRA_VLC) && s->codec_id != CODEC_ID_MPEG2VIDEO){ |
1104 av_log(avctx, AV_LOG_ERROR, "intra vlc table not supported by codec\n"); | |
1105 return -1; | |
1106 } | |
1107 | |
4189
3c98b0938897
add low delay forcing option for mpeg1/2 encoding
bcoudurier
parents:
4179
diff
changeset
|
1108 if(s->flags & CODEC_FLAG_LOW_DELAY){ |
3c98b0938897
add low delay forcing option for mpeg1/2 encoding
bcoudurier
parents:
4179
diff
changeset
|
1109 if (s->codec_id != CODEC_ID_MPEG2VIDEO && s->codec_id != CODEC_ID_MPEG1VIDEO){ |
3c98b0938897
add low delay forcing option for mpeg1/2 encoding
bcoudurier
parents:
4179
diff
changeset
|
1110 av_log(avctx, AV_LOG_ERROR, "low delay forcing is only available for mpeg1/2\n"); |
3c98b0938897
add low delay forcing option for mpeg1/2 encoding
bcoudurier
parents:
4179
diff
changeset
|
1111 return -1; |
3c98b0938897
add low delay forcing option for mpeg1/2 encoding
bcoudurier
parents:
4179
diff
changeset
|
1112 } |
3c98b0938897
add low delay forcing option for mpeg1/2 encoding
bcoudurier
parents:
4179
diff
changeset
|
1113 if (s->max_b_frames != 0){ |
3c98b0938897
add low delay forcing option for mpeg1/2 encoding
bcoudurier
parents:
4179
diff
changeset
|
1114 av_log(avctx, AV_LOG_ERROR, "b frames cannot be used with low delay\n"); |
3c98b0938897
add low delay forcing option for mpeg1/2 encoding
bcoudurier
parents:
4179
diff
changeset
|
1115 return -1; |
3c98b0938897
add low delay forcing option for mpeg1/2 encoding
bcoudurier
parents:
4179
diff
changeset
|
1116 } |
3c98b0938897
add low delay forcing option for mpeg1/2 encoding
bcoudurier
parents:
4179
diff
changeset
|
1117 } |
3c98b0938897
add low delay forcing option for mpeg1/2 encoding
bcoudurier
parents:
4179
diff
changeset
|
1118 |
4621 | 1119 if(s->q_scale_type == 1){ |
1120 if(s->codec_id != CODEC_ID_MPEG2VIDEO){ | |
1121 av_log(avctx, AV_LOG_ERROR, "non linear quant is only available for mpeg2\n"); | |
1122 return -1; | |
1123 } | |
1124 if(avctx->qmax > 12){ | |
1125 av_log(avctx, AV_LOG_ERROR, "non linear quant only supports qmax <= 12 currently\n"); | |
1126 return -1; | |
1127 } | |
1128 } | |
1129 | |
2967 | 1130 if(s->avctx->thread_count > 1 && s->codec_id != CODEC_ID_MPEG4 |
1131 && s->codec_id != CODEC_ID_MPEG1VIDEO && s->codec_id != CODEC_ID_MPEG2VIDEO | |
1799 | 1132 && (s->codec_id != CODEC_ID_H263P || !(s->flags & CODEC_FLAG_H263P_SLICE_STRUCT))){ |
1133 av_log(avctx, AV_LOG_ERROR, "multi threaded encoding not supported by codec\n"); | |
1134 return -1; | |
1135 } | |
2967 | 1136 |
1799 | 1137 if(s->avctx->thread_count > 1) |
1138 s->rtp_mode= 1; | |
1760 | 1139 |
2637 | 1140 if(!avctx->time_base.den || !avctx->time_base.num){ |
2450 | 1141 av_log(avctx, AV_LOG_ERROR, "framerate not set\n"); |
1142 return -1; | |
1143 } | |
2967 | 1144 |
2576
e237d9bd0f8c
check mb/me_threshold range, fixes assertion failure
michael
parents:
2570
diff
changeset
|
1145 i= (INT_MAX/2+128)>>8; |
e237d9bd0f8c
check mb/me_threshold range, fixes assertion failure
michael
parents:
2570
diff
changeset
|
1146 if(avctx->me_threshold >= i){ |
e237d9bd0f8c
check mb/me_threshold range, fixes assertion failure
michael
parents:
2570
diff
changeset
|
1147 av_log(avctx, AV_LOG_ERROR, "me_threshold too large, max is %d\n", i - 1); |
e237d9bd0f8c
check mb/me_threshold range, fixes assertion failure
michael
parents:
2570
diff
changeset
|
1148 return -1; |
e237d9bd0f8c
check mb/me_threshold range, fixes assertion failure
michael
parents:
2570
diff
changeset
|
1149 } |
e237d9bd0f8c
check mb/me_threshold range, fixes assertion failure
michael
parents:
2570
diff
changeset
|
1150 if(avctx->mb_threshold >= i){ |
e237d9bd0f8c
check mb/me_threshold range, fixes assertion failure
michael
parents:
2570
diff
changeset
|
1151 av_log(avctx, AV_LOG_ERROR, "mb_threshold too large, max is %d\n", i - 1); |
e237d9bd0f8c
check mb/me_threshold range, fixes assertion failure
michael
parents:
2570
diff
changeset
|
1152 return -1; |
e237d9bd0f8c
check mb/me_threshold range, fixes assertion failure
michael
parents:
2570
diff
changeset
|
1153 } |
2967 | 1154 |
2668 | 1155 if(avctx->b_frame_strategy && (avctx->flags&CODEC_FLAG_PASS2)){ |
3321
8869b4dd2ffe
Make b_frame_strategy not fail on pass 2, but still print a notice.
corey
parents:
3316
diff
changeset
|
1156 av_log(avctx, AV_LOG_INFO, "notice: b_frame_strategy only affects the first pass\n"); |
8869b4dd2ffe
Make b_frame_strategy not fail on pass 2, but still print a notice.
corey
parents:
3316
diff
changeset
|
1157 avctx->b_frame_strategy = 0; |
2668 | 1158 } |
1159 | |
2637 | 1160 i= ff_gcd(avctx->time_base.den, avctx->time_base.num); |
1760 | 1161 if(i > 1){ |
1162 av_log(avctx, AV_LOG_INFO, "removing common factors from framerate\n"); | |
2637 | 1163 avctx->time_base.den /= i; |
1164 avctx->time_base.num /= i; | |
1760 | 1165 // return -1; |
1166 } | |
2967 | 1167 |
1150 | 1168 if(s->codec_id==CODEC_ID_MJPEG){ |
1169 s->intra_quant_bias= 1<<(QUANT_BIAS_SHIFT-1); //(a + x/2)/x | |
1170 s->inter_quant_bias= 0; | |
1421 | 1171 }else if(s->mpeg_quant || s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO){ |
1150 | 1172 s->intra_quant_bias= 3<<(QUANT_BIAS_SHIFT-3); //(a + x*3/8)/x |
1173 s->inter_quant_bias= 0; | |
1174 }else{ | |
1175 s->intra_quant_bias=0; | |
1176 s->inter_quant_bias=-(1<<(QUANT_BIAS_SHIFT-2)); //(a - x/4)/x | |
1177 } | |
2967 | 1178 |
1150 | 1179 if(avctx->intra_quant_bias != FF_DEFAULT_QUANT_BIAS) |
1180 s->intra_quant_bias= avctx->intra_quant_bias; | |
1181 if(avctx->inter_quant_bias != FF_DEFAULT_QUANT_BIAS) | |
1182 s->inter_quant_bias= avctx->inter_quant_bias; | |
2967 | 1183 |
1315
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1288
diff
changeset
|
1184 avcodec_get_chroma_sub_sample(avctx->pix_fmt, &chroma_h_shift, &chroma_v_shift); |
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1288
diff
changeset
|
1185 |
2653
2515af7d3238
complain about mpeg4 limits only if codec_id == MPEG4
michael
parents:
2639
diff
changeset
|
1186 if(avctx->codec_id == CODEC_ID_MPEG4 && s->avctx->time_base.den > (1<<16)-1){ |
2637 | 1187 av_log(avctx, AV_LOG_ERROR, "timebase not supported by mpeg 4 standard\n"); |
2967 | 1188 return -1; |
2637 | 1189 } |
1190 s->time_increment_bits = av_log2(s->avctx->time_base.den - 1) + 1; | |
1424 | 1191 |
0 | 1192 switch(avctx->codec->id) { |
1193 case CODEC_ID_MPEG1VIDEO: | |
1194 s->out_format = FMT_MPEG1; | |
4189
3c98b0938897
add low delay forcing option for mpeg1/2 encoding
bcoudurier
parents:
4179
diff
changeset
|
1195 s->low_delay= !!(s->flags & CODEC_FLAG_LOW_DELAY); |
1126
77ccf7fe3bd0
per context frame_rate_base, this should finally fix frame_rate related av sync issues
michaelni
parents:
1124
diff
changeset
|
1196 avctx->delay= s->low_delay ? 0 : (s->max_b_frames + 1); |
0 | 1197 break; |
1421 | 1198 case CODEC_ID_MPEG2VIDEO: |
1199 s->out_format = FMT_MPEG1; | |
4189
3c98b0938897
add low delay forcing option for mpeg1/2 encoding
bcoudurier
parents:
4179
diff
changeset
|
1200 s->low_delay= !!(s->flags & CODEC_FLAG_LOW_DELAY); |
1421 | 1201 avctx->delay= s->low_delay ? 0 : (s->max_b_frames + 1); |
1661 | 1202 s->rtp_mode= 1; |
1421 | 1203 break; |
1315
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1288
diff
changeset
|
1204 case CODEC_ID_LJPEG: |
0 | 1205 case CODEC_ID_MJPEG: |
1206 s->out_format = FMT_MJPEG; | |
1207 s->intra_only = 1; /* force intra only for jpeg */ | |
3929 | 1208 s->mjpeg_vsample[0] = 2; |
1209 s->mjpeg_vsample[1] = 2>>chroma_v_shift; | |
1210 s->mjpeg_vsample[2] = 2>>chroma_v_shift; | |
1211 s->mjpeg_hsample[0] = 2; | |
1212 s->mjpeg_hsample[1] = 2>>chroma_h_shift; | |
1213 s->mjpeg_hsample[2] = 2>>chroma_h_shift; | |
5029
dbaa06366c3c
add a proper prefix to all mjpeg encoder exported functions
aurel
parents:
5028
diff
changeset
|
1214 if (!(ENABLE_MJPEG_ENCODER || ENABLE_LJPEG_ENCODER) |
dbaa06366c3c
add a proper prefix to all mjpeg encoder exported functions
aurel
parents:
5028
diff
changeset
|
1215 || ff_mjpeg_encode_init(s) < 0) |
0 | 1216 return -1; |
336 | 1217 avctx->delay=0; |
924 | 1218 s->low_delay=1; |
0 | 1219 break; |
2327
5e5cf598a48b
H.261 encoder by (Maarten Daniels <maarten dot daniels at luc dot ac dot be>)
michael
parents:
2298
diff
changeset
|
1220 case CODEC_ID_H261: |
4997 | 1221 if (!ENABLE_H261_ENCODER) return -1; |
4206
be94e97ecb6e
throw error if unsupported resolution is used with h261
bcoudurier
parents:
4189
diff
changeset
|
1222 if (ff_h261_get_picture_format(s->width, s->height) < 0) { |
be94e97ecb6e
throw error if unsupported resolution is used with h261
bcoudurier
parents:
4189
diff
changeset
|
1223 av_log(avctx, AV_LOG_ERROR, "The specified picture size of %dx%d is not valid for the H.261 codec.\nValid sizes are 176x144, 352x288\n", s->width, s->height); |
be94e97ecb6e
throw error if unsupported resolution is used with h261
bcoudurier
parents:
4189
diff
changeset
|
1224 return -1; |
be94e97ecb6e
throw error if unsupported resolution is used with h261
bcoudurier
parents:
4189
diff
changeset
|
1225 } |
2327
5e5cf598a48b
H.261 encoder by (Maarten Daniels <maarten dot daniels at luc dot ac dot be>)
michael
parents:
2298
diff
changeset
|
1226 s->out_format = FMT_H261; |
5e5cf598a48b
H.261 encoder by (Maarten Daniels <maarten dot daniels at luc dot ac dot be>)
michael
parents:
2298
diff
changeset
|
1227 avctx->delay=0; |
5e5cf598a48b
H.261 encoder by (Maarten Daniels <maarten dot daniels at luc dot ac dot be>)
michael
parents:
2298
diff
changeset
|
1228 s->low_delay=1; |
5e5cf598a48b
H.261 encoder by (Maarten Daniels <maarten dot daniels at luc dot ac dot be>)
michael
parents:
2298
diff
changeset
|
1229 break; |
0 | 1230 case CODEC_ID_H263: |
232
b640ec5948b0
- Now the ME is done for the entire picture when enconding, the
pulento
parents:
231
diff
changeset
|
1231 if (h263_get_picture_format(s->width, s->height) == 7) { |
3011 | 1232 av_log(avctx, AV_LOG_INFO, "The specified picture size of %dx%d is not valid for the H.263 codec.\nValid sizes are 128x96, 176x144, 352x288, 704x576, and 1408x1152. Try H.263+.\n", s->width, s->height); |
0 | 1233 return -1; |
232
b640ec5948b0
- Now the ME is done for the entire picture when enconding, the
pulento
parents:
231
diff
changeset
|
1234 } |
0 | 1235 s->out_format = FMT_H263; |
2979 | 1236 s->obmc= (avctx->flags & CODEC_FLAG_OBMC) ? 1:0; |
336 | 1237 avctx->delay=0; |
924 | 1238 s->low_delay=1; |
0 | 1239 break; |
1240 case CODEC_ID_H263P: | |
1241 s->out_format = FMT_H263; | |
1242 s->h263_plus = 1; | |
2979 | 1243 /* Fx */ |
1644 | 1244 s->umvplus = (avctx->flags & CODEC_FLAG_H263P_UMV) ? 1:0; |
4610
c81aa982b72b
get rid of CODEC_FLAG_H263P_AIC with next major bump
bcoudurier
parents:
4594
diff
changeset
|
1245 s->h263_aic= (avctx->flags & CODEC_FLAG_AC_PRED) ? 1:0; |
2979 | 1246 s->modified_quant= s->h263_aic; |
1247 s->alt_inter_vlc= (avctx->flags & CODEC_FLAG_H263P_AIV) ? 1:0; | |
1248 s->obmc= (avctx->flags & CODEC_FLAG_OBMC) ? 1:0; | |
1249 s->loop_filter= (avctx->flags & CODEC_FLAG_LOOP_FILTER) ? 1:0; | |
1250 s->unrestricted_mv= s->obmc || s->loop_filter || s->umvplus; | |
1661 | 1251 s->h263_slice_structured= (s->flags & CODEC_FLAG_H263P_SLICE_STRUCT) ? 1:0; |
1644 | 1252 |
2979 | 1253 /* /Fx */ |
79
82e579c37bc3
Moved some H.263+ variables to MpegEncContext to be thread-safe.
pulento
parents:
78
diff
changeset
|
1254 /* These are just to be sure */ |
336 | 1255 avctx->delay=0; |
924 | 1256 s->low_delay=1; |
0 | 1257 break; |
1353
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1344
diff
changeset
|
1258 case CODEC_ID_FLV1: |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1344
diff
changeset
|
1259 s->out_format = FMT_H263; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1344
diff
changeset
|
1260 s->h263_flv = 2; /* format = 1; 11-bit codes */ |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1344
diff
changeset
|
1261 s->unrestricted_mv = 1; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1344
diff
changeset
|
1262 s->rtp_mode=0; /* don't allow GOB */ |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1344
diff
changeset
|
1263 avctx->delay=0; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1344
diff
changeset
|
1264 s->low_delay=1; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1344
diff
changeset
|
1265 break; |
0 | 1266 case CODEC_ID_RV10: |
1267 s->out_format = FMT_H263; | |
336 | 1268 avctx->delay=0; |
924 | 1269 s->low_delay=1; |
0 | 1270 break; |
2380 | 1271 case CODEC_ID_RV20: |
1272 s->out_format = FMT_H263; | |
1273 avctx->delay=0; | |
1274 s->low_delay=1; | |
1275 s->modified_quant=1; | |
1276 s->h263_aic=1; | |
1277 s->h263_plus=1; | |
1278 s->loop_filter=1; | |
1279 s->unrestricted_mv= s->obmc || s->loop_filter || s->umvplus; | |
1280 break; | |
71 | 1281 case CODEC_ID_MPEG4: |
0 | 1282 s->out_format = FMT_H263; |
1283 s->h263_pred = 1; | |
1284 s->unrestricted_mv = 1; | |
924 | 1285 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
|
1286 avctx->delay= s->low_delay ? 0 : (s->max_b_frames + 1); |
0 | 1287 break; |
307 | 1288 case CODEC_ID_MSMPEG4V1: |
0 | 1289 s->out_format = FMT_H263; |
1290 s->h263_msmpeg4 = 1; | |
1291 s->h263_pred = 1; | |
1292 s->unrestricted_mv = 1; | |
307 | 1293 s->msmpeg4_version= 1; |
336 | 1294 avctx->delay=0; |
924 | 1295 s->low_delay=1; |
307 | 1296 break; |
1297 case CODEC_ID_MSMPEG4V2: | |
1298 s->out_format = FMT_H263; | |
1299 s->h263_msmpeg4 = 1; | |
1300 s->h263_pred = 1; | |
1301 s->unrestricted_mv = 1; | |
1302 s->msmpeg4_version= 2; | |
336 | 1303 avctx->delay=0; |
924 | 1304 s->low_delay=1; |
307 | 1305 break; |
1306 case CODEC_ID_MSMPEG4V3: | |
1307 s->out_format = FMT_H263; | |
1308 s->h263_msmpeg4 = 1; | |
1309 s->h263_pred = 1; | |
1310 s->unrestricted_mv = 1; | |
1311 s->msmpeg4_version= 3; | |
1163 | 1312 s->flipflop_rounding=1; |
336 | 1313 avctx->delay=0; |
924 | 1314 s->low_delay=1; |
0 | 1315 break; |
499 | 1316 case CODEC_ID_WMV1: |
1317 s->out_format = FMT_H263; | |
1318 s->h263_msmpeg4 = 1; | |
1319 s->h263_pred = 1; | |
1320 s->unrestricted_mv = 1; | |
1321 s->msmpeg4_version= 4; | |
1163 | 1322 s->flipflop_rounding=1; |
499 | 1323 avctx->delay=0; |
924 | 1324 s->low_delay=1; |
499 | 1325 break; |
1326 case CODEC_ID_WMV2: | |
1327 s->out_format = FMT_H263; | |
1328 s->h263_msmpeg4 = 1; | |
1329 s->h263_pred = 1; | |
1330 s->unrestricted_mv = 1; | |
1331 s->msmpeg4_version= 5; | |
1163 | 1332 s->flipflop_rounding=1; |
499 | 1333 avctx->delay=0; |
924 | 1334 s->low_delay=1; |
499 | 1335 break; |
0 | 1336 default: |
1337 return -1; | |
1338 } | |
2967 | 1339 |
2042 | 1340 avctx->has_b_frames= !s->low_delay; |
1749
7b11032507e2
removing broken framerate conversation hack in mpeg1/2
michael
parents:
1742
diff
changeset
|
1341 |
7
1d3ac9654178
added skip macroblock optimization (big perf win on black regions for example)
glantau
parents:
0
diff
changeset
|
1342 s->encoding = 1; |
1d3ac9654178
added skip macroblock optimization (big perf win on black regions for example)
glantau
parents:
0
diff
changeset
|
1343 |
0 | 1344 /* init */ |
1345 if (MPV_common_init(s) < 0) | |
1346 return -1; | |
1678 | 1347 |
1348 if(s->modified_quant) | |
1349 s->chroma_qscale_table= ff_h263_chroma_qscale_table; | |
2967 | 1350 s->progressive_frame= |
4121 | 1351 s->progressive_sequence= !(avctx->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME|CODEC_FLAG_ALT_SCAN)); |
1799 | 1352 s->quant_precision=5; |
2967 | 1353 |
1729 | 1354 ff_set_cmp(&s->dsp, s->dsp.ildct_cmp, s->avctx->ildct_cmp); |
2382 | 1355 ff_set_cmp(&s->dsp, s->dsp.frame_skip_cmp, s->avctx->frame_skip_cmp); |
2967 | 1356 |
4997 | 1357 if (ENABLE_H261_ENCODER && s->out_format == FMT_H261) |
2327
5e5cf598a48b
H.261 encoder by (Maarten Daniels <maarten dot daniels at luc dot ac dot be>)
michael
parents:
2298
diff
changeset
|
1358 ff_h261_encode_init(s); |
706
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
1359 if (s->out_format == FMT_H263) |
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
1360 h263_encode_init(s); |
4967
6d45158e0249
disable reference to msmpeg4 and wmv2 code when those codecs are not compiled in
aurel
parents:
4668
diff
changeset
|
1361 if (ENABLE_MSMPEG4_ENCODER && s->msmpeg4_version) |
706
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
1362 ff_msmpeg4_encode_init(s); |
1042 | 1363 if (s->out_format == FMT_MPEG1) |
1364 ff_mpeg1_encode_init(s); | |
706
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
1365 |
1892 | 1366 /* init q matrix */ |
60 | 1367 for(i=0;i<64;i++) { |
1092 | 1368 int j= s->dsp.idct_permutation[i]; |
599 | 1369 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
|
1370 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
|
1371 s->inter_matrix[j] = ff_mpeg4_default_non_intra_matrix[i]; |
2327
5e5cf598a48b
H.261 encoder by (Maarten Daniels <maarten dot daniels at luc dot ac dot be>)
michael
parents:
2298
diff
changeset
|
1372 }else if(s->out_format == FMT_H263 || s->out_format == FMT_H261){ |
706
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
1373 s->intra_matrix[j] = |
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
1374 s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i]; |
1042 | 1375 }else |
1421 | 1376 { /* mpeg1/2 */ |
706
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
1377 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
|
1378 s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i]; |
599 | 1379 } |
1411 | 1380 if(s->avctx->intra_matrix) |
1381 s->intra_matrix[j] = s->avctx->intra_matrix[i]; | |
1382 if(s->avctx->inter_matrix) | |
1383 s->inter_matrix[j] = s->avctx->inter_matrix[i]; | |
344 | 1384 } |
1385 | |
1386 /* precompute matrix */ | |
350
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
347
diff
changeset
|
1387 /* for mjpeg, we do include qscale in the matrix */ |
344 | 1388 if (s->out_format != FMT_MJPEG) { |
2967 | 1389 convert_matrix(&s->dsp, s->q_intra_matrix, s->q_intra_matrix16, |
2385
4605a8b188c3
warn the user if the quantization code could overflow with the selected custom matrix and qp limits
michael
parents:
2382
diff
changeset
|
1390 s->intra_matrix, s->intra_quant_bias, avctx->qmin, 31, 1); |
2967 | 1391 convert_matrix(&s->dsp, s->q_inter_matrix, s->q_inter_matrix16, |
2385
4605a8b188c3
warn the user if the quantization code could overflow with the selected custom matrix and qp limits
michael
parents:
2382
diff
changeset
|
1392 s->inter_matrix, s->inter_quant_bias, avctx->qmin, 31, 0); |
60 | 1393 } |
1394 | |
329 | 1395 if(ff_rate_control_init(s) < 0) |
1396 return -1; | |
2967 | 1397 |
0 | 1398 return 0; |
1399 } | |
1400 | |
1401 int MPV_encode_end(AVCodecContext *avctx) | |
1402 { | |
1403 MpegEncContext *s = avctx->priv_data; | |
1404 | |
329 | 1405 ff_rate_control_uninit(s); |
1406 | |
0 | 1407 MPV_common_end(s); |
4995 | 1408 if ((ENABLE_MJPEG_ENCODER || ENABLE_LJPEG_ENCODER) && s->out_format == FMT_MJPEG) |
5029
dbaa06366c3c
add a proper prefix to all mjpeg encoder exported functions
aurel
parents:
5028
diff
changeset
|
1409 ff_mjpeg_encode_close(s); |
1458
40b69d238beb
AVI stream header FCC / more reliable detection of old xvid files
michaelni
parents:
1451
diff
changeset
|
1410 |
1424 | 1411 av_freep(&avctx->extradata); |
2967 | 1412 |
0 | 1413 return 0; |
1414 } | |
1415 | |
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
|
1416 #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
|
1417 |
4668 | 1418 void init_rl(RLTable *rl, uint8_t static_store[2][2*MAX_RUN + MAX_LEVEL + 3]) |
1042 | 1419 { |
1064 | 1420 int8_t max_level[MAX_RUN+1], max_run[MAX_LEVEL+1]; |
1421 uint8_t index_run[MAX_RUN+1]; | |
1042 | 1422 int last, run, level, start, end, i; |
1423 | |
2370
26560d4fdb1f
Memory leak fix patch by (Burkhard Plaum <plaum >at< ipf.uni-stuttgart )dot( de>)
michael
parents:
2364
diff
changeset
|
1424 /* If table is static, we can quit if rl->max_level[0] is not NULL */ |
4668 | 1425 if(static_store && rl->max_level[0]) |
2370
26560d4fdb1f
Memory leak fix patch by (Burkhard Plaum <plaum >at< ipf.uni-stuttgart )dot( de>)
michael
parents:
2364
diff
changeset
|
1426 return; |
26560d4fdb1f
Memory leak fix patch by (Burkhard Plaum <plaum >at< ipf.uni-stuttgart )dot( de>)
michael
parents:
2364
diff
changeset
|
1427 |
1042 | 1428 /* compute max_level[], max_run[] and index_run[] */ |
1429 for(last=0;last<2;last++) { | |
1430 if (last == 0) { | |
1431 start = 0; | |
1432 end = rl->last; | |
1433 } else { | |
1434 start = rl->last; | |
1435 end = rl->n; | |
1436 } | |
1437 | |
1438 memset(max_level, 0, MAX_RUN + 1); | |
1439 memset(max_run, 0, MAX_LEVEL + 1); | |
1440 memset(index_run, rl->n, MAX_RUN + 1); | |
1441 for(i=start;i<end;i++) { | |
1442 run = rl->table_run[i]; | |
1443 level = rl->table_level[i]; | |
1444 if (index_run[run] == rl->n) | |
1445 index_run[run] = i; | |
1446 if (level > max_level[run]) | |
1447 max_level[run] = level; | |
1448 if (run > max_run[level]) | |
1449 max_run[level] = run; | |
1450 } | |
4668 | 1451 if(static_store) |
1452 rl->max_level[last] = static_store[last]; | |
2370
26560d4fdb1f
Memory leak fix patch by (Burkhard Plaum <plaum >at< ipf.uni-stuttgart )dot( de>)
michael
parents:
2364
diff
changeset
|
1453 else |
26560d4fdb1f
Memory leak fix patch by (Burkhard Plaum <plaum >at< ipf.uni-stuttgart )dot( de>)
michael
parents:
2364
diff
changeset
|
1454 rl->max_level[last] = av_malloc(MAX_RUN + 1); |
1042 | 1455 memcpy(rl->max_level[last], max_level, MAX_RUN + 1); |
4668 | 1456 if(static_store) |
1457 rl->max_run[last] = static_store[last] + MAX_RUN + 1; | |
2370
26560d4fdb1f
Memory leak fix patch by (Burkhard Plaum <plaum >at< ipf.uni-stuttgart )dot( de>)
michael
parents:
2364
diff
changeset
|
1458 else |
26560d4fdb1f
Memory leak fix patch by (Burkhard Plaum <plaum >at< ipf.uni-stuttgart )dot( de>)
michael
parents:
2364
diff
changeset
|
1459 rl->max_run[last] = av_malloc(MAX_LEVEL + 1); |
1042 | 1460 memcpy(rl->max_run[last], max_run, MAX_LEVEL + 1); |
4668 | 1461 if(static_store) |
1462 rl->index_run[last] = static_store[last] + MAX_RUN + MAX_LEVEL + 2; | |
2370
26560d4fdb1f
Memory leak fix patch by (Burkhard Plaum <plaum >at< ipf.uni-stuttgart )dot( de>)
michael
parents:
2364
diff
changeset
|
1463 else |
26560d4fdb1f
Memory leak fix patch by (Burkhard Plaum <plaum >at< ipf.uni-stuttgart )dot( de>)
michael
parents:
2364
diff
changeset
|
1464 rl->index_run[last] = av_malloc(MAX_RUN + 1); |
1042 | 1465 memcpy(rl->index_run[last], index_run, MAX_RUN + 1); |
1466 } | |
1467 } | |
1468 | |
0 | 1469 /* 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
|
1470 //FIXME check that this is ok for mpeg4 interlaced |
1064 | 1471 static void draw_edges_c(uint8_t *buf, int wrap, int width, int height, int w) |
0 | 1472 { |
1064 | 1473 uint8_t *ptr, *last_line; |
0 | 1474 int i; |
1475 | |
1476 last_line = buf + (height - 1) * wrap; | |
1477 for(i=0;i<w;i++) { | |
1478 /* top and bottom */ | |
1479 memcpy(buf - (i + 1) * wrap, buf, width); | |
1480 memcpy(last_line + (i + 1) * wrap, last_line, width); | |
1481 } | |
1482 /* left and right */ | |
1483 ptr = buf; | |
1484 for(i=0;i<height;i++) { | |
1485 memset(ptr - w, ptr[0], w); | |
1486 memset(ptr + width, ptr[width-1], w); | |
1487 ptr += wrap; | |
1488 } | |
1489 /* corners */ | |
1490 for(i=0;i<w;i++) { | |
1491 memset(buf - (i + 1) * wrap - w, buf[0], w); /* top left */ | |
1492 memset(buf - (i + 1) * wrap + width, buf[width-1], w); /* top right */ | |
1493 memset(last_line + (i + 1) * wrap - w, last_line[0], w); /* top left */ | |
1494 memset(last_line + (i + 1) * wrap + width, last_line[width-1], w); /* top right */ | |
1495 } | |
1496 } | |
1497 | |
1586 | 1498 int ff_find_unused_picture(MpegEncContext *s, int shared){ |
924 | 1499 int i; |
2967 | 1500 |
924 | 1501 if(shared){ |
1502 for(i=0; i<MAX_PICTURE_COUNT; i++){ | |
1586 | 1503 if(s->picture[i].data[0]==NULL && s->picture[i].type==0) return i; |
924 | 1504 } |
1505 }else{ | |
1506 for(i=0; i<MAX_PICTURE_COUNT; i++){ | |
1586 | 1507 if(s->picture[i].data[0]==NULL && s->picture[i].type!=0) return i; //FIXME |
924 | 1508 } |
1509 for(i=0; i<MAX_PICTURE_COUNT; i++){ | |
1586 | 1510 if(s->picture[i].data[0]==NULL) return i; |
924 | 1511 } |
1512 } | |
1513 | |
1586 | 1514 assert(0); |
1515 return -1; | |
924 | 1516 } |
1517 | |
1597 | 1518 static void update_noise_reduction(MpegEncContext *s){ |
1519 int intra, i; | |
1520 | |
1521 for(intra=0; intra<2; intra++){ | |
1522 if(s->dct_count[intra] > (1<<16)){ | |
1523 for(i=0; i<64; i++){ | |
1524 s->dct_error_sum[intra][i] >>=1; | |
1525 } | |
1526 s->dct_count[intra] >>= 1; | |
1527 } | |
2967 | 1528 |
1597 | 1529 for(i=0; i<64; i++){ |
1530 s->dct_offset[intra][i]= (s->avctx->noise_reduction * s->dct_count[intra] + s->dct_error_sum[intra][i]/2) / (s->dct_error_sum[intra][i]+1); | |
1531 } | |
1532 } | |
1533 } | |
1534 | |
1586 | 1535 /** |
1536 * generic function for encode/decode called after coding/decoding the header and before a frame is coded/decoded | |
1537 */ | |
771
d4cc92144266
handle direct rendering buffer allocation failure
michaelni
parents:
768
diff
changeset
|
1538 int MPV_frame_start(MpegEncContext *s, AVCodecContext *avctx) |
0 | 1539 { |
924 | 1540 int i; |
925 | 1541 AVFrame *pic; |
2628
511e3afc43e1
Ministry of English Composition, reporting for duty (and the word is "skipped", not "skiped"; "skiped" would rhyme with "hyped")
melanson
parents:
2627
diff
changeset
|
1542 s->mb_skipped = 0; |
1168 | 1543 |
1234 | 1544 assert(s->last_picture_ptr==NULL || s->out_format != FMT_H264 || s->codec_id == CODEC_ID_SVQ3); |
1228 | 1545 |
903 | 1546 /* mark&release old frames */ |
1944 | 1547 if (s->pict_type != B_TYPE && s->last_picture_ptr && s->last_picture_ptr != s->next_picture_ptr && s->last_picture_ptr->data[0]) { |
4396
8e78248586b0
set last_picture for h.264 too, this significantly improves error concealment quality, i hope it doesnt break anything as last_picture_ptr was always NULL for h.264
michael
parents:
4346
diff
changeset
|
1548 if(s->out_format != FMT_H264 || s->codec_id == CODEC_ID_SVQ3){ |
1138 | 1549 avctx->release_buffer(avctx, (AVFrame*)s->last_picture_ptr); |
903 | 1550 |
1551 /* release forgotten pictures */ | |
1552 /* if(mpeg124/h263) */ | |
1553 if(!s->encoding){ | |
1554 for(i=0; i<MAX_PICTURE_COUNT; i++){ | |
1138 | 1555 if(s->picture[i].data[0] && &s->picture[i] != s->next_picture_ptr && s->picture[i].reference){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1597
diff
changeset
|
1556 av_log(avctx, AV_LOG_ERROR, "releasing zombie picture\n"); |
2967 | 1557 avctx->release_buffer(avctx, (AVFrame*)&s->picture[i]); |
903 | 1558 } |
1559 } | |
1560 } | |
4396
8e78248586b0
set last_picture for h.264 too, this significantly improves error concealment quality, i hope it doesnt break anything as last_picture_ptr was always NULL for h.264
michael
parents:
4346
diff
changeset
|
1561 } |
903 | 1562 } |
910
eb448df811be
fixing files where the first frame isn a keyframe
michaelni
parents:
909
diff
changeset
|
1563 alloc: |
eb448df811be
fixing files where the first frame isn a keyframe
michaelni
parents:
909
diff
changeset
|
1564 if(!s->encoding){ |
2764 | 1565 /* release non reference frames */ |
1228 | 1566 for(i=0; i<MAX_PICTURE_COUNT; i++){ |
1567 if(s->picture[i].data[0] && !s->picture[i].reference /*&& s->picture[i].type!=FF_BUFFER_TYPE_SHARED*/){ | |
1568 s->avctx->release_buffer(s->avctx, (AVFrame*)&s->picture[i]); | |
1569 } | |
1570 } | |
1571 | |
1586 | 1572 if(s->current_picture_ptr && s->current_picture_ptr->data[0]==NULL) |
1573 pic= (AVFrame*)s->current_picture_ptr; //we allready have a unused image (maybe it was set before reading the header) | |
1574 else{ | |
1575 i= ff_find_unused_picture(s, 0); | |
1576 pic= (AVFrame*)&s->picture[i]; | |
1577 } | |
1578 | |
2537
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2534
diff
changeset
|
1579 pic->reference= (s->pict_type != B_TYPE || s->codec_id == CODEC_ID_H264) |
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2534
diff
changeset
|
1580 && !s->dropable ? 3 : 0; |
1138 | 1581 |
1705 | 1582 pic->coded_picture_number= s->coded_picture_number++; |
2967 | 1583 |
1384 | 1584 if( alloc_picture(s, (Picture*)pic, 0) < 0) |
1585 return -1; | |
903 | 1586 |
1586 | 1587 s->current_picture_ptr= (Picture*)pic; |
1658 | 1588 s->current_picture_ptr->top_field_first= s->top_field_first; //FIXME use only the vars from current_pic |
1659 | 1589 s->current_picture_ptr->interlaced_frame= !s->progressive_frame && !s->progressive_sequence; |
903 | 1590 } |
456 | 1591 |
1173 | 1592 s->current_picture_ptr->pict_type= s->pict_type; |
2967 | 1593 // if(s->flags && CODEC_FLAG_QSCALE) |
1505
010f76d07a27
use lagrange multipler instead of qp for ratecontrol, this may break some things, tell me ASAP if u notice anything broken
michaelni
parents:
1497
diff
changeset
|
1594 // s->current_picture_ptr->quality= s->new_picture_ptr->quality; |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1173
diff
changeset
|
1595 s->current_picture_ptr->key_frame= s->pict_type == I_TYPE; |
1173 | 1596 |
1539
14d01ccc0081
picture buffer cleanup, this fixes a assertion failure (if assertion checking was manualy enabled for utils.c) and a memleak at least
michael
parents:
1530
diff
changeset
|
1597 copy_picture(&s->current_picture, s->current_picture_ptr); |
2967 | 1598 |
903 | 1599 if (s->pict_type != B_TYPE) { |
1138 | 1600 s->last_picture_ptr= s->next_picture_ptr; |
1944 | 1601 if(!s->dropable) |
1602 s->next_picture_ptr= s->current_picture_ptr; | |
1603 } | |
1604 /* av_log(s->avctx, AV_LOG_DEBUG, "L%p N%p C%p L%p N%p C%p type:%d drop:%d\n", s->last_picture_ptr, s->next_picture_ptr,s->current_picture_ptr, | |
2967 | 1605 s->last_picture_ptr ? s->last_picture_ptr->data[0] : NULL, |
1606 s->next_picture_ptr ? s->next_picture_ptr->data[0] : NULL, | |
1944 | 1607 s->current_picture_ptr ? s->current_picture_ptr->data[0] : NULL, |
1608 s->pict_type, s->dropable);*/ | |
2967 | 1609 |
1539
14d01ccc0081
picture buffer cleanup, this fixes a assertion failure (if assertion checking was manualy enabled for utils.c) and a memleak at least
michael
parents:
1530
diff
changeset
|
1610 if(s->last_picture_ptr) copy_picture(&s->last_picture, s->last_picture_ptr); |
14d01ccc0081
picture buffer cleanup, this fixes a assertion failure (if assertion checking was manualy enabled for utils.c) and a memleak at least
michael
parents:
1530
diff
changeset
|
1611 if(s->next_picture_ptr) copy_picture(&s->next_picture, s->next_picture_ptr); |
2967 | 1612 |
4413
371bb9f644da
fix inifnite loop with http://sam.zoy.org/zzuf/lol-mplayer.mpg
michael
parents:
4399
diff
changeset
|
1613 if(s->pict_type != I_TYPE && (s->last_picture_ptr==NULL || s->last_picture_ptr->data[0]==NULL) && !s->dropable){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1597
diff
changeset
|
1614 av_log(avctx, AV_LOG_ERROR, "warning: first frame is no keyframe\n"); |
2764 | 1615 assert(s->pict_type != B_TYPE); //these should have been dropped if we don't have a reference |
1393 | 1616 goto alloc; |
1617 } | |
1618 | |
1619 assert(s->pict_type == I_TYPE || (s->last_picture_ptr && s->last_picture_ptr->data[0])); | |
1620 | |
1138 | 1621 if(s->picture_structure!=PICT_FRAME){ |
1622 int i; | |
1623 for(i=0; i<4; i++){ | |
1624 if(s->picture_structure == PICT_BOTTOM_FIELD){ | |
1625 s->current_picture.data[i] += s->current_picture.linesize[i]; | |
2967 | 1626 } |
1138 | 1627 s->current_picture.linesize[i] *= 2; |
1628 s->last_picture.linesize[i] *=2; | |
1629 s->next_picture.linesize[i] *=2; | |
1630 } | |
553 | 1631 } |
2967 | 1632 |
910
eb448df811be
fixing files where the first frame isn a keyframe
michaelni
parents:
909
diff
changeset
|
1633 s->hurry_up= s->avctx->hurry_up; |
eb448df811be
fixing files where the first frame isn a keyframe
michaelni
parents:
909
diff
changeset
|
1634 s->error_resilience= avctx->error_resilience; |
eb448df811be
fixing files where the first frame isn a keyframe
michaelni
parents:
909
diff
changeset
|
1635 |
2764 | 1636 /* set dequantizer, we can't do it during init as it might change for mpeg4 |
5127 | 1637 and we can't do it in the header decode as init is not called for mpeg4 there yet */ |
1689 | 1638 if(s->mpeg_quant || s->codec_id == CODEC_ID_MPEG2VIDEO){ |
1639 s->dct_unquantize_intra = s->dct_unquantize_mpeg2_intra; | |
1640 s->dct_unquantize_inter = s->dct_unquantize_mpeg2_inter; | |
2345 | 1641 }else if(s->out_format == FMT_H263 || s->out_format == FMT_H261){ |
1689 | 1642 s->dct_unquantize_intra = s->dct_unquantize_h263_intra; |
1643 s->dct_unquantize_inter = s->dct_unquantize_h263_inter; | |
1644 }else{ | |
1645 s->dct_unquantize_intra = s->dct_unquantize_mpeg1_intra; | |
1646 s->dct_unquantize_inter = s->dct_unquantize_mpeg1_inter; | |
1647 } | |
771
d4cc92144266
handle direct rendering buffer allocation failure
michaelni
parents:
768
diff
changeset
|
1648 |
1597 | 1649 if(s->dct_error_sum){ |
1650 assert(s->avctx->noise_reduction && s->encoding); | |
1651 | |
1652 update_noise_reduction(s); | |
1653 } | |
2967 | 1654 |
1381 | 1655 #ifdef HAVE_XVMC |
1656 if(s->avctx->xvmc_acceleration) | |
1657 return XVMC_field_start(s, avctx); | |
1658 #endif | |
771
d4cc92144266
handle direct rendering buffer allocation failure
michaelni
parents:
768
diff
changeset
|
1659 return 0; |
0 | 1660 } |
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
|
1661 |
0 | 1662 /* generic function for encode/decode called after a frame has been coded/decoded */ |
1663 void MPV_frame_end(MpegEncContext *s) | |
1664 { | |
903 | 1665 int i; |
0 | 1666 /* draw edge for correct motion prediction if outside */ |
1381 | 1667 #ifdef HAVE_XVMC |
1668 //just to make sure that all data is rendered. | |
1669 if(s->avctx->xvmc_acceleration){ | |
1670 XVMC_field_end(s); | |
1671 }else | |
1672 #endif | |
2537
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2534
diff
changeset
|
1673 if(s->unrestricted_mv && s->current_picture.reference && !s->intra_only && !(s->flags&CODEC_FLAG_EMU_EDGE)) { |
903 | 1674 draw_edges(s->current_picture.data[0], s->linesize , s->h_edge_pos , s->v_edge_pos , EDGE_WIDTH ); |
1675 draw_edges(s->current_picture.data[1], s->uvlinesize, s->h_edge_pos>>1, s->v_edge_pos>>1, EDGE_WIDTH/2); | |
1676 draw_edges(s->current_picture.data[2], s->uvlinesize, s->h_edge_pos>>1, s->v_edge_pos>>1, EDGE_WIDTH/2); | |
0 | 1677 } |
207 | 1678 emms_c(); |
2967 | 1679 |
612 | 1680 s->last_pict_type = s->pict_type; |
2997
188f4ef688f2
second try of improved lambda/qp guessing for motion estimation RD in first pass
michael
parents:
2990
diff
changeset
|
1681 s->last_lambda_for[s->pict_type]= s->current_picture_ptr->quality; |
329 | 1682 if(s->pict_type!=B_TYPE){ |
1683 s->last_non_b_pict_type= s->pict_type; | |
1684 } | |
1138 | 1685 #if 0 |
1686 /* copy back current_picture variables */ | |
903 | 1687 for(i=0; i<MAX_PICTURE_COUNT; i++){ |
1688 if(s->picture[i].data[0] == s->current_picture.data[0]){ | |
1689 s->picture[i]= s->current_picture; | |
1690 break; | |
2967 | 1691 } |
903 | 1692 } |
1693 assert(i<MAX_PICTURE_COUNT); | |
2967 | 1694 #endif |
903 | 1695 |
1228 | 1696 if(s->encoding){ |
2764 | 1697 /* release non-reference frames */ |
1228 | 1698 for(i=0; i<MAX_PICTURE_COUNT; i++){ |
1699 if(s->picture[i].data[0] && !s->picture[i].reference /*&& s->picture[i].type!=FF_BUFFER_TYPE_SHARED*/){ | |
1700 s->avctx->release_buffer(s->avctx, (AVFrame*)&s->picture[i]); | |
1701 } | |
1702 } | |
324 | 1703 } |
1138 | 1704 // clear copies, to avoid confusion |
1705 #if 0 | |
1706 memset(&s->last_picture, 0, sizeof(Picture)); | |
1707 memset(&s->next_picture, 0, sizeof(Picture)); | |
1708 memset(&s->current_picture, 0, sizeof(Picture)); | |
1709 #endif | |
2213 | 1710 s->avctx->coded_frame= (AVFrame*)s->current_picture_ptr; |
903 | 1711 } |
1712 | |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1173
diff
changeset
|
1713 /** |
1285 | 1714 * draws an line from (ex, ey) -> (sx, sy). |
1715 * @param w width of the image | |
1716 * @param h height of the image | |
1717 * @param stride stride/linesize of the image | |
1718 * @param color color of the arrow | |
1719 */ | |
1720 static void draw_line(uint8_t *buf, int sx, int sy, int ex, int ey, int w, int h, int stride, int color){ | |
3595 | 1721 int x, y, fr, f; |
2967 | 1722 |
4594 | 1723 sx= av_clip(sx, 0, w-1); |
1724 sy= av_clip(sy, 0, h-1); | |
1725 ex= av_clip(ex, 0, w-1); | |
1726 ey= av_clip(ey, 0, h-1); | |
2967 | 1727 |
1285 | 1728 buf[sy*stride + sx]+= color; |
2967 | 1729 |
4001 | 1730 if(FFABS(ex - sx) > FFABS(ey - sy)){ |
1285 | 1731 if(sx > ex){ |
4120 | 1732 FFSWAP(int, sx, ex); |
1733 FFSWAP(int, sy, ey); | |
1285 | 1734 } |
1735 buf+= sx + sy*stride; | |
1736 ex-= sx; | |
1737 f= ((ey-sy)<<16)/ex; | |
1738 for(x= 0; x <= ex; x++){ | |
1918
ea20f38b8d57
nicer looking arrows for the motion vector vissualization
michael
parents:
1916
diff
changeset
|
1739 y = (x*f)>>16; |
ea20f38b8d57
nicer looking arrows for the motion vector vissualization
michael
parents:
1916
diff
changeset
|
1740 fr= (x*f)&0xFFFF; |
ea20f38b8d57
nicer looking arrows for the motion vector vissualization
michael
parents:
1916
diff
changeset
|
1741 buf[ y *stride + x]+= (color*(0x10000-fr))>>16; |
ea20f38b8d57
nicer looking arrows for the motion vector vissualization
michael
parents:
1916
diff
changeset
|
1742 buf[(y+1)*stride + x]+= (color* fr )>>16; |
1285 | 1743 } |
1744 }else{ | |
1745 if(sy > ey){ | |
4120 | 1746 FFSWAP(int, sx, ex); |
1747 FFSWAP(int, sy, ey); | |
1285 | 1748 } |
1749 buf+= sx + sy*stride; | |
1750 ey-= sy; | |
1751 if(ey) f= ((ex-sx)<<16)/ey; | |
1752 else f= 0; | |
1753 for(y= 0; y <= ey; y++){ | |
1918
ea20f38b8d57
nicer looking arrows for the motion vector vissualization
michael
parents:
1916
diff
changeset
|
1754 x = (y*f)>>16; |
ea20f38b8d57
nicer looking arrows for the motion vector vissualization
michael
parents:
1916
diff
changeset
|
1755 fr= (y*f)&0xFFFF; |
ea20f38b8d57
nicer looking arrows for the motion vector vissualization
michael
parents:
1916
diff
changeset
|
1756 buf[y*stride + x ]+= (color*(0x10000-fr))>>16;; |
ea20f38b8d57
nicer looking arrows for the motion vector vissualization
michael
parents:
1916
diff
changeset
|
1757 buf[y*stride + x+1]+= (color* fr )>>16;; |
1285 | 1758 } |
1759 } | |
1760 } | |
1761 | |
1762 /** | |
1763 * draws an arrow from (ex, ey) -> (sx, sy). | |
1764 * @param w width of the image | |
1765 * @param h height of the image | |
1766 * @param stride stride/linesize of the image | |
1767 * @param color color of the arrow | |
1768 */ | |
2967 | 1769 static void draw_arrow(uint8_t *buf, int sx, int sy, int ex, int ey, int w, int h, int stride, int color){ |
1285 | 1770 int dx,dy; |
1771 | |
4594 | 1772 sx= av_clip(sx, -100, w+100); |
1773 sy= av_clip(sy, -100, h+100); | |
1774 ex= av_clip(ex, -100, w+100); | |
1775 ey= av_clip(ey, -100, h+100); | |
2967 | 1776 |
1285 | 1777 dx= ex - sx; |
1778 dy= ey - sy; | |
2967 | 1779 |
1285 | 1780 if(dx*dx + dy*dy > 3*3){ |
1781 int rx= dx + dy; | |
1782 int ry= -dx + dy; | |
1783 int length= ff_sqrt((rx*rx + ry*ry)<<8); | |
2967 | 1784 |
1285 | 1785 //FIXME subpixel accuracy |
1786 rx= ROUNDED_DIV(rx*3<<4, length); | |
1787 ry= ROUNDED_DIV(ry*3<<4, length); | |
2967 | 1788 |
1285 | 1789 draw_line(buf, sx, sy, sx + rx, sy + ry, w, h, stride, color); |
1790 draw_line(buf, sx, sy, sx - ry, sy + rx, w, h, stride, color); | |
1791 } | |
1792 draw_line(buf, sx, sy, ex, ey, w, h, stride, color); | |
1793 } | |
1794 | |
1795 /** | |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1173
diff
changeset
|
1796 * prints debuging info for the given picture. |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1173
diff
changeset
|
1797 */ |
1706
3ba5c493db6f
motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1705
diff
changeset
|
1798 void ff_print_debug_info(MpegEncContext *s, AVFrame *pict){ |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1173
diff
changeset
|
1799 |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1173
diff
changeset
|
1800 if(!pict || !pict->mb_type) return; |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1173
diff
changeset
|
1801 |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1173
diff
changeset
|
1802 if(s->avctx->debug&(FF_DEBUG_SKIP | FF_DEBUG_QP | FF_DEBUG_MB_TYPE)){ |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1173
diff
changeset
|
1803 int x,y; |
2967 | 1804 |
1706
3ba5c493db6f
motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1705
diff
changeset
|
1805 av_log(s->avctx,AV_LOG_DEBUG,"New frame, type: "); |
3ba5c493db6f
motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1705
diff
changeset
|
1806 switch (pict->pict_type) { |
3ba5c493db6f
motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1705
diff
changeset
|
1807 case FF_I_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"I\n"); break; |
3ba5c493db6f
motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1705
diff
changeset
|
1808 case FF_P_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"P\n"); break; |
3ba5c493db6f
motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1705
diff
changeset
|
1809 case FF_B_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"B\n"); break; |
3ba5c493db6f
motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1705
diff
changeset
|
1810 case FF_S_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"S\n"); break; |
3ba5c493db6f
motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1705
diff
changeset
|
1811 case FF_SI_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"SI\n"); break; |
2967 | 1812 case FF_SP_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"SP\n"); break; |
1706
3ba5c493db6f
motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1705
diff
changeset
|
1813 } |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1173
diff
changeset
|
1814 for(y=0; y<s->mb_height; y++){ |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1173
diff
changeset
|
1815 for(x=0; x<s->mb_width; x++){ |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1173
diff
changeset
|
1816 if(s->avctx->debug&FF_DEBUG_SKIP){ |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1173
diff
changeset
|
1817 int count= s->mbskip_table[x + y*s->mb_stride]; |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1173
diff
changeset
|
1818 if(count>9) count=9; |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1597
diff
changeset
|
1819 av_log(s->avctx, AV_LOG_DEBUG, "%1d", count); |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1173
diff
changeset
|
1820 } |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1173
diff
changeset
|
1821 if(s->avctx->debug&FF_DEBUG_QP){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1597
diff
changeset
|
1822 av_log(s->avctx, AV_LOG_DEBUG, "%2d", pict->qscale_table[x + y*s->mb_stride]); |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1173
diff
changeset
|
1823 } |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1173
diff
changeset
|
1824 if(s->avctx->debug&FF_DEBUG_MB_TYPE){ |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1173
diff
changeset
|
1825 int mb_type= pict->mb_type[x + y*s->mb_stride]; |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1173
diff
changeset
|
1826 //Type & MV direction |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1173
diff
changeset
|
1827 if(IS_PCM(mb_type)) |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1597
diff
changeset
|
1828 av_log(s->avctx, AV_LOG_DEBUG, "P"); |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1173
diff
changeset
|
1829 else if(IS_INTRA(mb_type) && IS_ACPRED(mb_type)) |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1597
diff
changeset
|
1830 av_log(s->avctx, AV_LOG_DEBUG, "A"); |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1173
diff
changeset
|
1831 else if(IS_INTRA4x4(mb_type)) |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1597
diff
changeset
|
1832 av_log(s->avctx, AV_LOG_DEBUG, "i"); |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1173
diff
changeset
|
1833 else if(IS_INTRA16x16(mb_type)) |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1597
diff
changeset
|
1834 av_log(s->avctx, AV_LOG_DEBUG, "I"); |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1173
diff
changeset
|
1835 else if(IS_DIRECT(mb_type) && IS_SKIP(mb_type)) |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1597
diff
changeset
|
1836 av_log(s->avctx, AV_LOG_DEBUG, "d"); |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1173
diff
changeset
|
1837 else if(IS_DIRECT(mb_type)) |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1597
diff
changeset
|
1838 av_log(s->avctx, AV_LOG_DEBUG, "D"); |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1173
diff
changeset
|
1839 else if(IS_GMC(mb_type) && IS_SKIP(mb_type)) |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1597
diff
changeset
|
1840 av_log(s->avctx, AV_LOG_DEBUG, "g"); |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1173
diff
changeset
|
1841 else if(IS_GMC(mb_type)) |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1597
diff
changeset
|
1842 av_log(s->avctx, AV_LOG_DEBUG, "G"); |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1173
diff
changeset
|
1843 else if(IS_SKIP(mb_type)) |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1597
diff
changeset
|
1844 av_log(s->avctx, AV_LOG_DEBUG, "S"); |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1173
diff
changeset
|
1845 else if(!USES_LIST(mb_type, 1)) |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1597
diff
changeset
|
1846 av_log(s->avctx, AV_LOG_DEBUG, ">"); |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1173
diff
changeset
|
1847 else if(!USES_LIST(mb_type, 0)) |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1597
diff
changeset
|
1848 av_log(s->avctx, AV_LOG_DEBUG, "<"); |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1173
diff
changeset
|
1849 else{ |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1173
diff
changeset
|
1850 assert(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1)); |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1597
diff
changeset
|
1851 av_log(s->avctx, AV_LOG_DEBUG, "X"); |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1173
diff
changeset
|
1852 } |
2967 | 1853 |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1173
diff
changeset
|
1854 //segmentation |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1173
diff
changeset
|
1855 if(IS_8X8(mb_type)) |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1597
diff
changeset
|
1856 av_log(s->avctx, AV_LOG_DEBUG, "+"); |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1173
diff
changeset
|
1857 else if(IS_16X8(mb_type)) |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1597
diff
changeset
|
1858 av_log(s->avctx, AV_LOG_DEBUG, "-"); |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1173
diff
changeset
|
1859 else if(IS_8X16(mb_type)) |
2677 | 1860 av_log(s->avctx, AV_LOG_DEBUG, "|"); |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1173
diff
changeset
|
1861 else if(IS_INTRA(mb_type) || IS_16X16(mb_type)) |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1597
diff
changeset
|
1862 av_log(s->avctx, AV_LOG_DEBUG, " "); |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1173
diff
changeset
|
1863 else |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1597
diff
changeset
|
1864 av_log(s->avctx, AV_LOG_DEBUG, "?"); |
2967 | 1865 |
1866 | |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1173
diff
changeset
|
1867 if(IS_INTERLACED(mb_type) && s->codec_id == CODEC_ID_H264) |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1597
diff
changeset
|
1868 av_log(s->avctx, AV_LOG_DEBUG, "="); |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1173
diff
changeset
|
1869 else |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1597
diff
changeset
|
1870 av_log(s->avctx, AV_LOG_DEBUG, " "); |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1173
diff
changeset
|
1871 } |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1597
diff
changeset
|
1872 // av_log(s->avctx, AV_LOG_DEBUG, " "); |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1173
diff
changeset
|
1873 } |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1597
diff
changeset
|
1874 av_log(s->avctx, AV_LOG_DEBUG, "\n"); |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1173
diff
changeset
|
1875 } |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1173
diff
changeset
|
1876 } |
1668
30746f429df6
move motion_val & mb_type to AVFrame patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1662
diff
changeset
|
1877 |
1706
3ba5c493db6f
motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1705
diff
changeset
|
1878 if((s->avctx->debug&(FF_DEBUG_VIS_QP|FF_DEBUG_VIS_MB_TYPE)) || (s->avctx->debug_mv)){ |
1285 | 1879 const int shift= 1 + s->quarter_sample; |
1880 int mb_y; | |
1706
3ba5c493db6f
motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1705
diff
changeset
|
1881 uint8_t *ptr; |
1707 | 1882 int i; |
1723
033d889d7c2c
non YV12 vissualization fix by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1722
diff
changeset
|
1883 int h_chroma_shift, v_chroma_shift; |
2266
514949de5d15
set AVCodecContext.width/height to the picture width/height instead of the one stored in the bitstream (that only matters if lowres!=0)
michael
parents:
2265
diff
changeset
|
1884 const int width = s->avctx->width; |
514949de5d15
set AVCodecContext.width/height to the picture width/height instead of the one stored in the bitstream (that only matters if lowres!=0)
michael
parents:
2265
diff
changeset
|
1885 const int height= s->avctx->height; |
2395 | 1886 const int mv_sample_log2= 4 - pict->motion_subsample_log2; |
3268 | 1887 const int mv_stride= (s->mb_width << mv_sample_log2) + (s->codec_id == CODEC_ID_H264 ? 0 : 1); |
1285 | 1888 s->low_delay=0; //needed to see the vectors without trashing the buffers |
1706
3ba5c493db6f
motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1705
diff
changeset
|
1889 |
1723
033d889d7c2c
non YV12 vissualization fix by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1722
diff
changeset
|
1890 avcodec_get_chroma_sub_sample(s->avctx->pix_fmt, &h_chroma_shift, &v_chroma_shift); |
1706
3ba5c493db6f
motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1705
diff
changeset
|
1891 for(i=0; i<3; i++){ |
2266
514949de5d15
set AVCodecContext.width/height to the picture width/height instead of the one stored in the bitstream (that only matters if lowres!=0)
michael
parents:
2265
diff
changeset
|
1892 memcpy(s->visualization_buffer[i], pict->data[i], (i==0) ? pict->linesize[i]*height:pict->linesize[i]*height >> v_chroma_shift); |
1706
3ba5c493db6f
motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1705
diff
changeset
|
1893 pict->data[i]= s->visualization_buffer[i]; |
3ba5c493db6f
motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1705
diff
changeset
|
1894 } |
3ba5c493db6f
motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1705
diff
changeset
|
1895 pict->type= FF_BUFFER_TYPE_COPY; |
3ba5c493db6f
motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1705
diff
changeset
|
1896 ptr= pict->data[0]; |
1285 | 1897 |
1898 for(mb_y=0; mb_y<s->mb_height; mb_y++){ | |
1899 int mb_x; | |
1900 for(mb_x=0; mb_x<s->mb_width; mb_x++){ | |
1901 const int mb_index= mb_x + mb_y*s->mb_stride; | |
1706
3ba5c493db6f
motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1705
diff
changeset
|
1902 if((s->avctx->debug_mv) && pict->motion_val){ |
3ba5c493db6f
motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1705
diff
changeset
|
1903 int type; |
3ba5c493db6f
motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1705
diff
changeset
|
1904 for(type=0; type<3; type++){ |
2024
f65d87bfdd5a
some of the warning fixes by (Michael Roitzsch <mroi at users dot sourceforge dot net>)
michael
parents:
2015
diff
changeset
|
1905 int direction = 0; |
1706
3ba5c493db6f
motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1705
diff
changeset
|
1906 switch (type) { |
3ba5c493db6f
motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1705
diff
changeset
|
1907 case 0: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_P_FOR)) || (pict->pict_type!=FF_P_TYPE)) |
3ba5c493db6f
motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1705
diff
changeset
|
1908 continue; |
3ba5c493db6f
motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1705
diff
changeset
|
1909 direction = 0; |
3ba5c493db6f
motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1705
diff
changeset
|
1910 break; |
3ba5c493db6f
motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1705
diff
changeset
|
1911 case 1: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_B_FOR)) || (pict->pict_type!=FF_B_TYPE)) |
3ba5c493db6f
motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1705
diff
changeset
|
1912 continue; |
3ba5c493db6f
motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1705
diff
changeset
|
1913 direction = 0; |
3ba5c493db6f
motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1705
diff
changeset
|
1914 break; |
3ba5c493db6f
motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1705
diff
changeset
|
1915 case 2: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_B_BACK)) || (pict->pict_type!=FF_B_TYPE)) |
3ba5c493db6f
motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1705
diff
changeset
|
1916 continue; |
3ba5c493db6f
motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1705
diff
changeset
|
1917 direction = 1; |
3ba5c493db6f
motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1705
diff
changeset
|
1918 break; |
3ba5c493db6f
motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1705
diff
changeset
|
1919 } |
1712 | 1920 if(!USES_LIST(pict->mb_type[mb_index], direction)) |
1921 continue; | |
1922 | |
1706
3ba5c493db6f
motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1705
diff
changeset
|
1923 if(IS_8X8(pict->mb_type[mb_index])){ |
3ba5c493db6f
motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1705
diff
changeset
|
1924 int i; |
3ba5c493db6f
motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1705
diff
changeset
|
1925 for(i=0; i<4; i++){ |
1285 | 1926 int sx= mb_x*16 + 4 + 8*(i&1); |
1927 int sy= mb_y*16 + 4 + 8*(i>>1); | |
2522
e25782262d7d
kill warnings patch by (M«©ns Rullg«©rd <mru inprovide com>)
michael
parents:
2514
diff
changeset
|
1928 int xy= (mb_x*2 + (i&1) + (mb_y*2 + (i>>1))*mv_stride) << (mv_sample_log2-1); |
1706
3ba5c493db6f
motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1705
diff
changeset
|
1929 int mx= (pict->motion_val[direction][xy][0]>>shift) + sx; |
3ba5c493db6f
motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1705
diff
changeset
|
1930 int my= (pict->motion_val[direction][xy][1]>>shift) + sy; |
2266
514949de5d15
set AVCodecContext.width/height to the picture width/height instead of the one stored in the bitstream (that only matters if lowres!=0)
michael
parents:
2265
diff
changeset
|
1931 draw_arrow(ptr, sx, sy, mx, my, width, height, s->linesize, 100); |
1706
3ba5c493db6f
motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1705
diff
changeset
|
1932 } |
3ba5c493db6f
motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1705
diff
changeset
|
1933 }else if(IS_16X8(pict->mb_type[mb_index])){ |
3ba5c493db6f
motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1705
diff
changeset
|
1934 int i; |
3ba5c493db6f
motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1705
diff
changeset
|
1935 for(i=0; i<2; i++){ |
1629
74685a0ec851
16x8 MV vissualization by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1628
diff
changeset
|
1936 int sx=mb_x*16 + 8; |
74685a0ec851
16x8 MV vissualization by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1628
diff
changeset
|
1937 int sy=mb_y*16 + 4 + 8*i; |
2522
e25782262d7d
kill warnings patch by (M«©ns Rullg«©rd <mru inprovide com>)
michael
parents:
2514
diff
changeset
|
1938 int xy= (mb_x*2 + (mb_y*2 + i)*mv_stride) << (mv_sample_log2-1); |
2395 | 1939 int mx=(pict->motion_val[direction][xy][0]>>shift); |
1940 int my=(pict->motion_val[direction][xy][1]>>shift); | |
2967 | 1941 |
2395 | 1942 if(IS_INTERLACED(pict->mb_type[mb_index])) |
1943 my*=2; | |
2967 | 1944 |
2395 | 1945 draw_arrow(ptr, sx, sy, mx+sx, my+sy, width, height, s->linesize, 100); |
1946 } | |
1947 }else if(IS_8X16(pict->mb_type[mb_index])){ | |
1948 int i; | |
1949 for(i=0; i<2; i++){ | |
1950 int sx=mb_x*16 + 4 + 8*i; | |
1951 int sy=mb_y*16 + 8; | |
2522
e25782262d7d
kill warnings patch by (M«©ns Rullg«©rd <mru inprovide com>)
michael
parents:
2514
diff
changeset
|
1952 int xy= (mb_x*2 + i + mb_y*2*mv_stride) << (mv_sample_log2-1); |
1947
b306574523ad
fix y scale of mv vissualization of interlaced MVs
michael
parents:
1945
diff
changeset
|
1953 int mx=(pict->motion_val[direction][xy][0]>>shift); |
b306574523ad
fix y scale of mv vissualization of interlaced MVs
michael
parents:
1945
diff
changeset
|
1954 int my=(pict->motion_val[direction][xy][1]>>shift); |
2967 | 1955 |
1947
b306574523ad
fix y scale of mv vissualization of interlaced MVs
michael
parents:
1945
diff
changeset
|
1956 if(IS_INTERLACED(pict->mb_type[mb_index])) |
b306574523ad
fix y scale of mv vissualization of interlaced MVs
michael
parents:
1945
diff
changeset
|
1957 my*=2; |
2967 | 1958 |
2266
514949de5d15
set AVCodecContext.width/height to the picture width/height instead of the one stored in the bitstream (that only matters if lowres!=0)
michael
parents:
2265
diff
changeset
|
1959 draw_arrow(ptr, sx, sy, mx+sx, my+sy, width, height, s->linesize, 100); |
1706
3ba5c493db6f
motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1705
diff
changeset
|
1960 } |
3ba5c493db6f
motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1705
diff
changeset
|
1961 }else{ |
3ba5c493db6f
motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1705
diff
changeset
|
1962 int sx= mb_x*16 + 8; |
3ba5c493db6f
motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1705
diff
changeset
|
1963 int sy= mb_y*16 + 8; |
2395 | 1964 int xy= (mb_x + mb_y*mv_stride) << mv_sample_log2; |
1706
3ba5c493db6f
motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1705
diff
changeset
|
1965 int mx= (pict->motion_val[direction][xy][0]>>shift) + sx; |
3ba5c493db6f
motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1705
diff
changeset
|
1966 int my= (pict->motion_val[direction][xy][1]>>shift) + sy; |
2266
514949de5d15
set AVCodecContext.width/height to the picture width/height instead of the one stored in the bitstream (that only matters if lowres!=0)
michael
parents:
2265
diff
changeset
|
1967 draw_arrow(ptr, sx, sy, mx, my, width, height, s->linesize, 100); |
1629
74685a0ec851
16x8 MV vissualization by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1628
diff
changeset
|
1968 } |
2967 | 1969 } |
1685 | 1970 } |
1971 if((s->avctx->debug&FF_DEBUG_VIS_QP) && pict->motion_val){ | |
1972 uint64_t c= (pict->qscale_table[mb_index]*128/31) * 0x0101010101010101ULL; | |
1973 int y; | |
1974 for(y=0; y<8; y++){ | |
1975 *(uint64_t*)(pict->data[1] + 8*mb_x + (8*mb_y + y)*pict->linesize[1])= c; | |
1976 *(uint64_t*)(pict->data[2] + 8*mb_x + (8*mb_y + y)*pict->linesize[2])= c; | |
1977 } | |
1978 } | |
1979 if((s->avctx->debug&FF_DEBUG_VIS_MB_TYPE) && pict->motion_val){ | |
1980 int mb_type= pict->mb_type[mb_index]; | |
1981 uint64_t u,v; | |
1982 int y; | |
1983 #define COLOR(theta, r)\ | |
1984 u= (int)(128 + r*cos(theta*3.141592/180));\ | |
1985 v= (int)(128 + r*sin(theta*3.141592/180)); | |
1986 | |
2967 | 1987 |
1685 | 1988 u=v=128; |
1989 if(IS_PCM(mb_type)){ | |
1990 COLOR(120,48) | |
1991 }else if((IS_INTRA(mb_type) && IS_ACPRED(mb_type)) || IS_INTRA16x16(mb_type)){ | |
1992 COLOR(30,48) | |
1993 }else if(IS_INTRA4x4(mb_type)){ | |
1994 COLOR(90,48) | |
1995 }else if(IS_DIRECT(mb_type) && IS_SKIP(mb_type)){ | |
1996 // COLOR(120,48) | |
1997 }else if(IS_DIRECT(mb_type)){ | |
1998 COLOR(150,48) | |
1999 }else if(IS_GMC(mb_type) && IS_SKIP(mb_type)){ | |
2000 COLOR(170,48) | |
2001 }else if(IS_GMC(mb_type)){ | |
2002 COLOR(190,48) | |
2003 }else if(IS_SKIP(mb_type)){ | |
2004 // COLOR(180,48) | |
2005 }else if(!USES_LIST(mb_type, 1)){ | |
2006 COLOR(240,48) | |
2007 }else if(!USES_LIST(mb_type, 0)){ | |
2008 COLOR(0,48) | |
2009 }else{ | |
2010 assert(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1)); | |
2011 COLOR(300,48) | |
2012 } | |
2013 | |
2014 u*= 0x0101010101010101ULL; | |
2015 v*= 0x0101010101010101ULL; | |
2016 for(y=0; y<8; y++){ | |
2017 *(uint64_t*)(pict->data[1] + 8*mb_x + (8*mb_y + y)*pict->linesize[1])= u; | |
2018 *(uint64_t*)(pict->data[2] + 8*mb_x + (8*mb_y + y)*pict->linesize[2])= v; | |
2019 } | |
2020 | |
2021 //segmentation | |
2022 if(IS_8X8(mb_type) || IS_16X8(mb_type)){ | |
2023 *(uint64_t*)(pict->data[0] + 16*mb_x + 0 + (16*mb_y + 8)*pict->linesize[0])^= 0x8080808080808080ULL; | |
2024 *(uint64_t*)(pict->data[0] + 16*mb_x + 8 + (16*mb_y + 8)*pict->linesize[0])^= 0x8080808080808080ULL; | |
2025 } | |
2026 if(IS_8X8(mb_type) || IS_8X16(mb_type)){ | |
2027 for(y=0; y<16; y++) | |
2028 pict->data[0][16*mb_x + 8 + (16*mb_y + y)*pict->linesize[0]]^= 0x80; | |
2029 } | |
2534 | 2030 if(IS_8X8(mb_type) && mv_sample_log2 >= 2){ |
2031 int dm= 1 << (mv_sample_log2-2); | |
2032 for(i=0; i<4; i++){ | |
2033 int sx= mb_x*16 + 8*(i&1); | |
2034 int sy= mb_y*16 + 8*(i>>1); | |
2035 int xy= (mb_x*2 + (i&1) + (mb_y*2 + (i>>1))*mv_stride) << (mv_sample_log2-1); | |
2036 //FIXME bidir | |
2037 int32_t *mv = (int32_t*)&pict->motion_val[0][xy]; | |
2038 if(mv[0] != mv[dm] || mv[dm*mv_stride] != mv[dm*(mv_stride+1)]) | |
2039 for(y=0; y<8; y++) | |
2040 pict->data[0][sx + 4 + (sy + y)*pict->linesize[0]]^= 0x80; | |
2041 if(mv[0] != mv[dm*mv_stride] || mv[dm] != mv[dm*(mv_stride+1)]) | |
2042 *(uint64_t*)(pict->data[0] + sx + (sy + 4)*pict->linesize[0])^= 0x8080808080808080ULL; | |
2043 } | |
2044 } | |
2967 | 2045 |
1685 | 2046 if(IS_INTERLACED(mb_type) && s->codec_id == CODEC_ID_H264){ |
2047 // hmm | |
2048 } | |
1285 | 2049 } |
2050 s->mbskip_table[mb_index]=0; | |
2051 } | |
2052 } | |
2053 } | |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1173
diff
changeset
|
2054 } |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1173
diff
changeset
|
2055 |
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
|
2056 #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
|
2057 |
915 | 2058 static int get_sae(uint8_t *src, int ref, int stride){ |
2059 int x,y; | |
2060 int acc=0; | |
2967 | 2061 |
915 | 2062 for(y=0; y<16; y++){ |
2063 for(x=0; x<16; x++){ | |
4001 | 2064 acc+= FFABS(src[x+y*stride] - ref); |
915 | 2065 } |
2066 } | |
2967 | 2067 |
915 | 2068 return acc; |
2069 } | |
2070 | |
2071 static int get_intra_count(MpegEncContext *s, uint8_t *src, uint8_t *ref, int stride){ | |
2072 int x, y, w, h; | |
2073 int acc=0; | |
2967 | 2074 |
915 | 2075 w= s->width &~15; |
2076 h= s->height&~15; | |
2967 | 2077 |
915 | 2078 for(y=0; y<h; y+=16){ |
2079 for(x=0; x<w; x+=16){ | |
2080 int offset= x + y*stride; | |
1708 | 2081 int sad = s->dsp.sad[0](NULL, src + offset, ref + offset, stride, 16); |
915 | 2082 int mean= (s->dsp.pix_sum(src + offset, stride) + 128)>>8; |
2083 int sae = get_sae(src + offset, mean, stride); | |
2967 | 2084 |
915 | 2085 acc+= sae + 500 < sad; |
2086 } | |
2087 } | |
2088 return acc; | |
2089 } | |
2090 | |
924 | 2091 |
925 | 2092 static int load_input_picture(MpegEncContext *s, AVFrame *pic_arg){ |
1373 | 2093 AVFrame *pic=NULL; |
2427 | 2094 int64_t pts; |
924 | 2095 int i; |
903 | 2096 const int encoding_delay= s->max_b_frames; |
924 | 2097 int direct=1; |
2967 | 2098 |
2419 | 2099 if(pic_arg){ |
2427 | 2100 pts= pic_arg->pts; |
2101 pic_arg->display_picture_number= s->input_picture_number++; | |
2102 | |
2967 | 2103 if(pts != AV_NOPTS_VALUE){ |
2419 | 2104 if(s->user_specified_pts != AV_NOPTS_VALUE){ |
2637 | 2105 int64_t time= pts; |
2106 int64_t last= s->user_specified_pts; | |
2967 | 2107 |
2108 if(time <= last){ | |
2962 | 2109 av_log(s->avctx, AV_LOG_ERROR, "Error, Invalid timestamp=%"PRId64", last=%"PRId64"\n", pts, s->user_specified_pts); |
2419 | 2110 return -1; |
2111 } | |
2112 } | |
2427 | 2113 s->user_specified_pts= pts; |
2419 | 2114 }else{ |
2115 if(s->user_specified_pts != AV_NOPTS_VALUE){ | |
2967 | 2116 s->user_specified_pts= |
2637 | 2117 pts= s->user_specified_pts + 1; |
2962 | 2118 av_log(s->avctx, AV_LOG_INFO, "Warning: AVFrame.pts=? trying to guess (%"PRId64")\n", pts); |
2419 | 2119 }else{ |
2637 | 2120 pts= pic_arg->display_picture_number; |
2419 | 2121 } |
2122 } | |
2123 } | |
2124 | |
1373 | 2125 if(pic_arg){ |
924 | 2126 if(encoding_delay && !(s->flags&CODEC_FLAG_INPUT_PRESERVED)) direct=0; |
2127 if(pic_arg->linesize[0] != s->linesize) direct=0; | |
2128 if(pic_arg->linesize[1] != s->uvlinesize) direct=0; | |
2129 if(pic_arg->linesize[2] != s->uvlinesize) direct=0; | |
2967 | 2130 |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1597
diff
changeset
|
2131 // av_log(AV_LOG_DEBUG, "%d %d %d %d\n",pic_arg->linesize[0], pic_arg->linesize[1], s->linesize, s->uvlinesize); |
2967 | 2132 |
924 | 2133 if(direct){ |
1586 | 2134 i= ff_find_unused_picture(s, 1); |
924 | 2135 |
925 | 2136 pic= (AVFrame*)&s->picture[i]; |
1168 | 2137 pic->reference= 3; |
2967 | 2138 |
924 | 2139 for(i=0; i<4; i++){ |
2140 pic->data[i]= pic_arg->data[i]; | |
2141 pic->linesize[i]= pic_arg->linesize[i]; | |
2142 } | |
2143 alloc_picture(s, (Picture*)pic, 1); | |
2144 }else{ | |
1586 | 2145 i= ff_find_unused_picture(s, 0); |
924 | 2146 |
925 | 2147 pic= (AVFrame*)&s->picture[i]; |
1168 | 2148 pic->reference= 3; |
924 | 2149 |
2150 alloc_picture(s, (Picture*)pic, 0); | |
1539
14d01ccc0081
picture buffer cleanup, this fixes a assertion failure (if assertion checking was manualy enabled for utils.c) and a memleak at least
michael
parents:
1530
diff
changeset
|
2151 |
3068 | 2152 if( pic->data[0] + INPLACE_OFFSET == pic_arg->data[0] |
2153 && pic->data[1] + INPLACE_OFFSET == pic_arg->data[1] | |
2154 && pic->data[2] + INPLACE_OFFSET == pic_arg->data[2]){ | |
924 | 2155 // empty |
2156 }else{ | |
2157 int h_chroma_shift, v_chroma_shift; | |
2158 avcodec_get_chroma_sub_sample(s->avctx->pix_fmt, &h_chroma_shift, &v_chroma_shift); | |
2967 | 2159 |
924 | 2160 for(i=0; i<3; i++){ |
2161 int src_stride= pic_arg->linesize[i]; | |
2162 int dst_stride= i ? s->uvlinesize : s->linesize; | |
2163 int h_shift= i ? h_chroma_shift : 0; | |
2164 int v_shift= i ? v_chroma_shift : 0; | |
2165 int w= s->width >>h_shift; | |
2166 int h= s->height>>v_shift; | |
2167 uint8_t *src= pic_arg->data[i]; | |
3939
16ace038f452
fix buffer underflows by reencoding the current frame with a higher QP
michael
parents:
3929
diff
changeset
|
2168 uint8_t *dst= pic->data[i]; |
16ace038f452
fix buffer underflows by reencoding the current frame with a higher QP
michael
parents:
3929
diff
changeset
|
2169 |
16ace038f452
fix buffer underflows by reencoding the current frame with a higher QP
michael
parents:
3929
diff
changeset
|
2170 if(!s->avctx->rc_buffer_size) |
16ace038f452
fix buffer underflows by reencoding the current frame with a higher QP
michael
parents:
3929
diff
changeset
|
2171 dst +=INPLACE_OFFSET; |
2967 | 2172 |
924 | 2173 if(src_stride==dst_stride) |
2174 memcpy(dst, src, src_stride*h); | |
2175 else{ | |
2176 while(h--){ | |
2177 memcpy(dst, src, w); | |
2178 dst += dst_stride; | |
2179 src += src_stride; | |
2180 } | |
2181 } | |
2182 } | |
2183 } | |
324 | 2184 } |
1938
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1918
diff
changeset
|
2185 copy_picture_attributes(s, pic, pic_arg); |
2427 | 2186 pic->pts= pts; //we set this here to avoid modifiying pic_arg |
1373 | 2187 } |
2967 | 2188 |
903 | 2189 /* shift buffer entries */ |
2190 for(i=1; i<MAX_PICTURE_COUNT /*s->encoding_delay+1*/; i++) | |
2191 s->input_picture[i-1]= s->input_picture[i]; | |
2967 | 2192 |
903 | 2193 s->input_picture[encoding_delay]= (Picture*)pic; |
2194 | |
2195 return 0; | |
2196 } | |
2197 | |
2381 | 2198 static int skip_check(MpegEncContext *s, Picture *p, Picture *ref){ |
2199 int x, y, plane; | |
2200 int score=0; | |
2382 | 2201 int64_t score64=0; |
2381 | 2202 |
2203 for(plane=0; plane<3; plane++){ | |
2204 const int stride= p->linesize[plane]; | |
2205 const int bw= plane ? 1 : 2; | |
2206 for(y=0; y<s->mb_height*bw; y++){ | |
2207 for(x=0; x<s->mb_width*bw; x++){ | |
2931 | 2208 int off= p->type == FF_BUFFER_TYPE_SHARED ? 0: 16; |
2209 int v= s->dsp.frame_skip_cmp[1](s, p->data[plane] + 8*(x + y*stride)+off, ref->data[plane] + 8*(x + y*stride), stride, 8); | |
2967 | 2210 |
2382 | 2211 switch(s->avctx->frame_skip_exp){ |
2212 case 0: score= FFMAX(score, v); break; | |
4001 | 2213 case 1: score+= FFABS(v);break; |
2382 | 2214 case 2: score+= v*v;break; |
4001 | 2215 case 3: score64+= FFABS(v*v*(int64_t)v);break; |
2382 | 2216 case 4: score64+= v*v*(int64_t)(v*v);break; |
2217 } | |
2381 | 2218 } |
2219 } | |
2220 } | |
2967 | 2221 |
2382 | 2222 if(score) score64= score; |
2223 | |
2224 if(score64 < s->avctx->frame_skip_threshold) | |
2381 | 2225 return 1; |
2382 | 2226 if(score64 < ((s->avctx->frame_skip_factor * (int64_t)s->lambda)>>8)) |
2381 | 2227 return 1; |
2228 return 0; | |
2229 } | |
2230 | |
2988 | 2231 static int estimate_best_b_count(MpegEncContext *s){ |
2232 AVCodec *codec= avcodec_find_encoder(s->avctx->codec_id); | |
2233 AVCodecContext *c= avcodec_alloc_context(); | |
2234 AVFrame input[FF_MAX_B_FRAMES+2]; | |
2990
0300c2647bc3
support downscaling frames for dynamic b frame decission
michael
parents:
2988
diff
changeset
|
2235 const int scale= s->avctx->brd_scale; |
3068 | 2236 int i, j, out_size, p_lambda, b_lambda, lambda2; |
2990
0300c2647bc3
support downscaling frames for dynamic b frame decission
michael
parents:
2988
diff
changeset
|
2237 int outbuf_size= s->width * s->height; //FIXME |
2988 | 2238 uint8_t *outbuf= av_malloc(outbuf_size); |
2239 int64_t best_rd= INT64_MAX; | |
2240 int best_b_count= -1; | |
3068 | 2241 |
3245 | 2242 assert(scale>=0 && scale <=3); |
2243 | |
3068 | 2244 // emms_c(); |
2245 p_lambda= s->last_lambda_for[P_TYPE]; //s->next_picture_ptr->quality; | |
4001 | 2246 b_lambda= s->last_lambda_for[B_TYPE]; //p_lambda *FFABS(s->avctx->b_quant_factor) + s->avctx->b_quant_offset; |
3068 | 2247 if(!b_lambda) b_lambda= p_lambda; //FIXME we should do this somewhere else |
2248 lambda2= (b_lambda*b_lambda + (1<<FF_LAMBDA_SHIFT)/2 ) >> FF_LAMBDA_SHIFT; | |
2988 | 2249 |
2250 c->width = s->width >> scale; | |
2251 c->height= s->height>> scale; | |
2252 c->flags= CODEC_FLAG_QSCALE | CODEC_FLAG_PSNR | CODEC_FLAG_INPUT_PRESERVED /*| CODEC_FLAG_EMU_EDGE*/; | |
2253 c->flags|= s->avctx->flags & CODEC_FLAG_QPEL; | |
2254 c->mb_decision= s->avctx->mb_decision; | |
2255 c->me_cmp= s->avctx->me_cmp; | |
2256 c->mb_cmp= s->avctx->mb_cmp; | |
2257 c->me_sub_cmp= s->avctx->me_sub_cmp; | |
2258 c->pix_fmt = PIX_FMT_YUV420P; | |
2259 c->time_base= s->avctx->time_base; | |
2260 c->max_b_frames= s->max_b_frames; | |
2261 | |
2262 if (avcodec_open(c, codec) < 0) | |
2263 return -1; | |
2264 | |
2265 for(i=0; i<s->max_b_frames+2; i++){ | |
2266 int ysize= c->width*c->height; | |
2267 int csize= (c->width/2)*(c->height/2); | |
3068 | 2268 Picture pre_input, *pre_input_ptr= i ? s->input_picture[i-1] : s->next_picture_ptr; |
2269 | |
2988 | 2270 avcodec_get_frame_defaults(&input[i]); |
2271 input[i].data[0]= av_malloc(ysize + 2*csize); | |
2272 input[i].data[1]= input[i].data[0] + ysize; | |
2273 input[i].data[2]= input[i].data[1] + csize; | |
2274 input[i].linesize[0]= c->width; | |
2275 input[i].linesize[1]= | |
2276 input[i].linesize[2]= c->width/2; | |
2277 | |
4416 | 2278 if(pre_input_ptr && (!i || s->input_picture[i-1])) { |
2279 pre_input= *pre_input_ptr; | |
2280 | |
2281 if(pre_input.type != FF_BUFFER_TYPE_SHARED && i) { | |
2282 pre_input.data[0]+=INPLACE_OFFSET; | |
2283 pre_input.data[1]+=INPLACE_OFFSET; | |
2284 pre_input.data[2]+=INPLACE_OFFSET; | |
2285 } | |
2286 | |
3245 | 2287 s->dsp.shrink[scale](input[i].data[0], input[i].linesize[0], pre_input.data[0], pre_input.linesize[0], c->width, c->height); |
2288 s->dsp.shrink[scale](input[i].data[1], input[i].linesize[1], pre_input.data[1], pre_input.linesize[1], c->width>>1, c->height>>1); | |
2289 s->dsp.shrink[scale](input[i].data[2], input[i].linesize[2], pre_input.data[2], pre_input.linesize[2], c->width>>1, c->height>>1); | |
2290 } | |
2988 | 2291 } |
2292 | |
2293 for(j=0; j<s->max_b_frames+1; j++){ | |
2294 int64_t rd=0; | |
2295 | |
2296 if(!s->input_picture[j]) | |
2297 break; | |
2298 | |
2299 c->error[0]= c->error[1]= c->error[2]= 0; | |
2300 | |
2301 input[0].pict_type= I_TYPE; | |
3068 | 2302 input[0].quality= 1 * FF_QP2LAMBDA; |
2988 | 2303 out_size = avcodec_encode_video(c, outbuf, outbuf_size, &input[0]); |
3068 | 2304 // rd += (out_size * lambda2) >> FF_LAMBDA_SHIFT; |
2988 | 2305 |
2306 for(i=0; i<s->max_b_frames+1; i++){ | |
2307 int is_p= i % (j+1) == j || i==s->max_b_frames; | |
2308 | |
2309 input[i+1].pict_type= is_p ? P_TYPE : B_TYPE; | |
3068 | 2310 input[i+1].quality= is_p ? p_lambda : b_lambda; |
2988 | 2311 out_size = avcodec_encode_video(c, outbuf, outbuf_size, &input[i+1]); |
3068 | 2312 rd += (out_size * lambda2) >> (FF_LAMBDA_SHIFT - 3); |
2988 | 2313 } |
2314 | |
2315 /* get the delayed frames */ | |
2316 while(out_size){ | |
2317 out_size = avcodec_encode_video(c, outbuf, outbuf_size, NULL); | |
3068 | 2318 rd += (out_size * lambda2) >> (FF_LAMBDA_SHIFT - 3); |
2988 | 2319 } |
2320 | |
2321 rd += c->error[0] + c->error[1] + c->error[2]; | |
2322 | |
2323 if(rd < best_rd){ | |
2324 best_rd= rd; | |
2325 best_b_count= j; | |
2326 } | |
2327 } | |
2328 | |
2329 av_freep(&outbuf); | |
2330 avcodec_close(c); | |
2331 av_freep(&c); | |
2332 | |
2333 for(i=0; i<s->max_b_frames+2; i++){ | |
2334 av_freep(&input[i].data[0]); | |
2335 } | |
2336 | |
2337 return best_b_count; | |
2338 } | |
2339 | |
903 | 2340 static void select_input_picture(MpegEncContext *s){ |
2341 int i; | |
924 | 2342 |
903 | 2343 for(i=1; i<MAX_PICTURE_COUNT; i++) |
2344 s->reordered_input_picture[i-1]= s->reordered_input_picture[i]; | |
2345 s->reordered_input_picture[MAX_PICTURE_COUNT-1]= NULL; | |
2346 | |
2764 | 2347 /* set next picture type & ordering */ |
903 | 2348 if(s->reordered_input_picture[0]==NULL && s->input_picture[0]){ |
1138 | 2349 if(/*s->picture_in_gop_number >= s->gop_size ||*/ s->next_picture_ptr==NULL || s->intra_only){ |
915 | 2350 s->reordered_input_picture[0]= s->input_picture[0]; |
2351 s->reordered_input_picture[0]->pict_type= I_TYPE; | |
1705 | 2352 s->reordered_input_picture[0]->coded_picture_number= s->coded_picture_number++; |
915 | 2353 }else{ |
2354 int b_frames; | |
2381 | 2355 |
2356 if(s->avctx->frame_skip_threshold || s->avctx->frame_skip_factor){ | |
2931 | 2357 if(s->picture_in_gop_number < s->gop_size && skip_check(s, s->input_picture[0], s->next_picture_ptr)){ |
2358 //FIXME check that te gop check above is +-1 correct | |
4122
daae66c03857
Replace most of the %lld and %llx by their (cleaner) PRI*64 counterparts.
diego
parents:
4121
diff
changeset
|
2359 //av_log(NULL, AV_LOG_DEBUG, "skip %p %"PRId64"\n", s->input_picture[0]->data[0], s->input_picture[0]->pts); |
2967 | 2360 |
2381 | 2361 if(s->input_picture[0]->type == FF_BUFFER_TYPE_SHARED){ |
2362 for(i=0; i<4; i++) | |
2363 s->input_picture[0]->data[i]= NULL; | |
2967 | 2364 s->input_picture[0]->type= 0; |
2381 | 2365 }else{ |
2967 | 2366 assert( s->input_picture[0]->type==FF_BUFFER_TYPE_USER |
2381 | 2367 || s->input_picture[0]->type==FF_BUFFER_TYPE_INTERNAL); |
2967 | 2368 |
2381 | 2369 s->avctx->release_buffer(s->avctx, (AVFrame*)s->input_picture[0]); |
2370 } | |
2967 | 2371 |
2931 | 2372 emms_c(); |
2373 ff_vbv_update(s, 0); | |
2381 | 2374 |
2375 goto no_output_pic; | |
2376 } | |
2377 } | |
2378 | |
915 | 2379 if(s->flags&CODEC_FLAG_PASS2){ |
2380 for(i=0; i<s->max_b_frames+1; i++){ | |
2381 int pict_num= s->input_picture[0]->display_picture_number + i; | |
2364
f8a229dfa2e8
check num_entries too to avoid reading over the array end and dont check i>0 it must be >0 there
michael
parents:
2363
diff
changeset
|
2382 |
2967 | 2383 if(pict_num >= s->rc_context.num_entries) |
2364
f8a229dfa2e8
check num_entries too to avoid reading over the array end and dont check i>0 it must be >0 there
michael
parents:
2363
diff
changeset
|
2384 break; |
2363
e0bda0b8359a
Fixes a segfault when flushing delayed B-frames on the 2nd pass. patch by (Loren Merritt <lorenm.u@washington@edu>)
michael
parents:
2345
diff
changeset
|
2385 if(!s->input_picture[i]){ |
2364
f8a229dfa2e8
check num_entries too to avoid reading over the array end and dont check i>0 it must be >0 there
michael
parents:
2363
diff
changeset
|
2386 s->rc_context.entry[pict_num-1].new_pict_type = P_TYPE; |
2363
e0bda0b8359a
Fixes a segfault when flushing delayed B-frames on the 2nd pass. patch by (Loren Merritt <lorenm.u@washington@edu>)
michael
parents:
2345
diff
changeset
|
2387 break; |
e0bda0b8359a
Fixes a segfault when flushing delayed B-frames on the 2nd pass. patch by (Loren Merritt <lorenm.u@washington@edu>)
michael
parents:
2345
diff
changeset
|
2388 } |
2364
f8a229dfa2e8
check num_entries too to avoid reading over the array end and dont check i>0 it must be >0 there
michael
parents:
2363
diff
changeset
|
2389 |
2967 | 2390 s->input_picture[i]->pict_type= |
2364
f8a229dfa2e8
check num_entries too to avoid reading over the array end and dont check i>0 it must be >0 there
michael
parents:
2363
diff
changeset
|
2391 s->rc_context.entry[pict_num].new_pict_type; |
915 | 2392 } |
2393 } | |
924 | 2394 |
2297 | 2395 if(s->avctx->b_frame_strategy==0){ |
915 | 2396 b_frames= s->max_b_frames; |
1373 | 2397 while(b_frames && !s->input_picture[b_frames]) b_frames--; |
1687 | 2398 }else if(s->avctx->b_frame_strategy==1){ |
915 | 2399 for(i=1; i<s->max_b_frames+1; i++){ |
1373 | 2400 if(s->input_picture[i] && s->input_picture[i]->b_frame_score==0){ |
2967 | 2401 s->input_picture[i]->b_frame_score= |
2402 get_intra_count(s, s->input_picture[i ]->data[0], | |
924 | 2403 s->input_picture[i-1]->data[0], s->linesize) + 1; |
915 | 2404 } |
2405 } | |
2728 | 2406 for(i=0; i<s->max_b_frames+1; i++){ |
3335
97af1b315f59
Make B-frame reduction sensitivity by b_strategy/vb_strategy = 1
corey
parents:
3321
diff
changeset
|
2407 if(s->input_picture[i]==NULL || s->input_picture[i]->b_frame_score - 1 > s->mb_num/s->avctx->b_sensitivity) break; |
915 | 2408 } |
2967 | 2409 |
915 | 2410 b_frames= FFMAX(0, i-1); |
2967 | 2411 |
915 | 2412 /* reset scores */ |
2413 for(i=0; i<b_frames+1; i++){ | |
2414 s->input_picture[i]->b_frame_score=0; | |
2415 } | |
2988 | 2416 }else if(s->avctx->b_frame_strategy==2){ |
2417 b_frames= estimate_best_b_count(s); | |
915 | 2418 }else{ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1597
diff
changeset
|
2419 av_log(s->avctx, AV_LOG_ERROR, "illegal b frame strategy\n"); |
915 | 2420 b_frames=0; |
909
8ae1e4c24e91
new PSNR code (now works with chroma, b frames, ...)
michaelni
parents:
903
diff
changeset
|
2421 } |
915 | 2422 |
2423 emms_c(); | |
2424 //static int b_count=0; | |
2425 //b_count+= b_frames; | |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1597
diff
changeset
|
2426 //av_log(s->avctx, AV_LOG_DEBUG, "b_frames: %d\n", b_count); |
2297 | 2427 |
2428 for(i= b_frames - 1; i>=0; i--){ | |
2429 int type= s->input_picture[i]->pict_type; | |
2430 if(type && type != B_TYPE) | |
2431 b_frames= i; | |
2432 } | |
2433 if(s->input_picture[b_frames]->pict_type == B_TYPE && b_frames == s->max_b_frames){ | |
2627
bf158d23bbcc
Spelling errors patch by (Kevin Baragona | kevinmb500 gawab com)
michael
parents:
2620
diff
changeset
|
2434 av_log(s->avctx, AV_LOG_ERROR, "warning, too many b frames in a row\n"); |
2297 | 2435 } |
2436 | |
1754
bdf3927bf8c5
closed gop support & flags2 as all bits in flags are used
michael
parents:
1751
diff
changeset
|
2437 if(s->picture_in_gop_number + b_frames >= s->gop_size){ |
2298 | 2438 if((s->flags2 & CODEC_FLAG2_STRICT_GOP) && s->gop_size > s->picture_in_gop_number){ |
2439 b_frames= s->gop_size - s->picture_in_gop_number - 1; | |
2440 }else{ | |
1754
bdf3927bf8c5
closed gop support & flags2 as all bits in flags are used
michael
parents:
1751
diff
changeset
|
2441 if(s->flags & CODEC_FLAG_CLOSED_GOP) |
bdf3927bf8c5
closed gop support & flags2 as all bits in flags are used
michael
parents:
1751
diff
changeset
|
2442 b_frames=0; |
bdf3927bf8c5
closed gop support & flags2 as all bits in flags are used
michael
parents:
1751
diff
changeset
|
2443 s->input_picture[b_frames]->pict_type= I_TYPE; |
2298 | 2444 } |
1754
bdf3927bf8c5
closed gop support & flags2 as all bits in flags are used
michael
parents:
1751
diff
changeset
|
2445 } |
2967 | 2446 |
1754
bdf3927bf8c5
closed gop support & flags2 as all bits in flags are used
michael
parents:
1751
diff
changeset
|
2447 if( (s->flags & CODEC_FLAG_CLOSED_GOP) |
bdf3927bf8c5
closed gop support & flags2 as all bits in flags are used
michael
parents:
1751
diff
changeset
|
2448 && b_frames |
bdf3927bf8c5
closed gop support & flags2 as all bits in flags are used
michael
parents:
1751
diff
changeset
|
2449 && s->input_picture[b_frames]->pict_type== I_TYPE) |
bdf3927bf8c5
closed gop support & flags2 as all bits in flags are used
michael
parents:
1751
diff
changeset
|
2450 b_frames--; |
bdf3927bf8c5
closed gop support & flags2 as all bits in flags are used
michael
parents:
1751
diff
changeset
|
2451 |
915 | 2452 s->reordered_input_picture[0]= s->input_picture[b_frames]; |
1754
bdf3927bf8c5
closed gop support & flags2 as all bits in flags are used
michael
parents:
1751
diff
changeset
|
2453 if(s->reordered_input_picture[0]->pict_type != I_TYPE) |
915 | 2454 s->reordered_input_picture[0]->pict_type= P_TYPE; |
1705 | 2455 s->reordered_input_picture[0]->coded_picture_number= s->coded_picture_number++; |
915 | 2456 for(i=0; i<b_frames; i++){ |
2457 s->reordered_input_picture[i+1]= s->input_picture[i]; | |
2458 s->reordered_input_picture[i+1]->pict_type= B_TYPE; | |
1705 | 2459 s->reordered_input_picture[i+1]->coded_picture_number= s->coded_picture_number++; |
903 | 2460 } |
324 | 2461 } |
2462 } | |
2381 | 2463 no_output_pic: |
903 | 2464 if(s->reordered_input_picture[0]){ |
1168 | 2465 s->reordered_input_picture[0]->reference= s->reordered_input_picture[0]->pict_type!=B_TYPE ? 3 : 0; |
1138 | 2466 |
1539
14d01ccc0081
picture buffer cleanup, this fixes a assertion failure (if assertion checking was manualy enabled for utils.c) and a memleak at least
michael
parents:
1530
diff
changeset
|
2467 copy_picture(&s->new_picture, s->reordered_input_picture[0]); |
924 | 2468 |
3939
16ace038f452
fix buffer underflows by reencoding the current frame with a higher QP
michael
parents:
3929
diff
changeset
|
2469 if(s->reordered_input_picture[0]->type == FF_BUFFER_TYPE_SHARED || s->avctx->rc_buffer_size){ |
2764 | 2470 // input is a shared pix, so we can't modifiy it -> alloc a new one & ensure that the shared one is reuseable |
2967 | 2471 |
1586 | 2472 int i= ff_find_unused_picture(s, 0); |
924 | 2473 Picture *pic= &s->picture[i]; |
2474 | |
3939
16ace038f452
fix buffer underflows by reencoding the current frame with a higher QP
michael
parents:
3929
diff
changeset
|
2475 pic->reference = s->reordered_input_picture[0]->reference; |
16ace038f452
fix buffer underflows by reencoding the current frame with a higher QP
michael
parents:
3929
diff
changeset
|
2476 alloc_picture(s, pic, 0); |
16ace038f452
fix buffer underflows by reencoding the current frame with a higher QP
michael
parents:
3929
diff
changeset
|
2477 |
924 | 2478 /* mark us unused / free shared pic */ |
3939
16ace038f452
fix buffer underflows by reencoding the current frame with a higher QP
michael
parents:
3929
diff
changeset
|
2479 if(s->reordered_input_picture[0]->type == FF_BUFFER_TYPE_INTERNAL) |
16ace038f452
fix buffer underflows by reencoding the current frame with a higher QP
michael
parents:
3929
diff
changeset
|
2480 s->avctx->release_buffer(s->avctx, (AVFrame*)s->reordered_input_picture[0]); |
924 | 2481 for(i=0; i<4; i++) |
2482 s->reordered_input_picture[0]->data[i]= NULL; | |
2483 s->reordered_input_picture[0]->type= 0; | |
2967 | 2484 |
1955
5dafb10e0252
reuse motion vectors/mb types/field select values of the source video, if the SSE for a macroblock which is predicted with these values is below me_threshold
michael
parents:
1948
diff
changeset
|
2485 copy_picture_attributes(s, (AVFrame*)pic, (AVFrame*)s->reordered_input_picture[0]); |
5dafb10e0252
reuse motion vectors/mb types/field select values of the source video, if the SSE for a macroblock which is predicted with these values is below me_threshold
michael
parents:
1948
diff
changeset
|
2486 |
1138 | 2487 s->current_picture_ptr= pic; |
924 | 2488 }else{ |
1138 | 2489 // input is not a shared pix -> reuse buffer for current_pix |
2490 | |
2967 | 2491 assert( s->reordered_input_picture[0]->type==FF_BUFFER_TYPE_USER |
924 | 2492 || s->reordered_input_picture[0]->type==FF_BUFFER_TYPE_INTERNAL); |
2967 | 2493 |
1138 | 2494 s->current_picture_ptr= s->reordered_input_picture[0]; |
924 | 2495 for(i=0; i<4; i++){ |
3068 | 2496 s->new_picture.data[i]+= INPLACE_OFFSET; |
924 | 2497 } |
903 | 2498 } |
1539
14d01ccc0081
picture buffer cleanup, this fixes a assertion failure (if assertion checking was manualy enabled for utils.c) and a memleak at least
michael
parents:
1530
diff
changeset
|
2499 copy_picture(&s->current_picture, s->current_picture_ptr); |
2967 | 2500 |
903 | 2501 s->picture_number= s->new_picture.display_picture_number; |
2502 //printf("dpn:%d\n", s->picture_number); | |
2503 }else{ | |
2504 memset(&s->new_picture, 0, sizeof(Picture)); | |
324 | 2505 } |
2506 } | |
2507 | |
0 | 2508 int MPV_encode_picture(AVCodecContext *avctx, |
2509 unsigned char *buf, int buf_size, void *data) | |
2510 { | |
2511 MpegEncContext *s = avctx->priv_data; | |
925 | 2512 AVFrame *pic_arg = data; |
1684 | 2513 int i, stuffing_count; |
0 | 2514 |
1799 | 2515 for(i=0; i<avctx->thread_count; i++){ |
1838 | 2516 int start_y= s->thread_context[i]->start_mb_y; |
2517 int end_y= s->thread_context[i]-> end_mb_y; | |
1799 | 2518 int h= s->mb_height; |
2807
3137aae854c9
Fix for overflow issue in mpegvideo.c patch by (Martin Boehme: boehme, inb uni-luebeck de)
michael
parents:
2792
diff
changeset
|
2519 uint8_t *start= buf + (size_t)(((int64_t) buf_size)*start_y/h); |
3137aae854c9
Fix for overflow issue in mpegvideo.c patch by (Martin Boehme: boehme, inb uni-luebeck de)
michael
parents:
2792
diff
changeset
|
2520 uint8_t *end = buf + (size_t)(((int64_t) buf_size)* end_y/h); |
1799 | 2521 |
2522 init_put_bits(&s->thread_context[i]->pb, start, end - start); | |
2523 } | |
0 | 2524 |
903 | 2525 s->picture_in_gop_number++; |
2526 | |
2243
b8bad8bbbc64
check if the user specified timestamps are strictly monotone
michael
parents:
2235
diff
changeset
|
2527 if(load_input_picture(s, pic_arg) < 0) |
b8bad8bbbc64
check if the user specified timestamps are strictly monotone
michael
parents:
2235
diff
changeset
|
2528 return -1; |
2967 | 2529 |
903 | 2530 select_input_picture(s); |
2967 | 2531 |
324 | 2532 /* output? */ |
903 | 2533 if(s->new_picture.data[0]){ |
2534 s->pict_type= s->new_picture.pict_type; | |
2535 //emms_c(); | |
2536 //printf("qs:%f %f %d\n", s->new_picture.quality, s->current_picture.quality, s->qscale); | |
553 | 2537 MPV_frame_start(s, avctx); |
3939
16ace038f452
fix buffer underflows by reencoding the current frame with a higher QP
michael
parents:
3929
diff
changeset
|
2538 vbv_retry: |
3766 | 2539 if (encode_picture(s, s->picture_number) < 0) |
2540 return -1; | |
2967 | 2541 |
376 | 2542 avctx->real_pict_num = s->picture_number; |
324 | 2543 avctx->header_bits = s->header_bits; |
2544 avctx->mv_bits = s->mv_bits; | |
2545 avctx->misc_bits = s->misc_bits; | |
2546 avctx->i_tex_bits = s->i_tex_bits; | |
2547 avctx->p_tex_bits = s->p_tex_bits; | |
2548 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
|
2549 avctx->p_count = s->mb_num - s->i_count - s->skip_count; //FIXME f/b_count in avctx |
324 | 2550 avctx->skip_count = s->skip_count; |
0 | 2551 |
324 | 2552 MPV_frame_end(s); |
2553 | |
4995 | 2554 if (ENABLE_MJPEG_ENCODER && s->out_format == FMT_MJPEG) |
5029
dbaa06366c3c
add a proper prefix to all mjpeg encoder exported functions
aurel
parents:
5028
diff
changeset
|
2555 ff_mjpeg_encode_picture_trailer(s); |
2967 | 2556 |
3939
16ace038f452
fix buffer underflows by reencoding the current frame with a higher QP
michael
parents:
3929
diff
changeset
|
2557 if(avctx->rc_buffer_size){ |
16ace038f452
fix buffer underflows by reencoding the current frame with a higher QP
michael
parents:
3929
diff
changeset
|
2558 RateControlContext *rcc= &s->rc_context; |
16ace038f452
fix buffer underflows by reencoding the current frame with a higher QP
michael
parents:
3929
diff
changeset
|
2559 int max_size= rcc->buffer_index/3; |
16ace038f452
fix buffer underflows by reencoding the current frame with a higher QP
michael
parents:
3929
diff
changeset
|
2560 |
4096
99616a74260a
use lambda/lmax instead of qscale/qmax as end check for vbv retry
michael
parents:
4052
diff
changeset
|
2561 if(put_bits_count(&s->pb) > max_size && s->lambda < s->avctx->lmax){ |
4052 | 2562 s->next_lambda= FFMAX(s->lambda+1, s->lambda*(s->qscale+1) / s->qscale); |
4218 | 2563 if(s->adaptive_quant){ |
2564 int i; | |
4223 | 2565 for(i=0; i<s->mb_height*s->mb_stride; i++) |
4218 | 2566 s->lambda_table[i]= FFMAX(s->lambda_table[i]+1, s->lambda_table[i]*(s->qscale+1) / s->qscale); |
2567 } | |
3939
16ace038f452
fix buffer underflows by reencoding the current frame with a higher QP
michael
parents:
3929
diff
changeset
|
2568 s->mb_skipped = 0; //done in MPV_frame_start() |
16ace038f452
fix buffer underflows by reencoding the current frame with a higher QP
michael
parents:
3929
diff
changeset
|
2569 if(s->pict_type==P_TYPE){ //done in encode_picture() so we must undo it |
16ace038f452
fix buffer underflows by reencoding the current frame with a higher QP
michael
parents:
3929
diff
changeset
|
2570 if(s->flipflop_rounding || s->codec_id == CODEC_ID_H263P || s->codec_id == CODEC_ID_MPEG4) |
16ace038f452
fix buffer underflows by reencoding the current frame with a higher QP
michael
parents:
3929
diff
changeset
|
2571 s->no_rounding ^= 1; |
16ace038f452
fix buffer underflows by reencoding the current frame with a higher QP
michael
parents:
3929
diff
changeset
|
2572 } |
4111 | 2573 if(s->pict_type!=B_TYPE){ |
2574 s->time_base= s->last_time_base; | |
2575 s->last_non_b_time= s->time - s->pp_time; | |
2576 } | |
3939
16ace038f452
fix buffer underflows by reencoding the current frame with a higher QP
michael
parents:
3929
diff
changeset
|
2577 // av_log(NULL, AV_LOG_ERROR, "R:%d ", s->next_lambda); |
16ace038f452
fix buffer underflows by reencoding the current frame with a higher QP
michael
parents:
3929
diff
changeset
|
2578 for(i=0; i<avctx->thread_count; i++){ |
16ace038f452
fix buffer underflows by reencoding the current frame with a higher QP
michael
parents:
3929
diff
changeset
|
2579 PutBitContext *pb= &s->thread_context[i]->pb; |
16ace038f452
fix buffer underflows by reencoding the current frame with a higher QP
michael
parents:
3929
diff
changeset
|
2580 init_put_bits(pb, pb->buf, pb->buf_end - pb->buf); |
16ace038f452
fix buffer underflows by reencoding the current frame with a higher QP
michael
parents:
3929
diff
changeset
|
2581 } |
16ace038f452
fix buffer underflows by reencoding the current frame with a higher QP
michael
parents:
3929
diff
changeset
|
2582 goto vbv_retry; |
16ace038f452
fix buffer underflows by reencoding the current frame with a higher QP
michael
parents:
3929
diff
changeset
|
2583 } |
16ace038f452
fix buffer underflows by reencoding the current frame with a higher QP
michael
parents:
3929
diff
changeset
|
2584 |
16ace038f452
fix buffer underflows by reencoding the current frame with a higher QP
michael
parents:
3929
diff
changeset
|
2585 assert(s->avctx->rc_max_rate); |
16ace038f452
fix buffer underflows by reencoding the current frame with a higher QP
michael
parents:
3929
diff
changeset
|
2586 } |
16ace038f452
fix buffer underflows by reencoding the current frame with a higher QP
michael
parents:
3929
diff
changeset
|
2587 |
329 | 2588 if(s->flags&CODEC_FLAG_PASS1) |
2589 ff_write_pass1_stats(s); | |
1138 | 2590 |
2591 for(i=0; i<4; i++){ | |
2955 | 2592 s->current_picture_ptr->error[i]= s->current_picture.error[i]; |
1138 | 2593 avctx->error[i] += s->current_picture_ptr->error[i]; |
2594 } | |
1766 | 2595 |
2428
548c87c06dbb
assertion about bits statistic and minor bits stat fix
michael
parents:
2427
diff
changeset
|
2596 if(s->flags&CODEC_FLAG_PASS1) |
548c87c06dbb
assertion about bits statistic and minor bits stat fix
michael
parents:
2427
diff
changeset
|
2597 assert(avctx->header_bits + avctx->mv_bits + avctx->misc_bits + avctx->i_tex_bits + avctx->p_tex_bits == put_bits_count(&s->pb)); |
1684 | 2598 flush_put_bits(&s->pb); |
1801
3f26dfb3eba4
replace a few pbBufPtr() by put_bits_count(), one of them was actually wrong
michael
parents:
1799
diff
changeset
|
2599 s->frame_bits = put_bits_count(&s->pb); |
1766 | 2600 |
2601 stuffing_count= ff_vbv_update(s, s->frame_bits); | |
2602 if(stuffing_count){ | |
2422 | 2603 if(s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb)>>3) < stuffing_count + 50){ |
2604 av_log(s->avctx, AV_LOG_ERROR, "stuffing too large\n"); | |
2605 return -1; | |
2606 } | |
2607 | |
1766 | 2608 switch(s->codec_id){ |
2609 case CODEC_ID_MPEG1VIDEO: | |
2610 case CODEC_ID_MPEG2VIDEO: | |
2611 while(stuffing_count--){ | |
2612 put_bits(&s->pb, 8, 0); | |
2613 } | |
2614 break; | |
2615 case CODEC_ID_MPEG4: | |
2616 put_bits(&s->pb, 16, 0); | |
2617 put_bits(&s->pb, 16, 0x1C3); | |
2618 stuffing_count -= 4; | |
2619 while(stuffing_count--){ | |
2620 put_bits(&s->pb, 8, 0xFF); | |
2621 } | |
2622 break; | |
2623 default: | |
2624 av_log(s->avctx, AV_LOG_ERROR, "vbv buffer overflow\n"); | |
2625 } | |
2626 flush_put_bits(&s->pb); | |
1801
3f26dfb3eba4
replace a few pbBufPtr() by put_bits_count(), one of them was actually wrong
michael
parents:
1799
diff
changeset
|
2627 s->frame_bits = put_bits_count(&s->pb); |
1766 | 2628 } |
2629 | |
2967 | 2630 /* update mpeg1/2 vbv_delay for CBR */ |
1907 | 2631 if(s->avctx->rc_max_rate && s->avctx->rc_min_rate == s->avctx->rc_max_rate && s->out_format == FMT_MPEG1 |
2632 && 90000LL * (avctx->rc_buffer_size-1) <= s->avctx->rc_max_rate*0xFFFFLL){ | |
1766 | 2633 int vbv_delay; |
2634 | |
2635 assert(s->repeat_first_field==0); | |
2967 | 2636 |
1766 | 2637 vbv_delay= lrintf(90000 * s->rc_context.buffer_index / s->avctx->rc_max_rate); |
2638 assert(vbv_delay < 0xFFFF); | |
2639 | |
2640 s->vbv_delay_ptr[0] &= 0xF8; | |
2641 s->vbv_delay_ptr[0] |= vbv_delay>>13; | |
2642 s->vbv_delay_ptr[1] = vbv_delay>>5; | |
2643 s->vbv_delay_ptr[2] &= 0x07; | |
2644 s->vbv_delay_ptr[2] |= vbv_delay<<3; | |
2645 } | |
2646 s->total_bits += s->frame_bits; | |
2647 avctx->frame_bits = s->frame_bits; | |
2648 }else{ | |
2649 assert((pbBufPtr(&s->pb) == s->pb.buf)); | |
2650 s->frame_bits=0; | |
1684 | 2651 } |
1766 | 2652 assert((s->frame_bits&7)==0); |
2967 | 2653 |
1684 | 2654 return s->frame_bits/8; |
0 | 2655 } |
2656 | |
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
|
2657 #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
|
2658 |
255 | 2659 static inline void gmc1_motion(MpegEncContext *s, |
1064 | 2660 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr, |
1842
0d82db458a3c
interlaced mpeg4 + edge emu fix (fixes decoding of mermaid.avi)
michael
parents:
1838
diff
changeset
|
2661 uint8_t **ref_picture) |
255 | 2662 { |
1064 | 2663 uint8_t *ptr; |
556 | 2664 int offset, src_x, src_y, linesize, uvlinesize; |
255 | 2665 int motion_x, motion_y; |
566 | 2666 int emu=0; |
255 | 2667 |
2668 motion_x= s->sprite_offset[0][0]; | |
2669 motion_y= s->sprite_offset[0][1]; | |
2670 src_x = s->mb_x * 16 + (motion_x >> (s->sprite_warping_accuracy+1)); | |
2671 src_y = s->mb_y * 16 + (motion_y >> (s->sprite_warping_accuracy+1)); | |
2672 motion_x<<=(3-s->sprite_warping_accuracy); | |
2673 motion_y<<=(3-s->sprite_warping_accuracy); | |
4594 | 2674 src_x = av_clip(src_x, -16, s->width); |
255 | 2675 if (src_x == s->width) |
2676 motion_x =0; | |
4594 | 2677 src_y = av_clip(src_y, -16, s->height); |
255 | 2678 if (src_y == s->height) |
2679 motion_y =0; | |
753 | 2680 |
255 | 2681 linesize = s->linesize; |
556 | 2682 uvlinesize = s->uvlinesize; |
2967 | 2683 |
1842
0d82db458a3c
interlaced mpeg4 + edge emu fix (fixes decoding of mermaid.avi)
michael
parents:
1838
diff
changeset
|
2684 ptr = ref_picture[0] + (src_y * linesize) + src_x; |
0d82db458a3c
interlaced mpeg4 + edge emu fix (fixes decoding of mermaid.avi)
michael
parents:
1838
diff
changeset
|
2685 |
566 | 2686 if(s->flags&CODEC_FLAG_EMU_EDGE){ |
1542
576861d6343a
emu_edge checks simplification and avoid redundant checks for mpeg1/2 if emu_edge is set
michael
parents:
1539
diff
changeset
|
2687 if( (unsigned)src_x >= s->h_edge_pos - 17 |
576861d6343a
emu_edge checks simplification and avoid redundant checks for mpeg1/2 if emu_edge is set
michael
parents:
1539
diff
changeset
|
2688 || (unsigned)src_y >= s->v_edge_pos - 17){ |
1317
26c44d2433c1
make ff_emulated_edge_mc() independant of MpegEncContext
michaelni
parents:
1315
diff
changeset
|
2689 ff_emulated_edge_mc(s->edge_emu_buffer, ptr, linesize, 17, 17, src_x, src_y, s->h_edge_pos, s->v_edge_pos); |
566 | 2690 ptr= s->edge_emu_buffer; |
2691 } | |
2692 } | |
2967 | 2693 |
753 | 2694 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
|
2695 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
|
2696 s->dsp.gmc1(dest_y+8, ptr+8, linesize, 16, motion_x&15, motion_y&15, 128 - s->no_rounding); |
753 | 2697 }else{ |
2698 int dxy; | |
2967 | 2699 |
753 | 2700 dxy= ((motion_x>>3)&1) | ((motion_y>>2)&2); |
2701 if (s->no_rounding){ | |
2979 | 2702 s->dsp.put_no_rnd_pixels_tab[0][dxy](dest_y, ptr, linesize, 16); |
753 | 2703 }else{ |
853
eacc2dd8fd9d
* using DSPContext - so each codec could use its local (sub)set of CPU extension
kabi
parents:
847
diff
changeset
|
2704 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
|
2705 } |
753 | 2706 } |
2967 | 2707 |
753 | 2708 if(s->flags&CODEC_FLAG_GRAY) return; |
255 | 2709 |
2710 motion_x= s->sprite_offset[1][0]; | |
2711 motion_y= s->sprite_offset[1][1]; | |
2712 src_x = s->mb_x * 8 + (motion_x >> (s->sprite_warping_accuracy+1)); | |
2713 src_y = s->mb_y * 8 + (motion_y >> (s->sprite_warping_accuracy+1)); | |
2714 motion_x<<=(3-s->sprite_warping_accuracy); | |
2715 motion_y<<=(3-s->sprite_warping_accuracy); | |
4594 | 2716 src_x = av_clip(src_x, -8, s->width>>1); |
255 | 2717 if (src_x == s->width>>1) |
2718 motion_x =0; | |
4594 | 2719 src_y = av_clip(src_y, -8, s->height>>1); |
255 | 2720 if (src_y == s->height>>1) |
2721 motion_y =0; | |
2722 | |
1842
0d82db458a3c
interlaced mpeg4 + edge emu fix (fixes decoding of mermaid.avi)
michael
parents:
1838
diff
changeset
|
2723 offset = (src_y * uvlinesize) + src_x; |
255 | 2724 ptr = ref_picture[1] + offset; |
1002 | 2725 if(s->flags&CODEC_FLAG_EMU_EDGE){ |
1542
576861d6343a
emu_edge checks simplification and avoid redundant checks for mpeg1/2 if emu_edge is set
michael
parents:
1539
diff
changeset
|
2726 if( (unsigned)src_x >= (s->h_edge_pos>>1) - 9 |
576861d6343a
emu_edge checks simplification and avoid redundant checks for mpeg1/2 if emu_edge is set
michael
parents:
1539
diff
changeset
|
2727 || (unsigned)src_y >= (s->v_edge_pos>>1) - 9){ |
1317
26c44d2433c1
make ff_emulated_edge_mc() independant of MpegEncContext
michaelni
parents:
1315
diff
changeset
|
2728 ff_emulated_edge_mc(s->edge_emu_buffer, ptr, uvlinesize, 9, 9, src_x, src_y, s->h_edge_pos>>1, s->v_edge_pos>>1); |
1002 | 2729 ptr= s->edge_emu_buffer; |
2730 emu=1; | |
2731 } | |
566 | 2732 } |
1842
0d82db458a3c
interlaced mpeg4 + edge emu fix (fixes decoding of mermaid.avi)
michael
parents:
1838
diff
changeset
|
2733 s->dsp.gmc1(dest_cb, ptr, uvlinesize, 8, motion_x&15, motion_y&15, 128 - s->no_rounding); |
2967 | 2734 |
255 | 2735 ptr = ref_picture[2] + offset; |
566 | 2736 if(emu){ |
1317
26c44d2433c1
make ff_emulated_edge_mc() independant of MpegEncContext
michaelni
parents:
1315
diff
changeset
|
2737 ff_emulated_edge_mc(s->edge_emu_buffer, ptr, uvlinesize, 9, 9, src_x, src_y, s->h_edge_pos>>1, s->v_edge_pos>>1); |
566 | 2738 ptr= s->edge_emu_buffer; |
2739 } | |
1842
0d82db458a3c
interlaced mpeg4 + edge emu fix (fixes decoding of mermaid.avi)
michael
parents:
1838
diff
changeset
|
2740 s->dsp.gmc1(dest_cr, ptr, uvlinesize, 8, motion_x&15, motion_y&15, 128 - s->no_rounding); |
2967 | 2741 |
255 | 2742 return; |
2743 } | |
2744 | |
753 | 2745 static inline void gmc_motion(MpegEncContext *s, |
1064 | 2746 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr, |
1842
0d82db458a3c
interlaced mpeg4 + edge emu fix (fixes decoding of mermaid.avi)
michael
parents:
1838
diff
changeset
|
2747 uint8_t **ref_picture) |
753 | 2748 { |
1064 | 2749 uint8_t *ptr; |
753 | 2750 int linesize, uvlinesize; |
2751 const int a= s->sprite_warping_accuracy; | |
2752 int ox, oy; | |
2753 | |
2754 linesize = s->linesize; | |
2755 uvlinesize = s->uvlinesize; | |
2756 | |
1842
0d82db458a3c
interlaced mpeg4 + edge emu fix (fixes decoding of mermaid.avi)
michael
parents:
1838
diff
changeset
|
2757 ptr = ref_picture[0]; |
0d82db458a3c
interlaced mpeg4 + edge emu fix (fixes decoding of mermaid.avi)
michael
parents:
1838
diff
changeset
|
2758 |
753 | 2759 ox= s->sprite_offset[0][0] + s->sprite_delta[0][0]*s->mb_x*16 + s->sprite_delta[0][1]*s->mb_y*16; |
2760 oy= s->sprite_offset[0][1] + s->sprite_delta[1][0]*s->mb_x*16 + s->sprite_delta[1][1]*s->mb_y*16; | |
2761 | |
853
eacc2dd8fd9d
* using DSPContext - so each codec could use its local (sub)set of CPU extension
kabi
parents:
847
diff
changeset
|
2762 s->dsp.gmc(dest_y, ptr, linesize, 16, |
2967 | 2763 ox, |
2764 oy, | |
753 | 2765 s->sprite_delta[0][0], s->sprite_delta[0][1], |
2967 | 2766 s->sprite_delta[1][0], s->sprite_delta[1][1], |
753 | 2767 a+1, (1<<(2*a+1)) - s->no_rounding, |
2768 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
|
2769 s->dsp.gmc(dest_y+8, ptr, linesize, 16, |
2967 | 2770 ox + s->sprite_delta[0][0]*8, |
2771 oy + s->sprite_delta[1][0]*8, | |
753 | 2772 s->sprite_delta[0][0], s->sprite_delta[0][1], |
2967 | 2773 s->sprite_delta[1][0], s->sprite_delta[1][1], |
753 | 2774 a+1, (1<<(2*a+1)) - s->no_rounding, |
2775 s->h_edge_pos, s->v_edge_pos); | |
2776 | |
2777 if(s->flags&CODEC_FLAG_GRAY) return; | |
2778 | |
2779 ox= s->sprite_offset[1][0] + s->sprite_delta[0][0]*s->mb_x*8 + s->sprite_delta[0][1]*s->mb_y*8; | |
2780 oy= s->sprite_offset[1][1] + s->sprite_delta[1][0]*s->mb_x*8 + s->sprite_delta[1][1]*s->mb_y*8; | |
2781 | |
1842
0d82db458a3c
interlaced mpeg4 + edge emu fix (fixes decoding of mermaid.avi)
michael
parents:
1838
diff
changeset
|
2782 ptr = ref_picture[1]; |
853
eacc2dd8fd9d
* using DSPContext - so each codec could use its local (sub)set of CPU extension
kabi
parents:
847
diff
changeset
|
2783 s->dsp.gmc(dest_cb, ptr, uvlinesize, 8, |
2967 | 2784 ox, |
2785 oy, | |
753 | 2786 s->sprite_delta[0][0], s->sprite_delta[0][1], |
2967 | 2787 s->sprite_delta[1][0], s->sprite_delta[1][1], |
753 | 2788 a+1, (1<<(2*a+1)) - s->no_rounding, |
2789 s->h_edge_pos>>1, s->v_edge_pos>>1); | |
2967 | 2790 |
1842
0d82db458a3c
interlaced mpeg4 + edge emu fix (fixes decoding of mermaid.avi)
michael
parents:
1838
diff
changeset
|
2791 ptr = ref_picture[2]; |
853
eacc2dd8fd9d
* using DSPContext - so each codec could use its local (sub)set of CPU extension
kabi
parents:
847
diff
changeset
|
2792 s->dsp.gmc(dest_cr, ptr, uvlinesize, 8, |
2967 | 2793 ox, |
2794 oy, | |
753 | 2795 s->sprite_delta[0][0], s->sprite_delta[0][1], |
2967 | 2796 s->sprite_delta[1][0], s->sprite_delta[1][1], |
753 | 2797 a+1, (1<<(2*a+1)) - s->no_rounding, |
2798 s->h_edge_pos>>1, s->v_edge_pos>>1); | |
2799 } | |
2800 | |
1317
26c44d2433c1
make ff_emulated_edge_mc() independant of MpegEncContext
michaelni
parents:
1315
diff
changeset
|
2801 /** |
26c44d2433c1
make ff_emulated_edge_mc() independant of MpegEncContext
michaelni
parents:
1315
diff
changeset
|
2802 * Copies a rectangular area of samples to a temporary buffer and replicates the boarder samples. |
26c44d2433c1
make ff_emulated_edge_mc() independant of MpegEncContext
michaelni
parents:
1315
diff
changeset
|
2803 * @param buf destination buffer |
26c44d2433c1
make ff_emulated_edge_mc() independant of MpegEncContext
michaelni
parents:
1315
diff
changeset
|
2804 * @param src source buffer |
26c44d2433c1
make ff_emulated_edge_mc() independant of MpegEncContext
michaelni
parents:
1315
diff
changeset
|
2805 * @param linesize number of bytes between 2 vertically adjacent samples in both the source and destination buffers |
26c44d2433c1
make ff_emulated_edge_mc() independant of MpegEncContext
michaelni
parents:
1315
diff
changeset
|
2806 * @param block_w width of block |
26c44d2433c1
make ff_emulated_edge_mc() independant of MpegEncContext
michaelni
parents:
1315
diff
changeset
|
2807 * @param block_h height of block |
26c44d2433c1
make ff_emulated_edge_mc() independant of MpegEncContext
michaelni
parents:
1315
diff
changeset
|
2808 * @param src_x x coordinate of the top left sample of the block in the source buffer |
26c44d2433c1
make ff_emulated_edge_mc() independant of MpegEncContext
michaelni
parents:
1315
diff
changeset
|
2809 * @param src_y y coordinate of the top left sample of the block in the source buffer |
26c44d2433c1
make ff_emulated_edge_mc() independant of MpegEncContext
michaelni
parents:
1315
diff
changeset
|
2810 * @param w width of the source buffer |
26c44d2433c1
make ff_emulated_edge_mc() independant of MpegEncContext
michaelni
parents:
1315
diff
changeset
|
2811 * @param h height of the source buffer |
26c44d2433c1
make ff_emulated_edge_mc() independant of MpegEncContext
michaelni
parents:
1315
diff
changeset
|
2812 */ |
2967 | 2813 void ff_emulated_edge_mc(uint8_t *buf, uint8_t *src, int linesize, int block_w, int block_h, |
553 | 2814 int src_x, int src_y, int w, int h){ |
2815 int x, y; | |
2816 int start_y, start_x, end_y, end_x; | |
853
eacc2dd8fd9d
* using DSPContext - so each codec could use its local (sub)set of CPU extension
kabi
parents:
847
diff
changeset
|
2817 |
553 | 2818 if(src_y>= h){ |
2819 src+= (h-1-src_y)*linesize; | |
2820 src_y=h-1; | |
554 | 2821 }else if(src_y<=-block_h){ |
2822 src+= (1-block_h-src_y)*linesize; | |
2823 src_y=1-block_h; | |
553 | 2824 } |
2825 if(src_x>= w){ | |
2826 src+= (w-1-src_x); | |
2827 src_x=w-1; | |
554 | 2828 }else if(src_x<=-block_w){ |
2829 src+= (1-block_w-src_x); | |
2830 src_x=1-block_w; | |
553 | 2831 } |
2832 | |
847 | 2833 start_y= FFMAX(0, -src_y); |
2834 start_x= FFMAX(0, -src_x); | |
2835 end_y= FFMIN(block_h, h-src_y); | |
2836 end_x= FFMIN(block_w, w-src_x); | |
566 | 2837 |
553 | 2838 // copy existing part |
2839 for(y=start_y; y<end_y; y++){ | |
2840 for(x=start_x; x<end_x; x++){ | |
2841 buf[x + y*linesize]= src[x + y*linesize]; | |
2842 } | |
2843 } | |
2844 | |
2845 //top | |
2846 for(y=0; y<start_y; y++){ | |
2847 for(x=start_x; x<end_x; x++){ | |
2848 buf[x + y*linesize]= buf[x + start_y*linesize]; | |
2849 } | |
2850 } | |
2851 | |
2852 //bottom | |
2853 for(y=end_y; y<block_h; y++){ | |
2854 for(x=start_x; x<end_x; x++){ | |
2855 buf[x + y*linesize]= buf[x + (end_y-1)*linesize]; | |
2856 } | |
2857 } | |
2967 | 2858 |
553 | 2859 for(y=0; y<block_h; y++){ |
2860 //left | |
2861 for(x=0; x<start_x; x++){ | |
2862 buf[x + y*linesize]= buf[start_x + y*linesize]; | |
2863 } | |
2967 | 2864 |
553 | 2865 //right |
2866 for(x=end_x; x<block_w; x++){ | |
2867 buf[x + y*linesize]= buf[end_x - 1 + y*linesize]; | |
2868 } | |
2869 } | |
2870 } | |
2871 | |
2967 | 2872 static inline int hpel_motion(MpegEncContext *s, |
1842
0d82db458a3c
interlaced mpeg4 + edge emu fix (fixes decoding of mermaid.avi)
michael
parents:
1838
diff
changeset
|
2873 uint8_t *dest, uint8_t *src, |
0d82db458a3c
interlaced mpeg4 + edge emu fix (fixes decoding of mermaid.avi)
michael
parents:
1838
diff
changeset
|
2874 int field_based, int field_select, |
1633 | 2875 int src_x, int src_y, |
2876 int width, int height, int stride, | |
2877 int h_edge_pos, int v_edge_pos, | |
2878 int w, int h, op_pixels_func *pix_op, | |
2879 int motion_x, int motion_y) | |
2880 { | |
2881 int dxy; | |
2882 int emu=0; | |
2883 | |
2884 dxy = ((motion_y & 1) << 1) | (motion_x & 1); | |
2885 src_x += motion_x >> 1; | |
2886 src_y += motion_y >> 1; | |
2967 | 2887 |
1633 | 2888 /* WARNING: do no forget half pels */ |
4594 | 2889 src_x = av_clip(src_x, -16, width); //FIXME unneeded for emu? |
1633 | 2890 if (src_x == width) |
2891 dxy &= ~1; | |
4594 | 2892 src_y = av_clip(src_y, -16, height); |
1633 | 2893 if (src_y == height) |
2894 dxy &= ~2; | |
2895 src += src_y * stride + src_x; | |
2896 | |
2897 if(s->unrestricted_mv && (s->flags&CODEC_FLAG_EMU_EDGE)){ | |
2898 if( (unsigned)src_x > h_edge_pos - (motion_x&1) - w | |
2899 || (unsigned)src_y > v_edge_pos - (motion_y&1) - h){ | |
1842
0d82db458a3c
interlaced mpeg4 + edge emu fix (fixes decoding of mermaid.avi)
michael
parents:
1838
diff
changeset
|
2900 ff_emulated_edge_mc(s->edge_emu_buffer, src, s->linesize, w+1, (h+1)<<field_based, |
0d82db458a3c
interlaced mpeg4 + edge emu fix (fixes decoding of mermaid.avi)
michael
parents:
1838
diff
changeset
|
2901 src_x, src_y<<field_based, h_edge_pos, s->v_edge_pos); |
1633 | 2902 src= s->edge_emu_buffer; |
2903 emu=1; | |
2904 } | |
2905 } | |
1842
0d82db458a3c
interlaced mpeg4 + edge emu fix (fixes decoding of mermaid.avi)
michael
parents:
1838
diff
changeset
|
2906 if(field_select) |
0d82db458a3c
interlaced mpeg4 + edge emu fix (fixes decoding of mermaid.avi)
michael
parents:
1838
diff
changeset
|
2907 src += s->linesize; |
1633 | 2908 pix_op[dxy](dest, src, stride, h); |
2909 return emu; | |
2910 } | |
553 | 2911 |
2967 | 2912 static inline int hpel_motion_lowres(MpegEncContext *s, |
2292 | 2913 uint8_t *dest, uint8_t *src, |
2914 int field_based, int field_select, | |
2915 int src_x, int src_y, | |
2916 int width, int height, int stride, | |
2917 int h_edge_pos, int v_edge_pos, | |
2918 int w, int h, h264_chroma_mc_func *pix_op, | |
2919 int motion_x, int motion_y) | |
2920 { | |
2921 const int lowres= s->avctx->lowres; | |
2922 const int s_mask= (2<<lowres)-1; | |
2923 int emu=0; | |
2924 int sx, sy; | |
2925 | |
2926 if(s->quarter_sample){ | |
2927 motion_x/=2; | |
2928 motion_y/=2; | |
2929 } | |
2930 | |
2931 sx= motion_x & s_mask; | |
2932 sy= motion_y & s_mask; | |
2933 src_x += motion_x >> (lowres+1); | |
2934 src_y += motion_y >> (lowres+1); | |
2967 | 2935 |
2292 | 2936 src += src_y * stride + src_x; |
2937 | |
2938 if( (unsigned)src_x > h_edge_pos - (!!sx) - w | |
2939 || (unsigned)src_y >(v_edge_pos >> field_based) - (!!sy) - h){ | |
2940 ff_emulated_edge_mc(s->edge_emu_buffer, src, s->linesize, w+1, (h+1)<<field_based, | |
2941 src_x, src_y<<field_based, h_edge_pos, v_edge_pos); | |
2942 src= s->edge_emu_buffer; | |
2943 emu=1; | |
2944 } | |
2945 | |
2946 sx <<= 2 - lowres; | |
2947 sy <<= 2 - lowres; | |
2948 if(field_select) | |
2949 src += s->linesize; | |
2950 pix_op[lowres](dest, src, stride, h, sx, sy); | |
2951 return emu; | |
2952 } | |
2953 | |
0 | 2954 /* apply one mpeg motion vector to the three components */ |
4283
d6f83e2f8804
rename always_inline to av_always_inline and move to common.h
mru
parents:
4281
diff
changeset
|
2955 static av_always_inline void mpeg_motion(MpegEncContext *s, |
1064 | 2956 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr, |
1842
0d82db458a3c
interlaced mpeg4 + edge emu fix (fixes decoding of mermaid.avi)
michael
parents:
1838
diff
changeset
|
2957 int field_based, int bottom_field, int field_select, |
0d82db458a3c
interlaced mpeg4 + edge emu fix (fixes decoding of mermaid.avi)
michael
parents:
1838
diff
changeset
|
2958 uint8_t **ref_picture, op_pixels_func (*pix_op)[4], |
0 | 2959 int motion_x, int motion_y, int h) |
2960 { | |
1846 | 2961 uint8_t *ptr_y, *ptr_cb, *ptr_cr; |
2962 int dxy, uvdxy, mx, my, src_x, src_y, uvsrc_x, uvsrc_y, v_edge_pos, uvlinesize, linesize; | |
2967 | 2963 |
2964 #if 0 | |
255 | 2965 if(s->quarter_sample) |
2966 { | |
2967 motion_x>>=1; | |
2968 motion_y>>=1; | |
2969 } | |
651 | 2970 #endif |
1633 | 2971 |
582
5132a4ee50cd
different edge positions fixed with edge emu / dr1
michaelni
parents:
575
diff
changeset
|
2972 v_edge_pos = s->v_edge_pos >> field_based; |
1846 | 2973 linesize = s->current_picture.linesize[0] << field_based; |
1138 | 2974 uvlinesize = s->current_picture.linesize[1] << field_based; |
1633 | 2975 |
1846 | 2976 dxy = ((motion_y & 1) << 1) | (motion_x & 1); |
2977 src_x = s->mb_x* 16 + (motion_x >> 1); | |
2074
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
2978 src_y =(s->mb_y<<(4-field_based)) + (motion_y >> 1); |
485 | 2979 |
0 | 2980 if (s->out_format == FMT_H263) { |
1916 | 2981 if((s->workaround_bugs & FF_BUG_HPEL_CHROMA) && field_based){ |
2982 mx = (motion_x>>1)|(motion_x&1); | |
2983 my = motion_y >>1; | |
2984 uvdxy = ((my & 1) << 1) | (mx & 1); | |
2985 uvsrc_x = s->mb_x* 8 + (mx >> 1); | |
2074
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
2986 uvsrc_y = (s->mb_y<<(3-field_based)) + (my >> 1); |
1916 | 2987 }else{ |
2988 uvdxy = dxy | (motion_y & 2) | ((motion_x & 2) >> 1); | |
2989 uvsrc_x = src_x>>1; | |
2990 uvsrc_y = src_y>>1; | |
2991 } | |
2044
b6f2add2511e
h261 decoder by (Maarten Daniels <maarten.daniels at student dot luc dot ac dot be>)
michael
parents:
2042
diff
changeset
|
2992 }else if(s->out_format == FMT_H261){//even chroma mv's are full pel in H261 |
b6f2add2511e
h261 decoder by (Maarten Daniels <maarten.daniels at student dot luc dot ac dot be>)
michael
parents:
2042
diff
changeset
|
2993 mx = motion_x / 4; |
b6f2add2511e
h261 decoder by (Maarten Daniels <maarten.daniels at student dot luc dot ac dot be>)
michael
parents:
2042
diff
changeset
|
2994 my = motion_y / 4; |
b6f2add2511e
h261 decoder by (Maarten Daniels <maarten.daniels at student dot luc dot ac dot be>)
michael
parents:
2042
diff
changeset
|
2995 uvdxy = 0; |
b6f2add2511e
h261 decoder by (Maarten Daniels <maarten.daniels at student dot luc dot ac dot be>)
michael
parents:
2042
diff
changeset
|
2996 uvsrc_x = s->mb_x*8 + mx; |
b6f2add2511e
h261 decoder by (Maarten Daniels <maarten.daniels at student dot luc dot ac dot be>)
michael
parents:
2042
diff
changeset
|
2997 uvsrc_y = s->mb_y*8 + my; |
0 | 2998 } else { |
2074
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
2999 if(s->chroma_y_shift){ |
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
3000 mx = motion_x / 2; |
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
3001 my = motion_y / 2; |
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
3002 uvdxy = ((my & 1) << 1) | (mx & 1); |
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
3003 uvsrc_x = s->mb_x* 8 + (mx >> 1); |
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
3004 uvsrc_y = (s->mb_y<<(3-field_based)) + (my >> 1); |
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
3005 } else { |
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
3006 if(s->chroma_x_shift){ |
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
3007 //Chroma422 |
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
3008 mx = motion_x / 2; |
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
3009 uvdxy = ((motion_y & 1) << 1) | (mx & 1); |
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
3010 uvsrc_x = s->mb_x* 8 + (mx >> 1); |
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
3011 uvsrc_y = src_y; |
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
3012 } else { |
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
3013 //Chroma444 |
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
3014 uvdxy = dxy; |
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
3015 uvsrc_x = src_x; |
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
3016 uvsrc_y = src_y; |
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
3017 } |
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
3018 } |
1846 | 3019 } |
3020 | |
3021 ptr_y = ref_picture[0] + src_y * linesize + src_x; | |
3022 ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x; | |
3023 ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x; | |
3024 | |
3025 if( (unsigned)src_x > s->h_edge_pos - (motion_x&1) - 16 | |
3026 || (unsigned)src_y > v_edge_pos - (motion_y&1) - h){ | |
2074
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
3027 if(s->codec_id == CODEC_ID_MPEG2VIDEO || |
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
3028 s->codec_id == CODEC_ID_MPEG1VIDEO){ |
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
3029 av_log(s->avctx,AV_LOG_DEBUG,"MPEG motion vector out of boundary\n"); |
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
3030 return ; |
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
3031 } |
1846 | 3032 ff_emulated_edge_mc(s->edge_emu_buffer, ptr_y, s->linesize, 17, 17+field_based, |
3033 src_x, src_y<<field_based, s->h_edge_pos, s->v_edge_pos); | |
3034 ptr_y = s->edge_emu_buffer; | |
3035 if(!(s->flags&CODEC_FLAG_GRAY)){ | |
1874 | 3036 uint8_t *uvbuf= s->edge_emu_buffer+18*s->linesize; |
2967 | 3037 ff_emulated_edge_mc(uvbuf , ptr_cb, s->uvlinesize, 9, 9+field_based, |
1846 | 3038 uvsrc_x, uvsrc_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1); |
2967 | 3039 ff_emulated_edge_mc(uvbuf+16, ptr_cr, s->uvlinesize, 9, 9+field_based, |
1846 | 3040 uvsrc_x, uvsrc_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1); |
3041 ptr_cb= uvbuf; | |
3042 ptr_cr= uvbuf+16; | |
3043 } | |
3044 } | |
3045 | |
3046 if(bottom_field){ //FIXME use this for field pix too instead of the obnoxious hack which changes picture.data | |
3047 dest_y += s->linesize; | |
3048 dest_cb+= s->uvlinesize; | |
3049 dest_cr+= s->uvlinesize; | |
3050 } | |
3051 | |
3052 if(field_select){ | |
3053 ptr_y += s->linesize; | |
3054 ptr_cb+= s->uvlinesize; | |
3055 ptr_cr+= s->uvlinesize; | |
3056 } | |
3057 | |
3058 pix_op[0][dxy](dest_y, ptr_y, linesize, h); | |
2967 | 3059 |
1846 | 3060 if(!(s->flags&CODEC_FLAG_GRAY)){ |
2074
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
3061 pix_op[s->chroma_x_shift][uvdxy](dest_cb, ptr_cb, uvlinesize, h >> s->chroma_y_shift); |
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
3062 pix_op[s->chroma_x_shift][uvdxy](dest_cr, ptr_cr, uvlinesize, h >> s->chroma_y_shift); |
1846 | 3063 } |
4997 | 3064 if((ENABLE_H261_ENCODER || ENABLE_H261_DECODER) && s->out_format == FMT_H261){ |
2291 | 3065 ff_h261_loop_filter(s); |
3066 } | |
0 | 3067 } |
2256 | 3068 |
3069 /* apply one mpeg motion vector to the three components */ | |
4283
d6f83e2f8804
rename always_inline to av_always_inline and move to common.h
mru
parents:
4281
diff
changeset
|
3070 static av_always_inline void mpeg_motion_lowres(MpegEncContext *s, |
2256 | 3071 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr, |
3072 int field_based, int bottom_field, int field_select, | |
3073 uint8_t **ref_picture, h264_chroma_mc_func *pix_op, | |
3074 int motion_x, int motion_y, int h) | |
3075 { | |
3076 uint8_t *ptr_y, *ptr_cb, *ptr_cr; | |
3077 int mx, my, src_x, src_y, uvsrc_x, uvsrc_y, uvlinesize, linesize, sx, sy, uvsx, uvsy; | |
3078 const int lowres= s->avctx->lowres; | |
3079 const int block_s= 8>>lowres; | |
3080 const int s_mask= (2<<lowres)-1; | |
3081 const int h_edge_pos = s->h_edge_pos >> lowres; | |
3082 const int v_edge_pos = s->v_edge_pos >> lowres; | |
3083 linesize = s->current_picture.linesize[0] << field_based; | |
3084 uvlinesize = s->current_picture.linesize[1] << field_based; | |
3085 | |
2260 | 3086 if(s->quarter_sample){ //FIXME obviously not perfect but qpel wont work in lowres anyway |
3087 motion_x/=2; | |
3088 motion_y/=2; | |
3089 } | |
2967 | 3090 |
2260 | 3091 if(field_based){ |
3092 motion_y += (bottom_field - field_select)*((1<<lowres)-1); | |
3093 } | |
3094 | |
2256 | 3095 sx= motion_x & s_mask; |
3096 sy= motion_y & s_mask; | |
3097 src_x = s->mb_x*2*block_s + (motion_x >> (lowres+1)); | |
2260 | 3098 src_y =(s->mb_y*2*block_s>>field_based) + (motion_y >> (lowres+1)); |
2967 | 3099 |
2256 | 3100 if (s->out_format == FMT_H263) { |
2265 | 3101 uvsx = ((motion_x>>1) & s_mask) | (sx&1); |
3102 uvsy = ((motion_y>>1) & s_mask) | (sy&1); | |
2256 | 3103 uvsrc_x = src_x>>1; |
3104 uvsrc_y = src_y>>1; | |
3105 }else if(s->out_format == FMT_H261){//even chroma mv's are full pel in H261 | |
3106 mx = motion_x / 4; | |
3107 my = motion_y / 4; | |
3108 uvsx = (2*mx) & s_mask; | |
3109 uvsy = (2*my) & s_mask; | |
3110 uvsrc_x = s->mb_x*block_s + (mx >> lowres); | |
3111 uvsrc_y = s->mb_y*block_s + (my >> lowres); | |
3112 } else { | |
3113 mx = motion_x / 2; | |
3114 my = motion_y / 2; | |
3115 uvsx = mx & s_mask; | |
3116 uvsy = my & s_mask; | |
3117 uvsrc_x = s->mb_x*block_s + (mx >> (lowres+1)); | |
2260 | 3118 uvsrc_y =(s->mb_y*block_s>>field_based) + (my >> (lowres+1)); |
2256 | 3119 } |
3120 | |
3121 ptr_y = ref_picture[0] + src_y * linesize + src_x; | |
3122 ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x; | |
3123 ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x; | |
3124 | |
3125 if( (unsigned)src_x > h_edge_pos - (!!sx) - 2*block_s | |
3126 || (unsigned)src_y >(v_edge_pos >> field_based) - (!!sy) - h){ | |
3127 ff_emulated_edge_mc(s->edge_emu_buffer, ptr_y, s->linesize, 17, 17+field_based, | |
3128 src_x, src_y<<field_based, h_edge_pos, v_edge_pos); | |
3129 ptr_y = s->edge_emu_buffer; | |
3130 if(!(s->flags&CODEC_FLAG_GRAY)){ | |
3131 uint8_t *uvbuf= s->edge_emu_buffer+18*s->linesize; | |
2967 | 3132 ff_emulated_edge_mc(uvbuf , ptr_cb, s->uvlinesize, 9, 9+field_based, |
2256 | 3133 uvsrc_x, uvsrc_y<<field_based, h_edge_pos>>1, v_edge_pos>>1); |
2967 | 3134 ff_emulated_edge_mc(uvbuf+16, ptr_cr, s->uvlinesize, 9, 9+field_based, |
2256 | 3135 uvsrc_x, uvsrc_y<<field_based, h_edge_pos>>1, v_edge_pos>>1); |
3136 ptr_cb= uvbuf; | |
3137 ptr_cr= uvbuf+16; | |
3138 } | |
3139 } | |
3140 | |
2260 | 3141 if(bottom_field){ //FIXME use this for field pix too instead of the obnoxious hack which changes picture.data |
3142 dest_y += s->linesize; | |
3143 dest_cb+= s->uvlinesize; | |
3144 dest_cr+= s->uvlinesize; | |
3145 } | |
3146 | |
3147 if(field_select){ | |
3148 ptr_y += s->linesize; | |
3149 ptr_cb+= s->uvlinesize; | |
3150 ptr_cr+= s->uvlinesize; | |
3151 } | |
3152 | |
2256 | 3153 sx <<= 2 - lowres; |
3154 sy <<= 2 - lowres; | |
3155 pix_op[lowres-1](dest_y, ptr_y, linesize, h, sx, sy); | |
2967 | 3156 |
2256 | 3157 if(!(s->flags&CODEC_FLAG_GRAY)){ |
3158 uvsx <<= 2 - lowres; | |
3159 uvsy <<= 2 - lowres; | |
3160 pix_op[lowres](dest_cb, ptr_cb, uvlinesize, h >> s->chroma_y_shift, uvsx, uvsy); | |
3161 pix_op[lowres](dest_cr, ptr_cr, uvlinesize, h >> s->chroma_y_shift, uvsx, uvsy); | |
3162 } | |
2291 | 3163 //FIXME h261 lowres loop filter |
2256 | 3164 } |
3165 | |
1633 | 3166 //FIXME move to dsputil, avg variant, 16x16 version |
3167 static inline void put_obmc(uint8_t *dst, uint8_t *src[5], int stride){ | |
3168 int x; | |
3169 uint8_t * const top = src[1]; | |
3170 uint8_t * const left = src[2]; | |
3171 uint8_t * const mid = src[0]; | |
3172 uint8_t * const right = src[3]; | |
3173 uint8_t * const bottom= src[4]; | |
3174 #define OBMC_FILTER(x, t, l, m, r, b)\ | |
3175 dst[x]= (t*top[x] + l*left[x] + m*mid[x] + r*right[x] + b*bottom[x] + 4)>>3 | |
3176 #define OBMC_FILTER4(x, t, l, m, r, b)\ | |
3177 OBMC_FILTER(x , t, l, m, r, b);\ | |
3178 OBMC_FILTER(x+1 , t, l, m, r, b);\ | |
3179 OBMC_FILTER(x +stride, t, l, m, r, b);\ | |
3180 OBMC_FILTER(x+1+stride, t, l, m, r, b); | |
2967 | 3181 |
1633 | 3182 x=0; |
3183 OBMC_FILTER (x , 2, 2, 4, 0, 0); | |
3184 OBMC_FILTER (x+1, 2, 1, 5, 0, 0); | |
3185 OBMC_FILTER4(x+2, 2, 1, 5, 0, 0); | |
3186 OBMC_FILTER4(x+4, 2, 0, 5, 1, 0); | |
3187 OBMC_FILTER (x+6, 2, 0, 5, 1, 0); | |
3188 OBMC_FILTER (x+7, 2, 0, 4, 2, 0); | |
3189 x+= stride; | |
3190 OBMC_FILTER (x , 1, 2, 5, 0, 0); | |
3191 OBMC_FILTER (x+1, 1, 2, 5, 0, 0); | |
3192 OBMC_FILTER (x+6, 1, 0, 5, 2, 0); | |
3193 OBMC_FILTER (x+7, 1, 0, 5, 2, 0); | |
3194 x+= stride; | |
3195 OBMC_FILTER4(x , 1, 2, 5, 0, 0); | |
3196 OBMC_FILTER4(x+2, 1, 1, 6, 0, 0); | |
3197 OBMC_FILTER4(x+4, 1, 0, 6, 1, 0); | |
3198 OBMC_FILTER4(x+6, 1, 0, 5, 2, 0); | |
3199 x+= 2*stride; | |
3200 OBMC_FILTER4(x , 0, 2, 5, 0, 1); | |
3201 OBMC_FILTER4(x+2, 0, 1, 6, 0, 1); | |
3202 OBMC_FILTER4(x+4, 0, 0, 6, 1, 1); | |
3203 OBMC_FILTER4(x+6, 0, 0, 5, 2, 1); | |
3204 x+= 2*stride; | |
3205 OBMC_FILTER (x , 0, 2, 5, 0, 1); | |
3206 OBMC_FILTER (x+1, 0, 2, 5, 0, 1); | |
3207 OBMC_FILTER4(x+2, 0, 1, 5, 0, 2); | |
3208 OBMC_FILTER4(x+4, 0, 0, 5, 1, 2); | |
3209 OBMC_FILTER (x+6, 0, 0, 5, 2, 1); | |
3210 OBMC_FILTER (x+7, 0, 0, 5, 2, 1); | |
3211 x+= stride; | |
3212 OBMC_FILTER (x , 0, 2, 4, 0, 2); | |
3213 OBMC_FILTER (x+1, 0, 1, 5, 0, 2); | |
3214 OBMC_FILTER (x+6, 0, 0, 5, 1, 2); | |
3215 OBMC_FILTER (x+7, 0, 0, 4, 2, 2); | |
3216 } | |
3217 | |
3218 /* obmc for 1 8x8 luma block */ | |
3219 static inline void obmc_motion(MpegEncContext *s, | |
3220 uint8_t *dest, uint8_t *src, | |
3221 int src_x, int src_y, | |
3222 op_pixels_func *pix_op, | |
3223 int16_t mv[5][2]/* mid top left right bottom*/) | |
3224 #define MID 0 | |
3225 { | |
3226 int i; | |
3227 uint8_t *ptr[5]; | |
2967 | 3228 |
1633 | 3229 assert(s->quarter_sample==0); |
2967 | 3230 |
1633 | 3231 for(i=0; i<5; i++){ |
3232 if(i && mv[i][0]==mv[MID][0] && mv[i][1]==mv[MID][1]){ | |
3233 ptr[i]= ptr[MID]; | |
3234 }else{ | |
1799 | 3235 ptr[i]= s->obmc_scratchpad + 8*(i&1) + s->linesize*8*(i>>1); |
1842
0d82db458a3c
interlaced mpeg4 + edge emu fix (fixes decoding of mermaid.avi)
michael
parents:
1838
diff
changeset
|
3236 hpel_motion(s, ptr[i], src, 0, 0, |
1633 | 3237 src_x, src_y, |
3238 s->width, s->height, s->linesize, | |
3239 s->h_edge_pos, s->v_edge_pos, | |
3240 8, 8, pix_op, | |
3241 mv[i][0], mv[i][1]); | |
3242 } | |
3243 } | |
3244 | |
2967 | 3245 put_obmc(dest, ptr, s->linesize); |
1633 | 3246 } |
0 | 3247 |
255 | 3248 static inline void qpel_motion(MpegEncContext *s, |
1064 | 3249 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr, |
1842
0d82db458a3c
interlaced mpeg4 + edge emu fix (fixes decoding of mermaid.avi)
michael
parents:
1838
diff
changeset
|
3250 int field_based, int bottom_field, int field_select, |
0d82db458a3c
interlaced mpeg4 + edge emu fix (fixes decoding of mermaid.avi)
michael
parents:
1838
diff
changeset
|
3251 uint8_t **ref_picture, op_pixels_func (*pix_op)[4], |
651 | 3252 qpel_mc_func (*qpix_op)[16], |
255 | 3253 int motion_x, int motion_y, int h) |
3254 { | |
1846 | 3255 uint8_t *ptr_y, *ptr_cb, *ptr_cr; |
3256 int dxy, uvdxy, mx, my, src_x, src_y, uvsrc_x, uvsrc_y, v_edge_pos, linesize, uvlinesize; | |
1842
0d82db458a3c
interlaced mpeg4 + edge emu fix (fixes decoding of mermaid.avi)
michael
parents:
1838
diff
changeset
|
3257 |
255 | 3258 dxy = ((motion_y & 3) << 2) | (motion_x & 3); |
1846 | 3259 src_x = s->mb_x * 16 + (motion_x >> 2); |
255 | 3260 src_y = s->mb_y * (16 >> field_based) + (motion_y >> 2); |
3261 | |
582
5132a4ee50cd
different edge positions fixed with edge emu / dr1
michaelni
parents:
575
diff
changeset
|
3262 v_edge_pos = s->v_edge_pos >> field_based; |
255 | 3263 linesize = s->linesize << field_based; |
671 | 3264 uvlinesize = s->uvlinesize << field_based; |
2967 | 3265 |
671 | 3266 if(field_based){ |
3267 mx= motion_x/2; | |
3268 my= motion_y>>1; | |
1048 | 3269 }else if(s->workaround_bugs&FF_BUG_QPEL_CHROMA2){ |
3270 static const int rtab[8]= {0,0,1,1,0,0,0,1}; | |
3271 mx= (motion_x>>1) + rtab[motion_x&7]; | |
3272 my= (motion_y>>1) + rtab[motion_y&7]; | |
760 | 3273 }else if(s->workaround_bugs&FF_BUG_QPEL_CHROMA){ |
671 | 3274 mx= (motion_x>>1)|(motion_x&1); |
3275 my= (motion_y>>1)|(motion_y&1); | |
3276 }else{ | |
3277 mx= motion_x/2; | |
3278 my= motion_y/2; | |
3279 } | |
3280 mx= (mx>>1)|(mx&1); | |
3281 my= (my>>1)|(my&1); | |
1048 | 3282 |
1846 | 3283 uvdxy= (mx&1) | ((my&1)<<1); |
671 | 3284 mx>>=1; |
3285 my>>=1; | |
255 | 3286 |
1846 | 3287 uvsrc_x = s->mb_x * 8 + mx; |
3288 uvsrc_y = s->mb_y * (8 >> field_based) + my; | |
3289 | |
3290 ptr_y = ref_picture[0] + src_y * linesize + src_x; | |
3291 ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x; | |
3292 ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x; | |
3293 | |
2967 | 3294 if( (unsigned)src_x > s->h_edge_pos - (motion_x&3) - 16 |
1846 | 3295 || (unsigned)src_y > v_edge_pos - (motion_y&3) - h ){ |
2967 | 3296 ff_emulated_edge_mc(s->edge_emu_buffer, ptr_y, s->linesize, 17, 17+field_based, |
1846 | 3297 src_x, src_y<<field_based, s->h_edge_pos, s->v_edge_pos); |
3298 ptr_y= s->edge_emu_buffer; | |
3299 if(!(s->flags&CODEC_FLAG_GRAY)){ | |
1874 | 3300 uint8_t *uvbuf= s->edge_emu_buffer + 18*s->linesize; |
2967 | 3301 ff_emulated_edge_mc(uvbuf, ptr_cb, s->uvlinesize, 9, 9 + field_based, |
1846 | 3302 uvsrc_x, uvsrc_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1); |
2967 | 3303 ff_emulated_edge_mc(uvbuf + 16, ptr_cr, s->uvlinesize, 9, 9 + field_based, |
1846 | 3304 uvsrc_x, uvsrc_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1); |
3305 ptr_cb= uvbuf; | |
3306 ptr_cr= uvbuf + 16; | |
3307 } | |
3308 } | |
3309 | |
3310 if(!field_based) | |
3311 qpix_op[0][dxy](dest_y, ptr_y, linesize); | |
3312 else{ | |
3313 if(bottom_field){ | |
3314 dest_y += s->linesize; | |
3315 dest_cb+= s->uvlinesize; | |
3316 dest_cr+= s->uvlinesize; | |
3317 } | |
3318 | |
3319 if(field_select){ | |
3320 ptr_y += s->linesize; | |
3321 ptr_cb += s->uvlinesize; | |
3322 ptr_cr += s->uvlinesize; | |
3323 } | |
3324 //damn interlaced mode | |
3325 //FIXME boundary mirroring is not exactly correct here | |
3326 qpix_op[1][dxy](dest_y , ptr_y , linesize); | |
3327 qpix_op[1][dxy](dest_y+8, ptr_y+8, linesize); | |
3328 } | |
3329 if(!(s->flags&CODEC_FLAG_GRAY)){ | |
3330 pix_op[1][uvdxy](dest_cr, ptr_cr, uvlinesize, h >> 1); | |
3331 pix_op[1][uvdxy](dest_cb, ptr_cb, uvlinesize, h >> 1); | |
3332 } | |
255 | 3333 } |
3334 | |
1013 | 3335 inline int ff_h263_round_chroma(int x){ |
3336 if (x >= 0) | |
3337 return (h263_chroma_roundtab[x & 0xf] + ((x >> 3) & ~1)); | |
3338 else { | |
3339 x = -x; | |
3340 return -(h263_chroma_roundtab[x & 0xf] + ((x >> 3) & ~1)); | |
3341 } | |
3342 } | |
255 | 3343 |
1225 | 3344 /** |
1633 | 3345 * h263 chorma 4mv motion compensation. |
3346 */ | |
3347 static inline void chroma_4mv_motion(MpegEncContext *s, | |
3348 uint8_t *dest_cb, uint8_t *dest_cr, | |
3349 uint8_t **ref_picture, | |
3350 op_pixels_func *pix_op, | |
3351 int mx, int my){ | |
3352 int dxy, emu=0, src_x, src_y, offset; | |
3353 uint8_t *ptr; | |
2967 | 3354 |
1633 | 3355 /* In case of 8X8, we construct a single chroma motion vector |
3356 with a special rounding */ | |
3357 mx= ff_h263_round_chroma(mx); | |
3358 my= ff_h263_round_chroma(my); | |
2967 | 3359 |
1633 | 3360 dxy = ((my & 1) << 1) | (mx & 1); |
3361 mx >>= 1; | |
3362 my >>= 1; | |
3363 | |
3364 src_x = s->mb_x * 8 + mx; | |
3365 src_y = s->mb_y * 8 + my; | |
4594 | 3366 src_x = av_clip(src_x, -8, s->width/2); |
1633 | 3367 if (src_x == s->width/2) |
3368 dxy &= ~1; | |
4594 | 3369 src_y = av_clip(src_y, -8, s->height/2); |
1633 | 3370 if (src_y == s->height/2) |
3371 dxy &= ~2; | |
2967 | 3372 |
1633 | 3373 offset = (src_y * (s->uvlinesize)) + src_x; |
3374 ptr = ref_picture[1] + offset; | |
3375 if(s->flags&CODEC_FLAG_EMU_EDGE){ | |
3376 if( (unsigned)src_x > (s->h_edge_pos>>1) - (dxy &1) - 8 | |
3377 || (unsigned)src_y > (s->v_edge_pos>>1) - (dxy>>1) - 8){ | |
3378 ff_emulated_edge_mc(s->edge_emu_buffer, ptr, s->uvlinesize, 9, 9, src_x, src_y, s->h_edge_pos>>1, s->v_edge_pos>>1); | |
3379 ptr= s->edge_emu_buffer; | |
3380 emu=1; | |
3381 } | |
3382 } | |
3383 pix_op[dxy](dest_cb, ptr, s->uvlinesize, 8); | |
3384 | |
3385 ptr = ref_picture[2] + offset; | |
3386 if(emu){ | |
3387 ff_emulated_edge_mc(s->edge_emu_buffer, ptr, s->uvlinesize, 9, 9, src_x, src_y, s->h_edge_pos>>1, s->v_edge_pos>>1); | |
3388 ptr= s->edge_emu_buffer; | |
3389 } | |
3390 pix_op[dxy](dest_cr, ptr, s->uvlinesize, 8); | |
3391 } | |
3392 | |
2292 | 3393 static inline void chroma_4mv_motion_lowres(MpegEncContext *s, |
3394 uint8_t *dest_cb, uint8_t *dest_cr, | |
3395 uint8_t **ref_picture, | |
3396 h264_chroma_mc_func *pix_op, | |
3397 int mx, int my){ | |
3398 const int lowres= s->avctx->lowres; | |
3399 const int block_s= 8>>lowres; | |
3400 const int s_mask= (2<<lowres)-1; | |
3401 const int h_edge_pos = s->h_edge_pos >> (lowres+1); | |
3402 const int v_edge_pos = s->v_edge_pos >> (lowres+1); | |
3403 int emu=0, src_x, src_y, offset, sx, sy; | |
3404 uint8_t *ptr; | |
2967 | 3405 |
2292 | 3406 if(s->quarter_sample){ |
3407 mx/=2; | |
3408 my/=2; | |
3409 } | |
3410 | |
3411 /* In case of 8X8, we construct a single chroma motion vector | |
3412 with a special rounding */ | |
3413 mx= ff_h263_round_chroma(mx); | |
3414 my= ff_h263_round_chroma(my); | |
2967 | 3415 |
2292 | 3416 sx= mx & s_mask; |
3417 sy= my & s_mask; | |
3418 src_x = s->mb_x*block_s + (mx >> (lowres+1)); | |
3419 src_y = s->mb_y*block_s + (my >> (lowres+1)); | |
2967 | 3420 |
2292 | 3421 offset = src_y * s->uvlinesize + src_x; |
3422 ptr = ref_picture[1] + offset; | |
3423 if(s->flags&CODEC_FLAG_EMU_EDGE){ | |
3424 if( (unsigned)src_x > h_edge_pos - (!!sx) - block_s | |
3425 || (unsigned)src_y > v_edge_pos - (!!sy) - block_s){ | |
3426 ff_emulated_edge_mc(s->edge_emu_buffer, ptr, s->uvlinesize, 9, 9, src_x, src_y, h_edge_pos, v_edge_pos); | |
3427 ptr= s->edge_emu_buffer; | |
3428 emu=1; | |
3429 } | |
2967 | 3430 } |
2292 | 3431 sx <<= 2 - lowres; |
3432 sy <<= 2 - lowres; | |
3433 pix_op[lowres](dest_cb, ptr, s->uvlinesize, block_s, sx, sy); | |
2967 | 3434 |
2292 | 3435 ptr = ref_picture[2] + offset; |
3436 if(emu){ | |
3437 ff_emulated_edge_mc(s->edge_emu_buffer, ptr, s->uvlinesize, 9, 9, src_x, src_y, h_edge_pos, v_edge_pos); | |
3438 ptr= s->edge_emu_buffer; | |
3439 } | |
3440 pix_op[lowres](dest_cr, ptr, s->uvlinesize, block_s, sx, sy); | |
3441 } | |
3442 | |
3216
4186eb8d29a1
prefetch pixels for future motion compensation. 4-10% faster mpeg1/2/4 decoding (on an athlon-xp).
lorenm
parents:
3145
diff
changeset
|
3443 static inline void prefetch_motion(MpegEncContext *s, uint8_t **pix, int dir){ |
4186eb8d29a1
prefetch pixels for future motion compensation. 4-10% faster mpeg1/2/4 decoding (on an athlon-xp).
lorenm
parents:
3145
diff
changeset
|
3444 /* fetch pixels for estimated mv 4 macroblocks ahead |
4186eb8d29a1
prefetch pixels for future motion compensation. 4-10% faster mpeg1/2/4 decoding (on an athlon-xp).
lorenm
parents:
3145
diff
changeset
|
3445 * optimized for 64byte cache lines */ |
4186eb8d29a1
prefetch pixels for future motion compensation. 4-10% faster mpeg1/2/4 decoding (on an athlon-xp).
lorenm
parents:
3145
diff
changeset
|
3446 const int shift = s->quarter_sample ? 2 : 1; |
4186eb8d29a1
prefetch pixels for future motion compensation. 4-10% faster mpeg1/2/4 decoding (on an athlon-xp).
lorenm
parents:
3145
diff
changeset
|
3447 const int mx= (s->mv[dir][0][0]>>shift) + 16*s->mb_x + 8; |
4186eb8d29a1
prefetch pixels for future motion compensation. 4-10% faster mpeg1/2/4 decoding (on an athlon-xp).
lorenm
parents:
3145
diff
changeset
|
3448 const int my= (s->mv[dir][0][1]>>shift) + 16*s->mb_y; |
4186eb8d29a1
prefetch pixels for future motion compensation. 4-10% faster mpeg1/2/4 decoding (on an athlon-xp).
lorenm
parents:
3145
diff
changeset
|
3449 int off= mx + (my + (s->mb_x&3)*4)*s->linesize + 64; |
4186eb8d29a1
prefetch pixels for future motion compensation. 4-10% faster mpeg1/2/4 decoding (on an athlon-xp).
lorenm
parents:
3145
diff
changeset
|
3450 s->dsp.prefetch(pix[0]+off, s->linesize, 4); |
4186eb8d29a1
prefetch pixels for future motion compensation. 4-10% faster mpeg1/2/4 decoding (on an athlon-xp).
lorenm
parents:
3145
diff
changeset
|
3451 off= (mx>>1) + ((my>>1) + (s->mb_x&7))*s->uvlinesize + 64; |
4186eb8d29a1
prefetch pixels for future motion compensation. 4-10% faster mpeg1/2/4 decoding (on an athlon-xp).
lorenm
parents:
3145
diff
changeset
|
3452 s->dsp.prefetch(pix[1]+off, pix[2]-pix[1], 2); |
4186eb8d29a1
prefetch pixels for future motion compensation. 4-10% faster mpeg1/2/4 decoding (on an athlon-xp).
lorenm
parents:
3145
diff
changeset
|
3453 } |
4186eb8d29a1
prefetch pixels for future motion compensation. 4-10% faster mpeg1/2/4 decoding (on an athlon-xp).
lorenm
parents:
3145
diff
changeset
|
3454 |
1633 | 3455 /** |
2764 | 3456 * motion compensation of a single macroblock |
1225 | 3457 * @param s context |
3458 * @param dest_y luma destination pointer | |
3459 * @param dest_cb chroma cb/u destination pointer | |
3460 * @param dest_cr chroma cr/v destination pointer | |
3461 * @param dir direction (0->forward, 1->backward) | |
3462 * @param ref_picture array[3] of pointers to the 3 planes of the reference picture | |
3463 * @param pic_op halfpel motion compensation function (average or put normally) | |
3464 * @param pic_op qpel motion compensation function (average or put normally) | |
3465 * the motion vectors are taken from s->mv and the MV type from s->mv_type | |
3466 */ | |
2967 | 3467 static inline void MPV_motion(MpegEncContext *s, |
1064 | 3468 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr, |
2967 | 3469 int dir, uint8_t **ref_picture, |
651 | 3470 op_pixels_func (*pix_op)[4], qpel_mc_func (*qpix_op)[16]) |
0 | 3471 { |
1633 | 3472 int dxy, mx, my, src_x, src_y, motion_x, motion_y; |
0 | 3473 int mb_x, mb_y, i; |
1064 | 3474 uint8_t *ptr, *dest; |
0 | 3475 |
3476 mb_x = s->mb_x; | |
3477 mb_y = s->mb_y; | |
3478 | |
3216
4186eb8d29a1
prefetch pixels for future motion compensation. 4-10% faster mpeg1/2/4 decoding (on an athlon-xp).
lorenm
parents:
3145
diff
changeset
|
3479 prefetch_motion(s, ref_picture, dir); |
4186eb8d29a1
prefetch pixels for future motion compensation. 4-10% faster mpeg1/2/4 decoding (on an athlon-xp).
lorenm
parents:
3145
diff
changeset
|
3480 |
1655 | 3481 if(s->obmc && s->pict_type != B_TYPE){ |
1633 | 3482 int16_t mv_cache[4][4][2]; |
3483 const int xy= s->mb_x + s->mb_y*s->mb_stride; | |
1938
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1918
diff
changeset
|
3484 const int mot_stride= s->b8_stride; |
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1918
diff
changeset
|
3485 const int mot_xy= mb_x*2 + mb_y*2*mot_stride; |
1633 | 3486 |
2628
511e3afc43e1
Ministry of English Composition, reporting for duty (and the word is "skipped", not "skiped"; "skiped" would rhyme with "hyped")
melanson
parents:
2627
diff
changeset
|
3487 assert(!s->mb_skipped); |
2967 | 3488 |
1668
30746f429df6
move motion_val & mb_type to AVFrame patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1662
diff
changeset
|
3489 memcpy(mv_cache[1][1], s->current_picture.motion_val[0][mot_xy ], sizeof(int16_t)*4); |
30746f429df6
move motion_val & mb_type to AVFrame patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1662
diff
changeset
|
3490 memcpy(mv_cache[2][1], s->current_picture.motion_val[0][mot_xy+mot_stride], sizeof(int16_t)*4); |
30746f429df6
move motion_val & mb_type to AVFrame patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1662
diff
changeset
|
3491 memcpy(mv_cache[3][1], s->current_picture.motion_val[0][mot_xy+mot_stride], sizeof(int16_t)*4); |
1633 | 3492 |
3493 if(mb_y==0 || IS_INTRA(s->current_picture.mb_type[xy-s->mb_stride])){ | |
3494 memcpy(mv_cache[0][1], mv_cache[1][1], sizeof(int16_t)*4); | |
3495 }else{ | |
1668
30746f429df6
move motion_val & mb_type to AVFrame patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1662
diff
changeset
|
3496 memcpy(mv_cache[0][1], s->current_picture.motion_val[0][mot_xy-mot_stride], sizeof(int16_t)*4); |
1633 | 3497 } |
3498 | |
3499 if(mb_x==0 || IS_INTRA(s->current_picture.mb_type[xy-1])){ | |
3500 *(int32_t*)mv_cache[1][0]= *(int32_t*)mv_cache[1][1]; | |
3501 *(int32_t*)mv_cache[2][0]= *(int32_t*)mv_cache[2][1]; | |
3502 }else{ | |
1668
30746f429df6
move motion_val & mb_type to AVFrame patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1662
diff
changeset
|
3503 *(int32_t*)mv_cache[1][0]= *(int32_t*)s->current_picture.motion_val[0][mot_xy-1]; |
30746f429df6
move motion_val & mb_type to AVFrame patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1662
diff
changeset
|
3504 *(int32_t*)mv_cache[2][0]= *(int32_t*)s->current_picture.motion_val[0][mot_xy-1+mot_stride]; |
1633 | 3505 } |
3506 | |
3507 if(mb_x+1>=s->mb_width || IS_INTRA(s->current_picture.mb_type[xy+1])){ | |
3508 *(int32_t*)mv_cache[1][3]= *(int32_t*)mv_cache[1][2]; | |
3509 *(int32_t*)mv_cache[2][3]= *(int32_t*)mv_cache[2][2]; | |
3510 }else{ | |
1668
30746f429df6
move motion_val & mb_type to AVFrame patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1662
diff
changeset
|
3511 *(int32_t*)mv_cache[1][3]= *(int32_t*)s->current_picture.motion_val[0][mot_xy+2]; |
30746f429df6
move motion_val & mb_type to AVFrame patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1662
diff
changeset
|
3512 *(int32_t*)mv_cache[2][3]= *(int32_t*)s->current_picture.motion_val[0][mot_xy+2+mot_stride]; |
1633 | 3513 } |
2967 | 3514 |
1633 | 3515 mx = 0; |
3516 my = 0; | |
3517 for(i=0;i<4;i++) { | |
3518 const int x= (i&1)+1; | |
3519 const int y= (i>>1)+1; | |
3520 int16_t mv[5][2]= { | |
3521 {mv_cache[y][x ][0], mv_cache[y][x ][1]}, | |
3522 {mv_cache[y-1][x][0], mv_cache[y-1][x][1]}, | |
3523 {mv_cache[y][x-1][0], mv_cache[y][x-1][1]}, | |
3524 {mv_cache[y][x+1][0], mv_cache[y][x+1][1]}, | |
3525 {mv_cache[y+1][x][0], mv_cache[y+1][x][1]}}; | |
3526 //FIXME cleanup | |
3527 obmc_motion(s, dest_y + ((i & 1) * 8) + (i >> 1) * 8 * s->linesize, | |
3528 ref_picture[0], | |
3529 mb_x * 16 + (i & 1) * 8, mb_y * 16 + (i >>1) * 8, | |
3530 pix_op[1], | |
3531 mv); | |
3532 | |
3533 mx += mv[0][0]; | |
3534 my += mv[0][1]; | |
3535 } | |
3536 if(!(s->flags&CODEC_FLAG_GRAY)) | |
3537 chroma_4mv_motion(s, dest_cb, dest_cr, ref_picture, pix_op[1], mx, my); | |
3538 | |
3539 return; | |
3540 } | |
2967 | 3541 |
0 | 3542 switch(s->mv_type) { |
3543 case MV_TYPE_16X16: | |
255 | 3544 if(s->mcsel){ |
753 | 3545 if(s->real_sprite_warping_points==1){ |
1842
0d82db458a3c
interlaced mpeg4 + edge emu fix (fixes decoding of mermaid.avi)
michael
parents:
1838
diff
changeset
|
3546 gmc1_motion(s, dest_y, dest_cb, dest_cr, |
0d82db458a3c
interlaced mpeg4 + edge emu fix (fixes decoding of mermaid.avi)
michael
parents:
1838
diff
changeset
|
3547 ref_picture); |
753 | 3548 }else{ |
1842
0d82db458a3c
interlaced mpeg4 + edge emu fix (fixes decoding of mermaid.avi)
michael
parents:
1838
diff
changeset
|
3549 gmc_motion(s, dest_y, dest_cb, dest_cr, |
0d82db458a3c
interlaced mpeg4 + edge emu fix (fixes decoding of mermaid.avi)
michael
parents:
1838
diff
changeset
|
3550 ref_picture); |
753 | 3551 } |
651 | 3552 }else if(s->quarter_sample){ |
2967 | 3553 qpel_motion(s, dest_y, dest_cb, dest_cr, |
1842
0d82db458a3c
interlaced mpeg4 + edge emu fix (fixes decoding of mermaid.avi)
michael
parents:
1838
diff
changeset
|
3554 0, 0, 0, |
0d82db458a3c
interlaced mpeg4 + edge emu fix (fixes decoding of mermaid.avi)
michael
parents:
1838
diff
changeset
|
3555 ref_picture, pix_op, qpix_op, |
255 | 3556 s->mv[dir][0][0], s->mv[dir][0][1], 16); |
4967
6d45158e0249
disable reference to msmpeg4 and wmv2 code when those codecs are not compiled in
aurel
parents:
4668
diff
changeset
|
3557 }else if(ENABLE_WMV2 && s->mspel){ |
936 | 3558 ff_mspel_motion(s, dest_y, dest_cb, dest_cr, |
3559 ref_picture, pix_op, | |
3560 s->mv[dir][0][0], s->mv[dir][0][1], 16); | |
1042 | 3561 }else |
3562 { | |
2967 | 3563 mpeg_motion(s, dest_y, dest_cb, dest_cr, |
1842
0d82db458a3c
interlaced mpeg4 + edge emu fix (fixes decoding of mermaid.avi)
michael
parents:
1838
diff
changeset
|
3564 0, 0, 0, |
0d82db458a3c
interlaced mpeg4 + edge emu fix (fixes decoding of mermaid.avi)
michael
parents:
1838
diff
changeset
|
3565 ref_picture, pix_op, |
255 | 3566 s->mv[dir][0][0], s->mv[dir][0][1], 16); |
2967 | 3567 } |
0 | 3568 break; |
3569 case MV_TYPE_8X8: | |
673 | 3570 mx = 0; |
3571 my = 0; | |
3572 if(s->quarter_sample){ | |
3573 for(i=0;i<4;i++) { | |
3574 motion_x = s->mv[dir][i][0]; | |
3575 motion_y = s->mv[dir][i][1]; | |
0 | 3576 |
673 | 3577 dxy = ((motion_y & 3) << 2) | (motion_x & 3); |
3578 src_x = mb_x * 16 + (motion_x >> 2) + (i & 1) * 8; | |
3579 src_y = mb_y * 16 + (motion_y >> 2) + (i >>1) * 8; | |
2967 | 3580 |
673 | 3581 /* WARNING: do no forget half pels */ |
4594 | 3582 src_x = av_clip(src_x, -16, s->width); |
673 | 3583 if (src_x == s->width) |
3584 dxy &= ~3; | |
4594 | 3585 src_y = av_clip(src_y, -16, s->height); |
673 | 3586 if (src_y == s->height) |
3587 dxy &= ~12; | |
2967 | 3588 |
673 | 3589 ptr = ref_picture[0] + (src_y * s->linesize) + (src_x); |
3590 if(s->flags&CODEC_FLAG_EMU_EDGE){ | |
2967 | 3591 if( (unsigned)src_x > s->h_edge_pos - (motion_x&3) - 8 |
1542
576861d6343a
emu_edge checks simplification and avoid redundant checks for mpeg1/2 if emu_edge is set
michael
parents:
1539
diff
changeset
|
3592 || (unsigned)src_y > s->v_edge_pos - (motion_y&3) - 8 ){ |
1317
26c44d2433c1
make ff_emulated_edge_mc() independant of MpegEncContext
michaelni
parents:
1315
diff
changeset
|
3593 ff_emulated_edge_mc(s->edge_emu_buffer, ptr, s->linesize, 9, 9, src_x, src_y, s->h_edge_pos, s->v_edge_pos); |
673 | 3594 ptr= s->edge_emu_buffer; |
3595 } | |
3596 } | |
3597 dest = dest_y + ((i & 1) * 8) + (i >> 1) * 8 * s->linesize; | |
3598 qpix_op[1][dxy](dest, ptr, s->linesize); | |
3599 | |
3600 mx += s->mv[dir][i][0]/2; | |
3601 my += s->mv[dir][i][1]/2; | |
3602 } | |
3603 }else{ | |
3604 for(i=0;i<4;i++) { | |
1633 | 3605 hpel_motion(s, dest_y + ((i & 1) * 8) + (i >> 1) * 8 * s->linesize, |
1842
0d82db458a3c
interlaced mpeg4 + edge emu fix (fixes decoding of mermaid.avi)
michael
parents:
1838
diff
changeset
|
3606 ref_picture[0], 0, 0, |
1633 | 3607 mb_x * 16 + (i & 1) * 8, mb_y * 16 + (i >>1) * 8, |
3608 s->width, s->height, s->linesize, | |
3609 s->h_edge_pos, s->v_edge_pos, | |
3610 8, 8, pix_op[1], | |
3611 s->mv[dir][i][0], s->mv[dir][i][1]); | |
673 | 3612 |
3613 mx += s->mv[dir][i][0]; | |
3614 my += s->mv[dir][i][1]; | |
554 | 3615 } |
0 | 3616 } |
673 | 3617 |
1633 | 3618 if(!(s->flags&CODEC_FLAG_GRAY)) |
3619 chroma_4mv_motion(s, dest_cb, dest_cr, ref_picture, pix_op[1], mx, my); | |
0 | 3620 break; |
3621 case MV_TYPE_FIELD: | |
3622 if (s->picture_structure == PICT_FRAME) { | |
671 | 3623 if(s->quarter_sample){ |
1843 | 3624 for(i=0; i<2; i++){ |
3625 qpel_motion(s, dest_y, dest_cb, dest_cr, | |
3626 1, i, s->field_select[dir][i], | |
3627 ref_picture, pix_op, qpix_op, | |
3628 s->mv[dir][i][0], s->mv[dir][i][1], 8); | |
3629 } | |
671 | 3630 }else{ |
2967 | 3631 /* top field */ |
1842
0d82db458a3c
interlaced mpeg4 + edge emu fix (fixes decoding of mermaid.avi)
michael
parents:
1838
diff
changeset
|
3632 mpeg_motion(s, dest_y, dest_cb, dest_cr, |
0d82db458a3c
interlaced mpeg4 + edge emu fix (fixes decoding of mermaid.avi)
michael
parents:
1838
diff
changeset
|
3633 1, 0, s->field_select[dir][0], |
0d82db458a3c
interlaced mpeg4 + edge emu fix (fixes decoding of mermaid.avi)
michael
parents:
1838
diff
changeset
|
3634 ref_picture, pix_op, |
671 | 3635 s->mv[dir][0][0], s->mv[dir][0][1], 8); |
3636 /* bottom field */ | |
1842
0d82db458a3c
interlaced mpeg4 + edge emu fix (fixes decoding of mermaid.avi)
michael
parents:
1838
diff
changeset
|
3637 mpeg_motion(s, dest_y, dest_cb, dest_cr, |
0d82db458a3c
interlaced mpeg4 + edge emu fix (fixes decoding of mermaid.avi)
michael
parents:
1838
diff
changeset
|
3638 1, 1, s->field_select[dir][1], |
0d82db458a3c
interlaced mpeg4 + edge emu fix (fixes decoding of mermaid.avi)
michael
parents:
1838
diff
changeset
|
3639 ref_picture, pix_op, |
671 | 3640 s->mv[dir][1][0], s->mv[dir][1][1], 8); |
3641 } | |
0 | 3642 } else { |
1842
0d82db458a3c
interlaced mpeg4 + edge emu fix (fixes decoding of mermaid.avi)
michael
parents:
1838
diff
changeset
|
3643 if(s->picture_structure != s->field_select[dir][0] + 1 && s->pict_type != B_TYPE && !s->first_field){ |
0d82db458a3c
interlaced mpeg4 + edge emu fix (fixes decoding of mermaid.avi)
michael
parents:
1838
diff
changeset
|
3644 ref_picture= s->current_picture_ptr->data; |
2967 | 3645 } |
1096
5e6e505d8997
field picture decoding support (16x16 MC blocks only as i dont have any samples which use other modes ...)
michaelni
parents:
1095
diff
changeset
|
3646 |
1842
0d82db458a3c
interlaced mpeg4 + edge emu fix (fixes decoding of mermaid.avi)
michael
parents:
1838
diff
changeset
|
3647 mpeg_motion(s, dest_y, dest_cb, dest_cr, |
0d82db458a3c
interlaced mpeg4 + edge emu fix (fixes decoding of mermaid.avi)
michael
parents:
1838
diff
changeset
|
3648 0, 0, s->field_select[dir][0], |
0d82db458a3c
interlaced mpeg4 + edge emu fix (fixes decoding of mermaid.avi)
michael
parents:
1838
diff
changeset
|
3649 ref_picture, pix_op, |
1096
5e6e505d8997
field picture decoding support (16x16 MC blocks only as i dont have any samples which use other modes ...)
michaelni
parents:
1095
diff
changeset
|
3650 s->mv[dir][0][0], s->mv[dir][0][1], 16); |
0 | 3651 } |
3652 break; | |
1843 | 3653 case MV_TYPE_16X8: |
3654 for(i=0; i<2; i++){ | |
3655 uint8_t ** ref2picture; | |
3656 | |
3657 if(s->picture_structure == s->field_select[dir][i] + 1 || s->pict_type == B_TYPE || s->first_field){ | |
1339
338a2f6e6402
Mpeg2 16x8 Patch by ("Ivan Kalvachev" <ivan at cacad dot com>)
michaelni
parents:
1328
diff
changeset
|
3658 ref2picture= ref_picture; |
338a2f6e6402
Mpeg2 16x8 Patch by ("Ivan Kalvachev" <ivan at cacad dot com>)
michaelni
parents:
1328
diff
changeset
|
3659 }else{ |
1842
0d82db458a3c
interlaced mpeg4 + edge emu fix (fixes decoding of mermaid.avi)
michael
parents:
1838
diff
changeset
|
3660 ref2picture= s->current_picture_ptr->data; |
2967 | 3661 } |
3662 | |
3663 mpeg_motion(s, dest_y, dest_cb, dest_cr, | |
1843 | 3664 0, 0, s->field_select[dir][i], |
1842
0d82db458a3c
interlaced mpeg4 + edge emu fix (fixes decoding of mermaid.avi)
michael
parents:
1838
diff
changeset
|
3665 ref2picture, pix_op, |
1843 | 3666 s->mv[dir][i][0], s->mv[dir][i][1] + 16*i, 8); |
2967 | 3667 |
1843 | 3668 dest_y += 16*s->linesize; |
2074
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
3669 dest_cb+= (16>>s->chroma_y_shift)*s->uvlinesize; |
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
3670 dest_cr+= (16>>s->chroma_y_shift)*s->uvlinesize; |
2967 | 3671 } |
1339
338a2f6e6402
Mpeg2 16x8 Patch by ("Ivan Kalvachev" <ivan at cacad dot com>)
michaelni
parents:
1328
diff
changeset
|
3672 break; |
1326
6cdd3b8f4fd3
DMV support patch by ("Ivan Kalvachev" <ivan at cacad dot com>)
michaelni
parents:
1317
diff
changeset
|
3673 case MV_TYPE_DMV: |
6cdd3b8f4fd3
DMV support patch by ("Ivan Kalvachev" <ivan at cacad dot com>)
michaelni
parents:
1317
diff
changeset
|
3674 if(s->picture_structure == PICT_FRAME){ |
1843 | 3675 for(i=0; i<2; i++){ |
3676 int j; | |
3677 for(j=0; j<2; j++){ | |
3678 mpeg_motion(s, dest_y, dest_cb, dest_cr, | |
3679 1, j, j^i, | |
3680 ref_picture, pix_op, | |
3681 s->mv[dir][2*i + j][0], s->mv[dir][2*i + j][1], 8); | |
3682 } | |
2967 | 3683 pix_op = s->dsp.avg_pixels_tab; |
1843 | 3684 } |
1326
6cdd3b8f4fd3
DMV support patch by ("Ivan Kalvachev" <ivan at cacad dot com>)
michaelni
parents:
1317
diff
changeset
|
3685 }else{ |
1843 | 3686 for(i=0; i<2; i++){ |
2967 | 3687 mpeg_motion(s, dest_y, dest_cb, dest_cr, |
1843 | 3688 0, 0, s->picture_structure != i+1, |
3689 ref_picture, pix_op, | |
3690 s->mv[dir][2*i][0],s->mv[dir][2*i][1],16); | |
3691 | |
3692 // after put we make avg of the same block | |
2967 | 3693 pix_op=s->dsp.avg_pixels_tab; |
1843 | 3694 |
3695 //opposite parity is always in the same frame if this is second field | |
3696 if(!s->first_field){ | |
2967 | 3697 ref_picture = s->current_picture_ptr->data; |
1843 | 3698 } |
1842
0d82db458a3c
interlaced mpeg4 + edge emu fix (fixes decoding of mermaid.avi)
michael
parents:
1838
diff
changeset
|
3699 } |
1326
6cdd3b8f4fd3
DMV support patch by ("Ivan Kalvachev" <ivan at cacad dot com>)
michaelni
parents:
1317
diff
changeset
|
3700 } |
6cdd3b8f4fd3
DMV support patch by ("Ivan Kalvachev" <ivan at cacad dot com>)
michaelni
parents:
1317
diff
changeset
|
3701 break; |
1633 | 3702 default: assert(0); |
0 | 3703 } |
3704 } | |
3705 | |
2256 | 3706 /** |
2764 | 3707 * motion compensation of a single macroblock |
2256 | 3708 * @param s context |
3709 * @param dest_y luma destination pointer | |
3710 * @param dest_cb chroma cb/u destination pointer | |
3711 * @param dest_cr chroma cr/v destination pointer | |
3712 * @param dir direction (0->forward, 1->backward) | |
3713 * @param ref_picture array[3] of pointers to the 3 planes of the reference picture | |
3714 * @param pic_op halfpel motion compensation function (average or put normally) | |
3715 * the motion vectors are taken from s->mv and the MV type from s->mv_type | |
3716 */ | |
2967 | 3717 static inline void MPV_motion_lowres(MpegEncContext *s, |
2256 | 3718 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr, |
2967 | 3719 int dir, uint8_t **ref_picture, |
2256 | 3720 h264_chroma_mc_func *pix_op) |
3721 { | |
2292 | 3722 int mx, my; |
2260 | 3723 int mb_x, mb_y, i; |
3724 const int lowres= s->avctx->lowres; | |
2967 | 3725 const int block_s= 8>>lowres; |
2260 | 3726 |
3727 mb_x = s->mb_x; | |
3728 mb_y = s->mb_y; | |
3729 | |
3730 switch(s->mv_type) { | |
3731 case MV_TYPE_16X16: | |
2967 | 3732 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr, |
2260 | 3733 0, 0, 0, |
3734 ref_picture, pix_op, | |
3735 s->mv[dir][0][0], s->mv[dir][0][1], 2*block_s); | |
3736 break; | |
2292 | 3737 case MV_TYPE_8X8: |
2260 | 3738 mx = 0; |
3739 my = 0; | |
3740 for(i=0;i<4;i++) { | |
2292 | 3741 hpel_motion_lowres(s, dest_y + ((i & 1) + (i >> 1) * s->linesize)*block_s, |
2260 | 3742 ref_picture[0], 0, 0, |
2292 | 3743 (2*mb_x + (i & 1))*block_s, (2*mb_y + (i >>1))*block_s, |
2260 | 3744 s->width, s->height, s->linesize, |
2292 | 3745 s->h_edge_pos >> lowres, s->v_edge_pos >> lowres, |
3746 block_s, block_s, pix_op, | |
2260 | 3747 s->mv[dir][i][0], s->mv[dir][i][1]); |
3748 | |
3749 mx += s->mv[dir][i][0]; | |
3750 my += s->mv[dir][i][1]; | |
3751 } | |
3752 | |
3753 if(!(s->flags&CODEC_FLAG_GRAY)) | |
2292 | 3754 chroma_4mv_motion_lowres(s, dest_cb, dest_cr, ref_picture, pix_op, mx, my); |
3755 break; | |
2260 | 3756 case MV_TYPE_FIELD: |
3757 if (s->picture_structure == PICT_FRAME) { | |
2967 | 3758 /* top field */ |
2260 | 3759 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr, |
3760 1, 0, s->field_select[dir][0], | |
3761 ref_picture, pix_op, | |
3762 s->mv[dir][0][0], s->mv[dir][0][1], block_s); | |
3763 /* bottom field */ | |
3764 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr, | |
3765 1, 1, s->field_select[dir][1], | |
3766 ref_picture, pix_op, | |
3767 s->mv[dir][1][0], s->mv[dir][1][1], block_s); | |
3768 } else { | |
3769 if(s->picture_structure != s->field_select[dir][0] + 1 && s->pict_type != B_TYPE && !s->first_field){ | |
3770 ref_picture= s->current_picture_ptr->data; | |
2967 | 3771 } |
2260 | 3772 |
3773 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr, | |
3774 0, 0, s->field_select[dir][0], | |
3775 ref_picture, pix_op, | |
3776 s->mv[dir][0][0], s->mv[dir][0][1], 2*block_s); | |
3777 } | |
3778 break; | |
3779 case MV_TYPE_16X8: | |
3780 for(i=0; i<2; i++){ | |
3781 uint8_t ** ref2picture; | |
3782 | |
3783 if(s->picture_structure == s->field_select[dir][i] + 1 || s->pict_type == B_TYPE || s->first_field){ | |
3784 ref2picture= ref_picture; | |
3785 }else{ | |
3786 ref2picture= s->current_picture_ptr->data; | |
2967 | 3787 } |
3788 | |
3789 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr, | |
2260 | 3790 0, 0, s->field_select[dir][i], |
3791 ref2picture, pix_op, | |
3792 s->mv[dir][i][0], s->mv[dir][i][1] + 2*block_s*i, block_s); | |
2967 | 3793 |
2260 | 3794 dest_y += 2*block_s*s->linesize; |
3795 dest_cb+= (2*block_s>>s->chroma_y_shift)*s->uvlinesize; | |
3796 dest_cr+= (2*block_s>>s->chroma_y_shift)*s->uvlinesize; | |
2967 | 3797 } |
2260 | 3798 break; |
3799 case MV_TYPE_DMV: | |
3800 if(s->picture_structure == PICT_FRAME){ | |
3801 for(i=0; i<2; i++){ | |
3802 int j; | |
3803 for(j=0; j<2; j++){ | |
3804 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr, | |
3805 1, j, j^i, | |
3806 ref_picture, pix_op, | |
3807 s->mv[dir][2*i + j][0], s->mv[dir][2*i + j][1], block_s); | |
3808 } | |
3809 pix_op = s->dsp.avg_h264_chroma_pixels_tab; | |
3810 } | |
3811 }else{ | |
3812 for(i=0; i<2; i++){ | |
2967 | 3813 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr, |
2260 | 3814 0, 0, s->picture_structure != i+1, |
3815 ref_picture, pix_op, | |
3816 s->mv[dir][2*i][0],s->mv[dir][2*i][1],2*block_s); | |
3817 | |
3818 // after put we make avg of the same block | |
3819 pix_op = s->dsp.avg_h264_chroma_pixels_tab; | |
3820 | |
3821 //opposite parity is always in the same frame if this is second field | |
3822 if(!s->first_field){ | |
2967 | 3823 ref_picture = s->current_picture_ptr->data; |
2260 | 3824 } |
3825 } | |
3826 } | |
3827 break; | |
3828 default: assert(0); | |
3829 } | |
2256 | 3830 } |
0 | 3831 |
3832 /* put block[] to dest[] */ | |
2967 | 3833 static inline void put_dct(MpegEncContext *s, |
1651 | 3834 DCTELEM *block, int i, uint8_t *dest, int line_size, int qscale) |
0 | 3835 { |
1689 | 3836 s->dct_unquantize_intra(s, block, i, qscale); |
1092 | 3837 s->dsp.idct_put (dest, line_size, block); |
0 | 3838 } |
3839 | |
3840 /* add block[] to dest[] */ | |
2967 | 3841 static inline void add_dct(MpegEncContext *s, |
1064 | 3842 DCTELEM *block, int i, uint8_t *dest, int line_size) |
0 | 3843 { |
3844 if (s->block_last_index[i] >= 0) { | |
1092 | 3845 s->dsp.idct_add (dest, line_size, block); |
481 | 3846 } |
3847 } | |
3848 | |
2967 | 3849 static inline void add_dequant_dct(MpegEncContext *s, |
1644 | 3850 DCTELEM *block, int i, uint8_t *dest, int line_size, int qscale) |
481 | 3851 { |
3852 if (s->block_last_index[i] >= 0) { | |
1689 | 3853 s->dct_unquantize_inter(s, block, i, qscale); |
324 | 3854 |
1092 | 3855 s->dsp.idct_add (dest, line_size, block); |
0 | 3856 } |
3857 } | |
3858 | |
456 | 3859 /** |
3860 * cleans dc, ac, coded_block for the current non intra MB | |
3861 */ | |
3862 void ff_clean_intra_table_entries(MpegEncContext *s) | |
3863 { | |
1938
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1918
diff
changeset
|
3864 int wrap = s->b8_stride; |
456 | 3865 int xy = s->block_index[0]; |
2967 | 3866 |
3867 s->dc_val[0][xy ] = | |
3868 s->dc_val[0][xy + 1 ] = | |
456 | 3869 s->dc_val[0][xy + wrap] = |
3870 s->dc_val[0][xy + 1 + wrap] = 1024; | |
3871 /* ac pred */ | |
1064 | 3872 memset(s->ac_val[0][xy ], 0, 32 * sizeof(int16_t)); |
3873 memset(s->ac_val[0][xy + wrap], 0, 32 * sizeof(int16_t)); | |
456 | 3874 if (s->msmpeg4_version>=3) { |
3875 s->coded_block[xy ] = | |
3876 s->coded_block[xy + 1 ] = | |
3877 s->coded_block[xy + wrap] = | |
3878 s->coded_block[xy + 1 + wrap] = 0; | |
3879 } | |
3880 /* chroma */ | |
1938
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1918
diff
changeset
|
3881 wrap = s->mb_stride; |
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1918
diff
changeset
|
3882 xy = s->mb_x + s->mb_y * wrap; |
456 | 3883 s->dc_val[1][xy] = |
3884 s->dc_val[2][xy] = 1024; | |
3885 /* ac pred */ | |
1064 | 3886 memset(s->ac_val[1][xy], 0, 16 * sizeof(int16_t)); |
3887 memset(s->ac_val[2][xy], 0, 16 * sizeof(int16_t)); | |
2967 | 3888 |
1938
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1918
diff
changeset
|
3889 s->mbintra_table[xy]= 0; |
456 | 3890 } |
3891 | |
0 | 3892 /* generic function called after a macroblock has been parsed by the |
3893 decoder or after it has been encoded by the encoder. | |
3894 | |
3895 Important variables used: | |
3896 s->mb_intra : true if intra macroblock | |
3897 s->mv_dir : motion vector direction | |
3898 s->mv_type : motion vector type | |
3899 s->mv : motion vector | |
3900 s->interlaced_dct : true if interlaced dct used (mpeg2) | |
3901 */ | |
4283
d6f83e2f8804
rename always_inline to av_always_inline and move to common.h
mru
parents:
4281
diff
changeset
|
3902 static av_always_inline void MPV_decode_mb_internal(MpegEncContext *s, DCTELEM block[12][64], int lowres_flag) |
0 | 3903 { |
244 | 3904 int mb_x, mb_y; |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1173
diff
changeset
|
3905 const int mb_xy = s->mb_y * s->mb_stride + s->mb_x; |
1381 | 3906 #ifdef HAVE_XVMC |
3907 if(s->avctx->xvmc_acceleration){ | |
1580
628bf341e099
XvMC speedup by removing one memcpy and doing MB packing
iive
parents:
1579
diff
changeset
|
3908 XVMC_decode_mb(s);//xvmc uses pblocks |
1381 | 3909 return; |
3910 } | |
3911 #endif | |
0 | 3912 |
3913 mb_x = s->mb_x; | |
3914 mb_y = s->mb_y; | |
3915 | |
1833
ba27ce284d07
export DCT coefficients patch by (Wolfgang Hesseler <wolfgang.hesseler at imk dot fraunhofer dot de>)
michael
parents:
1831
diff
changeset
|
3916 if(s->avctx->debug&FF_DEBUG_DCT_COEFF) { |
ba27ce284d07
export DCT coefficients patch by (Wolfgang Hesseler <wolfgang.hesseler at imk dot fraunhofer dot de>)
michael
parents:
1831
diff
changeset
|
3917 /* save DCT coefficients */ |
ba27ce284d07
export DCT coefficients patch by (Wolfgang Hesseler <wolfgang.hesseler at imk dot fraunhofer dot de>)
michael
parents:
1831
diff
changeset
|
3918 int i,j; |
ba27ce284d07
export DCT coefficients patch by (Wolfgang Hesseler <wolfgang.hesseler at imk dot fraunhofer dot de>)
michael
parents:
1831
diff
changeset
|
3919 DCTELEM *dct = &s->current_picture.dct_coeff[mb_xy*64*6]; |
ba27ce284d07
export DCT coefficients patch by (Wolfgang Hesseler <wolfgang.hesseler at imk dot fraunhofer dot de>)
michael
parents:
1831
diff
changeset
|
3920 for(i=0; i<6; i++) |
ba27ce284d07
export DCT coefficients patch by (Wolfgang Hesseler <wolfgang.hesseler at imk dot fraunhofer dot de>)
michael
parents:
1831
diff
changeset
|
3921 for(j=0; j<64; j++) |
ba27ce284d07
export DCT coefficients patch by (Wolfgang Hesseler <wolfgang.hesseler at imk dot fraunhofer dot de>)
michael
parents:
1831
diff
changeset
|
3922 *dct++ = block[i][s->dsp.idct_permutation[j]]; |
ba27ce284d07
export DCT coefficients patch by (Wolfgang Hesseler <wolfgang.hesseler at imk dot fraunhofer dot de>)
michael
parents:
1831
diff
changeset
|
3923 } |
ba27ce284d07
export DCT coefficients patch by (Wolfgang Hesseler <wolfgang.hesseler at imk dot fraunhofer dot de>)
michael
parents:
1831
diff
changeset
|
3924 |
903 | 3925 s->current_picture.qscale_table[mb_xy]= s->qscale; |
108
1e4a4af694d1
exporting qscale data for postprocessing (for MPlayer)
arpi_esp
parents:
79
diff
changeset
|
3926 |
0 | 3927 /* update DC predictors for P macroblocks */ |
3928 if (!s->mb_intra) { | |
249
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
3929 if (s->h263_pred || s->h263_aic) { |
481 | 3930 if(s->mbintra_table[mb_xy]) |
456 | 3931 ff_clean_intra_table_entries(s); |
0 | 3932 } else { |
456 | 3933 s->last_dc[0] = |
3934 s->last_dc[1] = | |
0 | 3935 s->last_dc[2] = 128 << s->intra_dc_precision; |
3936 } | |
3937 } | |
249
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
3938 else if (s->h263_pred || s->h263_aic) |
481 | 3939 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
|
3940 |
4224
8e0dcefcb464
fix b frames + -mbd rd without -psnr (yes that was seriously buggy and probably hasnt been noticed as everyone who tested stuff used -psnr)
michael
parents:
4223
diff
changeset
|
3941 if ((s->flags&CODEC_FLAG_PSNR) || !(s->encoding && (s->intra_only || s->pict_type==B_TYPE) && s->avctx->mb_decision != FF_MB_DECISION_RD)) { //FIXME precalc |
1064 | 3942 uint8_t *dest_y, *dest_cb, *dest_cr; |
481 | 3943 int dct_linesize, dct_offset; |
651 | 3944 op_pixels_func (*op_pix)[4]; |
3945 qpel_mc_func (*op_qpix)[16]; | |
2627
bf158d23bbcc
Spelling errors patch by (Kevin Baragona | kevinmb500 gawab com)
michael
parents:
2620
diff
changeset
|
3946 const int linesize= s->current_picture.linesize[0]; //not s->linesize as this would be wrong for field pics |
1138 | 3947 const int uvlinesize= s->current_picture.linesize[1]; |
2256 | 3948 const int readable= s->pict_type != B_TYPE || s->encoding || s->avctx->draw_horiz_band || lowres_flag; |
3949 const int block_size= lowres_flag ? 8>>s->avctx->lowres : 8; | |
7
1d3ac9654178
added skip macroblock optimization (big perf win on black regions for example)
glantau
parents:
0
diff
changeset
|
3950 |
903 | 3951 /* avoid copy if macroblock skipped in last frame too */ |
3952 /* skip only during decoding as we might trash the buffers during encoding a bit */ | |
3953 if(!s->encoding){ | |
1064 | 3954 uint8_t *mbskip_ptr = &s->mbskip_table[mb_xy]; |
903 | 3955 const int age= s->current_picture.age; |
3956 | |
3957 assert(age); | |
3958 | |
2628
511e3afc43e1
Ministry of English Composition, reporting for duty (and the word is "skipped", not "skiped"; "skiped" would rhyme with "hyped")
melanson
parents:
2627
diff
changeset
|
3959 if (s->mb_skipped) { |
511e3afc43e1
Ministry of English Composition, reporting for duty (and the word is "skipped", not "skiped"; "skiped" would rhyme with "hyped")
melanson
parents:
2627
diff
changeset
|
3960 s->mb_skipped= 0; |
903 | 3961 assert(s->pict_type!=I_TYPE); |
2967 | 3962 |
2628
511e3afc43e1
Ministry of English Composition, reporting for duty (and the word is "skipped", not "skiped"; "skiped" would rhyme with "hyped")
melanson
parents:
2627
diff
changeset
|
3963 (*mbskip_ptr) ++; /* indicate that this time we skipped it */ |
556 | 3964 if(*mbskip_ptr >99) *mbskip_ptr= 99; |
3965 | |
903 | 3966 /* 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
|
3967 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
|
3968 return; |
903 | 3969 } |
1021
2d7c9f5738de
trying to fix mb skip bug in mpeg1/2 if slices are not used
michaelni
parents:
1014
diff
changeset
|
3970 } 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
|
3971 (*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
|
3972 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
|
3973 } else{ |
7
1d3ac9654178
added skip macroblock optimization (big perf win on black regions for example)
glantau
parents:
0
diff
changeset
|
3974 *mbskip_ptr = 0; /* not skipped */ |
1d3ac9654178
added skip macroblock optimization (big perf win on black regions for example)
glantau
parents:
0
diff
changeset
|
3975 } |
717 | 3976 } |
2967 | 3977 |
2074
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
3978 dct_linesize = linesize << s->interlaced_dct; |
2256 | 3979 dct_offset =(s->interlaced_dct)? linesize : linesize*block_size; |
2967 | 3980 |
1632 | 3981 if(readable){ |
3982 dest_y= s->dest[0]; | |
3983 dest_cb= s->dest[1]; | |
3984 dest_cr= s->dest[2]; | |
3985 }else{ | |
1799 | 3986 dest_y = s->b_scratchpad; |
1834 | 3987 dest_cb= s->b_scratchpad+16*linesize; |
2074
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
3988 dest_cr= s->b_scratchpad+32*linesize; |
1632 | 3989 } |
2256 | 3990 |
0 | 3991 if (!s->mb_intra) { |
3992 /* motion handling */ | |
2627
bf158d23bbcc
Spelling errors patch by (Kevin Baragona | kevinmb500 gawab com)
michael
parents:
2620
diff
changeset
|
3993 /* decoding or more than one mb_type (MC was already done otherwise) */ |
1389 | 3994 if(!s->encoding){ |
2256 | 3995 if(lowres_flag){ |
3996 h264_chroma_mc_func *op_pix = s->dsp.put_h264_chroma_pixels_tab; | |
3997 | |
3998 if (s->mv_dir & MV_DIR_FORWARD) { | |
3999 MPV_motion_lowres(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.data, op_pix); | |
4000 op_pix = s->dsp.avg_h264_chroma_pixels_tab; | |
4001 } | |
4002 if (s->mv_dir & MV_DIR_BACKWARD) { | |
4003 MPV_motion_lowres(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.data, op_pix); | |
4004 } | |
324 | 4005 }else{ |
3807
6a40092eb9e6
approximate qpel functions: sacrifice some quality for some decoding speed. enabled on B-frames with -lavdopts fast.
lorenm
parents:
3780
diff
changeset
|
4006 op_qpix= s->me.qpel_put; |
2967 | 4007 if ((!s->no_rounding) || s->pict_type==B_TYPE){ |
2256 | 4008 op_pix = s->dsp.put_pixels_tab; |
4009 }else{ | |
4010 op_pix = s->dsp.put_no_rnd_pixels_tab; | |
4011 } | |
4012 if (s->mv_dir & MV_DIR_FORWARD) { | |
4013 MPV_motion(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.data, op_pix, op_qpix); | |
4014 op_pix = s->dsp.avg_pixels_tab; | |
3807
6a40092eb9e6
approximate qpel functions: sacrifice some quality for some decoding speed. enabled on B-frames with -lavdopts fast.
lorenm
parents:
3780
diff
changeset
|
4015 op_qpix= s->me.qpel_avg; |
2256 | 4016 } |
4017 if (s->mv_dir & MV_DIR_BACKWARD) { | |
4018 MPV_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.data, op_pix, op_qpix); | |
4019 } | |
324 | 4020 } |
0 | 4021 } |
4022 | |
481 | 4023 /* skip dequant / idct if we are really late ;) */ |
2792 | 4024 if(s->hurry_up>1) goto skip_idct; |
4025 if(s->avctx->skip_idct){ | |
4026 if( (s->avctx->skip_idct >= AVDISCARD_NONREF && s->pict_type == B_TYPE) | |
4027 ||(s->avctx->skip_idct >= AVDISCARD_NONKEY && s->pict_type != I_TYPE) | |
4028 || s->avctx->skip_idct >= AVDISCARD_ALL) | |
4029 goto skip_idct; | |
4030 } | |
481 | 4031 |
0 | 4032 /* add dct residue */ |
1421 | 4033 if(s->encoding || !( s->h263_msmpeg4 || s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO |
711 | 4034 || (s->codec_id==CODEC_ID_MPEG4 && !s->mpeg_quant))){ |
2256 | 4035 add_dequant_dct(s, block[0], 0, dest_y , dct_linesize, s->qscale); |
4036 add_dequant_dct(s, block[1], 1, dest_y + block_size, dct_linesize, s->qscale); | |
4037 add_dequant_dct(s, block[2], 2, dest_y + dct_offset , dct_linesize, s->qscale); | |
4038 add_dequant_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize, s->qscale); | |
0 | 4039 |
485 | 4040 if(!(s->flags&CODEC_FLAG_GRAY)){ |
3309 | 4041 if (s->chroma_y_shift){ |
4042 add_dequant_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale); | |
4043 add_dequant_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale); | |
4044 }else{ | |
4045 dct_linesize >>= 1; | |
4046 dct_offset >>=1; | |
4047 add_dequant_dct(s, block[4], 4, dest_cb, dct_linesize, s->chroma_qscale); | |
4048 add_dequant_dct(s, block[5], 5, dest_cr, dct_linesize, s->chroma_qscale); | |
4049 add_dequant_dct(s, block[6], 6, dest_cb + dct_offset, dct_linesize, s->chroma_qscale); | |
4050 add_dequant_dct(s, block[7], 7, dest_cr + dct_offset, dct_linesize, s->chroma_qscale); | |
4051 } | |
485 | 4052 } |
936 | 4053 } else if(s->codec_id != CODEC_ID_WMV2){ |
2256 | 4054 add_dct(s, block[0], 0, dest_y , dct_linesize); |
4055 add_dct(s, block[1], 1, dest_y + block_size, dct_linesize); | |
4056 add_dct(s, block[2], 2, dest_y + dct_offset , dct_linesize); | |
4057 add_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize); | |
481 | 4058 |
485 | 4059 if(!(s->flags&CODEC_FLAG_GRAY)){ |
2074
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
4060 if(s->chroma_y_shift){//Chroma420 |
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
4061 add_dct(s, block[4], 4, dest_cb, uvlinesize); |
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
4062 add_dct(s, block[5], 5, dest_cr, uvlinesize); |
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
4063 }else{ |
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
4064 //chroma422 |
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
4065 dct_linesize = uvlinesize << s->interlaced_dct; |
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
4066 dct_offset =(s->interlaced_dct)? uvlinesize : uvlinesize*8; |
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
4067 |
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
4068 add_dct(s, block[4], 4, dest_cb, dct_linesize); |
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
4069 add_dct(s, block[5], 5, dest_cr, dct_linesize); |
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
4070 add_dct(s, block[6], 6, dest_cb+dct_offset, dct_linesize); |
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
4071 add_dct(s, block[7], 7, dest_cr+dct_offset, dct_linesize); |
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
4072 if(!s->chroma_x_shift){//Chroma444 |
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
4073 add_dct(s, block[8], 8, dest_cb+8, dct_linesize); |
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
4074 add_dct(s, block[9], 9, dest_cr+8, dct_linesize); |
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
4075 add_dct(s, block[10], 10, dest_cb+8+dct_offset, dct_linesize); |
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
4076 add_dct(s, block[11], 11, dest_cr+8+dct_offset, dct_linesize); |
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
4077 } |
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
4078 } |
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
4079 }//fi gray |
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
4080 } |
4967
6d45158e0249
disable reference to msmpeg4 and wmv2 code when those codecs are not compiled in
aurel
parents:
4668
diff
changeset
|
4081 else if (ENABLE_WMV2) { |
936 | 4082 ff_wmv2_add_mb(s, block, dest_y, dest_cb, dest_cr); |
481 | 4083 } |
0 | 4084 } else { |
4085 /* dct only in intra block */ | |
1421 | 4086 if(s->encoding || !(s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO)){ |
2256 | 4087 put_dct(s, block[0], 0, dest_y , dct_linesize, s->qscale); |
4088 put_dct(s, block[1], 1, dest_y + block_size, dct_linesize, s->qscale); | |
4089 put_dct(s, block[2], 2, dest_y + dct_offset , dct_linesize, s->qscale); | |
4090 put_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize, s->qscale); | |
0 | 4091 |
711 | 4092 if(!(s->flags&CODEC_FLAG_GRAY)){ |
3309 | 4093 if(s->chroma_y_shift){ |
4094 put_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale); | |
4095 put_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale); | |
4096 }else{ | |
4097 dct_offset >>=1; | |
4098 dct_linesize >>=1; | |
4099 put_dct(s, block[4], 4, dest_cb, dct_linesize, s->chroma_qscale); | |
4100 put_dct(s, block[5], 5, dest_cr, dct_linesize, s->chroma_qscale); | |
4101 put_dct(s, block[6], 6, dest_cb + dct_offset, dct_linesize, s->chroma_qscale); | |
4102 put_dct(s, block[7], 7, dest_cr + dct_offset, dct_linesize, s->chroma_qscale); | |
4103 } | |
711 | 4104 } |
4105 }else{ | |
2256 | 4106 s->dsp.idct_put(dest_y , dct_linesize, block[0]); |
4107 s->dsp.idct_put(dest_y + block_size, dct_linesize, block[1]); | |
4108 s->dsp.idct_put(dest_y + dct_offset , dct_linesize, block[2]); | |
4109 s->dsp.idct_put(dest_y + dct_offset + block_size, dct_linesize, block[3]); | |
711 | 4110 |
4111 if(!(s->flags&CODEC_FLAG_GRAY)){ | |
2074
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
4112 if(s->chroma_y_shift){ |
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
4113 s->dsp.idct_put(dest_cb, uvlinesize, block[4]); |
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
4114 s->dsp.idct_put(dest_cr, uvlinesize, block[5]); |
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
4115 }else{ |
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
4116 |
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
4117 dct_linesize = uvlinesize << s->interlaced_dct; |
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
4118 dct_offset =(s->interlaced_dct)? uvlinesize : uvlinesize*8; |
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
4119 |
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
4120 s->dsp.idct_put(dest_cb, dct_linesize, block[4]); |
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
4121 s->dsp.idct_put(dest_cr, dct_linesize, block[5]); |
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
4122 s->dsp.idct_put(dest_cb + dct_offset, dct_linesize, block[6]); |
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
4123 s->dsp.idct_put(dest_cr + dct_offset, dct_linesize, block[7]); |
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
4124 if(!s->chroma_x_shift){//Chroma444 |
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
4125 s->dsp.idct_put(dest_cb + 8, dct_linesize, block[8]); |
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
4126 s->dsp.idct_put(dest_cr + 8, dct_linesize, block[9]); |
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
4127 s->dsp.idct_put(dest_cb + 8 + dct_offset, dct_linesize, block[10]); |
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
4128 s->dsp.idct_put(dest_cr + 8 + dct_offset, dct_linesize, block[11]); |
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
4129 } |
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
4130 } |
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
4131 }//gray |
485 | 4132 } |
0 | 4133 } |
2792 | 4134 skip_idct: |
1632 | 4135 if(!readable){ |
4136 s->dsp.put_pixels_tab[0][0](s->dest[0], dest_y , linesize,16); | |
2074
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
4137 s->dsp.put_pixels_tab[s->chroma_x_shift][0](s->dest[1], dest_cb, uvlinesize,16 >> s->chroma_y_shift); |
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
4138 s->dsp.put_pixels_tab[s->chroma_x_shift][0](s->dest[2], dest_cr, uvlinesize,16 >> s->chroma_y_shift); |
1632 | 4139 } |
0 | 4140 } |
294 | 4141 } |
4142 | |
2256 | 4143 void MPV_decode_mb(MpegEncContext *s, DCTELEM block[12][64]){ |
4144 if(s->avctx->lowres) MPV_decode_mb_internal(s, block, 1); | |
4145 else MPV_decode_mb_internal(s, block, 0); | |
4146 } | |
4147 | |
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
|
4148 #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
|
4149 |
605
40874804a5af
same dc skip behavior for chroma & luma elimination, its confusing otherwise imho
michaelni
parents:
604
diff
changeset
|
4150 static inline void dct_single_coeff_elimination(MpegEncContext *s, int n, int threshold) |
456 | 4151 { |
4152 static const char tab[64]= | |
4153 {3,2,2,1,1,1,1,1, | |
4154 1,1,1,1,1,1,1,1, | |
4155 1,1,1,1,1,1,1,1, | |
4156 0,0,0,0,0,0,0,0, | |
4157 0,0,0,0,0,0,0,0, | |
4158 0,0,0,0,0,0,0,0, | |
4159 0,0,0,0,0,0,0,0, | |
4160 0,0,0,0,0,0,0,0}; | |
4161 int score=0; | |
4162 int run=0; | |
4163 int i; | |
4164 DCTELEM *block= s->block[n]; | |
4165 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
|
4166 int skip_dc; |
456 | 4167 |
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
|
4168 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
|
4169 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
|
4170 threshold= -threshold; |
605
40874804a5af
same dc skip behavior for chroma & luma elimination, its confusing otherwise imho
michaelni
parents:
604
diff
changeset
|
4171 }else |
40874804a5af
same dc skip behavior for chroma & luma elimination, its confusing otherwise imho
michaelni
parents:
604
diff
changeset
|
4172 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
|
4173 |
456 | 4174 /* are all which we could set to zero are allready zero? */ |
4175 if(last_index<=skip_dc - 1) return; | |
4176 | |
4177 for(i=0; i<=last_index; i++){ | |
706
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
4178 const int j = s->intra_scantable.permutated[i]; |
4001 | 4179 const int level = FFABS(block[j]); |
456 | 4180 if(level==1){ |
4181 if(skip_dc && i==0) continue; | |
4182 score+= tab[run]; | |
4183 run=0; | |
4184 }else if(level>1){ | |
4185 return; | |
4186 }else{ | |
4187 run++; | |
4188 } | |
4189 } | |
4190 if(score >= threshold) return; | |
4191 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
|
4192 const int j = s->intra_scantable.permutated[i]; |
456 | 4193 block[j]=0; |
4194 } | |
4195 if(block[0]) s->block_last_index[n]= 0; | |
4196 else s->block_last_index[n]= -1; | |
4197 } | |
4198 | |
344 | 4199 static inline void clip_coeffs(MpegEncContext *s, DCTELEM *block, int last_index) |
4200 { | |
4201 int i; | |
4202 const int maxlevel= s->max_qcoeff; | |
4203 const int minlevel= s->min_qcoeff; | |
1722
7e040c2a86e4
warn the user if we had to clip some dct coefficient due to a crappy format which doenst support the whole needed range (msmpeg4/wmv mostly but mpeg1 too to a lesser extend)
michael
parents:
1719
diff
changeset
|
4204 int overflow=0; |
2967 | 4205 |
706
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
4206 if(s->mb_intra){ |
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
4207 i=1; //skip clipping of intra dc |
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
4208 }else |
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
4209 i=0; |
2967 | 4210 |
706
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
4211 for(;i<=last_index; i++){ |
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
4212 const int j= s->intra_scantable.permutated[i]; |
344 | 4213 int level = block[j]; |
2967 | 4214 |
1722
7e040c2a86e4
warn the user if we had to clip some dct coefficient due to a crappy format which doenst support the whole needed range (msmpeg4/wmv mostly but mpeg1 too to a lesser extend)
michael
parents:
1719
diff
changeset
|
4215 if (level>maxlevel){ |
7e040c2a86e4
warn the user if we had to clip some dct coefficient due to a crappy format which doenst support the whole needed range (msmpeg4/wmv mostly but mpeg1 too to a lesser extend)
michael
parents:
1719
diff
changeset
|
4216 level=maxlevel; |
7e040c2a86e4
warn the user if we had to clip some dct coefficient due to a crappy format which doenst support the whole needed range (msmpeg4/wmv mostly but mpeg1 too to a lesser extend)
michael
parents:
1719
diff
changeset
|
4217 overflow++; |
7e040c2a86e4
warn the user if we had to clip some dct coefficient due to a crappy format which doenst support the whole needed range (msmpeg4/wmv mostly but mpeg1 too to a lesser extend)
michael
parents:
1719
diff
changeset
|
4218 }else if(level<minlevel){ |
7e040c2a86e4
warn the user if we had to clip some dct coefficient due to a crappy format which doenst support the whole needed range (msmpeg4/wmv mostly but mpeg1 too to a lesser extend)
michael
parents:
1719
diff
changeset
|
4219 level=minlevel; |
7e040c2a86e4
warn the user if we had to clip some dct coefficient due to a crappy format which doenst support the whole needed range (msmpeg4/wmv mostly but mpeg1 too to a lesser extend)
michael
parents:
1719
diff
changeset
|
4220 overflow++; |
7e040c2a86e4
warn the user if we had to clip some dct coefficient due to a crappy format which doenst support the whole needed range (msmpeg4/wmv mostly but mpeg1 too to a lesser extend)
michael
parents:
1719
diff
changeset
|
4221 } |
2967 | 4222 |
344 | 4223 block[j]= level; |
4224 } | |
2967 | 4225 |
1722
7e040c2a86e4
warn the user if we had to clip some dct coefficient due to a crappy format which doenst support the whole needed range (msmpeg4/wmv mostly but mpeg1 too to a lesser extend)
michael
parents:
1719
diff
changeset
|
4226 if(overflow && s->avctx->mb_decision == FF_MB_DECISION_SIMPLE) |
2627
bf158d23bbcc
Spelling errors patch by (Kevin Baragona | kevinmb500 gawab com)
michael
parents:
2620
diff
changeset
|
4227 av_log(s->avctx, AV_LOG_INFO, "warning, clipping %d dct coefficients to %d..%d\n", overflow, minlevel, maxlevel); |
344 | 4228 } |
324 | 4229 |
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
|
4230 #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
|
4231 |
1098
b7f267d168b7
mpeg2 field pictures + sliced mode (doesnt work with mplayer though, dunno why)
michaelni
parents:
1096
diff
changeset
|
4232 /** |
b7f267d168b7
mpeg2 field pictures + sliced mode (doesnt work with mplayer though, dunno why)
michaelni
parents:
1096
diff
changeset
|
4233 * |
b7f267d168b7
mpeg2 field pictures + sliced mode (doesnt work with mplayer though, dunno why)
michaelni
parents:
1096
diff
changeset
|
4234 * @param h is the normal height, this will be reduced automatically if needed for the last row |
b7f267d168b7
mpeg2 field pictures + sliced mode (doesnt work with mplayer though, dunno why)
michaelni
parents:
1096
diff
changeset
|
4235 */ |
b7f267d168b7
mpeg2 field pictures + sliced mode (doesnt work with mplayer though, dunno why)
michaelni
parents:
1096
diff
changeset
|
4236 void ff_draw_horiz_band(MpegEncContext *s, int y, int h){ |
1368 | 4237 if (s->avctx->draw_horiz_band) { |
1370 | 4238 AVFrame *src; |
1368 | 4239 int offset[4]; |
2967 | 4240 |
1370 | 4241 if(s->picture_structure != PICT_FRAME){ |
4242 h <<= 1; | |
4243 y <<= 1; | |
4244 if(s->first_field && !(s->avctx->slice_flags&SLICE_FLAG_ALLOW_FIELD)) return; | |
4245 } | |
4246 | |
2266
514949de5d15
set AVCodecContext.width/height to the picture width/height instead of the one stored in the bitstream (that only matters if lowres!=0)
michael
parents:
2265
diff
changeset
|
4247 h= FFMIN(h, s->avctx->height - y); |
1098
b7f267d168b7
mpeg2 field pictures + sliced mode (doesnt work with mplayer though, dunno why)
michaelni
parents:
1096
diff
changeset
|
4248 |
2967 | 4249 if(s->pict_type==B_TYPE || s->low_delay || (s->avctx->slice_flags&SLICE_FLAG_CODED_ORDER)) |
1370 | 4250 src= (AVFrame*)s->current_picture_ptr; |
4251 else if(s->last_picture_ptr) | |
4252 src= (AVFrame*)s->last_picture_ptr; | |
4253 else | |
4254 return; | |
2967 | 4255 |
1369 | 4256 if(s->pict_type==B_TYPE && s->picture_structure == PICT_FRAME && s->out_format != FMT_H264){ |
1368 | 4257 offset[0]= |
4258 offset[1]= | |
4259 offset[2]= | |
4260 offset[3]= 0; | |
4261 }else{ | |
4262 offset[0]= y * s->linesize;; | |
2967 | 4263 offset[1]= |
2074
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
4264 offset[2]= (y >> s->chroma_y_shift) * s->uvlinesize; |
1368 | 4265 offset[3]= 0; |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
731
diff
changeset
|
4266 } |
1368 | 4267 |
813 | 4268 emms_c(); |
4269 | |
1370 | 4270 s->avctx->draw_horiz_band(s->avctx, src, offset, |
4271 y, s->picture_structure, h); | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
731
diff
changeset
|
4272 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
731
diff
changeset
|
4273 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
731
diff
changeset
|
4274 |
1389 | 4275 void ff_init_block_index(MpegEncContext *s){ //FIXME maybe rename |
2764 | 4276 const int linesize= s->current_picture.linesize[0]; //not s->linesize as this would be wrong for field pics |
1389 | 4277 const int uvlinesize= s->current_picture.linesize[1]; |
2256 | 4278 const int mb_size= 4 - s->avctx->lowres; |
2967 | 4279 |
1938
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1918
diff
changeset
|
4280 s->block_index[0]= s->b8_stride*(s->mb_y*2 ) - 2 + s->mb_x*2; |
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1918
diff
changeset
|
4281 s->block_index[1]= s->b8_stride*(s->mb_y*2 ) - 1 + s->mb_x*2; |
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1918
diff
changeset
|
4282 s->block_index[2]= s->b8_stride*(s->mb_y*2 + 1) - 2 + s->mb_x*2; |
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1918
diff
changeset
|
4283 s->block_index[3]= s->b8_stride*(s->mb_y*2 + 1) - 1 + s->mb_x*2; |
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1918
diff
changeset
|
4284 s->block_index[4]= s->mb_stride*(s->mb_y + 1) + s->b8_stride*s->mb_height*2 + s->mb_x - 1; |
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1918
diff
changeset
|
4285 s->block_index[5]= s->mb_stride*(s->mb_y + s->mb_height + 2) + s->b8_stride*s->mb_height*2 + s->mb_x - 1; |
2074
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
4286 //block_index is not used by mpeg2, so it is not affected by chroma_format |
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
4287 |
2256 | 4288 s->dest[0] = s->current_picture.data[0] + ((s->mb_x - 1) << mb_size); |
4289 s->dest[1] = s->current_picture.data[1] + ((s->mb_x - 1) << (mb_size - s->chroma_x_shift)); | |
4290 s->dest[2] = s->current_picture.data[2] + ((s->mb_x - 1) << (mb_size - s->chroma_x_shift)); | |
2168 | 4291 |
2074
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
4292 if(!(s->pict_type==B_TYPE && s->avctx->draw_horiz_band && s->picture_structure==PICT_FRAME)) |
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
4293 { |
2256 | 4294 s->dest[0] += s->mb_y * linesize << mb_size; |
4295 s->dest[1] += s->mb_y * uvlinesize << (mb_size - s->chroma_y_shift); | |
4296 s->dest[2] += s->mb_y * uvlinesize << (mb_size - s->chroma_y_shift); | |
2074
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
4297 } |
1389 | 4298 } |
4299 | |
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
|
4300 #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
|
4301 |
1777 | 4302 static void get_vissual_weight(int16_t *weight, uint8_t *ptr, int stride){ |
4303 int x, y; | |
4304 //FIXME optimize | |
4305 for(y=0; y<8; y++){ | |
4306 for(x=0; x<8; x++){ | |
4307 int x2, y2; | |
4308 int sum=0; | |
4309 int sqr=0; | |
4310 int count=0; | |
4311 | |
4312 for(y2= FFMAX(y-1, 0); y2 < FFMIN(8, y+2); y2++){ | |
4313 for(x2= FFMAX(x-1, 0); x2 < FFMIN(8, x+2); x2++){ | |
4314 int v= ptr[x2 + y2*stride]; | |
4315 sum += v; | |
4316 sqr += v*v; | |
4317 count++; | |
4318 } | |
4319 } | |
4320 weight[x + 8*y]= (36*ff_sqrt(count*sqr - sum*sum)) / count; | |
4321 } | |
4322 } | |
4323 } | |
4324 | |
4283
d6f83e2f8804
rename always_inline to av_always_inline and move to common.h
mru
parents:
4281
diff
changeset
|
4325 static av_always_inline void encode_mb_internal(MpegEncContext *s, int motion_x, int motion_y, int mb_block_height, int mb_block_count) |
294 | 4326 { |
3309 | 4327 int16_t weight[8][64]; |
4328 DCTELEM orig[8][64]; | |
294 | 4329 const int mb_x= s->mb_x; |
4330 const int mb_y= s->mb_y; | |
4331 int i; | |
3309 | 4332 int skip_dct[8]; |
697 | 4333 int dct_offset = s->linesize*8; //default for progressive frames |
1778 | 4334 uint8_t *ptr_y, *ptr_cb, *ptr_cr; |
4335 int wrap_y, wrap_c; | |
2967 | 4336 |
4327 | 4337 for(i=0; i<mb_block_count; i++) skip_dct[i]=s->skipdct; |
2967 | 4338 |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
673
diff
changeset
|
4339 if(s->adaptive_quant){ |
1505
010f76d07a27
use lagrange multipler instead of qp for ratecontrol, this may break some things, tell me ASAP if u notice anything broken
michaelni
parents:
1497
diff
changeset
|
4340 const int last_qp= s->qscale; |
010f76d07a27
use lagrange multipler instead of qp for ratecontrol, this may break some things, tell me ASAP if u notice anything broken
michaelni
parents:
1497
diff
changeset
|
4341 const int mb_xy= mb_x + mb_y*s->mb_stride; |
010f76d07a27
use lagrange multipler instead of qp for ratecontrol, this may break some things, tell me ASAP if u notice anything broken
michaelni
parents:
1497
diff
changeset
|
4342 |
010f76d07a27
use lagrange multipler instead of qp for ratecontrol, this may break some things, tell me ASAP if u notice anything broken
michaelni
parents:
1497
diff
changeset
|
4343 s->lambda= s->lambda_table[mb_xy]; |
010f76d07a27
use lagrange multipler instead of qp for ratecontrol, this may break some things, tell me ASAP if u notice anything broken
michaelni
parents:
1497
diff
changeset
|
4344 update_qscale(s); |
2967 | 4345 |
1616 | 4346 if(!(s->flags&CODEC_FLAG_QP_RD)){ |
4320 | 4347 s->qscale= s->current_picture_ptr->qscale_table[mb_xy]; |
1616 | 4348 s->dquant= s->qscale - last_qp; |
4349 | |
1805
5dd5b2052f5b
mpeg4 b frame + adaptive quantization assertion failure fix
michael
parents:
1804
diff
changeset
|
4350 if(s->out_format==FMT_H263){ |
4594 | 4351 s->dquant= av_clip(s->dquant, -2, 2); |
2967 | 4352 |
4353 if(s->codec_id==CODEC_ID_MPEG4){ | |
1805
5dd5b2052f5b
mpeg4 b frame + adaptive quantization assertion failure fix
michael
parents:
1804
diff
changeset
|
4354 if(!s->mb_intra){ |
5dd5b2052f5b
mpeg4 b frame + adaptive quantization assertion failure fix
michael
parents:
1804
diff
changeset
|
4355 if(s->pict_type == B_TYPE){ |
4324 | 4356 if(s->dquant&1 || s->mv_dir&MV_DIRECT) |
1805
5dd5b2052f5b
mpeg4 b frame + adaptive quantization assertion failure fix
michael
parents:
1804
diff
changeset
|
4357 s->dquant= 0; |
5dd5b2052f5b
mpeg4 b frame + adaptive quantization assertion failure fix
michael
parents:
1804
diff
changeset
|
4358 } |
5dd5b2052f5b
mpeg4 b frame + adaptive quantization assertion failure fix
michael
parents:
1804
diff
changeset
|
4359 if(s->mv_type==MV_TYPE_8X8) |
5dd5b2052f5b
mpeg4 b frame + adaptive quantization assertion failure fix
michael
parents:
1804
diff
changeset
|
4360 s->dquant=0; |
5dd5b2052f5b
mpeg4 b frame + adaptive quantization assertion failure fix
michael
parents:
1804
diff
changeset
|
4361 } |
1616 | 4362 } |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
673
diff
changeset
|
4363 } |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
673
diff
changeset
|
4364 } |
1652 | 4365 ff_set_qscale(s, last_qp + s->dquant); |
2054 | 4366 }else if(s->flags&CODEC_FLAG_QP_RD) |
4367 ff_set_qscale(s, s->qscale + s->dquant); | |
294 | 4368 |
1778 | 4369 wrap_y = s->linesize; |
4370 wrap_c = s->uvlinesize; | |
4371 ptr_y = s->new_picture.data[0] + (mb_y * 16 * wrap_y) + mb_x * 16; | |
3309 | 4372 ptr_cb = s->new_picture.data[1] + (mb_y * mb_block_height * wrap_c) + mb_x * 8; |
4373 ptr_cr = s->new_picture.data[2] + (mb_y * mb_block_height * wrap_c) + mb_x * 8; | |
1778 | 4374 |
4375 if(mb_x*16+16 > s->width || mb_y*16+16 > s->height){ | |
2165
5ca07515a309
10l (dont store 2 different things at the same place ...)
michael
parents:
2132
diff
changeset
|
4376 uint8_t *ebuf= s->edge_emu_buffer + 32; |
5ca07515a309
10l (dont store 2 different things at the same place ...)
michael
parents:
2132
diff
changeset
|
4377 ff_emulated_edge_mc(ebuf , ptr_y , wrap_y,16,16,mb_x*16,mb_y*16, s->width , s->height); |
5ca07515a309
10l (dont store 2 different things at the same place ...)
michael
parents:
2132
diff
changeset
|
4378 ptr_y= ebuf; |
3309 | 4379 ff_emulated_edge_mc(ebuf+18*wrap_y , ptr_cb, wrap_c, 8, mb_block_height, mb_x*8, mb_y*8, s->width>>1, s->height>>1); |
2165
5ca07515a309
10l (dont store 2 different things at the same place ...)
michael
parents:
2132
diff
changeset
|
4380 ptr_cb= ebuf+18*wrap_y; |
3309 | 4381 ff_emulated_edge_mc(ebuf+18*wrap_y+8, ptr_cr, wrap_c, 8, mb_block_height, mb_x*8, mb_y*8, s->width>>1, s->height>>1); |
2165
5ca07515a309
10l (dont store 2 different things at the same place ...)
michael
parents:
2132
diff
changeset
|
4382 ptr_cr= ebuf+18*wrap_y+8; |
1778 | 4383 } |
4384 | |
324 | 4385 if (s->mb_intra) { |
697 | 4386 if(s->flags&CODEC_FLAG_INTERLACED_DCT){ |
4387 int progressive_score, interlaced_score; | |
1708 | 4388 |
1729 | 4389 s->interlaced_dct=0; |
2967 | 4390 progressive_score= s->dsp.ildct_cmp[4](s, ptr_y , NULL, wrap_y, 8) |
1777 | 4391 +s->dsp.ildct_cmp[4](s, ptr_y + wrap_y*8, NULL, wrap_y, 8) - 400; |
1729 | 4392 |
4393 if(progressive_score > 0){ | |
2967 | 4394 interlaced_score = s->dsp.ildct_cmp[4](s, ptr_y , NULL, wrap_y*2, 8) |
1777 | 4395 +s->dsp.ildct_cmp[4](s, ptr_y + wrap_y , NULL, wrap_y*2, 8); |
1729 | 4396 if(progressive_score > interlaced_score){ |
4397 s->interlaced_dct=1; | |
2967 | 4398 |
1729 | 4399 dct_offset= wrap_y; |
4400 wrap_y<<=1; | |
3309 | 4401 if (s->chroma_format == CHROMA_422) |
4402 wrap_c<<=1; | |
1729 | 4403 } |
4404 } | |
697 | 4405 } |
2967 | 4406 |
2979 | 4407 s->dsp.get_pixels(s->block[0], ptr_y , wrap_y); |
1777 | 4408 s->dsp.get_pixels(s->block[1], ptr_y + 8, wrap_y); |
4409 s->dsp.get_pixels(s->block[2], ptr_y + dct_offset , wrap_y); | |
4410 s->dsp.get_pixels(s->block[3], ptr_y + dct_offset + 8, wrap_y); | |
294 | 4411 |
487 | 4412 if(s->flags&CODEC_FLAG_GRAY){ |
4413 skip_dct[4]= 1; | |
4414 skip_dct[5]= 1; | |
4415 }else{ | |
2979 | 4416 s->dsp.get_pixels(s->block[4], ptr_cb, wrap_c); |
1777 | 4417 s->dsp.get_pixels(s->block[5], ptr_cr, wrap_c); |
3309 | 4418 if(!s->chroma_y_shift){ /* 422 */ |
4419 s->dsp.get_pixels(s->block[6], ptr_cb + (dct_offset>>1), wrap_c); | |
4420 s->dsp.get_pixels(s->block[7], ptr_cr + (dct_offset>>1), wrap_c); | |
4421 } | |
1777 | 4422 } |
324 | 4423 }else{ |
651 | 4424 op_pixels_func (*op_pix)[4]; |
4425 qpel_mc_func (*op_qpix)[16]; | |
1064 | 4426 uint8_t *dest_y, *dest_cb, *dest_cr; |
294 | 4427 |
1389 | 4428 dest_y = s->dest[0]; |
4429 dest_cb = s->dest[1]; | |
4430 dest_cr = s->dest[2]; | |
324 | 4431 |
327 | 4432 if ((!s->no_rounding) || s->pict_type==B_TYPE){ |
2979 | 4433 op_pix = s->dsp.put_pixels_tab; |
853
eacc2dd8fd9d
* using DSPContext - so each codec could use its local (sub)set of CPU extension
kabi
parents:
847
diff
changeset
|
4434 op_qpix= s->dsp.put_qpel_pixels_tab; |
295 | 4435 }else{ |
853
eacc2dd8fd9d
* using DSPContext - so each codec could use its local (sub)set of CPU extension
kabi
parents:
847
diff
changeset
|
4436 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
|
4437 op_qpix= s->dsp.put_no_rnd_qpel_pixels_tab; |
324 | 4438 } |
295 | 4439 |
324 | 4440 if (s->mv_dir & MV_DIR_FORWARD) { |
903 | 4441 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
|
4442 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
|
4443 op_qpix= s->dsp.avg_qpel_pixels_tab; |
324 | 4444 } |
4445 if (s->mv_dir & MV_DIR_BACKWARD) { | |
903 | 4446 MPV_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.data, op_pix, op_qpix); |
324 | 4447 } |
295 | 4448 |
697 | 4449 if(s->flags&CODEC_FLAG_INTERLACED_DCT){ |
4450 int progressive_score, interlaced_score; | |
1729 | 4451 |
4452 s->interlaced_dct=0; | |
2967 | 4453 progressive_score= s->dsp.ildct_cmp[0](s, dest_y , ptr_y , wrap_y, 8) |
1729 | 4454 +s->dsp.ildct_cmp[0](s, dest_y + wrap_y*8, ptr_y + wrap_y*8, wrap_y, 8) - 400; |
2967 | 4455 |
1729 | 4456 if(s->avctx->ildct_cmp == FF_CMP_VSSE) progressive_score -= 400; |
4457 | |
4458 if(progressive_score>0){ | |
2967 | 4459 interlaced_score = s->dsp.ildct_cmp[0](s, dest_y , ptr_y , wrap_y*2, 8) |
1729 | 4460 +s->dsp.ildct_cmp[0](s, dest_y + wrap_y , ptr_y + wrap_y , wrap_y*2, 8); |
2967 | 4461 |
1729 | 4462 if(progressive_score > interlaced_score){ |
4463 s->interlaced_dct=1; | |
2967 | 4464 |
1729 | 4465 dct_offset= wrap_y; |
4466 wrap_y<<=1; | |
3309 | 4467 if (s->chroma_format == CHROMA_422) |
4468 wrap_c<<=1; | |
1729 | 4469 } |
4470 } | |
697 | 4471 } |
2967 | 4472 |
2979 | 4473 s->dsp.diff_pixels(s->block[0], ptr_y , dest_y , wrap_y); |
853
eacc2dd8fd9d
* using DSPContext - so each codec could use its local (sub)set of CPU extension
kabi
parents:
847
diff
changeset
|
4474 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
|
4475 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
|
4476 s->dsp.diff_pixels(s->block[3], ptr_y + dct_offset + 8, dest_y + dct_offset + 8, wrap_y); |
2967 | 4477 |
487 | 4478 if(s->flags&CODEC_FLAG_GRAY){ |
4479 skip_dct[4]= 1; | |
4480 skip_dct[5]= 1; | |
4481 }else{ | |
853
eacc2dd8fd9d
* using DSPContext - so each codec could use its local (sub)set of CPU extension
kabi
parents:
847
diff
changeset
|
4482 s->dsp.diff_pixels(s->block[4], ptr_cb, dest_cb, wrap_c); |
eacc2dd8fd9d
* using DSPContext - so each codec could use its local (sub)set of CPU extension
kabi
parents:
847
diff
changeset
|
4483 s->dsp.diff_pixels(s->block[5], ptr_cr, dest_cr, wrap_c); |
3309 | 4484 if(!s->chroma_y_shift){ /* 422 */ |
4485 s->dsp.diff_pixels(s->block[6], ptr_cb + (dct_offset>>1), dest_cb + (dct_offset>>1), wrap_c); | |
4486 s->dsp.diff_pixels(s->block[7], ptr_cr + (dct_offset>>1), dest_cr + (dct_offset>>1), wrap_c); | |
4487 } | |
487 | 4488 } |
2967 | 4489 /* pre quantization */ |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1173
diff
changeset
|
4490 if(s->current_picture.mc_mb_var[s->mb_stride*mb_y+ mb_x]<2*s->qscale*s->qscale){ |
697 | 4491 //FIXME optimize |
2979 | 4492 if(s->dsp.sad[1](NULL, ptr_y , dest_y , wrap_y, 8) < 20*s->qscale) skip_dct[0]= 1; |
1708 | 4493 if(s->dsp.sad[1](NULL, ptr_y + 8, dest_y + 8, wrap_y, 8) < 20*s->qscale) skip_dct[1]= 1; |
4494 if(s->dsp.sad[1](NULL, ptr_y +dct_offset , dest_y +dct_offset , wrap_y, 8) < 20*s->qscale) skip_dct[2]= 1; | |
4495 if(s->dsp.sad[1](NULL, ptr_y +dct_offset+ 8, dest_y +dct_offset+ 8, wrap_y, 8) < 20*s->qscale) skip_dct[3]= 1; | |
4496 if(s->dsp.sad[1](NULL, ptr_cb , dest_cb , wrap_c, 8) < 20*s->qscale) skip_dct[4]= 1; | |
4497 if(s->dsp.sad[1](NULL, ptr_cr , dest_cr , wrap_c, 8) < 20*s->qscale) skip_dct[5]= 1; | |
3309 | 4498 if(!s->chroma_y_shift){ /* 422 */ |
4499 if(s->dsp.sad[1](NULL, ptr_cb +(dct_offset>>1), dest_cb +(dct_offset>>1), wrap_c, 8) < 20*s->qscale) skip_dct[6]= 1; | |
4500 if(s->dsp.sad[1](NULL, ptr_cr +(dct_offset>>1), dest_cr +(dct_offset>>1), wrap_c, 8) < 20*s->qscale) skip_dct[7]= 1; | |
4501 } | |
456 | 4502 } |
1778 | 4503 } |
4504 | |
4505 if(s->avctx->quantizer_noise_shaping){ | |
4506 if(!skip_dct[0]) get_vissual_weight(weight[0], ptr_y , wrap_y); | |
4507 if(!skip_dct[1]) get_vissual_weight(weight[1], ptr_y + 8, wrap_y); | |
4508 if(!skip_dct[2]) get_vissual_weight(weight[2], ptr_y + dct_offset , wrap_y); | |
4509 if(!skip_dct[3]) get_vissual_weight(weight[3], ptr_y + dct_offset + 8, wrap_y); | |
4510 if(!skip_dct[4]) get_vissual_weight(weight[4], ptr_cb , wrap_c); | |
4511 if(!skip_dct[5]) get_vissual_weight(weight[5], ptr_cr , wrap_c); | |
3309 | 4512 if(!s->chroma_y_shift){ /* 422 */ |
4513 if(!skip_dct[6]) get_vissual_weight(weight[6], ptr_cb + (dct_offset>>1), wrap_c); | |
4514 if(!skip_dct[7]) get_vissual_weight(weight[7], ptr_cr + (dct_offset>>1), wrap_c); | |
4515 } | |
4516 memcpy(orig[0], s->block[0], sizeof(DCTELEM)*64*mb_block_count); | |
294 | 4517 } |
2967 | 4518 |
294 | 4519 /* DCT & quantize */ |
1778 | 4520 assert(s->out_format!=FMT_MJPEG || s->qscale==8); |
4521 { | |
3309 | 4522 for(i=0;i<mb_block_count;i++) { |
456 | 4523 if(!skip_dct[i]){ |
4524 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
|
4525 s->block_last_index[i] = s->dct_quantize(s, s->block[i], i, s->qscale, &overflow); |
344 | 4526 // 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
|
4527 // 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
|
4528 // of improve it. Just INTRADC clipping deserves changes in quantizer |
456 | 4529 if (overflow) clip_coeffs(s, s->block[i], s->block_last_index[i]); |
4530 }else | |
4531 s->block_last_index[i]= -1; | |
344 | 4532 } |
1777 | 4533 if(s->avctx->quantizer_noise_shaping){ |
3309 | 4534 for(i=0;i<mb_block_count;i++) { |
1777 | 4535 if(!skip_dct[i]){ |
4536 s->block_last_index[i] = dct_quantize_refine(s, s->block[i], weight[i], orig[i], i, s->qscale); | |
4537 } | |
4538 } | |
4539 } | |
2967 | 4540 |
456 | 4541 if(s->luma_elim_threshold && !s->mb_intra) |
4542 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
|
4543 dct_single_coeff_elimination(s, i, s->luma_elim_threshold); |
456 | 4544 if(s->chroma_elim_threshold && !s->mb_intra) |
3309 | 4545 for(i=4; i<mb_block_count; i++) |
605
40874804a5af
same dc skip behavior for chroma & luma elimination, its confusing otherwise imho
michaelni
parents:
604
diff
changeset
|
4546 dct_single_coeff_elimination(s, i, s->chroma_elim_threshold); |
1497 | 4547 |
4548 if(s->flags & CODEC_FLAG_CBP_RD){ | |
3309 | 4549 for(i=0;i<mb_block_count;i++) { |
1497 | 4550 if(s->block_last_index[i] == -1) |
4551 s->coded_score[i]= INT_MAX/256; | |
4552 } | |
4553 } | |
294 | 4554 } |
4555 | |
487 | 4556 if((s->flags&CODEC_FLAG_GRAY) && s->mb_intra){ |
4557 s->block_last_index[4]= | |
4558 s->block_last_index[5]= 0; | |
4559 s->block[4][0]= | |
1011 | 4560 s->block[5][0]= (1024 + s->c_dc_scale/2)/ s->c_dc_scale; |
487 | 4561 } |
4562 | |
1708 | 4563 //non c quantize code returns incorrect block_last_index FIXME |
4564 if(s->alternate_scan && s->dct_quantize != dct_quantize_c){ | |
3309 | 4565 for(i=0; i<mb_block_count; i++){ |
1708 | 4566 int j; |
4567 if(s->block_last_index[i]>0){ | |
4568 for(j=63; j>0; j--){ | |
4569 if(s->block[i][ s->intra_scantable.permutated[j] ]) break; | |
4570 } | |
4571 s->block_last_index[i]= j; | |
4572 } | |
4573 } | |
4574 } | |
4575 | |
294 | 4576 /* huffman encode */ |
936 | 4577 switch(s->codec_id){ //FIXME funct ptr could be slightly faster |
4578 case CODEC_ID_MPEG1VIDEO: | |
1421 | 4579 case CODEC_ID_MPEG2VIDEO: |
936 | 4580 mpeg1_encode_mb(s, s->block, motion_x, motion_y); break; |
4581 case CODEC_ID_MPEG4: | |
4582 mpeg4_encode_mb(s, s->block, motion_x, motion_y); break; | |
4583 case CODEC_ID_MSMPEG4V2: | |
4584 case CODEC_ID_MSMPEG4V3: | |
4585 case CODEC_ID_WMV1: | |
4967
6d45158e0249
disable reference to msmpeg4 and wmv2 code when those codecs are not compiled in
aurel
parents:
4668
diff
changeset
|
4586 if (ENABLE_MSMPEG4_ENCODER) |
4976 | 4587 msmpeg4_encode_mb(s, s->block, motion_x, motion_y); |
4588 break; | |
936 | 4589 case CODEC_ID_WMV2: |
4967
6d45158e0249
disable reference to msmpeg4 and wmv2 code when those codecs are not compiled in
aurel
parents:
4668
diff
changeset
|
4590 if (ENABLE_WMV2_ENCODER) |
4976 | 4591 ff_wmv2_encode_mb(s, s->block, motion_x, motion_y); |
4592 break; | |
2327
5e5cf598a48b
H.261 encoder by (Maarten Daniels <maarten dot daniels at luc dot ac dot be>)
michael
parents:
2298
diff
changeset
|
4593 case CODEC_ID_H261: |
4997 | 4594 if (ENABLE_H261_ENCODER) |
4998 | 4595 ff_h261_encode_mb(s, s->block, motion_x, motion_y); |
4596 break; | |
936 | 4597 case CODEC_ID_H263: |
4598 case CODEC_ID_H263P: | |
1353
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1344
diff
changeset
|
4599 case CODEC_ID_FLV1: |
936 | 4600 case CODEC_ID_RV10: |
2380 | 4601 case CODEC_ID_RV20: |
936 | 4602 h263_encode_mb(s, s->block, motion_x, motion_y); break; |
1042 | 4603 case CODEC_ID_MJPEG: |
4995 | 4604 if (ENABLE_MJPEG_ENCODER) |
5029
dbaa06366c3c
add a proper prefix to all mjpeg encoder exported functions
aurel
parents:
5028
diff
changeset
|
4605 ff_mjpeg_encode_mb(s, s->block); |
4996 | 4606 break; |
936 | 4607 default: |
4608 assert(0); | |
294 | 4609 } |
4610 } | |
4611 | |
4283
d6f83e2f8804
rename always_inline to av_always_inline and move to common.h
mru
parents:
4281
diff
changeset
|
4612 static av_always_inline void encode_mb(MpegEncContext *s, int motion_x, int motion_y) |
3309 | 4613 { |
4614 if (s->chroma_format == CHROMA_420) encode_mb_internal(s, motion_x, motion_y, 8, 6); | |
4615 else encode_mb_internal(s, motion_x, motion_y, 16, 8); | |
4616 } | |
4617 | |
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
|
4618 #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
|
4619 |
1368 | 4620 void ff_mpeg_flush(AVCodecContext *avctx){ |
4621 int i; | |
4622 MpegEncContext *s = avctx->priv_data; | |
2967 | 4623 |
4624 if(s==NULL || s->picture==NULL) | |
1751 | 4625 return; |
2967 | 4626 |
1368 | 4627 for(i=0; i<MAX_PICTURE_COUNT; i++){ |
4628 if(s->picture[i].data[0] && ( s->picture[i].type == FF_BUFFER_TYPE_INTERNAL | |
4629 || s->picture[i].type == FF_BUFFER_TYPE_USER)) | |
4630 avctx->release_buffer(avctx, (AVFrame*)&s->picture[i]); | |
4631 } | |
1601 | 4632 s->current_picture_ptr = s->last_picture_ptr = s->next_picture_ptr = NULL; |
2967 | 4633 |
2380 | 4634 s->mb_x= s->mb_y= 0; |
2967 | 4635 |
1395 | 4636 s->parse_context.state= -1; |
4637 s->parse_context.frame_start_found= 0; | |
4638 s->parse_context.overread= 0; | |
4639 s->parse_context.overread_index= 0; | |
4640 s->parse_context.index= 0; | |
4641 s->parse_context.last_index= 0; | |
1851 | 4642 s->bitstream_buffer_size=0; |
4346 | 4643 s->pp_time=0; |
1368 | 4644 } |
4645 | |
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
|
4646 #ifdef CONFIG_ENCODERS |
1064 | 4647 void ff_copy_bits(PutBitContext *pb, uint8_t *src, int length) |
294 | 4648 { |
1810 | 4649 const uint16_t *srcw= (uint16_t*)src; |
1799 | 4650 int words= length>>4; |
326 | 4651 int bits= length&15; |
4652 int i; | |
4653 | |
456 | 4654 if(length==0) return; |
2967 | 4655 |
1803 | 4656 if(words < 16){ |
4657 for(i=0; i<words; i++) put_bits(pb, 16, be2me_16(srcw[i])); | |
4658 }else if(put_bits_count(pb)&7){ | |
4659 for(i=0; i<words; i++) put_bits(pb, 16, be2me_16(srcw[i])); | |
1802
e91dbb5b1a8d
activate the memcpy special case for the byte aligned case in ff_copy_bits(), wasnt working before because of a incorrectly used pbBufPtr()
michael
parents:
1801
diff
changeset
|
4660 }else{ |
1803 | 4661 for(i=0; put_bits_count(pb)&31; i++) |
4662 put_bits(pb, 8, src[i]); | |
1799 | 4663 flush_put_bits(pb); |
1803 | 4664 memcpy(pbBufPtr(pb), src+i, 2*words-i); |
4665 skip_put_bytes(pb, 2*words-i); | |
1802
e91dbb5b1a8d
activate the memcpy special case for the byte aligned case in ff_copy_bits(), wasnt working before because of a incorrectly used pbBufPtr()
michael
parents:
1801
diff
changeset
|
4666 } |
2967 | 4667 |
1803 | 4668 put_bits(pb, bits, be2me_16(srcw[words])>>(16-bits)); |
0 | 4669 } |
4670 | |
456 | 4671 static inline void copy_context_before_encode(MpegEncContext *d, MpegEncContext *s, int type){ |
326 | 4672 int i; |
4673 | |
4674 memcpy(d->last_mv, s->last_mv, 2*2*2*sizeof(int)); //FIXME is memcpy faster then a loop? | |
4675 | |
4676 /* mpeg1 */ | |
1160 | 4677 d->mb_skip_run= s->mb_skip_run; |
326 | 4678 for(i=0; i<3; i++) |
4679 d->last_dc[i]= s->last_dc[i]; | |
2967 | 4680 |
326 | 4681 /* statistics */ |
4682 d->mv_bits= s->mv_bits; | |
4683 d->i_tex_bits= s->i_tex_bits; | |
4684 d->p_tex_bits= s->p_tex_bits; | |
4685 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
|
4686 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
|
4687 d->b_count= s->b_count; |
326 | 4688 d->skip_count= s->skip_count; |
4689 d->misc_bits= s->misc_bits; | |
329 | 4690 d->last_bits= 0; |
327 | 4691 |
2628
511e3afc43e1
Ministry of English Composition, reporting for duty (and the word is "skipped", not "skiped"; "skiped" would rhyme with "hyped")
melanson
parents:
2627
diff
changeset
|
4692 d->mb_skipped= 0; |
912 | 4693 d->qscale= s->qscale; |
1616 | 4694 d->dquant= s->dquant; |
326 | 4695 } |
4696 | |
456 | 4697 static inline void copy_context_after_encode(MpegEncContext *d, MpegEncContext *s, int type){ |
326 | 4698 int i; |
4699 | |
2967 | 4700 memcpy(d->mv, s->mv, 2*4*2*sizeof(int)); |
326 | 4701 memcpy(d->last_mv, s->last_mv, 2*2*2*sizeof(int)); //FIXME is memcpy faster then a loop? |
2967 | 4702 |
326 | 4703 /* mpeg1 */ |
1160 | 4704 d->mb_skip_run= s->mb_skip_run; |
326 | 4705 for(i=0; i<3; i++) |
4706 d->last_dc[i]= s->last_dc[i]; | |
2967 | 4707 |
326 | 4708 /* statistics */ |
4709 d->mv_bits= s->mv_bits; | |
4710 d->i_tex_bits= s->i_tex_bits; | |
4711 d->p_tex_bits= s->p_tex_bits; | |
4712 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
|
4713 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
|
4714 d->b_count= s->b_count; |
326 | 4715 d->skip_count= s->skip_count; |
4716 d->misc_bits= s->misc_bits; | |
4717 | |
4718 d->mb_intra= s->mb_intra; | |
2628
511e3afc43e1
Ministry of English Composition, reporting for duty (and the word is "skipped", not "skiped"; "skiped" would rhyme with "hyped")
melanson
parents:
2627
diff
changeset
|
4719 d->mb_skipped= s->mb_skipped; |
326 | 4720 d->mv_type= s->mv_type; |
4721 d->mv_dir= s->mv_dir; | |
4722 d->pb= s->pb; | |
456 | 4723 if(s->data_partitioning){ |
4724 d->pb2= s->pb2; | |
4725 d->tex_pb= s->tex_pb; | |
4726 } | |
326 | 4727 d->block= s->block; |
3309 | 4728 for(i=0; i<8; i++) |
326 | 4729 d->block_last_index[i]= s->block_last_index[i]; |
755 | 4730 d->interlaced_dct= s->interlaced_dct; |
912 | 4731 d->qscale= s->qscale; |
326 | 4732 } |
4733 | |
2967 | 4734 static inline void encode_mb_hq(MpegEncContext *s, MpegEncContext *backup, MpegEncContext *best, int type, |
456 | 4735 PutBitContext pb[2], PutBitContext pb2[2], PutBitContext tex_pb[2], |
4736 int *dmin, int *next_block, int motion_x, int motion_y) | |
4737 { | |
1389 | 4738 int score; |
4739 uint8_t *dest_backup[3]; | |
2967 | 4740 |
456 | 4741 copy_context_before_encode(s, backup, type); |
4742 | |
4743 s->block= s->blocks[*next_block]; | |
4744 s->pb= pb[*next_block]; | |
4745 if(s->data_partitioning){ | |
4746 s->pb2 = pb2 [*next_block]; | |
4747 s->tex_pb= tex_pb[*next_block]; | |
4748 } | |
2967 | 4749 |
1389 | 4750 if(*next_block){ |
4751 memcpy(dest_backup, s->dest, sizeof(s->dest)); | |
1799 | 4752 s->dest[0] = s->rd_scratchpad; |
4753 s->dest[1] = s->rd_scratchpad + 16*s->linesize; | |
4754 s->dest[2] = s->rd_scratchpad + 16*s->linesize + 8; | |
4755 assert(s->linesize >= 32); //FIXME | |
1389 | 4756 } |
456 | 4757 |
4758 encode_mb(s, motion_x, motion_y); | |
2967 | 4759 |
1786 | 4760 score= put_bits_count(&s->pb); |
456 | 4761 if(s->data_partitioning){ |
1786 | 4762 score+= put_bits_count(&s->pb2); |
4763 score+= put_bits_count(&s->tex_pb); | |
456 | 4764 } |
2967 | 4765 |
1389 | 4766 if(s->avctx->mb_decision == FF_MB_DECISION_RD){ |
4767 MPV_decode_mb(s, s->block); | |
4768 | |
1505
010f76d07a27
use lagrange multipler instead of qp for ratecontrol, this may break some things, tell me ASAP if u notice anything broken
michaelni
parents:
1497
diff
changeset
|
4769 score *= s->lambda2; |
010f76d07a27
use lagrange multipler instead of qp for ratecontrol, this may break some things, tell me ASAP if u notice anything broken
michaelni
parents:
1497
diff
changeset
|
4770 score += sse_mb(s) << FF_LAMBDA_SHIFT; |
1389 | 4771 } |
2967 | 4772 |
1389 | 4773 if(*next_block){ |
4774 memcpy(s->dest, dest_backup, sizeof(s->dest)); | |
4775 } | |
4776 | |
4777 if(score<*dmin){ | |
4778 *dmin= score; | |
456 | 4779 *next_block^=1; |
4780 | |
4781 copy_context_after_encode(best, s, type); | |
4782 } | |
4783 } | |
2967 | 4784 |
1389 | 4785 static int sse(MpegEncContext *s, uint8_t *src1, uint8_t *src2, int w, int h, int stride){ |
4179 | 4786 uint32_t *sq = ff_squareTbl + 256; |
909
8ae1e4c24e91
new PSNR code (now works with chroma, b frames, ...)
michaelni
parents:
903
diff
changeset
|
4787 int acc=0; |
8ae1e4c24e91
new PSNR code (now works with chroma, b frames, ...)
michaelni
parents:
903
diff
changeset
|
4788 int x,y; |
2967 | 4789 |
4790 if(w==16 && h==16) | |
1708 | 4791 return s->dsp.sse[0](NULL, src1, src2, stride, 16); |
936 | 4792 else if(w==8 && h==8) |
1708 | 4793 return s->dsp.sse[1](NULL, src1, src2, stride, 8); |
2967 | 4794 |
909
8ae1e4c24e91
new PSNR code (now works with chroma, b frames, ...)
michaelni
parents:
903
diff
changeset
|
4795 for(y=0; y<h; y++){ |
8ae1e4c24e91
new PSNR code (now works with chroma, b frames, ...)
michaelni
parents:
903
diff
changeset
|
4796 for(x=0; x<w; x++){ |
8ae1e4c24e91
new PSNR code (now works with chroma, b frames, ...)
michaelni
parents:
903
diff
changeset
|
4797 acc+= sq[src1[x + y*stride] - src2[x + y*stride]]; |
2967 | 4798 } |
4799 } | |
4800 | |
936 | 4801 assert(acc>=0); |
2967 | 4802 |
909
8ae1e4c24e91
new PSNR code (now works with chroma, b frames, ...)
michaelni
parents:
903
diff
changeset
|
4803 return acc; |
8ae1e4c24e91
new PSNR code (now works with chroma, b frames, ...)
michaelni
parents:
903
diff
changeset
|
4804 } |
326 | 4805 |
1389 | 4806 static int sse_mb(MpegEncContext *s){ |
4807 int w= 16; | |
4808 int h= 16; | |
4809 | |
4810 if(s->mb_x*16 + 16 > s->width ) w= s->width - s->mb_x*16; | |
4811 if(s->mb_y*16 + 16 > s->height) h= s->height- s->mb_y*16; | |
4812 | |
4813 if(w==16 && h==16) | |
2065
9e4bebc39ade
noise preserving sum of squares comparission function
michael
parents:
2063
diff
changeset
|
4814 if(s->avctx->mb_cmp == FF_CMP_NSSE){ |
2066 | 4815 return s->dsp.nsse[0](s, s->new_picture.data[0] + s->mb_x*16 + s->mb_y*s->linesize*16, s->dest[0], s->linesize, 16) |
4816 +s->dsp.nsse[1](s, s->new_picture.data[1] + s->mb_x*8 + s->mb_y*s->uvlinesize*8,s->dest[1], s->uvlinesize, 8) | |
4817 +s->dsp.nsse[1](s, s->new_picture.data[2] + s->mb_x*8 + s->mb_y*s->uvlinesize*8,s->dest[2], s->uvlinesize, 8); | |
2065
9e4bebc39ade
noise preserving sum of squares comparission function
michael
parents:
2063
diff
changeset
|
4818 }else{ |
1708 | 4819 return s->dsp.sse[0](NULL, s->new_picture.data[0] + s->mb_x*16 + s->mb_y*s->linesize*16, s->dest[0], s->linesize, 16) |
4820 +s->dsp.sse[1](NULL, s->new_picture.data[1] + s->mb_x*8 + s->mb_y*s->uvlinesize*8,s->dest[1], s->uvlinesize, 8) | |
4821 +s->dsp.sse[1](NULL, s->new_picture.data[2] + s->mb_x*8 + s->mb_y*s->uvlinesize*8,s->dest[2], s->uvlinesize, 8); | |
2065
9e4bebc39ade
noise preserving sum of squares comparission function
michael
parents:
2063
diff
changeset
|
4822 } |
1389 | 4823 else |
4824 return sse(s, s->new_picture.data[0] + s->mb_x*16 + s->mb_y*s->linesize*16, s->dest[0], w, h, s->linesize) | |
4825 +sse(s, s->new_picture.data[1] + s->mb_x*8 + s->mb_y*s->uvlinesize*8,s->dest[1], w>>1, h>>1, s->uvlinesize) | |
4826 +sse(s, s->new_picture.data[2] + s->mb_x*8 + s->mb_y*s->uvlinesize*8,s->dest[2], w>>1, h>>1, s->uvlinesize); | |
4827 } | |
4828 | |
1799 | 4829 static int pre_estimate_motion_thread(AVCodecContext *c, void *arg){ |
4830 MpegEncContext *s= arg; | |
4831 | |
2967 | 4832 |
1799 | 4833 s->me.pre_pass=1; |
4834 s->me.dia_size= s->avctx->pre_dia_size; | |
4835 s->first_slice_line=1; | |
4836 for(s->mb_y= s->end_mb_y-1; s->mb_y >= s->start_mb_y; s->mb_y--) { | |
4837 for(s->mb_x=s->mb_width-1; s->mb_x >=0 ;s->mb_x--) { | |
4838 ff_pre_estimate_p_frame_motion(s, s->mb_x, s->mb_y); | |
4839 } | |
4840 s->first_slice_line=0; | |
4841 } | |
2967 | 4842 |
1799 | 4843 s->me.pre_pass=0; |
2967 | 4844 |
1799 | 4845 return 0; |
4846 } | |
4847 | |
4848 static int estimate_motion_thread(AVCodecContext *c, void *arg){ | |
4849 MpegEncContext *s= arg; | |
4850 | |
4281
de525a2b41db
ff_check_alignment to warn the user about a missaligned stack
michael
parents:
4274
diff
changeset
|
4851 ff_check_alignment(); |
de525a2b41db
ff_check_alignment to warn the user about a missaligned stack
michael
parents:
4274
diff
changeset
|
4852 |
1799 | 4853 s->me.dia_size= s->avctx->dia_size; |
4854 s->first_slice_line=1; | |
4855 for(s->mb_y= s->start_mb_y; s->mb_y < s->end_mb_y; s->mb_y++) { | |
4856 s->mb_x=0; //for block init below | |
4857 ff_init_block_index(s); | |
4858 for(s->mb_x=0; s->mb_x < s->mb_width; s->mb_x++) { | |
4859 s->block_index[0]+=2; | |
4860 s->block_index[1]+=2; | |
4861 s->block_index[2]+=2; | |
4862 s->block_index[3]+=2; | |
2967 | 4863 |
1799 | 4864 /* compute motion vector & mb_type and store in context */ |
4865 if(s->pict_type==B_TYPE) | |
4866 ff_estimate_b_frame_motion(s, s->mb_x, s->mb_y); | |
4867 else | |
4868 ff_estimate_p_frame_motion(s, s->mb_x, s->mb_y); | |
4869 } | |
4870 s->first_slice_line=0; | |
4871 } | |
4872 return 0; | |
4873 } | |
4874 | |
1804
cc0a15943a87
multithreaded spatial complexity calculation for i frames
michael
parents:
1803
diff
changeset
|
4875 static int mb_var_thread(AVCodecContext *c, void *arg){ |
cc0a15943a87
multithreaded spatial complexity calculation for i frames
michael
parents:
1803
diff
changeset
|
4876 MpegEncContext *s= arg; |
cc0a15943a87
multithreaded spatial complexity calculation for i frames
michael
parents:
1803
diff
changeset
|
4877 int mb_x, mb_y; |
cc0a15943a87
multithreaded spatial complexity calculation for i frames
michael
parents:
1803
diff
changeset
|
4878 |
4281
de525a2b41db
ff_check_alignment to warn the user about a missaligned stack
michael
parents:
4274
diff
changeset
|
4879 ff_check_alignment(); |
de525a2b41db
ff_check_alignment to warn the user about a missaligned stack
michael
parents:
4274
diff
changeset
|
4880 |
1804
cc0a15943a87
multithreaded spatial complexity calculation for i frames
michael
parents:
1803
diff
changeset
|
4881 for(mb_y=s->start_mb_y; mb_y < s->end_mb_y; mb_y++) { |
cc0a15943a87
multithreaded spatial complexity calculation for i frames
michael
parents:
1803
diff
changeset
|
4882 for(mb_x=0; mb_x < s->mb_width; mb_x++) { |
cc0a15943a87
multithreaded spatial complexity calculation for i frames
michael
parents:
1803
diff
changeset
|
4883 int xx = mb_x * 16; |
cc0a15943a87
multithreaded spatial complexity calculation for i frames
michael
parents:
1803
diff
changeset
|
4884 int yy = mb_y * 16; |
cc0a15943a87
multithreaded spatial complexity calculation for i frames
michael
parents:
1803
diff
changeset
|
4885 uint8_t *pix = s->new_picture.data[0] + (yy * s->linesize) + xx; |
cc0a15943a87
multithreaded spatial complexity calculation for i frames
michael
parents:
1803
diff
changeset
|
4886 int varc; |
cc0a15943a87
multithreaded spatial complexity calculation for i frames
michael
parents:
1803
diff
changeset
|
4887 int sum = s->dsp.pix_sum(pix, s->linesize); |
2967 | 4888 |
1804
cc0a15943a87
multithreaded spatial complexity calculation for i frames
michael
parents:
1803
diff
changeset
|
4889 varc = (s->dsp.pix_norm1(pix, s->linesize) - (((unsigned)(sum*sum))>>8) + 500 + 128)>>8; |
cc0a15943a87
multithreaded spatial complexity calculation for i frames
michael
parents:
1803
diff
changeset
|
4890 |
cc0a15943a87
multithreaded spatial complexity calculation for i frames
michael
parents:
1803
diff
changeset
|
4891 s->current_picture.mb_var [s->mb_stride * mb_y + mb_x] = varc; |
cc0a15943a87
multithreaded spatial complexity calculation for i frames
michael
parents:
1803
diff
changeset
|
4892 s->current_picture.mb_mean[s->mb_stride * mb_y + mb_x] = (sum+128)>>8; |
2015
3ab8f3e2ae6a
moving motion estimation specific variables from MpegEncContext -> MotionEstContext
michael
parents:
1994
diff
changeset
|
4893 s->me.mb_var_sum_temp += varc; |
1804
cc0a15943a87
multithreaded spatial complexity calculation for i frames
michael
parents:
1803
diff
changeset
|
4894 } |
cc0a15943a87
multithreaded spatial complexity calculation for i frames
michael
parents:
1803
diff
changeset
|
4895 } |
1805
5dd5b2052f5b
mpeg4 b frame + adaptive quantization assertion failure fix
michael
parents:
1804
diff
changeset
|
4896 return 0; |
1804
cc0a15943a87
multithreaded spatial complexity calculation for i frames
michael
parents:
1803
diff
changeset
|
4897 } |
cc0a15943a87
multithreaded spatial complexity calculation for i frames
michael
parents:
1803
diff
changeset
|
4898 |
1799 | 4899 static void write_slice_end(MpegEncContext *s){ |
4900 if(s->codec_id==CODEC_ID_MPEG4){ | |
4901 if(s->partitioned_frame){ | |
4902 ff_mpeg4_merge_partitions(s); | |
4903 } | |
2967 | 4904 |
1799 | 4905 ff_mpeg4_stuffing(&s->pb); |
4995 | 4906 }else if(ENABLE_MJPEG_ENCODER && s->out_format == FMT_MJPEG){ |
5029
dbaa06366c3c
add a proper prefix to all mjpeg encoder exported functions
aurel
parents:
5028
diff
changeset
|
4907 ff_mjpeg_encode_stuffing(&s->pb); |
1799 | 4908 } |
4909 | |
4910 align_put_bits(&s->pb); | |
4911 flush_put_bits(&s->pb); | |
2967 | 4912 |
2428
548c87c06dbb
assertion about bits statistic and minor bits stat fix
michael
parents:
2427
diff
changeset
|
4913 if((s->flags&CODEC_FLAG_PASS1) && !s->partitioned_frame) |
548c87c06dbb
assertion about bits statistic and minor bits stat fix
michael
parents:
2427
diff
changeset
|
4914 s->misc_bits+= get_bits_diff(s); |
1799 | 4915 } |
4916 | |
4917 static int encode_thread(AVCodecContext *c, void *arg){ | |
4918 MpegEncContext *s= arg; | |
766 | 4919 int mb_x, mb_y, pdif = 0; |
1708 | 4920 int i, j; |
326 | 4921 MpegEncContext best_s, backup_s; |
2422 | 4922 uint8_t bit_buf[2][MAX_MB_BYTES]; |
4923 uint8_t bit_buf2[2][MAX_MB_BYTES]; | |
4924 uint8_t bit_buf_tex[2][MAX_MB_BYTES]; | |
456 | 4925 PutBitContext pb[2], pb2[2], tex_pb[2]; |
1799 | 4926 //printf("%d->%d\n", s->resync_mb_y, s->end_mb_y); |
456 | 4927 |
4281
de525a2b41db
ff_check_alignment to warn the user about a missaligned stack
michael
parents:
4274
diff
changeset
|
4928 ff_check_alignment(); |
de525a2b41db
ff_check_alignment to warn the user about a missaligned stack
michael
parents:
4274
diff
changeset
|
4929 |
456 | 4930 for(i=0; i<2; i++){ |
2422 | 4931 init_put_bits(&pb [i], bit_buf [i], MAX_MB_BYTES); |
4932 init_put_bits(&pb2 [i], bit_buf2 [i], MAX_MB_BYTES); | |
4933 init_put_bits(&tex_pb[i], bit_buf_tex[i], MAX_MB_BYTES); | |
456 | 4934 } |
0 | 4935 |
1786 | 4936 s->last_bits= put_bits_count(&s->pb); |
286 | 4937 s->mv_bits=0; |
4938 s->misc_bits=0; | |
4939 s->i_tex_bits=0; | |
4940 s->p_tex_bits=0; | |
4941 s->i_count=0; | |
656
e47fa3e3f2d5
statistics for forw & back p-MBs instead of just one counter for both
michaelni
parents:
652
diff
changeset
|
4942 s->f_count=0; |
e47fa3e3f2d5
statistics for forw & back p-MBs instead of just one counter for both
michaelni
parents:
652
diff
changeset
|
4943 s->b_count=0; |
286 | 4944 s->skip_count=0; |
4945 | |
909
8ae1e4c24e91
new PSNR code (now works with chroma, b frames, ...)
michaelni
parents:
903
diff
changeset
|
4946 for(i=0; i<3; i++){ |
8ae1e4c24e91
new PSNR code (now works with chroma, b frames, ...)
michaelni
parents:
903
diff
changeset
|
4947 /* init last dc values */ |
8ae1e4c24e91
new PSNR code (now works with chroma, b frames, ...)
michaelni
parents:
903
diff
changeset
|
4948 /* note: quant matrix value (8) is implied here */ |
1992 | 4949 s->last_dc[i] = 128 << s->intra_dc_precision; |
2967 | 4950 |
2955 | 4951 s->current_picture.error[i] = 0; |
909
8ae1e4c24e91
new PSNR code (now works with chroma, b frames, ...)
michaelni
parents:
903
diff
changeset
|
4952 } |
1160 | 4953 s->mb_skip_run = 0; |
1708 | 4954 memset(s->last_mv, 0, sizeof(s->last_mv)); |
2967 | 4955 |
1051
e5a9dbf597d4
mpeg1 bframe encoding patch by (Rapha«³l LEGRAND) with some modifications by me
michaelni
parents:
1048
diff
changeset
|
4956 s->last_mv_dir = 0; |
0 | 4957 |
1353
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1344
diff
changeset
|
4958 switch(s->codec_id){ |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1344
diff
changeset
|
4959 case CODEC_ID_H263: |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1344
diff
changeset
|
4960 case CODEC_ID_H263P: |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1344
diff
changeset
|
4961 case CODEC_ID_FLV1: |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
731
diff
changeset
|
4962 s->gob_index = ff_h263_get_gob_height(s); |
1353
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1344
diff
changeset
|
4963 break; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1344
diff
changeset
|
4964 case CODEC_ID_MPEG4: |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1344
diff
changeset
|
4965 if(s->partitioned_frame) |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1344
diff
changeset
|
4966 ff_mpeg4_init_partitions(s); |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1344
diff
changeset
|
4967 break; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1344
diff
changeset
|
4968 } |
456 | 4969 |
4970 s->resync_mb_x=0; | |
2967 | 4971 s->resync_mb_y=0; |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
731
diff
changeset
|
4972 s->first_slice_line = 1; |
766 | 4973 s->ptr_lastgob = s->pb.buf; |
1799 | 4974 for(mb_y= s->start_mb_y; mb_y < s->end_mb_y; mb_y++) { |
4975 // printf("row %d at %X\n", s->mb_y, (int)s); | |
1389 | 4976 s->mb_x=0; |
4977 s->mb_y= mb_y; | |
4978 | |
1652 | 4979 ff_set_qscale(s, s->qscale); |
1389 | 4980 ff_init_block_index(s); |
2967 | 4981 |
232
b640ec5948b0
- Now the ME is done for the entire picture when enconding, the
pulento
parents:
231
diff
changeset
|
4982 for(mb_x=0; mb_x < s->mb_width; mb_x++) { |
2327
5e5cf598a48b
H.261 encoder by (Maarten Daniels <maarten dot daniels at luc dot ac dot be>)
michael
parents:
2298
diff
changeset
|
4983 int xy= mb_y*s->mb_stride + mb_x; // removed const, H261 needs to adjust this |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1173
diff
changeset
|
4984 int mb_type= s->mb_type[xy]; |
456 | 4985 // int d; |
1389 | 4986 int dmin= INT_MAX; |
1708 | 4987 int dir; |
0 | 4988 |
2422 | 4989 if(s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb)>>3) < MAX_MB_BYTES){ |
4990 av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n"); | |
4991 return -1; | |
4992 } | |
4993 if(s->data_partitioning){ | |
4994 if( s->pb2 .buf_end - s->pb2 .buf - (put_bits_count(&s-> pb2)>>3) < MAX_MB_BYTES | |
4995 || s->tex_pb.buf_end - s->tex_pb.buf - (put_bits_count(&s->tex_pb )>>3) < MAX_MB_BYTES){ | |
4996 av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n"); | |
4997 return -1; | |
4998 } | |
4999 } | |
5000 | |
232
b640ec5948b0
- Now the ME is done for the entire picture when enconding, the
pulento
parents:
231
diff
changeset
|
5001 s->mb_x = mb_x; |
2327
5e5cf598a48b
H.261 encoder by (Maarten Daniels <maarten dot daniels at luc dot ac dot be>)
michael
parents:
2298
diff
changeset
|
5002 s->mb_y = mb_y; // moved into loop, can get changed by H.261 |
1389 | 5003 ff_update_block_index(s); |
456 | 5004 |
4997 | 5005 if(ENABLE_H261_ENCODER && s->codec_id == CODEC_ID_H261){ |
2327
5e5cf598a48b
H.261 encoder by (Maarten Daniels <maarten dot daniels at luc dot ac dot be>)
michael
parents:
2298
diff
changeset
|
5006 ff_h261_reorder_mb_index(s); |
5e5cf598a48b
H.261 encoder by (Maarten Daniels <maarten dot daniels at luc dot ac dot be>)
michael
parents:
2298
diff
changeset
|
5007 xy= s->mb_y*s->mb_stride + s->mb_x; |
2345 | 5008 mb_type= s->mb_type[xy]; |
2327
5e5cf598a48b
H.261 encoder by (Maarten Daniels <maarten dot daniels at luc dot ac dot be>)
michael
parents:
2298
diff
changeset
|
5009 } |
5e5cf598a48b
H.261 encoder by (Maarten Daniels <maarten dot daniels at luc dot ac dot be>)
michael
parents:
2298
diff
changeset
|
5010 |
766 | 5011 /* write gob / video packet header */ |
1661 | 5012 if(s->rtp_mode){ |
766 | 5013 int current_packet_size, is_gob_start; |
2967 | 5014 |
1801
3f26dfb3eba4
replace a few pbBufPtr() by put_bits_count(), one of them was actually wrong
michael
parents:
1799
diff
changeset
|
5015 current_packet_size= ((put_bits_count(&s->pb)+7)>>3) - (s->ptr_lastgob - s->pb.buf); |
2967 | 5016 |
5017 is_gob_start= s->avctx->rtp_payload_size && current_packet_size >= s->avctx->rtp_payload_size && mb_y + mb_x>0; | |
5018 | |
1799 | 5019 if(s->start_mb_y == mb_y && mb_y > 0 && mb_x==0) is_gob_start=1; |
2967 | 5020 |
1661 | 5021 switch(s->codec_id){ |
5022 case CODEC_ID_H263: | |
5023 case CODEC_ID_H263P: | |
5024 if(!s->h263_slice_structured) | |
5025 if(s->mb_x || s->mb_y%s->gob_index) is_gob_start=0; | |
5026 break; | |
5027 case CODEC_ID_MPEG2VIDEO: | |
5028 if(s->mb_x==0 && s->mb_y!=0) is_gob_start=1; | |
5029 case CODEC_ID_MPEG1VIDEO: | |
5030 if(s->mb_skip_run) is_gob_start=0; | |
5031 break; | |
5032 } | |
1799 | 5033 |
1661 | 5034 if(is_gob_start){ |
1799 | 5035 if(s->start_mb_y != mb_y || mb_x!=0){ |
5036 write_slice_end(s); | |
5037 | |
5038 if(s->codec_id==CODEC_ID_MPEG4 && s->partitioned_frame){ | |
5039 ff_mpeg4_init_partitions(s); | |
5040 } | |
1661 | 5041 } |
2967 | 5042 |
1786 | 5043 assert((put_bits_count(&s->pb)&7) == 0); |
1661 | 5044 current_packet_size= pbBufPtr(&s->pb) - s->ptr_lastgob; |
2967 | 5045 |
1688 | 5046 if(s->avctx->error_rate && s->resync_mb_x + s->resync_mb_y > 0){ |
2371 | 5047 int r= put_bits_count(&s->pb)/8 + s->picture_number + 16 + s->mb_x + s->mb_y; |
1688 | 5048 int d= 100 / s->avctx->error_rate; |
5049 if(r % d == 0){ | |
5050 current_packet_size=0; | |
5051 #ifndef ALT_BITSTREAM_WRITER | |
5052 s->pb.buf_ptr= s->ptr_lastgob; | |
5053 #endif | |
5054 assert(pbBufPtr(&s->pb) == s->ptr_lastgob); | |
5055 } | |
5056 } | |
2492
57ba17bd3924
rtp_callback: send number of mb patch by (Johan Bilien {jobi via.ecp fr)
michael
parents:
2450
diff
changeset
|
5057 |
57ba17bd3924
rtp_callback: send number of mb patch by (Johan Bilien {jobi via.ecp fr)
michael
parents:
2450
diff
changeset
|
5058 if (s->avctx->rtp_callback){ |
57ba17bd3924
rtp_callback: send number of mb patch by (Johan Bilien {jobi via.ecp fr)
michael
parents:
2450
diff
changeset
|
5059 int number_mb = (mb_y - s->resync_mb_y)*s->mb_width + mb_x - s->resync_mb_x; |
57ba17bd3924
rtp_callback: send number of mb patch by (Johan Bilien {jobi via.ecp fr)
michael
parents:
2450
diff
changeset
|
5060 s->avctx->rtp_callback(s->avctx, s->ptr_lastgob, current_packet_size, number_mb); |
57ba17bd3924
rtp_callback: send number of mb patch by (Johan Bilien {jobi via.ecp fr)
michael
parents:
2450
diff
changeset
|
5061 } |
2967 | 5062 |
1661 | 5063 switch(s->codec_id){ |
5064 case CODEC_ID_MPEG4: | |
456 | 5065 ff_mpeg4_encode_video_packet_header(s); |
5066 ff_mpeg4_clean_buffers(s); | |
1661 | 5067 break; |
5068 case CODEC_ID_MPEG1VIDEO: | |
5069 case CODEC_ID_MPEG2VIDEO: | |
1421 | 5070 ff_mpeg1_encode_slice_header(s); |
5071 ff_mpeg1_clean_buffers(s); | |
1661 | 5072 break; |
5073 case CODEC_ID_H263: | |
5074 case CODEC_ID_H263P: | |
2967 | 5075 h263_encode_gob_header(s, mb_y); |
1661 | 5076 break; |
1160 | 5077 } |
1661 | 5078 |
5079 if(s->flags&CODEC_FLAG_PASS1){ | |
1786 | 5080 int bits= put_bits_count(&s->pb); |
1661 | 5081 s->misc_bits+= bits - s->last_bits; |
5082 s->last_bits= bits; | |
766 | 5083 } |
2967 | 5084 |
1662 | 5085 s->ptr_lastgob += current_packet_size; |
456 | 5086 s->first_slice_line=1; |
5087 s->resync_mb_x=mb_x; | |
5088 s->resync_mb_y=mb_y; | |
5089 } | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
731
diff
changeset
|
5090 } |
456 | 5091 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
731
diff
changeset
|
5092 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
|
5093 && s->resync_mb_y+1 == s->mb_y){ |
2967 | 5094 s->first_slice_line=0; |
456 | 5095 } |
5096 | |
2628
511e3afc43e1
Ministry of English Composition, reporting for duty (and the word is "skipped", not "skiped"; "skiped" would rhyme with "hyped")
melanson
parents:
2627
diff
changeset
|
5097 s->mb_skipped=0; |
1616 | 5098 s->dquant=0; //only for QP_RD |
5099 | |
2230 | 5100 if(mb_type & (mb_type-1) || (s->flags & CODEC_FLAG_QP_RD)){ // more than 1 MB type possible or CODEC_FLAG_QP_RD |
327 | 5101 int next_block=0; |
456 | 5102 int pb_bits_count, pb2_bits_count, tex_pb_bits_count; |
326 | 5103 |
5104 copy_context_before_encode(&backup_s, s, -1); | |
456 | 5105 backup_s.pb= s->pb; |
5106 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
|
5107 best_s.partitioned_frame= s->partitioned_frame; |
456 | 5108 if(s->data_partitioning){ |
5109 backup_s.pb2= s->pb2; | |
5110 backup_s.tex_pb= s->tex_pb; | |
5111 } | |
326 | 5112 |
1708 | 5113 if(mb_type&CANDIDATE_MB_TYPE_INTER){ |
327 | 5114 s->mv_dir = MV_DIR_FORWARD; |
295 | 5115 s->mv_type = MV_TYPE_16X16; |
294 | 5116 s->mb_intra= 0; |
324 | 5117 s->mv[0][0][0] = s->p_mv_table[xy][0]; |
5118 s->mv[0][0][1] = s->p_mv_table[xy][1]; | |
2967 | 5119 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER, pb, pb2, tex_pb, |
456 | 5120 &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]); |
0 | 5121 } |
2967 | 5122 if(mb_type&CANDIDATE_MB_TYPE_INTER_I){ |
1708 | 5123 s->mv_dir = MV_DIR_FORWARD; |
5124 s->mv_type = MV_TYPE_FIELD; | |
5125 s->mb_intra= 0; | |
5126 for(i=0; i<2; i++){ | |
5127 j= s->field_select[0][i] = s->p_field_select_table[i][xy]; | |
5128 s->mv[0][i][0] = s->p_field_mv_table[i][j][xy][0]; | |
5129 s->mv[0][i][1] = s->p_field_mv_table[i][j][xy][1]; | |
5130 } | |
2967 | 5131 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER_I, pb, pb2, tex_pb, |
1708 | 5132 &dmin, &next_block, 0, 0); |
5133 } | |
2628
511e3afc43e1
Ministry of English Composition, reporting for duty (and the word is "skipped", not "skiped"; "skiped" would rhyme with "hyped")
melanson
parents:
2627
diff
changeset
|
5134 if(mb_type&CANDIDATE_MB_TYPE_SKIPPED){ |
1494
3ee63c12ea30
optionally try to encode each MB with MV=<0,0> and choose the one with better RD
michaelni
parents:
1490
diff
changeset
|
5135 s->mv_dir = MV_DIR_FORWARD; |
3ee63c12ea30
optionally try to encode each MB with MV=<0,0> and choose the one with better RD
michaelni
parents:
1490
diff
changeset
|
5136 s->mv_type = MV_TYPE_16X16; |
3ee63c12ea30
optionally try to encode each MB with MV=<0,0> and choose the one with better RD
michaelni
parents:
1490
diff
changeset
|
5137 s->mb_intra= 0; |
3ee63c12ea30
optionally try to encode each MB with MV=<0,0> and choose the one with better RD
michaelni
parents:
1490
diff
changeset
|
5138 s->mv[0][0][0] = 0; |
3ee63c12ea30
optionally try to encode each MB with MV=<0,0> and choose the one with better RD
michaelni
parents:
1490
diff
changeset
|
5139 s->mv[0][0][1] = 0; |
2967 | 5140 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_SKIPPED, pb, pb2, tex_pb, |
1494
3ee63c12ea30
optionally try to encode each MB with MV=<0,0> and choose the one with better RD
michaelni
parents:
1490
diff
changeset
|
5141 &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]); |
3ee63c12ea30
optionally try to encode each MB with MV=<0,0> and choose the one with better RD
michaelni
parents:
1490
diff
changeset
|
5142 } |
2967 | 5143 if(mb_type&CANDIDATE_MB_TYPE_INTER4V){ |
327 | 5144 s->mv_dir = MV_DIR_FORWARD; |
295 | 5145 s->mv_type = MV_TYPE_8X8; |
5146 s->mb_intra= 0; | |
5147 for(i=0; i<4; i++){ | |
1668
30746f429df6
move motion_val & mb_type to AVFrame patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1662
diff
changeset
|
5148 s->mv[0][i][0] = s->current_picture.motion_val[0][s->block_index[i]][0]; |
30746f429df6
move motion_val & mb_type to AVFrame patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1662
diff
changeset
|
5149 s->mv[0][i][1] = s->current_picture.motion_val[0][s->block_index[i]][1]; |
295 | 5150 } |
2967 | 5151 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER4V, pb, pb2, tex_pb, |
456 | 5152 &dmin, &next_block, 0, 0); |
327 | 5153 } |
1708 | 5154 if(mb_type&CANDIDATE_MB_TYPE_FORWARD){ |
327 | 5155 s->mv_dir = MV_DIR_FORWARD; |
5156 s->mv_type = MV_TYPE_16X16; | |
5157 s->mb_intra= 0; | |
5158 s->mv[0][0][0] = s->b_forw_mv_table[xy][0]; | |
5159 s->mv[0][0][1] = s->b_forw_mv_table[xy][1]; | |
2967 | 5160 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_FORWARD, pb, pb2, tex_pb, |
456 | 5161 &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]); |
327 | 5162 } |
1708 | 5163 if(mb_type&CANDIDATE_MB_TYPE_BACKWARD){ |
327 | 5164 s->mv_dir = MV_DIR_BACKWARD; |
5165 s->mv_type = MV_TYPE_16X16; | |
5166 s->mb_intra= 0; | |
5167 s->mv[1][0][0] = s->b_back_mv_table[xy][0]; | |
5168 s->mv[1][0][1] = s->b_back_mv_table[xy][1]; | |
2967 | 5169 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BACKWARD, pb, pb2, tex_pb, |
456 | 5170 &dmin, &next_block, s->mv[1][0][0], s->mv[1][0][1]); |
327 | 5171 } |
1708 | 5172 if(mb_type&CANDIDATE_MB_TYPE_BIDIR){ |
327 | 5173 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD; |
5174 s->mv_type = MV_TYPE_16X16; | |
5175 s->mb_intra= 0; | |
5176 s->mv[0][0][0] = s->b_bidir_forw_mv_table[xy][0]; | |
5177 s->mv[0][0][1] = s->b_bidir_forw_mv_table[xy][1]; | |
5178 s->mv[1][0][0] = s->b_bidir_back_mv_table[xy][0]; | |
5179 s->mv[1][0][1] = s->b_bidir_back_mv_table[xy][1]; | |
2967 | 5180 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BIDIR, pb, pb2, tex_pb, |
456 | 5181 &dmin, &next_block, 0, 0); |
327 | 5182 } |
2967 | 5183 if(mb_type&CANDIDATE_MB_TYPE_FORWARD_I){ |
1708 | 5184 s->mv_dir = MV_DIR_FORWARD; |
5185 s->mv_type = MV_TYPE_FIELD; | |
5186 s->mb_intra= 0; | |
5187 for(i=0; i<2; i++){ | |
5188 j= s->field_select[0][i] = s->b_field_select_table[0][i][xy]; | |
5189 s->mv[0][i][0] = s->b_field_mv_table[0][i][j][xy][0]; | |
5190 s->mv[0][i][1] = s->b_field_mv_table[0][i][j][xy][1]; | |
5191 } | |
2967 | 5192 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_FORWARD_I, pb, pb2, tex_pb, |
1708 | 5193 &dmin, &next_block, 0, 0); |
5194 } | |
2967 | 5195 if(mb_type&CANDIDATE_MB_TYPE_BACKWARD_I){ |
1708 | 5196 s->mv_dir = MV_DIR_BACKWARD; |
5197 s->mv_type = MV_TYPE_FIELD; | |
5198 s->mb_intra= 0; | |
5199 for(i=0; i<2; i++){ | |
5200 j= s->field_select[1][i] = s->b_field_select_table[1][i][xy]; | |
5201 s->mv[1][i][0] = s->b_field_mv_table[1][i][j][xy][0]; | |
5202 s->mv[1][i][1] = s->b_field_mv_table[1][i][j][xy][1]; | |
5203 } | |
2967 | 5204 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BACKWARD_I, pb, pb2, tex_pb, |
1708 | 5205 &dmin, &next_block, 0, 0); |
5206 } | |
2967 | 5207 if(mb_type&CANDIDATE_MB_TYPE_BIDIR_I){ |
1708 | 5208 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD; |
5209 s->mv_type = MV_TYPE_FIELD; | |
5210 s->mb_intra= 0; | |
5211 for(dir=0; dir<2; dir++){ | |
5212 for(i=0; i<2; i++){ | |
5213 j= s->field_select[dir][i] = s->b_field_select_table[dir][i][xy]; | |
5214 s->mv[dir][i][0] = s->b_field_mv_table[dir][i][j][xy][0]; | |
5215 s->mv[dir][i][1] = s->b_field_mv_table[dir][i][j][xy][1]; | |
5216 } | |
5217 } | |
2967 | 5218 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BIDIR_I, pb, pb2, tex_pb, |
1708 | 5219 &dmin, &next_block, 0, 0); |
5220 } | |
5221 if(mb_type&CANDIDATE_MB_TYPE_INTRA){ | |
1051
e5a9dbf597d4
mpeg1 bframe encoding patch by (Rapha«³l LEGRAND) with some modifications by me
michaelni
parents:
1048
diff
changeset
|
5222 s->mv_dir = 0; |
295 | 5223 s->mv_type = MV_TYPE_16X16; |
294 | 5224 s->mb_intra= 1; |
5225 s->mv[0][0][0] = 0; | |
5226 s->mv[0][0][1] = 0; | |
2967 | 5227 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTRA, pb, pb2, tex_pb, |
456 | 5228 &dmin, &next_block, 0, 0); |
1389 | 5229 if(s->h263_pred || s->h263_aic){ |
5230 if(best_s.mb_intra) | |
5231 s->mbintra_table[mb_x + mb_y*s->mb_stride]=1; | |
5232 else | |
5233 ff_clean_intra_table_entries(s); //old mode? | |
5234 } | |
295 | 5235 } |
1616 | 5236 |
4317
5a2ee0bc2739
skip motion estimation and encoding of non direct-0,0 MBs if the next MB is skiped (mpeg4 doesnt allow such MBs and in the past we did ME and encoding until at the end we droped them, so this should be faster though i didnt benchmark it, benchmark welcome)
michael
parents:
4314
diff
changeset
|
5237 if((s->flags & CODEC_FLAG_QP_RD) && dmin < INT_MAX){ |
5a2ee0bc2739
skip motion estimation and encoding of non direct-0,0 MBs if the next MB is skiped (mpeg4 doesnt allow such MBs and in the past we did ME and encoding until at the end we droped them, so this should be faster though i didnt benchmark it, benchmark welcome)
michael
parents:
4314
diff
changeset
|
5238 if(best_s.mv_type==MV_TYPE_16X16){ //FIXME move 4mv after QPRD |
1616 | 5239 const int last_qp= backup_s.qscale; |
4217 | 5240 int qpi, qp, dc[6]; |
1617 | 5241 DCTELEM ac[6][16]; |
1623 | 5242 const int mvdir= (best_s.mv_dir&MV_DIR_BACKWARD) ? 1 : 0; |
4215
7583920b3217
testing all dquant for qp_rd fixes the qp runaway to 31 bug
michael
parents:
4206
diff
changeset
|
5243 static const int dquant_tab[4]={-1,1,-2,2}; |
2967 | 5244 |
1616 | 5245 assert(backup_s.dquant == 0); |
5246 | |
5247 //FIXME intra | |
5248 s->mv_dir= best_s.mv_dir; | |
5249 s->mv_type = MV_TYPE_16X16; | |
5250 s->mb_intra= best_s.mb_intra; | |
5251 s->mv[0][0][0] = best_s.mv[0][0][0]; | |
5252 s->mv[0][0][1] = best_s.mv[0][0][1]; | |
5253 s->mv[1][0][0] = best_s.mv[1][0][0]; | |
5254 s->mv[1][0][1] = best_s.mv[1][0][1]; | |
2967 | 5255 |
4215
7583920b3217
testing all dquant for qp_rd fixes the qp runaway to 31 bug
michael
parents:
4206
diff
changeset
|
5256 qpi = s->pict_type == B_TYPE ? 2 : 0; |
4217 | 5257 for(; qpi<4; qpi++){ |
5258 int dquant= dquant_tab[qpi]; | |
1616 | 5259 qp= last_qp + dquant; |
5260 if(qp < s->avctx->qmin || qp > s->avctx->qmax) | |
4215
7583920b3217
testing all dquant for qp_rd fixes the qp runaway to 31 bug
michael
parents:
4206
diff
changeset
|
5261 continue; |
1616 | 5262 backup_s.dquant= dquant; |
2229 | 5263 if(s->mb_intra && s->dc_val[0]){ |
1617 | 5264 for(i=0; i<6; i++){ |
5265 dc[i]= s->dc_val[0][ s->block_index[i] ]; | |
5266 memcpy(ac[i], s->ac_val[0][s->block_index[i]], sizeof(DCTELEM)*16); | |
5267 } | |
1616 | 5268 } |
1617 | 5269 |
2967 | 5270 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER /* wrong but unused */, pb, pb2, tex_pb, |
1623 | 5271 &dmin, &next_block, s->mv[mvdir][0][0], s->mv[mvdir][0][1]); |
1616 | 5272 if(best_s.qscale != qp){ |
2229 | 5273 if(s->mb_intra && s->dc_val[0]){ |
1617 | 5274 for(i=0; i<6; i++){ |
5275 s->dc_val[0][ s->block_index[i] ]= dc[i]; | |
5276 memcpy(s->ac_val[0][s->block_index[i]], ac[i], sizeof(DCTELEM)*16); | |
5277 } | |
1616 | 5278 } |
5279 } | |
5280 } | |
5281 } | |
5282 } | |
4314
5ed8f8fd71e9
try direct mode MB after QPRD, slight PSNR/bitrate gain if b frames + QPRD
michael
parents:
4283
diff
changeset
|
5283 if(mb_type&CANDIDATE_MB_TYPE_DIRECT){ |
5ed8f8fd71e9
try direct mode MB after QPRD, slight PSNR/bitrate gain if b frames + QPRD
michael
parents:
4283
diff
changeset
|
5284 int mx= s->b_direct_mv_table[xy][0]; |
5ed8f8fd71e9
try direct mode MB after QPRD, slight PSNR/bitrate gain if b frames + QPRD
michael
parents:
4283
diff
changeset
|
5285 int my= s->b_direct_mv_table[xy][1]; |
5ed8f8fd71e9
try direct mode MB after QPRD, slight PSNR/bitrate gain if b frames + QPRD
michael
parents:
4283
diff
changeset
|
5286 |
5ed8f8fd71e9
try direct mode MB after QPRD, slight PSNR/bitrate gain if b frames + QPRD
michael
parents:
4283
diff
changeset
|
5287 backup_s.dquant = 0; |
5ed8f8fd71e9
try direct mode MB after QPRD, slight PSNR/bitrate gain if b frames + QPRD
michael
parents:
4283
diff
changeset
|
5288 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT; |
5ed8f8fd71e9
try direct mode MB after QPRD, slight PSNR/bitrate gain if b frames + QPRD
michael
parents:
4283
diff
changeset
|
5289 s->mb_intra= 0; |
5ed8f8fd71e9
try direct mode MB after QPRD, slight PSNR/bitrate gain if b frames + QPRD
michael
parents:
4283
diff
changeset
|
5290 ff_mpeg4_set_direct_mv(s, mx, my); |
5ed8f8fd71e9
try direct mode MB after QPRD, slight PSNR/bitrate gain if b frames + QPRD
michael
parents:
4283
diff
changeset
|
5291 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_DIRECT, pb, pb2, tex_pb, |
5ed8f8fd71e9
try direct mode MB after QPRD, slight PSNR/bitrate gain if b frames + QPRD
michael
parents:
4283
diff
changeset
|
5292 &dmin, &next_block, mx, my); |
5ed8f8fd71e9
try direct mode MB after QPRD, slight PSNR/bitrate gain if b frames + QPRD
michael
parents:
4283
diff
changeset
|
5293 } |
4317
5a2ee0bc2739
skip motion estimation and encoding of non direct-0,0 MBs if the next MB is skiped (mpeg4 doesnt allow such MBs and in the past we did ME and encoding until at the end we droped them, so this should be faster though i didnt benchmark it, benchmark welcome)
michael
parents:
4314
diff
changeset
|
5294 if(mb_type&CANDIDATE_MB_TYPE_DIRECT0){ |
5a2ee0bc2739
skip motion estimation and encoding of non direct-0,0 MBs if the next MB is skiped (mpeg4 doesnt allow such MBs and in the past we did ME and encoding until at the end we droped them, so this should be faster though i didnt benchmark it, benchmark welcome)
michael
parents:
4314
diff
changeset
|
5295 backup_s.dquant = 0; |
5a2ee0bc2739
skip motion estimation and encoding of non direct-0,0 MBs if the next MB is skiped (mpeg4 doesnt allow such MBs and in the past we did ME and encoding until at the end we droped them, so this should be faster though i didnt benchmark it, benchmark welcome)
michael
parents:
4314
diff
changeset
|
5296 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT; |
5a2ee0bc2739
skip motion estimation and encoding of non direct-0,0 MBs if the next MB is skiped (mpeg4 doesnt allow such MBs and in the past we did ME and encoding until at the end we droped them, so this should be faster though i didnt benchmark it, benchmark welcome)
michael
parents:
4314
diff
changeset
|
5297 s->mb_intra= 0; |
5a2ee0bc2739
skip motion estimation and encoding of non direct-0,0 MBs if the next MB is skiped (mpeg4 doesnt allow such MBs and in the past we did ME and encoding until at the end we droped them, so this should be faster though i didnt benchmark it, benchmark welcome)
michael
parents:
4314
diff
changeset
|
5298 ff_mpeg4_set_direct_mv(s, 0, 0); |
5a2ee0bc2739
skip motion estimation and encoding of non direct-0,0 MBs if the next MB is skiped (mpeg4 doesnt allow such MBs and in the past we did ME and encoding until at the end we droped them, so this should be faster though i didnt benchmark it, benchmark welcome)
michael
parents:
4314
diff
changeset
|
5299 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_DIRECT, pb, pb2, tex_pb, |
5a2ee0bc2739
skip motion estimation and encoding of non direct-0,0 MBs if the next MB is skiped (mpeg4 doesnt allow such MBs and in the past we did ME and encoding until at the end we droped them, so this should be faster though i didnt benchmark it, benchmark welcome)
michael
parents:
4314
diff
changeset
|
5300 &dmin, &next_block, 0, 0); |
5a2ee0bc2739
skip motion estimation and encoding of non direct-0,0 MBs if the next MB is skiped (mpeg4 doesnt allow such MBs and in the past we did ME and encoding until at the end we droped them, so this should be faster though i didnt benchmark it, benchmark welcome)
michael
parents:
4314
diff
changeset
|
5301 } |
4327 | 5302 if(!best_s.mb_intra && s->flags2&CODEC_FLAG2_SKIP_RD){ |
5303 int coded=0; | |
5304 for(i=0; i<6; i++) | |
5305 coded |= s->block_last_index[i]; | |
5306 if(coded){ | |
5307 int mx,my; | |
5308 memcpy(s->mv, best_s.mv, sizeof(s->mv)); | |
5309 if(best_s.mv_dir & MV_DIRECT){ | |
5310 mx=my=0; //FIXME find the one we actually used | |
5311 ff_mpeg4_set_direct_mv(s, mx, my); | |
5312 }else if(best_s.mv_dir&MV_DIR_BACKWARD){ | |
5313 mx= s->mv[1][0][0]; | |
5314 my= s->mv[1][0][1]; | |
5315 }else{ | |
5316 mx= s->mv[0][0][0]; | |
5317 my= s->mv[0][0][1]; | |
5318 } | |
5319 | |
5320 s->mv_dir= best_s.mv_dir; | |
5321 s->mv_type = best_s.mv_type; | |
5322 s->mb_intra= 0; | |
5323 /* s->mv[0][0][0] = best_s.mv[0][0][0]; | |
5324 s->mv[0][0][1] = best_s.mv[0][0][1]; | |
5325 s->mv[1][0][0] = best_s.mv[1][0][0]; | |
5326 s->mv[1][0][1] = best_s.mv[1][0][1];*/ | |
5327 backup_s.dquant= 0; | |
5328 s->skipdct=1; | |
5329 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER /* wrong but unused */, pb, pb2, tex_pb, | |
5330 &dmin, &next_block, mx, my); | |
5331 s->skipdct=0; | |
5332 } | |
5333 } | |
5334 | |
4314
5ed8f8fd71e9
try direct mode MB after QPRD, slight PSNR/bitrate gain if b frames + QPRD
michael
parents:
4283
diff
changeset
|
5335 s->current_picture.qscale_table[xy]= best_s.qscale; |
1616 | 5336 |
326 | 5337 copy_context_after_encode(s, &best_s, -1); |
2967 | 5338 |
1786 | 5339 pb_bits_count= put_bits_count(&s->pb); |
456 | 5340 flush_put_bits(&s->pb); |
5341 ff_copy_bits(&backup_s.pb, bit_buf[next_block^1], pb_bits_count); | |
5342 s->pb= backup_s.pb; | |
2967 | 5343 |
456 | 5344 if(s->data_partitioning){ |
1786 | 5345 pb2_bits_count= put_bits_count(&s->pb2); |
456 | 5346 flush_put_bits(&s->pb2); |
5347 ff_copy_bits(&backup_s.pb2, bit_buf2[next_block^1], pb2_bits_count); | |
5348 s->pb2= backup_s.pb2; | |
2967 | 5349 |
1786 | 5350 tex_pb_bits_count= put_bits_count(&s->tex_pb); |
456 | 5351 flush_put_bits(&s->tex_pb); |
5352 ff_copy_bits(&backup_s.tex_pb, bit_buf_tex[next_block^1], tex_pb_bits_count); | |
5353 s->tex_pb= backup_s.tex_pb; | |
5354 } | |
1786 | 5355 s->last_bits= put_bits_count(&s->pb); |
2967 | 5356 |
1389 | 5357 if (s->out_format == FMT_H263 && s->pict_type!=B_TYPE) |
5358 ff_h263_update_motion_val(s); | |
2967 | 5359 |
1799 | 5360 if(next_block==0){ //FIXME 16 vs linesize16 |
5361 s->dsp.put_pixels_tab[0][0](s->dest[0], s->rd_scratchpad , s->linesize ,16); | |
5362 s->dsp.put_pixels_tab[1][0](s->dest[1], s->rd_scratchpad + 16*s->linesize , s->uvlinesize, 8); | |
5363 s->dsp.put_pixels_tab[1][0](s->dest[2], s->rd_scratchpad + 16*s->linesize + 8, s->uvlinesize, 8); | |
1389 | 5364 } |
5365 | |
5366 if(s->avctx->mb_decision == FF_MB_DECISION_BITS) | |
5367 MPV_decode_mb(s, s->block); | |
294 | 5368 } else { |
4416 | 5369 int motion_x = 0, motion_y = 0; |
324 | 5370 s->mv_type=MV_TYPE_16X16; |
294 | 5371 // only one MB-Type possible |
2967 | 5372 |
327 | 5373 switch(mb_type){ |
1708 | 5374 case CANDIDATE_MB_TYPE_INTRA: |
1051
e5a9dbf597d4
mpeg1 bframe encoding patch by (Rapha«³l LEGRAND) with some modifications by me
michaelni
parents:
1048
diff
changeset
|
5375 s->mv_dir = 0; |
294 | 5376 s->mb_intra= 1; |
324 | 5377 motion_x= s->mv[0][0][0] = 0; |
5378 motion_y= s->mv[0][0][1] = 0; | |
327 | 5379 break; |
1708 | 5380 case CANDIDATE_MB_TYPE_INTER: |
324 | 5381 s->mv_dir = MV_DIR_FORWARD; |
5382 s->mb_intra= 0; | |
5383 motion_x= s->mv[0][0][0] = s->p_mv_table[xy][0]; | |
5384 motion_y= s->mv[0][0][1] = s->p_mv_table[xy][1]; | |
327 | 5385 break; |
1708 | 5386 case CANDIDATE_MB_TYPE_INTER_I: |
5387 s->mv_dir = MV_DIR_FORWARD; | |
5388 s->mv_type = MV_TYPE_FIELD; | |
5389 s->mb_intra= 0; | |
5390 for(i=0; i<2; i++){ | |
5391 j= s->field_select[0][i] = s->p_field_select_table[i][xy]; | |
5392 s->mv[0][i][0] = s->p_field_mv_table[i][j][xy][0]; | |
5393 s->mv[0][i][1] = s->p_field_mv_table[i][j][xy][1]; | |
5394 } | |
5395 break; | |
5396 case CANDIDATE_MB_TYPE_INTER4V: | |
456 | 5397 s->mv_dir = MV_DIR_FORWARD; |
5398 s->mv_type = MV_TYPE_8X8; | |
5399 s->mb_intra= 0; | |
5400 for(i=0; i<4; i++){ | |
1668
30746f429df6
move motion_val & mb_type to AVFrame patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1662
diff
changeset
|
5401 s->mv[0][i][0] = s->current_picture.motion_val[0][s->block_index[i]][0]; |
30746f429df6
move motion_val & mb_type to AVFrame patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1662
diff
changeset
|
5402 s->mv[0][i][1] = s->current_picture.motion_val[0][s->block_index[i]][1]; |
456 | 5403 } |
5404 break; | |
1708 | 5405 case CANDIDATE_MB_TYPE_DIRECT: |
324 | 5406 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT; |
5407 s->mb_intra= 0; | |
327 | 5408 motion_x=s->b_direct_mv_table[xy][0]; |
5409 motion_y=s->b_direct_mv_table[xy][1]; | |
936 | 5410 ff_mpeg4_set_direct_mv(s, motion_x, motion_y); |
327 | 5411 break; |
4323 | 5412 case CANDIDATE_MB_TYPE_DIRECT0: |
5413 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT; | |
5414 s->mb_intra= 0; | |
5415 ff_mpeg4_set_direct_mv(s, 0, 0); | |
5416 break; | |
1708 | 5417 case CANDIDATE_MB_TYPE_BIDIR: |
324 | 5418 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD; |
294 | 5419 s->mb_intra= 0; |
324 | 5420 s->mv[0][0][0] = s->b_bidir_forw_mv_table[xy][0]; |
5421 s->mv[0][0][1] = s->b_bidir_forw_mv_table[xy][1]; | |
5422 s->mv[1][0][0] = s->b_bidir_back_mv_table[xy][0]; | |
5423 s->mv[1][0][1] = s->b_bidir_back_mv_table[xy][1]; | |
327 | 5424 break; |
1708 | 5425 case CANDIDATE_MB_TYPE_BACKWARD: |
324 | 5426 s->mv_dir = MV_DIR_BACKWARD; |
5427 s->mb_intra= 0; | |
5428 motion_x= s->mv[1][0][0] = s->b_back_mv_table[xy][0]; | |
5429 motion_y= s->mv[1][0][1] = s->b_back_mv_table[xy][1]; | |
327 | 5430 break; |
1708 | 5431 case CANDIDATE_MB_TYPE_FORWARD: |
324 | 5432 s->mv_dir = MV_DIR_FORWARD; |
5433 s->mb_intra= 0; | |
5434 motion_x= s->mv[0][0][0] = s->b_forw_mv_table[xy][0]; | |
5435 motion_y= s->mv[0][0][1] = s->b_forw_mv_table[xy][1]; | |
5436 // printf(" %d %d ", motion_x, motion_y); | |
327 | 5437 break; |
1708 | 5438 case CANDIDATE_MB_TYPE_FORWARD_I: |
5439 s->mv_dir = MV_DIR_FORWARD; | |
5440 s->mv_type = MV_TYPE_FIELD; | |
5441 s->mb_intra= 0; | |
5442 for(i=0; i<2; i++){ | |
5443 j= s->field_select[0][i] = s->b_field_select_table[0][i][xy]; | |
5444 s->mv[0][i][0] = s->b_field_mv_table[0][i][j][xy][0]; | |
5445 s->mv[0][i][1] = s->b_field_mv_table[0][i][j][xy][1]; | |
5446 } | |
5447 break; | |
5448 case CANDIDATE_MB_TYPE_BACKWARD_I: | |
5449 s->mv_dir = MV_DIR_BACKWARD; | |
5450 s->mv_type = MV_TYPE_FIELD; | |
5451 s->mb_intra= 0; | |
5452 for(i=0; i<2; i++){ | |
5453 j= s->field_select[1][i] = s->b_field_select_table[1][i][xy]; | |
5454 s->mv[1][i][0] = s->b_field_mv_table[1][i][j][xy][0]; | |
5455 s->mv[1][i][1] = s->b_field_mv_table[1][i][j][xy][1]; | |
5456 } | |
5457 break; | |
5458 case CANDIDATE_MB_TYPE_BIDIR_I: | |
5459 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD; | |
5460 s->mv_type = MV_TYPE_FIELD; | |
5461 s->mb_intra= 0; | |
5462 for(dir=0; dir<2; dir++){ | |
5463 for(i=0; i<2; i++){ | |
5464 j= s->field_select[dir][i] = s->b_field_select_table[dir][i][xy]; | |
5465 s->mv[dir][i][0] = s->b_field_mv_table[dir][i][j][xy][0]; | |
5466 s->mv[dir][i][1] = s->b_field_mv_table[dir][i][j][xy][1]; | |
5467 } | |
5468 } | |
5469 break; | |
327 | 5470 default: |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1597
diff
changeset
|
5471 av_log(s->avctx, AV_LOG_ERROR, "illegal MB type\n"); |
294 | 5472 } |
1051
e5a9dbf597d4
mpeg1 bframe encoding patch by (Rapha«³l LEGRAND) with some modifications by me
michaelni
parents:
1048
diff
changeset
|
5473 |
324 | 5474 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
|
5475 |
2627
bf158d23bbcc
Spelling errors patch by (Kevin Baragona | kevinmb500 gawab com)
michael
parents:
2620
diff
changeset
|
5476 // RAL: Update last macroblock type |
1051
e5a9dbf597d4
mpeg1 bframe encoding patch by (Rapha«³l LEGRAND) with some modifications by me
michaelni
parents:
1048
diff
changeset
|
5477 s->last_mv_dir = s->mv_dir; |
2967 | 5478 |
1389 | 5479 if (s->out_format == FMT_H263 && s->pict_type!=B_TYPE) |
5480 ff_h263_update_motion_val(s); | |
2967 | 5481 |
1389 | 5482 MPV_decode_mb(s, s->block); |
248
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
244
diff
changeset
|
5483 } |
1051
e5a9dbf597d4
mpeg1 bframe encoding patch by (Rapha«³l LEGRAND) with some modifications by me
michaelni
parents:
1048
diff
changeset
|
5484 |
327 | 5485 /* clean the MV table in IPS frames for direct mode in B frames */ |
5486 if(s->mb_intra /* && I,P,S_TYPE */){ | |
5487 s->p_mv_table[xy][0]=0; | |
5488 s->p_mv_table[xy][1]=0; | |
5489 } | |
2967 | 5490 |
909
8ae1e4c24e91
new PSNR code (now works with chroma, b frames, ...)
michaelni
parents:
903
diff
changeset
|
5491 if(s->flags&CODEC_FLAG_PSNR){ |
8ae1e4c24e91
new PSNR code (now works with chroma, b frames, ...)
michaelni
parents:
903
diff
changeset
|
5492 int w= 16; |
8ae1e4c24e91
new PSNR code (now works with chroma, b frames, ...)
michaelni
parents:
903
diff
changeset
|
5493 int h= 16; |
8ae1e4c24e91
new PSNR code (now works with chroma, b frames, ...)
michaelni
parents:
903
diff
changeset
|
5494 |
8ae1e4c24e91
new PSNR code (now works with chroma, b frames, ...)
michaelni
parents:
903
diff
changeset
|
5495 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
|
5496 if(s->mb_y*16 + 16 > s->height) h= s->height- s->mb_y*16; |
936 | 5497 |
2955 | 5498 s->current_picture.error[0] += sse( |
1389 | 5499 s, s->new_picture.data[0] + s->mb_x*16 + s->mb_y*s->linesize*16, |
5500 s->dest[0], w, h, s->linesize); | |
2955 | 5501 s->current_picture.error[1] += sse( |
1389 | 5502 s, s->new_picture.data[1] + s->mb_x*8 + s->mb_y*s->uvlinesize*8, |
5503 s->dest[1], w>>1, h>>1, s->uvlinesize); | |
2955 | 5504 s->current_picture.error[2] += sse( |
1389 | 5505 s, s->new_picture .data[2] + s->mb_x*8 + s->mb_y*s->uvlinesize*8, |
5506 s->dest[2], w>>1, h>>1, s->uvlinesize); | |
909
8ae1e4c24e91
new PSNR code (now works with chroma, b frames, ...)
michaelni
parents:
903
diff
changeset
|
5507 } |
2345 | 5508 if(s->loop_filter){ |
5509 if(s->out_format == FMT_H263) | |
5510 ff_h263_loop_filter(s); | |
5511 } | |
1786 | 5512 //printf("MB %d %d bits\n", s->mb_x+s->mb_y*s->mb_stride, put_bits_count(&s->pb)); |
0 | 5513 } |
5514 } | |
286 | 5515 |
2627
bf158d23bbcc
Spelling errors patch by (Kevin Baragona | kevinmb500 gawab com)
michael
parents:
2620
diff
changeset
|
5516 //not beautiful here but we must write it before flushing so it has to be here |
4967
6d45158e0249
disable reference to msmpeg4 and wmv2 code when those codecs are not compiled in
aurel
parents:
4668
diff
changeset
|
5517 if (ENABLE_MSMPEG4_ENCODER && s->msmpeg4_version && s->msmpeg4_version<4 && s->pict_type == I_TYPE) |
208 | 5518 msmpeg4_encode_ext_header(s); |
456 | 5519 |
1799 | 5520 write_slice_end(s); |
5521 | |
2967 | 5522 /* Send the last GOB if RTP */ |
1661 | 5523 if (s->avctx->rtp_callback) { |
2492
57ba17bd3924
rtp_callback: send number of mb patch by (Johan Bilien {jobi via.ecp fr)
michael
parents:
2450
diff
changeset
|
5524 int number_mb = (mb_y - s->resync_mb_y)*s->mb_width - s->resync_mb_x; |
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
|
5525 pdif = pbBufPtr(&s->pb) - s->ptr_lastgob; |
231 | 5526 /* Call the RTP callback to send the last GOB */ |
1799 | 5527 emms_c(); |
2492
57ba17bd3924
rtp_callback: send number of mb patch by (Johan Bilien {jobi via.ecp fr)
michael
parents:
2450
diff
changeset
|
5528 s->avctx->rtp_callback(s->avctx, s->ptr_lastgob, pdif, number_mb); |
231 | 5529 } |
1799 | 5530 |
5531 return 0; | |
5532 } | |
5533 | |
5534 #define MERGE(field) dst->field += src->field; src->field=0 | |
5535 static void merge_context_after_me(MpegEncContext *dst, MpegEncContext *src){ | |
2015
3ab8f3e2ae6a
moving motion estimation specific variables from MpegEncContext -> MotionEstContext
michael
parents:
1994
diff
changeset
|
5536 MERGE(me.scene_change_score); |
3ab8f3e2ae6a
moving motion estimation specific variables from MpegEncContext -> MotionEstContext
michael
parents:
1994
diff
changeset
|
5537 MERGE(me.mc_mb_var_sum_temp); |
3ab8f3e2ae6a
moving motion estimation specific variables from MpegEncContext -> MotionEstContext
michael
parents:
1994
diff
changeset
|
5538 MERGE(me.mb_var_sum_temp); |
1799 | 5539 } |
5540 | |
5541 static void merge_context_after_encode(MpegEncContext *dst, MpegEncContext *src){ | |
5542 int i; | |
5543 | |
5544 MERGE(dct_count[0]); //note, the other dct vars are not part of the context | |
5545 MERGE(dct_count[1]); | |
5546 MERGE(mv_bits); | |
5547 MERGE(i_tex_bits); | |
5548 MERGE(p_tex_bits); | |
5549 MERGE(i_count); | |
5550 MERGE(f_count); | |
5551 MERGE(b_count); | |
5552 MERGE(skip_count); | |
5553 MERGE(misc_bits); | |
5554 MERGE(error_count); | |
5555 MERGE(padding_bug_score); | |
2955 | 5556 MERGE(current_picture.error[0]); |
5557 MERGE(current_picture.error[1]); | |
5558 MERGE(current_picture.error[2]); | |
1799 | 5559 |
5560 if(dst->avctx->noise_reduction){ | |
5561 for(i=0; i<64; i++){ | |
5562 MERGE(dct_error_sum[0][i]); | |
5563 MERGE(dct_error_sum[1][i]); | |
5564 } | |
5565 } | |
2967 | 5566 |
1799 | 5567 assert(put_bits_count(&src->pb) % 8 ==0); |
5568 assert(put_bits_count(&dst->pb) % 8 ==0); | |
5569 ff_copy_bits(&dst->pb, src->pb.buf, put_bits_count(&src->pb)); | |
5570 flush_put_bits(&dst->pb); | |
5571 } | |
5572 | |
3766 | 5573 static int estimate_qp(MpegEncContext *s, int dry_run){ |
3939
16ace038f452
fix buffer underflows by reencoding the current frame with a higher QP
michael
parents:
3929
diff
changeset
|
5574 if (s->next_lambda){ |
16ace038f452
fix buffer underflows by reencoding the current frame with a higher QP
michael
parents:
3929
diff
changeset
|
5575 s->current_picture_ptr->quality= |
16ace038f452
fix buffer underflows by reencoding the current frame with a higher QP
michael
parents:
3929
diff
changeset
|
5576 s->current_picture.quality = s->next_lambda; |
16ace038f452
fix buffer underflows by reencoding the current frame with a higher QP
michael
parents:
3929
diff
changeset
|
5577 if(!dry_run) s->next_lambda= 0; |
16ace038f452
fix buffer underflows by reencoding the current frame with a higher QP
michael
parents:
3929
diff
changeset
|
5578 } else if (!s->fixed_qscale) { |
2974 | 5579 s->current_picture_ptr->quality= |
5580 s->current_picture.quality = ff_rate_estimate_qscale(s, dry_run); | |
3766 | 5581 if (s->current_picture.quality < 0) |
5582 return -1; | |
5583 } | |
2974 | 5584 |
5585 if(s->adaptive_quant){ | |
5586 switch(s->codec_id){ | |
5587 case CODEC_ID_MPEG4: | |
5588 ff_clean_mpeg4_qscales(s); | |
5589 break; | |
5590 case CODEC_ID_H263: | |
5591 case CODEC_ID_H263P: | |
5592 case CODEC_ID_FLV1: | |
5593 ff_clean_h263_qscales(s); | |
5594 break; | |
5595 } | |
5596 | |
5597 s->lambda= s->lambda_table[0]; | |
5598 //FIXME broken | |
5599 }else | |
5600 s->lambda= s->current_picture.quality; | |
5601 //printf("%d %d\n", s->avctx->global_quality, s->current_picture.quality); | |
5602 update_qscale(s); | |
3780
6741c0e88310
return 0 from encode_picture() and estimate_qp() on success
mru
parents:
3777
diff
changeset
|
5603 return 0; |
2974 | 5604 } |
5605 | |
3766 | 5606 static int encode_picture(MpegEncContext *s, int picture_number) |
1799 | 5607 { |
2024
f65d87bfdd5a
some of the warning fixes by (Michael Roitzsch <mroi at users dot sourceforge dot net>)
michael
parents:
2015
diff
changeset
|
5608 int i; |
1799 | 5609 int bits; |
5610 | |
5611 s->picture_number = picture_number; | |
2967 | 5612 |
1799 | 5613 /* Reset the average MB variance */ |
2015
3ab8f3e2ae6a
moving motion estimation specific variables from MpegEncContext -> MotionEstContext
michael
parents:
1994
diff
changeset
|
5614 s->me.mb_var_sum_temp = |
3ab8f3e2ae6a
moving motion estimation specific variables from MpegEncContext -> MotionEstContext
michael
parents:
1994
diff
changeset
|
5615 s->me.mc_mb_var_sum_temp = 0; |
1799 | 5616 |
5617 /* we need to initialize some time vars before we can encode b-frames */ | |
5618 // RAL: Condition added for MPEG1VIDEO | |
5619 if (s->codec_id == CODEC_ID_MPEG1VIDEO || s->codec_id == CODEC_ID_MPEG2VIDEO || (s->h263_pred && !s->h263_msmpeg4)) | |
1834 | 5620 ff_set_mpeg4_time(s, s->picture_number); //FIXME rename and use has_b_frames or similar |
2967 | 5621 |
2015
3ab8f3e2ae6a
moving motion estimation specific variables from MpegEncContext -> MotionEstContext
michael
parents:
1994
diff
changeset
|
5622 s->me.scene_change_score=0; |
2967 | 5623 |
2053 | 5624 // s->lambda= s->current_picture_ptr->quality; //FIXME qscale / ... stuff for ME ratedistoration |
2967 | 5625 |
1799 | 5626 if(s->pict_type==I_TYPE){ |
5627 if(s->msmpeg4_version >= 3) s->no_rounding=1; | |
5628 else s->no_rounding=0; | |
5629 }else if(s->pict_type!=B_TYPE){ | |
5630 if(s->flipflop_rounding || s->codec_id == CODEC_ID_H263P || s->codec_id == CODEC_ID_MPEG4) | |
2967 | 5631 s->no_rounding ^= 1; |
5632 } | |
5633 | |
2981 | 5634 if(s->flags & CODEC_FLAG_PASS2){ |
3766 | 5635 if (estimate_qp(s,1) < 0) |
5636 return -1; | |
2981 | 5637 ff_get_2pass_fcode(s); |
5638 }else if(!(s->flags & CODEC_FLAG_QSCALE)){ | |
2980
529163f99474
improved lambda/qp guessing for motion estimation RD in first pass
michael
parents:
2979
diff
changeset
|
5639 if(s->pict_type==B_TYPE) |
2997
188f4ef688f2
second try of improved lambda/qp guessing for motion estimation RD in first pass
michael
parents:
2990
diff
changeset
|
5640 s->lambda= s->last_lambda_for[s->pict_type]; |
2980
529163f99474
improved lambda/qp guessing for motion estimation RD in first pass
michael
parents:
2979
diff
changeset
|
5641 else |
2997
188f4ef688f2
second try of improved lambda/qp guessing for motion estimation RD in first pass
michael
parents:
2990
diff
changeset
|
5642 s->lambda= s->last_lambda_for[s->last_non_b_pict_type]; |
2980
529163f99474
improved lambda/qp guessing for motion estimation RD in first pass
michael
parents:
2979
diff
changeset
|
5643 update_qscale(s); |
529163f99474
improved lambda/qp guessing for motion estimation RD in first pass
michael
parents:
2979
diff
changeset
|
5644 } |
2974 | 5645 |
2627
bf158d23bbcc
Spelling errors patch by (Kevin Baragona | kevinmb500 gawab com)
michael
parents:
2620
diff
changeset
|
5646 s->mb_intra=0; //for the rate distortion & bit compare functions |
1799 | 5647 for(i=1; i<s->avctx->thread_count; i++){ |
1827 | 5648 ff_update_duplicate_context(s->thread_context[i], s); |
1799 | 5649 } |
1962 | 5650 |
5651 ff_init_me(s); | |
5652 | |
1799 | 5653 /* Estimate motion for every MB */ |
5654 if(s->pict_type != I_TYPE){ | |
2584 | 5655 s->lambda = (s->lambda * s->avctx->me_penalty_compensation + 128)>>8; |
4097 | 5656 s->lambda2= (s->lambda2* (int64_t)s->avctx->me_penalty_compensation + 128)>>8; |
1955
5dafb10e0252
reuse motion vectors/mb types/field select values of the source video, if the SSE for a macroblock which is predicted with these values is below me_threshold
michael
parents:
1948
diff
changeset
|
5657 if(s->pict_type != B_TYPE && s->avctx->me_threshold==0){ |
1799 | 5658 if((s->avctx->pre_me && s->last_non_b_pict_type==I_TYPE) || s->avctx->pre_me==2){ |
5659 s->avctx->execute(s->avctx, pre_estimate_motion_thread, (void**)&(s->thread_context[0]), NULL, s->avctx->thread_count); | |
5660 } | |
5661 } | |
5662 | |
5663 s->avctx->execute(s->avctx, estimate_motion_thread, (void**)&(s->thread_context[0]), NULL, s->avctx->thread_count); | |
5664 }else /* if(s->pict_type == I_TYPE) */{ | |
5665 /* I-Frame */ | |
5666 for(i=0; i<s->mb_stride*s->mb_height; i++) | |
5667 s->mb_type[i]= CANDIDATE_MB_TYPE_INTRA; | |
2967 | 5668 |
1799 | 5669 if(!s->fixed_qscale){ |
5670 /* finding spatial complexity for I-frame rate control */ | |
1804
cc0a15943a87
multithreaded spatial complexity calculation for i frames
michael
parents:
1803
diff
changeset
|
5671 s->avctx->execute(s->avctx, mb_var_thread, (void**)&(s->thread_context[0]), NULL, s->avctx->thread_count); |
1799 | 5672 } |
5673 } | |
1804
cc0a15943a87
multithreaded spatial complexity calculation for i frames
michael
parents:
1803
diff
changeset
|
5674 for(i=1; i<s->avctx->thread_count; i++){ |
cc0a15943a87
multithreaded spatial complexity calculation for i frames
michael
parents:
1803
diff
changeset
|
5675 merge_context_after_me(s, s->thread_context[i]); |
cc0a15943a87
multithreaded spatial complexity calculation for i frames
michael
parents:
1803
diff
changeset
|
5676 } |
2015
3ab8f3e2ae6a
moving motion estimation specific variables from MpegEncContext -> MotionEstContext
michael
parents:
1994
diff
changeset
|
5677 s->current_picture.mc_mb_var_sum= s->current_picture_ptr->mc_mb_var_sum= s->me.mc_mb_var_sum_temp; |
3ab8f3e2ae6a
moving motion estimation specific variables from MpegEncContext -> MotionEstContext
michael
parents:
1994
diff
changeset
|
5678 s->current_picture. mb_var_sum= s->current_picture_ptr-> mb_var_sum= s->me. mb_var_sum_temp; |
1799 | 5679 emms_c(); |
5680 | |
2015
3ab8f3e2ae6a
moving motion estimation specific variables from MpegEncContext -> MotionEstContext
michael
parents:
1994
diff
changeset
|
5681 if(s->me.scene_change_score > s->avctx->scenechange_threshold && s->pict_type == P_TYPE){ |
1799 | 5682 s->pict_type= I_TYPE; |
5683 for(i=0; i<s->mb_stride*s->mb_height; i++) | |
5684 s->mb_type[i]= CANDIDATE_MB_TYPE_INTRA; | |
5685 //printf("Scene change detected, encoding as I Frame %d %d\n", s->current_picture.mb_var_sum, s->current_picture.mc_mb_var_sum); | |
5686 } | |
5687 | |
5688 if(!s->umvplus){ | |
5689 if(s->pict_type==P_TYPE || s->pict_type==S_TYPE) { | |
5690 s->f_code= ff_get_best_fcode(s, s->p_mv_table, CANDIDATE_MB_TYPE_INTER); | |
5691 | |
5692 if(s->flags & CODEC_FLAG_INTERLACED_ME){ | |
5693 int a,b; | |
5694 a= ff_get_best_fcode(s, s->p_field_mv_table[0][0], CANDIDATE_MB_TYPE_INTER_I); //FIXME field_select | |
5695 b= ff_get_best_fcode(s, s->p_field_mv_table[1][1], CANDIDATE_MB_TYPE_INTER_I); | |
5696 s->f_code= FFMAX(s->f_code, FFMAX(a,b)); | |
5697 } | |
2967 | 5698 |
1799 | 5699 ff_fix_long_p_mvs(s); |
5700 ff_fix_long_mvs(s, NULL, 0, s->p_mv_table, s->f_code, CANDIDATE_MB_TYPE_INTER, 0); | |
5701 if(s->flags & CODEC_FLAG_INTERLACED_ME){ | |
2024
f65d87bfdd5a
some of the warning fixes by (Michael Roitzsch <mroi at users dot sourceforge dot net>)
michael
parents:
2015
diff
changeset
|
5702 int j; |
1799 | 5703 for(i=0; i<2; i++){ |
5704 for(j=0; j<2; j++) | |
2967 | 5705 ff_fix_long_mvs(s, s->p_field_select_table[i], j, |
1799 | 5706 s->p_field_mv_table[i][j], s->f_code, CANDIDATE_MB_TYPE_INTER_I, 0); |
5707 } | |
5708 } | |
5709 } | |
5710 | |
5711 if(s->pict_type==B_TYPE){ | |
5712 int a, b; | |
5713 | |
5714 a = ff_get_best_fcode(s, s->b_forw_mv_table, CANDIDATE_MB_TYPE_FORWARD); | |
5715 b = ff_get_best_fcode(s, s->b_bidir_forw_mv_table, CANDIDATE_MB_TYPE_BIDIR); | |
5716 s->f_code = FFMAX(a, b); | |
5717 | |
5718 a = ff_get_best_fcode(s, s->b_back_mv_table, CANDIDATE_MB_TYPE_BACKWARD); | |
5719 b = ff_get_best_fcode(s, s->b_bidir_back_mv_table, CANDIDATE_MB_TYPE_BIDIR); | |
5720 s->b_code = FFMAX(a, b); | |
5721 | |
5722 ff_fix_long_mvs(s, NULL, 0, s->b_forw_mv_table, s->f_code, CANDIDATE_MB_TYPE_FORWARD, 1); | |
5723 ff_fix_long_mvs(s, NULL, 0, s->b_back_mv_table, s->b_code, CANDIDATE_MB_TYPE_BACKWARD, 1); | |
5724 ff_fix_long_mvs(s, NULL, 0, s->b_bidir_forw_mv_table, s->f_code, CANDIDATE_MB_TYPE_BIDIR, 1); | |
5725 ff_fix_long_mvs(s, NULL, 0, s->b_bidir_back_mv_table, s->b_code, CANDIDATE_MB_TYPE_BIDIR, 1); | |
5726 if(s->flags & CODEC_FLAG_INTERLACED_ME){ | |
2024
f65d87bfdd5a
some of the warning fixes by (Michael Roitzsch <mroi at users dot sourceforge dot net>)
michael
parents:
2015
diff
changeset
|
5727 int dir, j; |
1799 | 5728 for(dir=0; dir<2; dir++){ |
5729 for(i=0; i<2; i++){ | |
5730 for(j=0; j<2; j++){ | |
2967 | 5731 int type= dir ? (CANDIDATE_MB_TYPE_BACKWARD_I|CANDIDATE_MB_TYPE_BIDIR_I) |
1799 | 5732 : (CANDIDATE_MB_TYPE_FORWARD_I |CANDIDATE_MB_TYPE_BIDIR_I); |
2967 | 5733 ff_fix_long_mvs(s, s->b_field_select_table[dir][i], j, |
1799 | 5734 s->b_field_mv_table[dir][i][j], dir ? s->b_code : s->f_code, type, 1); |
5735 } | |
5736 } | |
5737 } | |
5738 } | |
5739 } | |
5740 } | |
5741 | |
3766 | 5742 if (estimate_qp(s, 0) < 0) |
5743 return -1; | |
2967 | 5744 |
5745 if(s->qscale < 3 && s->max_qcoeff<=128 && s->pict_type==I_TYPE && !(s->flags & CODEC_FLAG_QSCALE)) | |
2627
bf158d23bbcc
Spelling errors patch by (Kevin Baragona | kevinmb500 gawab com)
michael
parents:
2620
diff
changeset
|
5746 s->qscale= 3; //reduce clipping problems |
2967 | 5747 |
1799 | 5748 if (s->out_format == FMT_MJPEG) { |
5749 /* for mjpeg, we do include qscale in the matrix */ | |
5750 s->intra_matrix[0] = ff_mpeg1_default_intra_matrix[0]; | |
5751 for(i=1;i<64;i++){ | |
5752 int j= s->dsp.idct_permutation[i]; | |
5753 | |
4594 | 5754 s->intra_matrix[j] = av_clip_uint8((ff_mpeg1_default_intra_matrix[i] * s->qscale) >> 3); |
1799 | 5755 } |
2967 | 5756 convert_matrix(&s->dsp, s->q_intra_matrix, s->q_intra_matrix16, |
2385
4605a8b188c3
warn the user if the quantization code could overflow with the selected custom matrix and qp limits
michael
parents:
2382
diff
changeset
|
5757 s->intra_matrix, s->intra_quant_bias, 8, 8, 1); |
1799 | 5758 s->qscale= 8; |
5759 } | |
2967 | 5760 |
1799 | 5761 //FIXME var duplication |
2235
0c04463f79d8
10l (scene change pict_type was wrong after coded_frame fix) patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2231
diff
changeset
|
5762 s->current_picture_ptr->key_frame= |
1799 | 5763 s->current_picture.key_frame= s->pict_type == I_TYPE; //FIXME pic_ptr |
2235
0c04463f79d8
10l (scene change pict_type was wrong after coded_frame fix) patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2231
diff
changeset
|
5764 s->current_picture_ptr->pict_type= |
1799 | 5765 s->current_picture.pict_type= s->pict_type; |
5766 | |
5767 if(s->current_picture.key_frame) | |
5768 s->picture_in_gop_number=0; | |
5769 | |
5770 s->last_bits= put_bits_count(&s->pb); | |
5771 switch(s->out_format) { | |
5772 case FMT_MJPEG: | |
4995 | 5773 if (ENABLE_MJPEG_ENCODER) |
5029
dbaa06366c3c
add a proper prefix to all mjpeg encoder exported functions
aurel
parents:
5028
diff
changeset
|
5774 ff_mjpeg_encode_picture_header(s); |
1799 | 5775 break; |
2327
5e5cf598a48b
H.261 encoder by (Maarten Daniels <maarten dot daniels at luc dot ac dot be>)
michael
parents:
2298
diff
changeset
|
5776 case FMT_H261: |
4997 | 5777 if (ENABLE_H261_ENCODER) |
4998 | 5778 ff_h261_encode_picture_header(s, picture_number); |
2327
5e5cf598a48b
H.261 encoder by (Maarten Daniels <maarten dot daniels at luc dot ac dot be>)
michael
parents:
2298
diff
changeset
|
5779 break; |
1799 | 5780 case FMT_H263: |
4967
6d45158e0249
disable reference to msmpeg4 and wmv2 code when those codecs are not compiled in
aurel
parents:
4668
diff
changeset
|
5781 if (ENABLE_WMV2_ENCODER && s->codec_id == CODEC_ID_WMV2) |
1799 | 5782 ff_wmv2_encode_picture_header(s, picture_number); |
4967
6d45158e0249
disable reference to msmpeg4 and wmv2 code when those codecs are not compiled in
aurel
parents:
4668
diff
changeset
|
5783 else if (ENABLE_MSMPEG4_ENCODER && s->h263_msmpeg4) |
1799 | 5784 msmpeg4_encode_picture_header(s, picture_number); |
5785 else if (s->h263_pred) | |
5786 mpeg4_encode_picture_header(s, picture_number); | |
4997 | 5787 else if (ENABLE_RV10_ENCODER && s->codec_id == CODEC_ID_RV10) |
1799 | 5788 rv10_encode_picture_header(s, picture_number); |
4997 | 5789 else if (ENABLE_RV20_ENCODER && s->codec_id == CODEC_ID_RV20) |
2380 | 5790 rv20_encode_picture_header(s, picture_number); |
1799 | 5791 else if (s->codec_id == CODEC_ID_FLV1) |
5792 ff_flv_encode_picture_header(s, picture_number); | |
5793 else | |
5794 h263_encode_picture_header(s, picture_number); | |
5795 break; | |
5796 case FMT_MPEG1: | |
5797 mpeg1_encode_picture_header(s, picture_number); | |
5798 break; | |
5799 case FMT_H264: | |
5800 break; | |
5801 default: | |
5802 assert(0); | |
5803 } | |
5804 bits= put_bits_count(&s->pb); | |
5805 s->header_bits= bits - s->last_bits; | |
2967 | 5806 |
1799 | 5807 for(i=1; i<s->avctx->thread_count; i++){ |
5808 update_duplicate_context_after_me(s->thread_context[i], s); | |
5809 } | |
5810 s->avctx->execute(s->avctx, encode_thread, (void**)&(s->thread_context[0]), NULL, s->avctx->thread_count); | |
5811 for(i=1; i<s->avctx->thread_count; i++){ | |
5812 merge_context_after_encode(s, s->thread_context[i]); | |
5813 } | |
5814 emms_c(); | |
3780
6741c0e88310
return 0 from encode_picture() and estimate_qp() on success
mru
parents:
3777
diff
changeset
|
5815 return 0; |
0 | 5816 } |
5817 | |
1719 | 5818 static void denoise_dct_c(MpegEncContext *s, DCTELEM *block){ |
1597 | 5819 const int intra= s->mb_intra; |
5820 int i; | |
5821 | |
1599 | 5822 s->dct_count[intra]++; |
5823 | |
1597 | 5824 for(i=0; i<64; i++){ |
5825 int level= block[i]; | |
5826 | |
5827 if(level){ | |
5828 if(level>0){ | |
5829 s->dct_error_sum[intra][i] += level; | |
5830 level -= s->dct_offset[intra][i]; | |
5831 if(level<0) level=0; | |
5832 }else{ | |
5833 s->dct_error_sum[intra][i] -= level; | |
5834 level += s->dct_offset[intra][i]; | |
5835 if(level>0) level=0; | |
5836 } | |
5837 block[i]= level; | |
5838 } | |
5839 } | |
5840 } | |
5841 | |
2967 | 5842 static int dct_quantize_trellis_c(MpegEncContext *s, |
945 | 5843 DCTELEM *block, int n, |
5844 int qscale, int *overflow){ | |
5845 const int *qmat; | |
1064 | 5846 const uint8_t *scantable= s->intra_scantable.scantable; |
1718 | 5847 const uint8_t *perm_scantable= s->intra_scantable.permutated; |
945 | 5848 int max=0; |
5849 unsigned int threshold1, threshold2; | |
5850 int bias=0; | |
5851 int run_tab[65]; | |
5852 int level_tab[65]; | |
5853 int score_tab[65]; | |
1718 | 5854 int survivor[65]; |
5855 int survivor_count; | |
946 | 5856 int last_run=0; |
5857 int last_level=0; | |
5858 int last_score= 0; | |
1718 | 5859 int last_i; |
1715 | 5860 int coeff[2][64]; |
945 | 5861 int coeff_count[64]; |
1505
010f76d07a27
use lagrange multipler instead of qp for ratecontrol, this may break some things, tell me ASAP if u notice anything broken
michaelni
parents:
1497
diff
changeset
|
5862 int qmul, qadd, start_i, last_non_zero, i, dc; |
945 | 5863 const int esc_length= s->ac_esc_length; |
5864 uint8_t * length; | |
5865 uint8_t * last_length; | |
1505
010f76d07a27
use lagrange multipler instead of qp for ratecontrol, this may break some things, tell me ASAP if u notice anything broken
michaelni
parents:
1497
diff
changeset
|
5866 const int lambda= s->lambda2 >> (FF_LAMBDA_SHIFT - 6); |
2967 | 5867 |
1092 | 5868 s->dsp.fdct (block); |
2967 | 5869 |
1597 | 5870 if(s->dct_error_sum) |
1719 | 5871 s->denoise_dct(s, block); |
945 | 5872 qmul= qscale*16; |
5873 qadd= ((qscale-1)|1)*8; | |
946 | 5874 |
945 | 5875 if (s->mb_intra) { |
5876 int q; | |
5877 if (!s->h263_aic) { | |
5878 if (n < 4) | |
5879 q = s->y_dc_scale; | |
5880 else | |
5881 q = s->c_dc_scale; | |
5882 q = q << 3; | |
5883 } else{ | |
5884 /* For AIC we skip quant/dequant of INTRADC */ | |
5885 q = 1 << 3; | |
5886 qadd=0; | |
5887 } | |
2967 | 5888 |
945 | 5889 /* note: block[0] is assumed to be positive */ |
5890 block[0] = (block[0] + (q >> 1)) / q; | |
5891 start_i = 1; | |
5892 last_non_zero = 0; | |
5893 qmat = s->q_intra_matrix[qscale]; | |
1422
efeed6e29f9b
oooooops, having 2 Eterms open and doing cvs diff in one and cvs commit in the other sucks, especially if they are in different directories (MPlayer/main/libavcodec vs. ffmpeg/libavcodec)
michaelni
parents:
1421
diff
changeset
|
5894 if(s->mpeg_quant || s->out_format == FMT_MPEG1) |
945 | 5895 bias= 1<<(QMAT_SHIFT-1); |
5896 length = s->intra_ac_vlc_length; | |
5897 last_length= s->intra_ac_vlc_last_length; | |
5898 } else { | |
5899 start_i = 0; | |
5900 last_non_zero = -1; | |
5901 qmat = s->q_inter_matrix[qscale]; | |
5902 length = s->inter_ac_vlc_length; | |
5903 last_length= s->inter_ac_vlc_last_length; | |
5904 } | |
1718 | 5905 last_i= start_i; |
945 | 5906 |
5907 threshold1= (1<<QMAT_SHIFT) - bias - 1; | |
5908 threshold2= (threshold1<<1); | |
946 | 5909 |
1715 | 5910 for(i=63; i>=start_i; i--) { |
5911 const int j = scantable[i]; | |
5912 int level = block[j] * qmat[j]; | |
5913 | |
5914 if(((unsigned)(level+threshold1))>threshold2){ | |
5915 last_non_zero = i; | |
5916 break; | |
5917 } | |
5918 } | |
5919 | |
5920 for(i=start_i; i<=last_non_zero; i++) { | |
945 | 5921 const int j = scantable[i]; |
1715 | 5922 int level = block[j] * qmat[j]; |
945 | 5923 |
5924 // if( bias+level >= (1<<(QMAT_SHIFT - 3)) | |
5925 // || bias-level >= (1<<(QMAT_SHIFT - 3))){ | |
5926 if(((unsigned)(level+threshold1))>threshold2){ | |
5927 if(level>0){ | |
5928 level= (bias + level)>>QMAT_SHIFT; | |
1718 | 5929 coeff[0][i]= level; |
5930 coeff[1][i]= level-1; | |
946 | 5931 // coeff[2][k]= level-2; |
945 | 5932 }else{ |
5933 level= (bias - level)>>QMAT_SHIFT; | |
1718 | 5934 coeff[0][i]= -level; |
5935 coeff[1][i]= -level+1; | |
946 | 5936 // coeff[2][k]= -level+2; |
945 | 5937 } |
1718 | 5938 coeff_count[i]= FFMIN(level, 2); |
5939 assert(coeff_count[i]); | |
945 | 5940 max |=level; |
5941 }else{ | |
1718 | 5942 coeff[0][i]= (level>>31)|1; |
5943 coeff_count[i]= 1; | |
945 | 5944 } |
5945 } | |
2967 | 5946 |
2627
bf158d23bbcc
Spelling errors patch by (Kevin Baragona | kevinmb500 gawab com)
michael
parents:
2620
diff
changeset
|
5947 *overflow= s->max_qcoeff < max; //overflow might have happened |
2967 | 5948 |
945 | 5949 if(last_non_zero < start_i){ |
5950 memset(block + start_i, 0, (64-start_i)*sizeof(DCTELEM)); | |
5951 return last_non_zero; | |
5952 } | |
5953 | |
1718 | 5954 score_tab[start_i]= 0; |
5955 survivor[0]= start_i; | |
5956 survivor_count= 1; | |
2967 | 5957 |
1718 | 5958 for(i=start_i; i<=last_non_zero; i++){ |
5959 int level_index, j; | |
4001 | 5960 const int dct_coeff= FFABS(block[ scantable[i] ]); |
945 | 5961 const int zero_distoration= dct_coeff*dct_coeff; |
946 | 5962 int best_score=256*256*256*120; |
945 | 5963 for(level_index=0; level_index < coeff_count[i]; level_index++){ |
5964 int distoration; | |
5965 int level= coeff[level_index][i]; | |
4001 | 5966 const int alevel= FFABS(level); |
945 | 5967 int unquant_coeff; |
2967 | 5968 |
945 | 5969 assert(level); |
5970 | |
5971 if(s->out_format == FMT_H263){ | |
1716 | 5972 unquant_coeff= alevel*qmul + qadd; |
947 | 5973 }else{ //MPEG1 |
1718 | 5974 j= s->dsp.idct_permutation[ scantable[i] ]; //FIXME optimize |
947 | 5975 if(s->mb_intra){ |
1716 | 5976 unquant_coeff = (int)( alevel * qscale * s->intra_matrix[j]) >> 3; |
947 | 5977 unquant_coeff = (unquant_coeff - 1) | 1; |
5978 }else{ | |
1716 | 5979 unquant_coeff = ((( alevel << 1) + 1) * qscale * ((int) s->inter_matrix[j])) >> 4; |
947 | 5980 unquant_coeff = (unquant_coeff - 1) | 1; |
5981 } | |
5982 unquant_coeff<<= 3; | |
5983 } | |
946 | 5984 |
1715 | 5985 distoration= (unquant_coeff - dct_coeff) * (unquant_coeff - dct_coeff) - zero_distoration; |
945 | 5986 level+=64; |
5987 if((level&(~127)) == 0){ | |
1718 | 5988 for(j=survivor_count-1; j>=0; j--){ |
5989 int run= i - survivor[j]; | |
947 | 5990 int score= distoration + length[UNI_AC_ENC_INDEX(run, level)]*lambda; |
945 | 5991 score += score_tab[i-run]; |
2967 | 5992 |
945 | 5993 if(score < best_score){ |
1718 | 5994 best_score= score; |
945 | 5995 run_tab[i+1]= run; |
5996 level_tab[i+1]= level-64; | |
5997 } | |
5998 } | |
5999 | |
6000 if(s->out_format == FMT_H263){ | |
1718 | 6001 for(j=survivor_count-1; j>=0; j--){ |
6002 int run= i - survivor[j]; | |
947 | 6003 int score= distoration + last_length[UNI_AC_ENC_INDEX(run, level)]*lambda; |
945 | 6004 score += score_tab[i-run]; |
946 | 6005 if(score < last_score){ |
6006 last_score= score; | |
6007 last_run= run; | |
6008 last_level= level-64; | |
6009 last_i= i+1; | |
945 | 6010 } |
6011 } | |
6012 } | |
6013 }else{ | |
6014 distoration += esc_length*lambda; | |
1718 | 6015 for(j=survivor_count-1; j>=0; j--){ |
6016 int run= i - survivor[j]; | |
945 | 6017 int score= distoration + score_tab[i-run]; |
2967 | 6018 |
945 | 6019 if(score < best_score){ |
1718 | 6020 best_score= score; |
945 | 6021 run_tab[i+1]= run; |
6022 level_tab[i+1]= level-64; | |
6023 } | |
6024 } | |
6025 | |
6026 if(s->out_format == FMT_H263){ | |
1718 | 6027 for(j=survivor_count-1; j>=0; j--){ |
6028 int run= i - survivor[j]; | |
945 | 6029 int score= distoration + score_tab[i-run]; |
946 | 6030 if(score < last_score){ |
6031 last_score= score; | |
6032 last_run= run; | |
6033 last_level= level-64; | |
6034 last_i= i+1; | |
945 | 6035 } |
6036 } | |
6037 } | |
6038 } | |
6039 } | |
2967 | 6040 |
1718 | 6041 score_tab[i+1]= best_score; |
6042 | |
946 | 6043 //Note: there is a vlc code in mpeg4 which is 1 bit shorter then another one with a shorter run and the same level |
1718 | 6044 if(last_non_zero <= 27){ |
6045 for(; survivor_count; survivor_count--){ | |
6046 if(score_tab[ survivor[survivor_count-1] ] <= best_score) | |
6047 break; | |
6048 } | |
6049 }else{ | |
6050 for(; survivor_count; survivor_count--){ | |
6051 if(score_tab[ survivor[survivor_count-1] ] <= best_score + lambda) | |
6052 break; | |
6053 } | |
1505
010f76d07a27
use lagrange multipler instead of qp for ratecontrol, this may break some things, tell me ASAP if u notice anything broken
michaelni
parents:
1497
diff
changeset
|
6054 } |
1718 | 6055 |
6056 survivor[ survivor_count++ ]= i+1; | |
945 | 6057 } |
946 | 6058 |
945 | 6059 if(s->out_format != FMT_H263){ |
946 | 6060 last_score= 256*256*256*120; |
1718 | 6061 for(i= survivor[0]; i<=last_non_zero + 1; i++){ |
946 | 6062 int score= score_tab[i]; |
947 | 6063 if(i) score += lambda*2; //FIXME exacter? |
6064 | |
946 | 6065 if(score < last_score){ |
6066 last_score= score; | |
6067 last_i= i; | |
6068 last_level= level_tab[i]; | |
6069 last_run= run_tab[i]; | |
6070 } | |
945 | 6071 } |
6072 } | |
1490
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1480
diff
changeset
|
6073 |
1715 | 6074 s->coded_score[n] = last_score; |
2967 | 6075 |
4001 | 6076 dc= FFABS(block[0]); |
1718 | 6077 last_non_zero= last_i - 1; |
945 | 6078 memset(block + start_i, 0, (64-start_i)*sizeof(DCTELEM)); |
2967 | 6079 |
945 | 6080 if(last_non_zero < start_i) |
6081 return last_non_zero; | |
1490
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1480
diff
changeset
|
6082 |
1480
8657d6800d15
slight quality improvement ( < +0.04 PSNR) for high bitrate videos with trellis quantization
michaelni
parents:
1471
diff
changeset
|
6083 if(last_non_zero == 0 && start_i == 0){ |
8657d6800d15
slight quality improvement ( < +0.04 PSNR) for high bitrate videos with trellis quantization
michaelni
parents:
1471
diff
changeset
|
6084 int best_level= 0; |
8657d6800d15
slight quality improvement ( < +0.04 PSNR) for high bitrate videos with trellis quantization
michaelni
parents:
1471
diff
changeset
|
6085 int best_score= dc * dc; |
2967 | 6086 |
1480
8657d6800d15
slight quality improvement ( < +0.04 PSNR) for high bitrate videos with trellis quantization
michaelni
parents:
1471
diff
changeset
|
6087 for(i=0; i<coeff_count[0]; i++){ |
1490
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1480
diff
changeset
|
6088 int level= coeff[i][0]; |
4001 | 6089 int alevel= FFABS(level); |
1716 | 6090 int unquant_coeff, score, distortion; |
1480
8657d6800d15
slight quality improvement ( < +0.04 PSNR) for high bitrate videos with trellis quantization
michaelni
parents:
1471
diff
changeset
|
6091 |
8657d6800d15
slight quality improvement ( < +0.04 PSNR) for high bitrate videos with trellis quantization
michaelni
parents:
1471
diff
changeset
|
6092 if(s->out_format == FMT_H263){ |
1716 | 6093 unquant_coeff= (alevel*qmul + qadd)>>3; |
1480
8657d6800d15
slight quality improvement ( < +0.04 PSNR) for high bitrate videos with trellis quantization
michaelni
parents:
1471
diff
changeset
|
6094 }else{ //MPEG1 |
1716 | 6095 unquant_coeff = ((( alevel << 1) + 1) * qscale * ((int) s->inter_matrix[0])) >> 4; |
6096 unquant_coeff = (unquant_coeff - 1) | 1; | |
1480
8657d6800d15
slight quality improvement ( < +0.04 PSNR) for high bitrate videos with trellis quantization
michaelni
parents:
1471
diff
changeset
|
6097 } |
8657d6800d15
slight quality improvement ( < +0.04 PSNR) for high bitrate videos with trellis quantization
michaelni
parents:
1471
diff
changeset
|
6098 unquant_coeff = (unquant_coeff + 4) >> 3; |
8657d6800d15
slight quality improvement ( < +0.04 PSNR) for high bitrate videos with trellis quantization
michaelni
parents:
1471
diff
changeset
|
6099 unquant_coeff<<= 3 + 3; |
8657d6800d15
slight quality improvement ( < +0.04 PSNR) for high bitrate videos with trellis quantization
michaelni
parents:
1471
diff
changeset
|
6100 |
1716 | 6101 distortion= (unquant_coeff - dc) * (unquant_coeff - dc); |
1490
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1480
diff
changeset
|
6102 level+=64; |
1716 | 6103 if((level&(~127)) == 0) score= distortion + last_length[UNI_AC_ENC_INDEX(0, level)]*lambda; |
6104 else score= distortion + esc_length*lambda; | |
1490
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1480
diff
changeset
|
6105 |
1480
8657d6800d15
slight quality improvement ( < +0.04 PSNR) for high bitrate videos with trellis quantization
michaelni
parents:
1471
diff
changeset
|
6106 if(score < best_score){ |
8657d6800d15
slight quality improvement ( < +0.04 PSNR) for high bitrate videos with trellis quantization
michaelni
parents:
1471
diff
changeset
|
6107 best_score= score; |
1490
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1480
diff
changeset
|
6108 best_level= level - 64; |
1480
8657d6800d15
slight quality improvement ( < +0.04 PSNR) for high bitrate videos with trellis quantization
michaelni
parents:
1471
diff
changeset
|
6109 } |
8657d6800d15
slight quality improvement ( < +0.04 PSNR) for high bitrate videos with trellis quantization
michaelni
parents:
1471
diff
changeset
|
6110 } |
8657d6800d15
slight quality improvement ( < +0.04 PSNR) for high bitrate videos with trellis quantization
michaelni
parents:
1471
diff
changeset
|
6111 block[0]= best_level; |
1490
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1480
diff
changeset
|
6112 s->coded_score[n] = best_score - dc*dc; |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1480
diff
changeset
|
6113 if(best_level == 0) return -1; |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1480
diff
changeset
|
6114 else return last_non_zero; |
1480
8657d6800d15
slight quality improvement ( < +0.04 PSNR) for high bitrate videos with trellis quantization
michaelni
parents:
1471
diff
changeset
|
6115 } |
1490
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1480
diff
changeset
|
6116 |
946 | 6117 i= last_i; |
6118 assert(last_level); | |
1718 | 6119 |
6120 block[ perm_scantable[last_non_zero] ]= last_level; | |
946 | 6121 i -= last_run + 1; |
2967 | 6122 |
1718 | 6123 for(; i>start_i; i -= run_tab[i] + 1){ |
6124 block[ perm_scantable[i-1] ]= level_tab[i]; | |
945 | 6125 } |
6126 | |
6127 return last_non_zero; | |
6128 } | |
6129 | |
1777 | 6130 //#define REFINE_STATS 1 |
6131 static int16_t basis[64][64]; | |
6132 | |
6133 static void build_basis(uint8_t *perm){ | |
6134 int i, j, x, y; | |
6135 emms_c(); | |
6136 for(i=0; i<8; i++){ | |
6137 for(j=0; j<8; j++){ | |
6138 for(y=0; y<8; y++){ | |
6139 for(x=0; x<8; x++){ | |
6140 double s= 0.25*(1<<BASIS_SHIFT); | |
6141 int index= 8*i + j; | |
6142 int perm_index= perm[index]; | |
6143 if(i==0) s*= sqrt(0.5); | |
6144 if(j==0) s*= sqrt(0.5); | |
6145 basis[perm_index][8*x + y]= lrintf(s * cos((M_PI/8.0)*i*(x+0.5)) * cos((M_PI/8.0)*j*(y+0.5))); | |
6146 } | |
6147 } | |
6148 } | |
6149 } | |
6150 } | |
6151 | |
6152 static int dct_quantize_refine(MpegEncContext *s, //FIXME breaks denoise? | |
6153 DCTELEM *block, int16_t *weight, DCTELEM *orig, | |
6154 int n, int qscale){ | |
6155 int16_t rem[64]; | |
3089 | 6156 DECLARE_ALIGNED_16(DCTELEM, d1[64]); |
1777 | 6157 const int *qmat; |
6158 const uint8_t *scantable= s->intra_scantable.scantable; | |
6159 const uint8_t *perm_scantable= s->intra_scantable.permutated; | |
6160 // unsigned int threshold1, threshold2; | |
6161 // int bias=0; | |
6162 int run_tab[65]; | |
6163 int prev_run=0; | |
6164 int prev_level=0; | |
6165 int qmul, qadd, start_i, last_non_zero, i, dc; | |
6166 uint8_t * length; | |
6167 uint8_t * last_length; | |
6168 int lambda; | |
4416 | 6169 int rle_index, run, q = 1, sum; //q is only used when s->mb_intra is true |
1777 | 6170 #ifdef REFINE_STATS |
6171 static int count=0; | |
6172 static int after_last=0; | |
6173 static int to_zero=0; | |
6174 static int from_zero=0; | |
6175 static int raise=0; | |
6176 static int lower=0; | |
6177 static int messed_sign=0; | |
6178 #endif | |
6179 | |
6180 if(basis[0][0] == 0) | |
6181 build_basis(s->dsp.idct_permutation); | |
2967 | 6182 |
1777 | 6183 qmul= qscale*2; |
6184 qadd= (qscale-1)|1; | |
6185 if (s->mb_intra) { | |
6186 if (!s->h263_aic) { | |
6187 if (n < 4) | |
6188 q = s->y_dc_scale; | |
6189 else | |
6190 q = s->c_dc_scale; | |
6191 } else{ | |
6192 /* For AIC we skip quant/dequant of INTRADC */ | |
6193 q = 1; | |
6194 qadd=0; | |
6195 } | |
6196 q <<= RECON_SHIFT-3; | |
6197 /* note: block[0] is assumed to be positive */ | |
6198 dc= block[0]*q; | |
6199 // block[0] = (block[0] + (q >> 1)) / q; | |
6200 start_i = 1; | |
6201 qmat = s->q_intra_matrix[qscale]; | |
6202 // if(s->mpeg_quant || s->out_format == FMT_MPEG1) | |
6203 // bias= 1<<(QMAT_SHIFT-1); | |
6204 length = s->intra_ac_vlc_length; | |
6205 last_length= s->intra_ac_vlc_last_length; | |
6206 } else { | |
6207 dc= 0; | |
6208 start_i = 0; | |
6209 qmat = s->q_inter_matrix[qscale]; | |
6210 length = s->inter_ac_vlc_length; | |
6211 last_length= s->inter_ac_vlc_last_length; | |
6212 } | |
6213 last_non_zero = s->block_last_index[n]; | |
6214 | |
6215 #ifdef REFINE_STATS | |
6216 {START_TIMER | |
6217 #endif | |
1784 | 6218 dc += (1<<(RECON_SHIFT-1)); |
6219 for(i=0; i<64; i++){ | |
2627
bf158d23bbcc
Spelling errors patch by (Kevin Baragona | kevinmb500 gawab com)
michael
parents:
2620
diff
changeset
|
6220 rem[i]= dc - (orig[i]<<RECON_SHIFT); //FIXME use orig dirrectly instead of copying to rem[] |
1777 | 6221 } |
6222 #ifdef REFINE_STATS | |
6223 STOP_TIMER("memset rem[]")} | |
6224 #endif | |
6225 sum=0; | |
6226 for(i=0; i<64; i++){ | |
6227 int one= 36; | |
6228 int qns=4; | |
6229 int w; | |
6230 | |
4001 | 6231 w= FFABS(weight[i]) + qns*one; |
1777 | 6232 w= 15 + (48*qns*one + w/2)/w; // 16 .. 63 |
6233 | |
6234 weight[i] = w; | |
6235 // w=weight[i] = (63*qns + (w/2)) / w; | |
2967 | 6236 |
1777 | 6237 assert(w>0); |
6238 assert(w<(1<<6)); | |
6239 sum += w*w; | |
6240 } | |
6241 lambda= sum*(uint64_t)s->lambda2 >> (FF_LAMBDA_SHIFT - 6 + 6 + 6 + 6); | |
6242 #ifdef REFINE_STATS | |
6243 {START_TIMER | |
6244 #endif | |
6245 run=0; | |
6246 rle_index=0; | |
6247 for(i=start_i; i<=last_non_zero; i++){ | |
6248 int j= perm_scantable[i]; | |
6249 const int level= block[j]; | |
6250 int coeff; | |
2967 | 6251 |
1777 | 6252 if(level){ |
6253 if(level<0) coeff= qmul*level - qadd; | |
6254 else coeff= qmul*level + qadd; | |
6255 run_tab[rle_index++]=run; | |
6256 run=0; | |
6257 | |
1784 | 6258 s->dsp.add_8x8basis(rem, basis[j], coeff); |
1777 | 6259 }else{ |
6260 run++; | |
6261 } | |
6262 } | |
6263 #ifdef REFINE_STATS | |
6264 if(last_non_zero>0){ | |
6265 STOP_TIMER("init rem[]") | |
6266 } | |
6267 } | |
6268 | |
6269 {START_TIMER | |
6270 #endif | |
6271 for(;;){ | |
1784 | 6272 int best_score=s->dsp.try_8x8basis(rem, weight, basis[0], 0); |
1777 | 6273 int best_coeff=0; |
6274 int best_change=0; | |
2024
f65d87bfdd5a
some of the warning fixes by (Michael Roitzsch <mroi at users dot sourceforge dot net>)
michael
parents:
2015
diff
changeset
|
6275 int run2, best_unquant_change=0, analyze_gradient; |
1785
14d918d0ef42
analyze the gradient of the error surface to avoid a few checks in the quantizing noise shaper
michael
parents:
1784
diff
changeset
|
6276 #ifdef REFINE_STATS |
14d918d0ef42
analyze the gradient of the error surface to avoid a few checks in the quantizing noise shaper
michael
parents:
1784
diff
changeset
|
6277 {START_TIMER |
14d918d0ef42
analyze the gradient of the error surface to avoid a few checks in the quantizing noise shaper
michael
parents:
1784
diff
changeset
|
6278 #endif |
14d918d0ef42
analyze the gradient of the error surface to avoid a few checks in the quantizing noise shaper
michael
parents:
1784
diff
changeset
|
6279 analyze_gradient = last_non_zero > 2 || s->avctx->quantizer_noise_shaping >= 3; |
14d918d0ef42
analyze the gradient of the error surface to avoid a few checks in the quantizing noise shaper
michael
parents:
1784
diff
changeset
|
6280 |
14d918d0ef42
analyze the gradient of the error surface to avoid a few checks in the quantizing noise shaper
michael
parents:
1784
diff
changeset
|
6281 if(analyze_gradient){ |
1777 | 6282 #ifdef REFINE_STATS |
6283 {START_TIMER | |
6284 #endif | |
1785
14d918d0ef42
analyze the gradient of the error surface to avoid a few checks in the quantizing noise shaper
michael
parents:
1784
diff
changeset
|
6285 for(i=0; i<64; i++){ |
14d918d0ef42
analyze the gradient of the error surface to avoid a few checks in the quantizing noise shaper
michael
parents:
1784
diff
changeset
|
6286 int w= weight[i]; |
2967 | 6287 |
1785
14d918d0ef42
analyze the gradient of the error surface to avoid a few checks in the quantizing noise shaper
michael
parents:
1784
diff
changeset
|
6288 d1[i] = (rem[i]*w*w + (1<<(RECON_SHIFT+12-1)))>>(RECON_SHIFT+12); |
14d918d0ef42
analyze the gradient of the error surface to avoid a few checks in the quantizing noise shaper
michael
parents:
1784
diff
changeset
|
6289 } |
14d918d0ef42
analyze the gradient of the error surface to avoid a few checks in the quantizing noise shaper
michael
parents:
1784
diff
changeset
|
6290 #ifdef REFINE_STATS |
14d918d0ef42
analyze the gradient of the error surface to avoid a few checks in the quantizing noise shaper
michael
parents:
1784
diff
changeset
|
6291 STOP_TIMER("rem*w*w")} |
14d918d0ef42
analyze the gradient of the error surface to avoid a few checks in the quantizing noise shaper
michael
parents:
1784
diff
changeset
|
6292 {START_TIMER |
14d918d0ef42
analyze the gradient of the error surface to avoid a few checks in the quantizing noise shaper
michael
parents:
1784
diff
changeset
|
6293 #endif |
14d918d0ef42
analyze the gradient of the error surface to avoid a few checks in the quantizing noise shaper
michael
parents:
1784
diff
changeset
|
6294 s->dsp.fdct(d1); |
14d918d0ef42
analyze the gradient of the error surface to avoid a few checks in the quantizing noise shaper
michael
parents:
1784
diff
changeset
|
6295 #ifdef REFINE_STATS |
14d918d0ef42
analyze the gradient of the error surface to avoid a few checks in the quantizing noise shaper
michael
parents:
1784
diff
changeset
|
6296 STOP_TIMER("dct")} |
14d918d0ef42
analyze the gradient of the error surface to avoid a few checks in the quantizing noise shaper
michael
parents:
1784
diff
changeset
|
6297 #endif |
14d918d0ef42
analyze the gradient of the error surface to avoid a few checks in the quantizing noise shaper
michael
parents:
1784
diff
changeset
|
6298 } |
14d918d0ef42
analyze the gradient of the error surface to avoid a few checks in the quantizing noise shaper
michael
parents:
1784
diff
changeset
|
6299 |
1777 | 6300 if(start_i){ |
6301 const int level= block[0]; | |
6302 int change, old_coeff; | |
6303 | |
6304 assert(s->mb_intra); | |
2967 | 6305 |
1777 | 6306 old_coeff= q*level; |
2967 | 6307 |
1777 | 6308 for(change=-1; change<=1; change+=2){ |
6309 int new_level= level + change; | |
6310 int score, new_coeff; | |
2967 | 6311 |
1777 | 6312 new_coeff= q*new_level; |
6313 if(new_coeff >= 2048 || new_coeff < 0) | |
6314 continue; | |
6315 | |
1784 | 6316 score= s->dsp.try_8x8basis(rem, weight, basis[0], new_coeff - old_coeff); |
1777 | 6317 if(score<best_score){ |
6318 best_score= score; | |
6319 best_coeff= 0; | |
6320 best_change= change; | |
6321 best_unquant_change= new_coeff - old_coeff; | |
6322 } | |
6323 } | |
6324 } | |
2967 | 6325 |
1777 | 6326 run=0; |
6327 rle_index=0; | |
6328 run2= run_tab[rle_index++]; | |
6329 prev_level=0; | |
6330 prev_run=0; | |
6331 | |
6332 for(i=start_i; i<64; i++){ | |
6333 int j= perm_scantable[i]; | |
6334 const int level= block[j]; | |
6335 int change, old_coeff; | |
6336 | |
6337 if(s->avctx->quantizer_noise_shaping < 3 && i > last_non_zero + 1) | |
6338 break; | |
6339 | |
6340 if(level){ | |
6341 if(level<0) old_coeff= qmul*level - qadd; | |
6342 else old_coeff= qmul*level + qadd; | |
6343 run2= run_tab[rle_index++]; //FIXME ! maybe after last | |
6344 }else{ | |
6345 old_coeff=0; | |
6346 run2--; | |
6347 assert(run2>=0 || i >= last_non_zero ); | |
6348 } | |
2967 | 6349 |
1777 | 6350 for(change=-1; change<=1; change+=2){ |
6351 int new_level= level + change; | |
6352 int score, new_coeff, unquant_change; | |
2967 | 6353 |
1777 | 6354 score=0; |
4001 | 6355 if(s->avctx->quantizer_noise_shaping < 2 && FFABS(new_level) > FFABS(level)) |
1777 | 6356 continue; |
6357 | |
6358 if(new_level){ | |
6359 if(new_level<0) new_coeff= qmul*new_level - qadd; | |
6360 else new_coeff= qmul*new_level + qadd; | |
6361 if(new_coeff >= 2048 || new_coeff <= -2048) | |
6362 continue; | |
6363 //FIXME check for overflow | |
2967 | 6364 |
1777 | 6365 if(level){ |
6366 if(level < 63 && level > -63){ | |
6367 if(i < last_non_zero) | |
6368 score += length[UNI_AC_ENC_INDEX(run, new_level+64)] | |
6369 - length[UNI_AC_ENC_INDEX(run, level+64)]; | |
6370 else | |
6371 score += last_length[UNI_AC_ENC_INDEX(run, new_level+64)] | |
6372 - last_length[UNI_AC_ENC_INDEX(run, level+64)]; | |
6373 } | |
6374 }else{ | |
4001 | 6375 assert(FFABS(new_level)==1); |
2967 | 6376 |
1785
14d918d0ef42
analyze the gradient of the error surface to avoid a few checks in the quantizing noise shaper
michael
parents:
1784
diff
changeset
|
6377 if(analyze_gradient){ |
14d918d0ef42
analyze the gradient of the error surface to avoid a few checks in the quantizing noise shaper
michael
parents:
1784
diff
changeset
|
6378 int g= d1[ scantable[i] ]; |
14d918d0ef42
analyze the gradient of the error surface to avoid a few checks in the quantizing noise shaper
michael
parents:
1784
diff
changeset
|
6379 if(g && (g^new_level) >= 0) |
14d918d0ef42
analyze the gradient of the error surface to avoid a few checks in the quantizing noise shaper
michael
parents:
1784
diff
changeset
|
6380 continue; |
14d918d0ef42
analyze the gradient of the error surface to avoid a few checks in the quantizing noise shaper
michael
parents:
1784
diff
changeset
|
6381 } |
14d918d0ef42
analyze the gradient of the error surface to avoid a few checks in the quantizing noise shaper
michael
parents:
1784
diff
changeset
|
6382 |
1777 | 6383 if(i < last_non_zero){ |
6384 int next_i= i + run2 + 1; | |
6385 int next_level= block[ perm_scantable[next_i] ] + 64; | |
2967 | 6386 |
1777 | 6387 if(next_level&(~127)) |
6388 next_level= 0; | |
6389 | |
6390 if(next_i < last_non_zero) | |
6391 score += length[UNI_AC_ENC_INDEX(run, 65)] | |
6392 + length[UNI_AC_ENC_INDEX(run2, next_level)] | |
6393 - length[UNI_AC_ENC_INDEX(run + run2 + 1, next_level)]; | |
6394 else | |
6395 score += length[UNI_AC_ENC_INDEX(run, 65)] | |
6396 + last_length[UNI_AC_ENC_INDEX(run2, next_level)] | |
6397 - last_length[UNI_AC_ENC_INDEX(run + run2 + 1, next_level)]; | |
6398 }else{ | |
6399 score += last_length[UNI_AC_ENC_INDEX(run, 65)]; | |
6400 if(prev_level){ | |
6401 score += length[UNI_AC_ENC_INDEX(prev_run, prev_level)] | |
6402 - last_length[UNI_AC_ENC_INDEX(prev_run, prev_level)]; | |
6403 } | |
6404 } | |
6405 } | |
6406 }else{ | |
6407 new_coeff=0; | |
4001 | 6408 assert(FFABS(level)==1); |
1777 | 6409 |
6410 if(i < last_non_zero){ | |
6411 int next_i= i + run2 + 1; | |
6412 int next_level= block[ perm_scantable[next_i] ] + 64; | |
2967 | 6413 |
1777 | 6414 if(next_level&(~127)) |
6415 next_level= 0; | |
6416 | |
6417 if(next_i < last_non_zero) | |
6418 score += length[UNI_AC_ENC_INDEX(run + run2 + 1, next_level)] | |
6419 - length[UNI_AC_ENC_INDEX(run2, next_level)] | |
6420 - length[UNI_AC_ENC_INDEX(run, 65)]; | |
6421 else | |
6422 score += last_length[UNI_AC_ENC_INDEX(run + run2 + 1, next_level)] | |
6423 - last_length[UNI_AC_ENC_INDEX(run2, next_level)] | |
6424 - length[UNI_AC_ENC_INDEX(run, 65)]; | |
6425 }else{ | |
6426 score += -last_length[UNI_AC_ENC_INDEX(run, 65)]; | |
6427 if(prev_level){ | |
6428 score += last_length[UNI_AC_ENC_INDEX(prev_run, prev_level)] | |
6429 - length[UNI_AC_ENC_INDEX(prev_run, prev_level)]; | |
6430 } | |
6431 } | |
6432 } | |
2967 | 6433 |
1777 | 6434 score *= lambda; |
6435 | |
6436 unquant_change= new_coeff - old_coeff; | |
6437 assert((score < 100*lambda && score > -100*lambda) || lambda==0); | |
2967 | 6438 |
1784 | 6439 score+= s->dsp.try_8x8basis(rem, weight, basis[j], unquant_change); |
1777 | 6440 if(score<best_score){ |
6441 best_score= score; | |
6442 best_coeff= i; | |
6443 best_change= change; | |
6444 best_unquant_change= unquant_change; | |
6445 } | |
6446 } | |
6447 if(level){ | |
6448 prev_level= level + 64; | |
6449 if(prev_level&(~127)) | |
6450 prev_level= 0; | |
6451 prev_run= run; | |
6452 run=0; | |
6453 }else{ | |
6454 run++; | |
6455 } | |
6456 } | |
6457 #ifdef REFINE_STATS | |
6458 STOP_TIMER("iterative step")} | |
6459 #endif | |
6460 | |
6461 if(best_change){ | |
6462 int j= perm_scantable[ best_coeff ]; | |
2967 | 6463 |
1777 | 6464 block[j] += best_change; |
2967 | 6465 |
1777 | 6466 if(best_coeff > last_non_zero){ |
6467 last_non_zero= best_coeff; | |
6468 assert(block[j]); | |
6469 #ifdef REFINE_STATS | |
6470 after_last++; | |
6471 #endif | |
6472 }else{ | |
6473 #ifdef REFINE_STATS | |
6474 if(block[j]){ | |
6475 if(block[j] - best_change){ | |
4001 | 6476 if(FFABS(block[j]) > FFABS(block[j] - best_change)){ |
1777 | 6477 raise++; |
6478 }else{ | |
6479 lower++; | |
6480 } | |
6481 }else{ | |
6482 from_zero++; | |
6483 } | |
6484 }else{ | |
6485 to_zero++; | |
6486 } | |
6487 #endif | |
6488 for(; last_non_zero>=start_i; last_non_zero--){ | |
6489 if(block[perm_scantable[last_non_zero]]) | |
6490 break; | |
6491 } | |
6492 } | |
6493 #ifdef REFINE_STATS | |
6494 count++; | |
6495 if(256*256*256*64 % count == 0){ | |
6496 printf("after_last:%d to_zero:%d from_zero:%d raise:%d lower:%d sign:%d xyp:%d/%d/%d\n", after_last, to_zero, from_zero, raise, lower, messed_sign, s->mb_x, s->mb_y, s->picture_number); | |
6497 } | |
6498 #endif | |
6499 run=0; | |
6500 rle_index=0; | |
6501 for(i=start_i; i<=last_non_zero; i++){ | |
6502 int j= perm_scantable[i]; | |
6503 const int level= block[j]; | |
2967 | 6504 |
1777 | 6505 if(level){ |
6506 run_tab[rle_index++]=run; | |
6507 run=0; | |
6508 }else{ | |
6509 run++; | |
6510 } | |
6511 } | |
2967 | 6512 |
1784 | 6513 s->dsp.add_8x8basis(rem, basis[j], best_unquant_change); |
1777 | 6514 }else{ |
6515 break; | |
6516 } | |
6517 } | |
6518 #ifdef REFINE_STATS | |
6519 if(last_non_zero>0){ | |
6520 STOP_TIMER("iterative search") | |
6521 } | |
6522 } | |
6523 #endif | |
6524 | |
6525 return last_non_zero; | |
6526 } | |
6527 | |
2967 | 6528 static int dct_quantize_c(MpegEncContext *s, |
0 | 6529 DCTELEM *block, int n, |
344 | 6530 int qscale, int *overflow) |
0 | 6531 { |
1715 | 6532 int i, j, level, last_non_zero, q, start_i; |
0 | 6533 const int *qmat; |
1064 | 6534 const uint8_t *scantable= s->intra_scantable.scantable; |
344 | 6535 int bias; |
6536 int max=0; | |
6537 unsigned int threshold1, threshold2; | |
828
ace3ccd18dd2
Altivec Patch (Mark III) by (Dieter Shirley <dieters at schemasoft dot com>)
michaelni
parents:
815
diff
changeset
|
6538 |
1092 | 6539 s->dsp.fdct (block); |
0 | 6540 |
1597 | 6541 if(s->dct_error_sum) |
1719 | 6542 s->denoise_dct(s, block); |
1597 | 6543 |
0 | 6544 if (s->mb_intra) { |
350
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
347
diff
changeset
|
6545 if (!s->h263_aic) { |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
347
diff
changeset
|
6546 if (n < 4) |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
347
diff
changeset
|
6547 q = s->y_dc_scale; |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
347
diff
changeset
|
6548 else |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
347
diff
changeset
|
6549 q = s->c_dc_scale; |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
347
diff
changeset
|
6550 q = q << 3; |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
347
diff
changeset
|
6551 } else |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
347
diff
changeset
|
6552 /* 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
|
6553 q = 1 << 3; |
2967 | 6554 |
0 | 6555 /* note: block[0] is assumed to be positive */ |
6556 block[0] = (block[0] + (q >> 1)) / q; | |
1715 | 6557 start_i = 1; |
0 | 6558 last_non_zero = 0; |
344 | 6559 qmat = s->q_intra_matrix[qscale]; |
635 | 6560 bias= s->intra_quant_bias<<(QMAT_SHIFT - QUANT_BIAS_SHIFT); |
0 | 6561 } else { |
1715 | 6562 start_i = 0; |
0 | 6563 last_non_zero = -1; |
344 | 6564 qmat = s->q_inter_matrix[qscale]; |
635 | 6565 bias= s->inter_quant_bias<<(QMAT_SHIFT - QUANT_BIAS_SHIFT); |
0 | 6566 } |
635 | 6567 threshold1= (1<<QMAT_SHIFT) - bias - 1; |
6568 threshold2= (threshold1<<1); | |
1715 | 6569 for(i=63;i>=start_i;i--) { |
764 | 6570 j = scantable[i]; |
1715 | 6571 level = block[j] * qmat[j]; |
6572 | |
6573 if(((unsigned)(level+threshold1))>threshold2){ | |
6574 last_non_zero = i; | |
6575 break; | |
6576 }else{ | |
6577 block[j]=0; | |
6578 } | |
6579 } | |
6580 for(i=start_i; i<=last_non_zero; i++) { | |
6581 j = scantable[i]; | |
6582 level = block[j] * qmat[j]; | |
344 | 6583 |
1215 | 6584 // if( bias+level >= (1<<QMAT_SHIFT) |
6585 // || bias-level >= (1<<QMAT_SHIFT)){ | |
344 | 6586 if(((unsigned)(level+threshold1))>threshold2){ |
6587 if(level>0){ | |
635 | 6588 level= (bias + level)>>QMAT_SHIFT; |
344 | 6589 block[j]= level; |
6590 }else{ | |
635 | 6591 level= (bias - level)>>QMAT_SHIFT; |
344 | 6592 block[j]= -level; |
0 | 6593 } |
344 | 6594 max |=level; |
6595 }else{ | |
6596 block[j]=0; | |
0 | 6597 } |
6598 } | |
2627
bf158d23bbcc
Spelling errors patch by (Kevin Baragona | kevinmb500 gawab com)
michael
parents:
2620
diff
changeset
|
6599 *overflow= s->max_qcoeff < max; //overflow might have happened |
2967 | 6600 |
764 | 6601 /* we need this permutation so that we correct the IDCT, we only permute the !=0 elements */ |
1092 | 6602 if (s->dsp.idct_permutation_type != FF_NO_IDCT_PERM) |
2979 | 6603 ff_block_permute(block, s->dsp.idct_permutation, scantable, last_non_zero); |
764 | 6604 |
0 | 6605 return last_non_zero; |
6606 } | |
6607 | |
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
|
6608 #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
|
6609 |
2967 | 6610 static void dct_unquantize_mpeg1_intra_c(MpegEncContext *s, |
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
|
6611 DCTELEM *block, int n, int qscale) |
0 | 6612 { |
200 | 6613 int i, level, nCoeffs; |
1064 | 6614 const uint16_t *quant_matrix; |
0 | 6615 |
706
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
6616 nCoeffs= s->block_last_index[n]; |
2967 | 6617 |
6618 if (n < 4) | |
1689 | 6619 block[0] = block[0] * s->y_dc_scale; |
6620 else | |
6621 block[0] = block[0] * s->c_dc_scale; | |
6622 /* XXX: only mpeg1 */ | |
6623 quant_matrix = s->intra_matrix; | |
6624 for(i=1;i<=nCoeffs;i++) { | |
6625 int j= s->intra_scantable.permutated[i]; | |
6626 level = block[j]; | |
6627 if (level) { | |
6628 if (level < 0) { | |
6629 level = -level; | |
6630 level = (int)(level * qscale * quant_matrix[j]) >> 3; | |
6631 level = (level - 1) | 1; | |
6632 level = -level; | |
6633 } else { | |
6634 level = (int)(level * qscale * quant_matrix[j]) >> 3; | |
6635 level = (level - 1) | 1; | |
0 | 6636 } |
1689 | 6637 block[j] = level; |
0 | 6638 } |
6639 } | |
6640 } | |
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
|
6641 |
2967 | 6642 static void dct_unquantize_mpeg1_inter_c(MpegEncContext *s, |
1689 | 6643 DCTELEM *block, int n, int qscale) |
6644 { | |
6645 int i, level, nCoeffs; | |
6646 const uint16_t *quant_matrix; | |
6647 | |
6648 nCoeffs= s->block_last_index[n]; | |
2967 | 6649 |
1689 | 6650 quant_matrix = s->inter_matrix; |
6651 for(i=0; i<=nCoeffs; i++) { | |
6652 int j= s->intra_scantable.permutated[i]; | |
6653 level = block[j]; | |
6654 if (level) { | |
6655 if (level < 0) { | |
6656 level = -level; | |
6657 level = (((level << 1) + 1) * qscale * | |
6658 ((int) (quant_matrix[j]))) >> 4; | |
6659 level = (level - 1) | 1; | |
6660 level = -level; | |
6661 } else { | |
6662 level = (((level << 1) + 1) * qscale * | |
6663 ((int) (quant_matrix[j]))) >> 4; | |
6664 level = (level - 1) | 1; | |
6665 } | |
6666 block[j] = level; | |
6667 } | |
6668 } | |
6669 } | |
6670 | |
2967 | 6671 static void dct_unquantize_mpeg2_intra_c(MpegEncContext *s, |
325 | 6672 DCTELEM *block, int n, int qscale) |
6673 { | |
6674 int i, level, nCoeffs; | |
1064 | 6675 const uint16_t *quant_matrix; |
325 | 6676 |
706
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
6677 if(s->alternate_scan) nCoeffs= 63; |
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
6678 else nCoeffs= s->block_last_index[n]; |
2967 | 6679 |
6680 if (n < 4) | |
1689 | 6681 block[0] = block[0] * s->y_dc_scale; |
6682 else | |
6683 block[0] = block[0] * s->c_dc_scale; | |
6684 quant_matrix = s->intra_matrix; | |
6685 for(i=1;i<=nCoeffs;i++) { | |
6686 int j= s->intra_scantable.permutated[i]; | |
6687 level = block[j]; | |
6688 if (level) { | |
6689 if (level < 0) { | |
6690 level = -level; | |
6691 level = (int)(level * qscale * quant_matrix[j]) >> 3; | |
6692 level = -level; | |
6693 } else { | |
6694 level = (int)(level * qscale * quant_matrix[j]) >> 3; | |
6695 } | |
6696 block[j] = level; | |
6697 } | |
6698 } | |
6699 } | |
6700 | |
3281
7fac25904a8b
missmatch control for mpeg2 intra dequantization if bitexact=1
michael
parents:
3268
diff
changeset
|
6701 static void dct_unquantize_mpeg2_intra_bitexact(MpegEncContext *s, |
7fac25904a8b
missmatch control for mpeg2 intra dequantization if bitexact=1
michael
parents:
3268
diff
changeset
|
6702 DCTELEM *block, int n, int qscale) |
7fac25904a8b
missmatch control for mpeg2 intra dequantization if bitexact=1
michael
parents:
3268
diff
changeset
|
6703 { |
7fac25904a8b
missmatch control for mpeg2 intra dequantization if bitexact=1
michael
parents:
3268
diff
changeset
|
6704 int i, level, nCoeffs; |
7fac25904a8b
missmatch control for mpeg2 intra dequantization if bitexact=1
michael
parents:
3268
diff
changeset
|
6705 const uint16_t *quant_matrix; |
7fac25904a8b
missmatch control for mpeg2 intra dequantization if bitexact=1
michael
parents:
3268
diff
changeset
|
6706 int sum=-1; |
7fac25904a8b
missmatch control for mpeg2 intra dequantization if bitexact=1
michael
parents:
3268
diff
changeset
|
6707 |
7fac25904a8b
missmatch control for mpeg2 intra dequantization if bitexact=1
michael
parents:
3268
diff
changeset
|
6708 if(s->alternate_scan) nCoeffs= 63; |
7fac25904a8b
missmatch control for mpeg2 intra dequantization if bitexact=1
michael
parents:
3268
diff
changeset
|
6709 else nCoeffs= s->block_last_index[n]; |
7fac25904a8b
missmatch control for mpeg2 intra dequantization if bitexact=1
michael
parents:
3268
diff
changeset
|
6710 |
7fac25904a8b
missmatch control for mpeg2 intra dequantization if bitexact=1
michael
parents:
3268
diff
changeset
|
6711 if (n < 4) |
7fac25904a8b
missmatch control for mpeg2 intra dequantization if bitexact=1
michael
parents:
3268
diff
changeset
|
6712 block[0] = block[0] * s->y_dc_scale; |
7fac25904a8b
missmatch control for mpeg2 intra dequantization if bitexact=1
michael
parents:
3268
diff
changeset
|
6713 else |
7fac25904a8b
missmatch control for mpeg2 intra dequantization if bitexact=1
michael
parents:
3268
diff
changeset
|
6714 block[0] = block[0] * s->c_dc_scale; |
7fac25904a8b
missmatch control for mpeg2 intra dequantization if bitexact=1
michael
parents:
3268
diff
changeset
|
6715 quant_matrix = s->intra_matrix; |
7fac25904a8b
missmatch control for mpeg2 intra dequantization if bitexact=1
michael
parents:
3268
diff
changeset
|
6716 for(i=1;i<=nCoeffs;i++) { |
7fac25904a8b
missmatch control for mpeg2 intra dequantization if bitexact=1
michael
parents:
3268
diff
changeset
|
6717 int j= s->intra_scantable.permutated[i]; |
7fac25904a8b
missmatch control for mpeg2 intra dequantization if bitexact=1
michael
parents:
3268
diff
changeset
|
6718 level = block[j]; |
7fac25904a8b
missmatch control for mpeg2 intra dequantization if bitexact=1
michael
parents:
3268
diff
changeset
|
6719 if (level) { |
7fac25904a8b
missmatch control for mpeg2 intra dequantization if bitexact=1
michael
parents:
3268
diff
changeset
|
6720 if (level < 0) { |
7fac25904a8b
missmatch control for mpeg2 intra dequantization if bitexact=1
michael
parents:
3268
diff
changeset
|
6721 level = -level; |
7fac25904a8b
missmatch control for mpeg2 intra dequantization if bitexact=1
michael
parents:
3268
diff
changeset
|
6722 level = (int)(level * qscale * quant_matrix[j]) >> 3; |
7fac25904a8b
missmatch control for mpeg2 intra dequantization if bitexact=1
michael
parents:
3268
diff
changeset
|
6723 level = -level; |
7fac25904a8b
missmatch control for mpeg2 intra dequantization if bitexact=1
michael
parents:
3268
diff
changeset
|
6724 } else { |
7fac25904a8b
missmatch control for mpeg2 intra dequantization if bitexact=1
michael
parents:
3268
diff
changeset
|
6725 level = (int)(level * qscale * quant_matrix[j]) >> 3; |
7fac25904a8b
missmatch control for mpeg2 intra dequantization if bitexact=1
michael
parents:
3268
diff
changeset
|
6726 } |
7fac25904a8b
missmatch control for mpeg2 intra dequantization if bitexact=1
michael
parents:
3268
diff
changeset
|
6727 block[j] = level; |
7fac25904a8b
missmatch control for mpeg2 intra dequantization if bitexact=1
michael
parents:
3268
diff
changeset
|
6728 sum+=level; |
7fac25904a8b
missmatch control for mpeg2 intra dequantization if bitexact=1
michael
parents:
3268
diff
changeset
|
6729 } |
7fac25904a8b
missmatch control for mpeg2 intra dequantization if bitexact=1
michael
parents:
3268
diff
changeset
|
6730 } |
7fac25904a8b
missmatch control for mpeg2 intra dequantization if bitexact=1
michael
parents:
3268
diff
changeset
|
6731 block[63]^=sum&1; |
7fac25904a8b
missmatch control for mpeg2 intra dequantization if bitexact=1
michael
parents:
3268
diff
changeset
|
6732 } |
7fac25904a8b
missmatch control for mpeg2 intra dequantization if bitexact=1
michael
parents:
3268
diff
changeset
|
6733 |
2967 | 6734 static void dct_unquantize_mpeg2_inter_c(MpegEncContext *s, |
1689 | 6735 DCTELEM *block, int n, int qscale) |
6736 { | |
6737 int i, level, nCoeffs; | |
6738 const uint16_t *quant_matrix; | |
6739 int sum=-1; | |
6740 | |
6741 if(s->alternate_scan) nCoeffs= 63; | |
6742 else nCoeffs= s->block_last_index[n]; | |
2967 | 6743 |
1689 | 6744 quant_matrix = s->inter_matrix; |
6745 for(i=0; i<=nCoeffs; i++) { | |
6746 int j= s->intra_scantable.permutated[i]; | |
6747 level = block[j]; | |
6748 if (level) { | |
6749 if (level < 0) { | |
6750 level = -level; | |
6751 level = (((level << 1) + 1) * qscale * | |
6752 ((int) (quant_matrix[j]))) >> 4; | |
6753 level = -level; | |
6754 } else { | |
6755 level = (((level << 1) + 1) * qscale * | |
6756 ((int) (quant_matrix[j]))) >> 4; | |
6757 } | |
6758 block[j] = level; | |
6759 sum+=level; | |
6760 } | |
6761 } | |
6762 block[63]^=sum&1; | |
6763 } | |
6764 | |
2967 | 6765 static void dct_unquantize_h263_intra_c(MpegEncContext *s, |
1689 | 6766 DCTELEM *block, int n, int qscale) |
6767 { | |
6768 int i, level, qmul, qadd; | |
6769 int nCoeffs; | |
2967 | 6770 |
1689 | 6771 assert(s->block_last_index[n]>=0); |
2967 | 6772 |
1689 | 6773 qmul = qscale << 1; |
2967 | 6774 |
1689 | 6775 if (!s->h263_aic) { |
2967 | 6776 if (n < 4) |
325 | 6777 block[0] = block[0] * s->y_dc_scale; |
6778 else | |
6779 block[0] = block[0] * s->c_dc_scale; | |
1689 | 6780 qadd = (qscale - 1) | 1; |
6781 }else{ | |
6782 qadd = 0; | |
6783 } | |
6784 if(s->ac_pred) | |
6785 nCoeffs=63; | |
6786 else | |
6787 nCoeffs= s->inter_scantable.raster_end[ s->block_last_index[n] ]; | |
6788 | |
6789 for(i=1; i<=nCoeffs; i++) { | |
6790 level = block[i]; | |
6791 if (level) { | |
6792 if (level < 0) { | |
6793 level = level * qmul - qadd; | |
6794 } else { | |
6795 level = level * qmul + qadd; | |
325 | 6796 } |
1689 | 6797 block[i] = level; |
325 | 6798 } |
6799 } | |
6800 } | |
6801 | |
2967 | 6802 static void dct_unquantize_h263_inter_c(MpegEncContext *s, |
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
|
6803 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
|
6804 { |
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
|
6805 int i, level, qmul, qadd; |
200 | 6806 int nCoeffs; |
2967 | 6807 |
706
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
6808 assert(s->block_last_index[n]>=0); |
2967 | 6809 |
706
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
6810 qadd = (qscale - 1) | 1; |
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
6811 qmul = qscale << 1; |
2967 | 6812 |
1689 | 6813 nCoeffs= s->inter_scantable.raster_end[ s->block_last_index[n] ]; |
6814 | |
6815 for(i=0; 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
|
6816 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
|
6817 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
|
6818 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
|
6819 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
|
6820 } 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
|
6821 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
|
6822 } |
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
|
6823 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
|
6824 } |
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
|
6825 } |
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
|
6826 } |
0 | 6827 |
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
|
6828 #ifdef CONFIG_ENCODERS |
0 | 6829 AVCodec h263_encoder = { |
6830 "h263", | |
6831 CODEC_TYPE_VIDEO, | |
6832 CODEC_ID_H263, | |
6833 sizeof(MpegEncContext), | |
6834 MPV_encode_init, | |
6835 MPV_encode_picture, | |
6836 MPV_encode_end, | |
2524 | 6837 .pix_fmts= (enum PixelFormat[]){PIX_FMT_YUV420P, -1}, |
0 | 6838 }; |
6839 | |
6840 AVCodec h263p_encoder = { | |
6841 "h263p", | |
6842 CODEC_TYPE_VIDEO, | |
6843 CODEC_ID_H263P, | |
6844 sizeof(MpegEncContext), | |
6845 MPV_encode_init, | |
6846 MPV_encode_picture, | |
6847 MPV_encode_end, | |
2524 | 6848 .pix_fmts= (enum PixelFormat[]){PIX_FMT_YUV420P, -1}, |
0 | 6849 }; |
6850 | |
1353
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1344
diff
changeset
|
6851 AVCodec flv_encoder = { |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1344
diff
changeset
|
6852 "flv", |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1344
diff
changeset
|
6853 CODEC_TYPE_VIDEO, |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1344
diff
changeset
|
6854 CODEC_ID_FLV1, |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1344
diff
changeset
|
6855 sizeof(MpegEncContext), |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1344
diff
changeset
|
6856 MPV_encode_init, |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1344
diff
changeset
|
6857 MPV_encode_picture, |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1344
diff
changeset
|
6858 MPV_encode_end, |
2524 | 6859 .pix_fmts= (enum PixelFormat[]){PIX_FMT_YUV420P, -1}, |
1353
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1344
diff
changeset
|
6860 }; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1344
diff
changeset
|
6861 |
0 | 6862 AVCodec rv10_encoder = { |
6863 "rv10", | |
6864 CODEC_TYPE_VIDEO, | |
6865 CODEC_ID_RV10, | |
6866 sizeof(MpegEncContext), | |
6867 MPV_encode_init, | |
6868 MPV_encode_picture, | |
6869 MPV_encode_end, | |
2524 | 6870 .pix_fmts= (enum PixelFormat[]){PIX_FMT_YUV420P, -1}, |
0 | 6871 }; |
6872 | |
2380 | 6873 AVCodec rv20_encoder = { |
6874 "rv20", | |
6875 CODEC_TYPE_VIDEO, | |
6876 CODEC_ID_RV20, | |
6877 sizeof(MpegEncContext), | |
6878 MPV_encode_init, | |
6879 MPV_encode_picture, | |
6880 MPV_encode_end, | |
2524 | 6881 .pix_fmts= (enum PixelFormat[]){PIX_FMT_YUV420P, -1}, |
2380 | 6882 }; |
6883 | |
71 | 6884 AVCodec mpeg4_encoder = { |
6885 "mpeg4", | |
0 | 6886 CODEC_TYPE_VIDEO, |
71 | 6887 CODEC_ID_MPEG4, |
0 | 6888 sizeof(MpegEncContext), |
6889 MPV_encode_init, | |
6890 MPV_encode_picture, | |
6891 MPV_encode_end, | |
2524 | 6892 .pix_fmts= (enum PixelFormat[]){PIX_FMT_YUV420P, -1}, |
2111 | 6893 .capabilities= CODEC_CAP_DELAY, |
0 | 6894 }; |
6895 | |
307 | 6896 AVCodec msmpeg4v1_encoder = { |
6897 "msmpeg4v1", | |
0 | 6898 CODEC_TYPE_VIDEO, |
307 | 6899 CODEC_ID_MSMPEG4V1, |
0 | 6900 sizeof(MpegEncContext), |
6901 MPV_encode_init, | |
6902 MPV_encode_picture, | |
6903 MPV_encode_end, | |
2524 | 6904 .pix_fmts= (enum PixelFormat[]){PIX_FMT_YUV420P, -1}, |
0 | 6905 }; |
307 | 6906 |
6907 AVCodec msmpeg4v2_encoder = { | |
6908 "msmpeg4v2", | |
6909 CODEC_TYPE_VIDEO, | |
6910 CODEC_ID_MSMPEG4V2, | |
6911 sizeof(MpegEncContext), | |
6912 MPV_encode_init, | |
6913 MPV_encode_picture, | |
6914 MPV_encode_end, | |
2524 | 6915 .pix_fmts= (enum PixelFormat[]){PIX_FMT_YUV420P, -1}, |
307 | 6916 }; |
6917 | |
6918 AVCodec msmpeg4v3_encoder = { | |
6919 "msmpeg4", | |
6920 CODEC_TYPE_VIDEO, | |
6921 CODEC_ID_MSMPEG4V3, | |
6922 sizeof(MpegEncContext), | |
6923 MPV_encode_init, | |
6924 MPV_encode_picture, | |
6925 MPV_encode_end, | |
2524 | 6926 .pix_fmts= (enum PixelFormat[]){PIX_FMT_YUV420P, -1}, |
307 | 6927 }; |
499 | 6928 |
6929 AVCodec wmv1_encoder = { | |
6930 "wmv1", | |
6931 CODEC_TYPE_VIDEO, | |
6932 CODEC_ID_WMV1, | |
6933 sizeof(MpegEncContext), | |
6934 MPV_encode_init, | |
6935 MPV_encode_picture, | |
6936 MPV_encode_end, | |
2524 | 6937 .pix_fmts= (enum PixelFormat[]){PIX_FMT_YUV420P, -1}, |
499 | 6938 }; |
6939 | |
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
|
6940 #endif //CONFIG_ENCODERS |