Mercurial > libavcodec.hg
annotate mpegvideo.c @ 4656:f5499f9c2dbe libavcodec
remove redundant memset()
author | michael |
---|---|
date | Tue, 13 Mar 2007 22:47:59 +0000 |
parents | f0ce30e115ac |
children | e1939f338a0e |
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" | |
1557 | 33 #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
|
34 #include <limits.h> |
0 | 35 |
17
b69fe46fd708
Adding fastmemcpy stuff to speedup mplayer project
nickols_k
parents:
13
diff
changeset
|
36 #ifdef USE_FASTMEMCPY |
3589 | 37 #include "libvo/fastmemcpy.h" |
17
b69fe46fd708
Adding fastmemcpy stuff to speedup mplayer project
nickols_k
parents:
13
diff
changeset
|
38 #endif |
b69fe46fd708
Adding fastmemcpy stuff to speedup mplayer project
nickols_k
parents:
13
diff
changeset
|
39 |
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
|
40 //#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
|
41 //#include <assert.h> |
706
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
42 |
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 #ifdef CONFIG_ENCODERS |
3766 | 44 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
|
45 #endif //CONFIG_ENCODERS |
2967 | 46 static void dct_unquantize_mpeg1_intra_c(MpegEncContext *s, |
1689 | 47 DCTELEM *block, int n, int qscale); |
2967 | 48 static void dct_unquantize_mpeg1_inter_c(MpegEncContext *s, |
1689 | 49 DCTELEM *block, int n, int qscale); |
50 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
|
51 DCTELEM *block, int n, int qscale); |
3281
7fac25904a8b
missmatch control for mpeg2 intra dequantization if bitexact=1
michael
parents:
3268
diff
changeset
|
52 static void dct_unquantize_mpeg2_intra_bitexact(MpegEncContext *s, |
7fac25904a8b
missmatch control for mpeg2 intra dequantization if bitexact=1
michael
parents:
3268
diff
changeset
|
53 DCTELEM *block, int n, int qscale); |
1689 | 54 static void dct_unquantize_mpeg2_inter_c(MpegEncContext *s, |
325 | 55 DCTELEM *block, int n, int qscale); |
2967 | 56 static void dct_unquantize_h263_intra_c(MpegEncContext *s, |
1689 | 57 DCTELEM *block, int n, int qscale); |
2967 | 58 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
|
59 DCTELEM *block, int n, int qscale); |
1064 | 60 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
|
61 #ifdef CONFIG_ENCODERS |
344 | 62 static int dct_quantize_c(MpegEncContext *s, DCTELEM *block, int n, int qscale, int *overflow); |
945 | 63 static int dct_quantize_trellis_c(MpegEncContext *s, DCTELEM *block, int n, int qscale, int *overflow); |
1777 | 64 static int dct_quantize_refine(MpegEncContext *s, DCTELEM *block, int16_t *weight, DCTELEM *orig, int n, int qscale); |
1389 | 65 static int sse_mb(MpegEncContext *s); |
1719 | 66 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
|
67 #endif //CONFIG_ENCODERS |
206 | 68 |
1381 | 69 #ifdef HAVE_XVMC |
70 extern int XVMC_field_start(MpegEncContext*s, AVCodecContext *avctx); | |
71 extern void XVMC_field_end(MpegEncContext *s); | |
1580
628bf341e099
XvMC speedup by removing one memcpy and doing MB packing
iive
parents:
1579
diff
changeset
|
72 extern void XVMC_decode_mb(MpegEncContext *s); |
1381 | 73 #endif |
74 | |
1064 | 75 void (*draw_edges)(uint8_t *buf, int wrap, int width, int height, int w)= draw_edges_c; |
206 | 76 |
0 | 77 |
78 /* enable all paranoid tests for rounding, overflows, etc... */ | |
79 //#define PARANOID | |
80 | |
81 //#define DEBUG | |
82 | |
321 | 83 |
0 | 84 /* for jpeg fast DCT */ |
85 #define CONST_BITS 14 | |
86 | |
853
eacc2dd8fd9d
* using DSPContext - so each codec could use its local (sub)set of CPU extension
kabi
parents:
847
diff
changeset
|
87 static const uint16_t aanscales[64] = { |
0 | 88 /* precomputed values scaled up by 14 bits */ |
89 16384, 22725, 21407, 19266, 16384, 12873, 8867, 4520, | |
90 22725, 31521, 29692, 26722, 22725, 17855, 12299, 6270, | |
91 21407, 29692, 27969, 25172, 21407, 16819, 11585, 5906, | |
92 19266, 26722, 25172, 22654, 19266, 15137, 10426, 5315, | |
93 16384, 22725, 21407, 19266, 16384, 12873, 8867, 4520, | |
94 12873, 17855, 16819, 15137, 12873, 10114, 6967, 3552, | |
936 | 95 8867 , 12299, 11585, 10426, 8867, 6967, 4799, 2446, |
96 4520 , 6270, 5906, 5315, 4520, 3552, 2446, 1247 | |
0 | 97 }; |
98 | |
853
eacc2dd8fd9d
* using DSPContext - so each codec could use its local (sub)set of CPU extension
kabi
parents:
847
diff
changeset
|
99 static const uint8_t h263_chroma_roundtab[16] = { |
1013 | 100 // 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
0 | 101 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, |
102 }; | |
103 | |
1644 | 104 static const uint8_t ff_default_chroma_qscale_table[32]={ |
105 // 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 | |
106 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 | |
107 }; | |
108 | |
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
|
109 #ifdef CONFIG_ENCODERS |
4655 | 110 static uint8_t default_mv_penalty[MAX_FCODE+1][MAX_MV*2+1]; |
1064 | 111 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
|
112 |
998 | 113 enum PixelFormat ff_yuv420p_list[2]= {PIX_FMT_YUV420P, -1}; |
114 | |
1579
039cb2296de2
make convert_matrix() independant of MpegEncContext
michael
parents:
1573
diff
changeset
|
115 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
|
116 const uint16_t *quant_matrix, int bias, int qmin, int qmax, int intra) |
0 | 117 { |
344 | 118 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
|
119 int shift=0; |
0 | 120 |
709
afeff6ccb7f5
convert only needed matrixes in convert_matrix() (mjpeg calls it for every frame)
michaelni
parents:
706
diff
changeset
|
121 for(qscale=qmin; qscale<=qmax; qscale++){ |
344 | 122 int i; |
2967 | 123 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
|
124 #ifdef FAAN_POSTSCALE |
1579
039cb2296de2
make convert_matrix() independant of MpegEncContext
michael
parents:
1573
diff
changeset
|
125 || dsp->fdct == ff_faandct |
1562
bf452704100f
optionally merge postscale into quantization table for the float aan dct
michael
parents:
1557
diff
changeset
|
126 #endif |
bf452704100f
optionally merge postscale into quantization table for the float aan dct
michael
parents:
1557
diff
changeset
|
127 ) { |
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 for(i=0;i<64;i++) { |
1579
039cb2296de2
make convert_matrix() independant of MpegEncContext
michael
parents:
1573
diff
changeset
|
129 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
|
130 /* 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
|
131 /* 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
|
132 /* (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
|
133 /* 3444240 >= (1<<36)/(aanscales[i] * qscale * quant_matrix[i]) >= 275 */ |
2967 | 134 |
4274 | 135 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
|
136 (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
|
137 } |
1579
039cb2296de2
make convert_matrix() independant of MpegEncContext
michael
parents:
1573
diff
changeset
|
138 } else if (dsp->fdct == fdct_ifast |
1562
bf452704100f
optionally merge postscale into quantization table for the float aan dct
michael
parents:
1557
diff
changeset
|
139 #ifndef FAAN_POSTSCALE |
1579
039cb2296de2
make convert_matrix() independant of MpegEncContext
michael
parents:
1573
diff
changeset
|
140 || dsp->fdct == ff_faandct |
1562
bf452704100f
optionally merge postscale into quantization table for the float aan dct
michael
parents:
1557
diff
changeset
|
141 #endif |
bf452704100f
optionally merge postscale into quantization table for the float aan dct
michael
parents:
1557
diff
changeset
|
142 ) { |
344 | 143 for(i=0;i<64;i++) { |
1579
039cb2296de2
make convert_matrix() independant of MpegEncContext
michael
parents:
1573
diff
changeset
|
144 const int j= dsp->idct_permutation[i]; |
344 | 145 /* 16 <= qscale * quant_matrix[i] <= 7905 */ |
146 /* 19952 <= aanscales[i] * qscale * quant_matrix[i] <= 249205026 */ | |
147 /* (1<<36)/19952 >= (1<<36)/(aanscales[i] * qscale * quant_matrix[i]) >= (1<<36)/249205026 */ | |
148 /* 3444240 >= (1<<36)/(aanscales[i] * qscale * quant_matrix[i]) >= 275 */ | |
2967 | 149 |
4274 | 150 qmat[qscale][i] = (int)((UINT64_C(1) << (QMAT_SHIFT + 14)) / |
344 | 151 (aanscales[i] * qscale * quant_matrix[j])); |
152 } | |
153 } else { | |
154 for(i=0;i<64;i++) { | |
1579
039cb2296de2
make convert_matrix() independant of MpegEncContext
michael
parents:
1573
diff
changeset
|
155 const int j= dsp->idct_permutation[i]; |
344 | 156 /* We can safely suppose that 16 <= quant_matrix[i] <= 255 |
157 So 16 <= qscale * quant_matrix[i] <= 7905 | |
158 so (1<<19) / 16 >= (1<<19) / (qscale * quant_matrix[i]) >= (1<<19) / 7905 | |
159 so 32768 >= (1<<19) / (qscale * quant_matrix[i]) >= 67 | |
160 */ | |
4274 | 161 qmat[qscale][i] = (int)((UINT64_C(1) << QMAT_SHIFT) / (qscale * quant_matrix[j])); |
945 | 162 // 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
|
163 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
|
164 |
d736e24bf303
move mmx quantizer matrixes out of MpegEncContext (23k -> 7k) (no meassureable slowdown)
michael
parents:
1553
diff
changeset
|
165 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
|
166 qmat16[qscale][1][i]= ROUNDED_DIV(bias<<(16-QUANT_BIAS_SHIFT), qmat16[qscale][0][i]); |
344 | 167 } |
0 | 168 } |
2967 | 169 |
2385
4605a8b188c3
warn the user if the quantization code could overflow with the selected custom matrix and qp limits
michael
parents:
2382
diff
changeset
|
170 for(i=intra; i<64; i++){ |
2390 | 171 int64_t max= 8191; |
172 if (dsp->fdct == fdct_ifast | |
173 #ifndef FAAN_POSTSCALE | |
174 || dsp->fdct == ff_faandct | |
175 #endif | |
176 ) { | |
177 max= (8191LL*aanscales[i]) >> 14; | |
178 } | |
2967 | 179 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
|
180 shift++; |
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 } |
4605a8b188c3
warn the user if the quantization code could overflow with the selected custom matrix and qp limits
michael
parents:
2382
diff
changeset
|
183 } |
4605a8b188c3
warn the user if the quantization code could overflow with the selected custom matrix and qp limits
michael
parents:
2382
diff
changeset
|
184 if(shift){ |
4525 | 185 av_log(NULL, AV_LOG_INFO, "Warning, QMAT_SHIFT is larger than %d, overflows possible\n", QMAT_SHIFT - shift); |
0 | 186 } |
187 } | |
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
|
188 |
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
|
189 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
|
190 s->qscale= (s->lambda*139 + FF_LAMBDA_SCALE*64) >> (FF_LAMBDA_SHIFT + 7); |
4594 | 191 s->qscale= av_clip(s->qscale, s->avctx->qmin, s->avctx->qmax); |
2967 | 192 |
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
|
193 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
|
194 } |
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
|
195 #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
|
196 |
1273 | 197 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
|
198 int i; |
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
199 int end; |
2967 | 200 |
764 | 201 st->scantable= src_scantable; |
706
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
202 |
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
203 for(i=0; i<64; i++){ |
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
204 int j; |
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
205 j = src_scantable[i]; |
1273 | 206 st->permutated[i] = permutation[j]; |
828
ace3ccd18dd2
Altivec Patch (Mark III) by (Dieter Shirley <dieters at schemasoft dot com>)
michaelni
parents:
815
diff
changeset
|
207 #ifdef ARCH_POWERPC |
ace3ccd18dd2
Altivec Patch (Mark III) by (Dieter Shirley <dieters at schemasoft dot com>)
michaelni
parents:
815
diff
changeset
|
208 st->inverse[j] = i; |
ace3ccd18dd2
Altivec Patch (Mark III) by (Dieter Shirley <dieters at schemasoft dot com>)
michaelni
parents:
815
diff
changeset
|
209 #endif |
706
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
210 } |
2967 | 211 |
706
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
212 end=-1; |
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
213 for(i=0; i<64; i++){ |
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
214 int j; |
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
215 j = st->permutated[i]; |
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
216 if(j>end) end=j; |
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
217 st->raster_end[i]= end; |
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
218 } |
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
219 } |
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
220 |
1530
3b31998fe22f
disable encoders where appropriate (patch courtesy of BERO
melanson
parents:
1523
diff
changeset
|
221 #ifdef CONFIG_ENCODERS |
3776 | 222 void ff_write_quant_matrix(PutBitContext *pb, uint16_t *matrix){ |
1411 | 223 int i; |
224 | |
225 if(matrix){ | |
226 put_bits(pb, 1, 1); | |
227 for(i=0;i<64;i++) { | |
228 put_bits(pb, 8, matrix[ ff_zigzag_direct[i] ]); | |
229 } | |
230 }else | |
231 put_bits(pb, 1, 0); | |
232 } | |
1530
3b31998fe22f
disable encoders where appropriate (patch courtesy of BERO
melanson
parents:
1523
diff
changeset
|
233 #endif //CONFIG_ENCODERS |
1411 | 234 |
3086 | 235 const uint8_t *ff_find_start_code(const uint8_t * restrict p, const uint8_t *end, uint32_t * restrict state){ |
236 int i; | |
237 | |
3092 | 238 assert(p<=end); |
239 if(p>=end) | |
240 return end; | |
241 | |
3086 | 242 for(i=0; i<3; i++){ |
243 uint32_t tmp= *state << 8; | |
244 *state= tmp + *(p++); | |
245 if(tmp == 0x100 || p==end) | |
246 return p; | |
247 } | |
248 | |
249 while(p<end){ | |
3087 | 250 if (p[-1] > 1 ) p+= 3; |
251 else if(p[-2] ) p+= 2; | |
252 else if(p[-3]|(p[-1]-1)) p++; | |
3086 | 253 else{ |
254 p++; | |
255 break; | |
256 } | |
257 } | |
258 | |
3087 | 259 p= FFMIN(p, end)-4; |
3086 | 260 *state= be2me_32(unaligned32(p)); |
261 | |
262 return p+4; | |
263 } | |
264 | |
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
|
265 /* 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
|
266 int DCT_common_init(MpegEncContext *s) |
0 | 267 { |
1689 | 268 s->dct_unquantize_h263_intra = dct_unquantize_h263_intra_c; |
269 s->dct_unquantize_h263_inter = dct_unquantize_h263_inter_c; | |
270 s->dct_unquantize_mpeg1_intra = dct_unquantize_mpeg1_intra_c; | |
271 s->dct_unquantize_mpeg1_inter = dct_unquantize_mpeg1_inter_c; | |
272 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
|
273 if(s->flags & CODEC_FLAG_BITEXACT) |
7fac25904a8b
missmatch control for mpeg2 intra dequantization if bitexact=1
michael
parents:
3268
diff
changeset
|
274 s->dct_unquantize_mpeg2_intra = dct_unquantize_mpeg2_intra_bitexact; |
1689 | 275 s->dct_unquantize_mpeg2_inter = dct_unquantize_mpeg2_inter_c; |
1092 | 276 |
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
|
277 #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
|
278 s->dct_quantize= dct_quantize_c; |
1719 | 279 s->denoise_dct= denoise_dct_c; |
2616
ba6530ae8e34
remove superfluous CONFIG_ENCODERS (entire function is already wrapped)
melanson
parents:
2584
diff
changeset
|
280 #endif //CONFIG_ENCODERS |
2967 | 281 |
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
|
282 #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
|
283 MPV_common_init_mmx(s); |
8 | 284 #endif |
514
c9f724e3a797
Update and activate dct_unquantize_h263_mvi. Thanks to M«©ns Rullg«©rd
mellum
parents:
506
diff
changeset
|
285 #ifdef ARCH_ALPHA |
c9f724e3a797
Update and activate dct_unquantize_h263_mvi. Thanks to M«©ns Rullg«©rd
mellum
parents:
506
diff
changeset
|
286 MPV_common_init_axp(s); |
c9f724e3a797
Update and activate dct_unquantize_h263_mvi. Thanks to M«©ns Rullg«©rd
mellum
parents:
506
diff
changeset
|
287 #endif |
628
f596db4aa871
sun solaris compilation bugfix, patch by (Martin Olschewski <olschewski at zpr dot uni-koeln dot de>)
michaelni
parents:
625
diff
changeset
|
288 #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
|
289 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
|
290 #endif |
721
71f669e9f633
ps2 optimizations update patch by (Leon van Stuivenberg <leonvs at iae dot nl>)
michaelni
parents:
717
diff
changeset
|
291 #ifdef HAVE_MMI |
71f669e9f633
ps2 optimizations update patch by (Leon van Stuivenberg <leonvs at iae dot nl>)
michaelni
parents:
717
diff
changeset
|
292 MPV_common_init_mmi(s); |
71f669e9f633
ps2 optimizations update patch by (Leon van Stuivenberg <leonvs at iae dot nl>)
michaelni
parents:
717
diff
changeset
|
293 #endif |
730 | 294 #ifdef ARCH_ARMV4L |
874 | 295 MPV_common_init_armv4l(s); |
730 | 296 #endif |
828
ace3ccd18dd2
Altivec Patch (Mark III) by (Dieter Shirley <dieters at schemasoft dot com>)
michaelni
parents:
815
diff
changeset
|
297 #ifdef ARCH_POWERPC |
ace3ccd18dd2
Altivec Patch (Mark III) by (Dieter Shirley <dieters at schemasoft dot com>)
michaelni
parents:
815
diff
changeset
|
298 MPV_common_init_ppc(s); |
ace3ccd18dd2
Altivec Patch (Mark III) by (Dieter Shirley <dieters at schemasoft dot com>)
michaelni
parents:
815
diff
changeset
|
299 #endif |
730 | 300 |
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
|
301 #ifdef CONFIG_ENCODERS |
1007 | 302 s->fast_dct_quantize= s->dct_quantize; |
303 | |
945 | 304 if(s->flags&CODEC_FLAG_TRELLIS_QUANT){ |
305 s->dct_quantize= dct_quantize_trellis_c; //move before MPV_common_init_* | |
306 } | |
307 | |
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
|
308 #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
|
309 |
706
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
310 /* load & permutate scantables |
2967 | 311 note: only wmv uses different ones |
706
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
312 */ |
1708 | 313 if(s->alternate_scan){ |
314 ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable , ff_alternate_vertical_scan); | |
315 ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable , ff_alternate_vertical_scan); | |
316 }else{ | |
317 ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable , ff_zigzag_direct); | |
318 ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable , ff_zigzag_direct); | |
319 } | |
1273 | 320 ff_init_scantable(s->dsp.idct_permutation, &s->intra_h_scantable, ff_alternate_horizontal_scan); |
321 ff_init_scantable(s->dsp.idct_permutation, &s->intra_v_scantable, ff_alternate_vertical_scan); | |
591 | 322 |
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
|
323 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
|
324 } |
a91203b34e71
moved dct init out from mpv_common_init to dct_common_init (for less-uglier way for dv)
al3x
parents:
721
diff
changeset
|
325 |
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
|
326 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
|
327 *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
|
328 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
|
329 } |
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
|
330 |
3777 | 331 #ifdef CONFIG_ENCODERS |
1938
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1918
diff
changeset
|
332 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
|
333 int i; |
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1918
diff
changeset
|
334 |
1702 | 335 dst->pict_type = src->pict_type; |
336 dst->quality = src->quality; | |
337 dst->coded_picture_number = src->coded_picture_number; | |
338 dst->display_picture_number = src->display_picture_number; | |
339 // dst->reference = src->reference; | |
340 dst->pts = src->pts; | |
341 dst->interlaced_frame = src->interlaced_frame; | |
342 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
|
343 |
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
|
344 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
|
345 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
|
346 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
|
347 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
|
348 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
|
349 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
|
350 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
|
351 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
|
352 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
|
353 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
|
354 |
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 memcpy(dst->mb_type, src->mb_type, s->mb_stride * s->mb_height * sizeof(dst->mb_type[0])); |
2967 | 356 |
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
|
357 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
|
358 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
|
359 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
|
360 |
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
|
361 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
|
362 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
|
363 } |
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 if(src->ref_index[i] && src->ref_index[i] != dst->ref_index[i]){ |
1948 | 365 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
|
366 } |
1938
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1918
diff
changeset
|
367 } |
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1918
diff
changeset
|
368 } |
1702 | 369 } |
3777 | 370 #endif |
1702 | 371 |
903 | 372 /** |
924 | 373 * allocates a Picture |
374 * The pixels are allocated/set by calling get_buffer() if shared=0 | |
903 | 375 */ |
924 | 376 static int alloc_picture(MpegEncContext *s, Picture *pic, int shared){ |
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
|
377 const int big_mb_num= s->mb_stride*(s->mb_height+1) + 1; //the +1 is needed so memset(,,stride*height) doesnt sig11 |
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
|
378 const int mb_array_size= s->mb_stride*s->mb_height; |
1655 | 379 const int b8_array_size= s->b8_stride*s->mb_height*2; |
380 const int b4_array_size= s->b4_stride*s->mb_height*4; | |
1168 | 381 int i; |
2967 | 382 |
924 | 383 if(shared){ |
384 assert(pic->data[0]); | |
385 assert(pic->type == 0 || pic->type == FF_BUFFER_TYPE_SHARED); | |
386 pic->type= FF_BUFFER_TYPE_SHARED; | |
387 }else{ | |
388 int r; | |
2967 | 389 |
924 | 390 assert(!pic->data[0]); |
2967 | 391 |
925 | 392 r= s->avctx->get_buffer(s->avctx, (AVFrame*)pic); |
2967 | 393 |
924 | 394 if(r<0 || !pic->age || !pic->type || !pic->data[0]){ |
2979 | 395 av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed (%d %d %d %p)\n", r, pic->age, pic->type, pic->data[0]); |
924 | 396 return -1; |
397 } | |
398 | |
399 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
|
400 av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed (stride changed)\n"); |
924 | 401 return -1; |
402 } | |
403 | |
404 if(pic->linesize[1] != pic->linesize[2]){ | |
2764 | 405 av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed (uv stride mismatch)\n"); |
924 | 406 return -1; |
407 } | |
408 | |
409 s->linesize = pic->linesize[0]; | |
410 s->uvlinesize= pic->linesize[1]; | |
903 | 411 } |
2967 | 412 |
924 | 413 if(pic->qscale_table==NULL){ |
2967 | 414 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
|
415 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
|
416 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
|
417 CHECKED_ALLOCZ(pic->mb_mean , mb_array_size * sizeof(int8_t)) |
924 | 418 } |
419 | |
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
|
420 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
|
421 CHECKED_ALLOCZ(pic->qscale_table , mb_array_size * sizeof(uint8_t)) |
1742 | 422 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
|
423 pic->mb_type= pic->mb_type_base + s->mb_stride+1; |
1168 | 424 if(s->out_format == FMT_H264){ |
425 for(i=0; i<2; i++){ | |
2570 | 426 CHECKED_ALLOCZ(pic->motion_val_base[i], 2 * (b4_array_size+4) * sizeof(int16_t)) |
427 pic->motion_val[i]= pic->motion_val_base[i]+4; | |
1948 | 428 CHECKED_ALLOCZ(pic->ref_index[i], b8_array_size * sizeof(uint8_t)) |
1655 | 429 } |
1669 | 430 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
|
431 }else if(s->out_format == FMT_H263 || s->encoding || (s->avctx->debug&FF_DEBUG_MV) || (s->avctx->debug_mv)){ |
1655 | 432 for(i=0; i<2; i++){ |
2570 | 433 CHECKED_ALLOCZ(pic->motion_val_base[i], 2 * (b8_array_size+4) * sizeof(int16_t)) |
434 pic->motion_val[i]= pic->motion_val_base[i]+4; | |
1948 | 435 CHECKED_ALLOCZ(pic->ref_index[i], b8_array_size * sizeof(uint8_t)) |
1168 | 436 } |
1669 | 437 pic->motion_subsample_log2= 3; |
1168 | 438 } |
1833
ba27ce284d07
export DCT coefficients patch by (Wolfgang Hesseler <wolfgang.hesseler at imk dot fraunhofer dot de>)
michael
parents:
1831
diff
changeset
|
439 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
|
440 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
|
441 } |
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
|
442 pic->qstride= s->mb_stride; |
1546 | 443 CHECKED_ALLOCZ(pic->pan_scan , 1 * sizeof(AVPanScan)) |
924 | 444 } |
1168 | 445 |
1021
2d7c9f5738de
trying to fix mb skip bug in mpeg1/2 if slices are not used
michaelni
parents:
1014
diff
changeset
|
446 //it might be nicer if the application would keep track of these but it would require a API change |
2d7c9f5738de
trying to fix mb skip bug in mpeg1/2 if slices are not used
michaelni
parents:
1014
diff
changeset
|
447 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
|
448 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
|
449 if(pic->age < PREV_PICT_TYPES_BUFFER_SIZE && s->prev_pict_types[pic->age] == B_TYPE) |
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
|
450 pic->age= INT_MAX; // skipped MBs in b frames are quite rare in mpeg1/2 and its a bit tricky to skip them anyway |
2967 | 451 |
903 | 452 return 0; |
453 fail: //for the CHECKED_ALLOCZ macro | |
454 return -1; | |
455 } | |
456 | |
924 | 457 /** |
458 * deallocates a picture | |
459 */ | |
903 | 460 static void free_picture(MpegEncContext *s, Picture *pic){ |
461 int i; | |
924 | 462 |
463 if(pic->data[0] && pic->type!=FF_BUFFER_TYPE_SHARED){ | |
925 | 464 s->avctx->release_buffer(s->avctx, (AVFrame*)pic); |
924 | 465 } |
466 | |
903 | 467 av_freep(&pic->mb_var); |
468 av_freep(&pic->mc_mb_var); | |
469 av_freep(&pic->mb_mean); | |
470 av_freep(&pic->mbskip_table); | |
471 av_freep(&pic->qscale_table); | |
1168 | 472 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
|
473 av_freep(&pic->dct_coeff); |
1546 | 474 av_freep(&pic->pan_scan); |
1168 | 475 pic->mb_type= NULL; |
476 for(i=0; i<2; i++){ | |
1655 | 477 av_freep(&pic->motion_val_base[i]); |
1168 | 478 av_freep(&pic->ref_index[i]); |
479 } | |
2967 | 480 |
1214 | 481 if(pic->type == FF_BUFFER_TYPE_SHARED){ |
924 | 482 for(i=0; i<4; i++){ |
483 pic->base[i]= | |
484 pic->data[i]= NULL; | |
485 } | |
2967 | 486 pic->type= 0; |
903 | 487 } |
488 } | |
489 | |
1799 | 490 static int init_duplicate_context(MpegEncContext *s, MpegEncContext *base){ |
491 int i; | |
492 | |
2967 | 493 // edge emu needs blocksize + filter length - 1 (=17x17 for halfpel / 21x21 for h264) |
3316 | 494 CHECKED_ALLOCZ(s->allocated_edge_emu_buffer, (s->width+64)*2*21*2); //(width + edge + align)*interlaced*MBsize*tolerance |
495 s->edge_emu_buffer= s->allocated_edge_emu_buffer + (s->width+64)*2*21; | |
1799 | 496 |
497 //FIXME should be linesize instead of s->width*2 but that isnt known before get_buffer() | |
2967 | 498 CHECKED_ALLOCZ(s->me.scratchpad, (s->width+64)*4*16*2*sizeof(uint8_t)) |
1799 | 499 s->rd_scratchpad= s->me.scratchpad; |
500 s->b_scratchpad= s->me.scratchpad; | |
501 s->obmc_scratchpad= s->me.scratchpad + 16; | |
502 if (s->encoding) { | |
503 CHECKED_ALLOCZ(s->me.map , ME_MAP_SIZE*sizeof(uint32_t)) | |
504 CHECKED_ALLOCZ(s->me.score_map, ME_MAP_SIZE*sizeof(uint32_t)) | |
505 if(s->avctx->noise_reduction){ | |
506 CHECKED_ALLOCZ(s->dct_error_sum, 2 * 64 * sizeof(int)) | |
507 } | |
2967 | 508 } |
1848
c72589baee53
initial chroma_format changes,xvmc tweaks and codec_cap
iive
parents:
1846
diff
changeset
|
509 CHECKED_ALLOCZ(s->blocks, 64*12*2 * sizeof(DCTELEM)) |
1799 | 510 s->block= s->blocks[0]; |
511 | |
512 for(i=0;i<12;i++){ | |
513 s->pblocks[i] = (short *)(&s->block[i]); | |
514 } | |
515 return 0; | |
516 fail: | |
517 return -1; //free() through MPV_common_end() | |
518 } | |
519 | |
520 static void free_duplicate_context(MpegEncContext *s){ | |
521 if(s==NULL) return; | |
522 | |
523 av_freep(&s->allocated_edge_emu_buffer); s->edge_emu_buffer= NULL; | |
524 av_freep(&s->me.scratchpad); | |
2967 | 525 s->rd_scratchpad= |
526 s->b_scratchpad= | |
1799 | 527 s->obmc_scratchpad= NULL; |
2967 | 528 |
1799 | 529 av_freep(&s->dct_error_sum); |
530 av_freep(&s->me.map); | |
531 av_freep(&s->me.score_map); | |
532 av_freep(&s->blocks); | |
533 s->block= NULL; | |
534 } | |
535 | |
536 static void backup_duplicate_context(MpegEncContext *bak, MpegEncContext *src){ | |
537 #define COPY(a) bak->a= src->a | |
538 COPY(allocated_edge_emu_buffer); | |
539 COPY(edge_emu_buffer); | |
540 COPY(me.scratchpad); | |
541 COPY(rd_scratchpad); | |
542 COPY(b_scratchpad); | |
543 COPY(obmc_scratchpad); | |
544 COPY(me.map); | |
545 COPY(me.score_map); | |
546 COPY(blocks); | |
547 COPY(block); | |
548 COPY(start_mb_y); | |
549 COPY(end_mb_y); | |
550 COPY(me.map_generation); | |
551 COPY(pb); | |
552 COPY(dct_error_sum); | |
1810 | 553 COPY(dct_count[0]); |
554 COPY(dct_count[1]); | |
1799 | 555 #undef COPY |
556 } | |
557 | |
1827 | 558 void ff_update_duplicate_context(MpegEncContext *dst, MpegEncContext *src){ |
1799 | 559 MpegEncContext bak; |
1827 | 560 int i; |
1799 | 561 //FIXME copy only needed parts |
562 //START_TIMER | |
563 backup_duplicate_context(&bak, dst); | |
564 memcpy(dst, src, sizeof(MpegEncContext)); | |
565 backup_duplicate_context(dst, &bak); | |
1827 | 566 for(i=0;i<12;i++){ |
567 dst->pblocks[i] = (short *)(&dst->block[i]); | |
568 } | |
1799 | 569 //STOP_TIMER("update_duplicate_context") //about 10k cycles / 0.01 sec for 1000frames on 1ghz with 2 threads |
570 } | |
571 | |
3777 | 572 #ifdef CONFIG_ENCODERS |
1799 | 573 static void update_duplicate_context_after_me(MpegEncContext *dst, MpegEncContext *src){ |
574 #define COPY(a) dst->a= src->a | |
575 COPY(pict_type); | |
576 COPY(current_picture); | |
577 COPY(f_code); | |
578 COPY(b_code); | |
579 COPY(qscale); | |
580 COPY(lambda); | |
581 COPY(lambda2); | |
582 COPY(picture_in_gop_number); | |
583 COPY(gop_picture_number); | |
2764 | 584 COPY(frame_pred_frame_dct); //FIXME don't set in encode_header |
585 COPY(progressive_frame); //FIXME don't set in encode_header | |
586 COPY(partitioned_frame); //FIXME don't set in encode_header | |
1799 | 587 #undef COPY |
588 } | |
3777 | 589 #endif |
1799 | 590 |
1892 | 591 /** |
592 * sets the given MpegEncContext to common defaults (same for encoding and decoding). | |
593 * the changed fields will not depend upon the prior state of the MpegEncContext. | |
594 */ | |
595 static void MPV_common_defaults(MpegEncContext *s){ | |
596 s->y_dc_scale_table= | |
597 s->c_dc_scale_table= ff_mpeg1_dc_scale_table; | |
598 s->chroma_qscale_table= ff_default_chroma_qscale_table; | |
599 s->progressive_frame= 1; | |
600 s->progressive_sequence= 1; | |
601 s->picture_structure= PICT_FRAME; | |
602 | |
603 s->coded_picture_number = 0; | |
604 s->picture_number = 0; | |
605 s->input_picture_number = 0; | |
606 | |
607 s->picture_in_gop_number = 0; | |
1894 | 608 |
609 s->f_code = 1; | |
610 s->b_code = 1; | |
1892 | 611 } |
612 | |
613 /** | |
614 * sets the given MpegEncContext to defaults for decoding. | |
615 * the changed fields will not depend upon the prior state of the MpegEncContext. | |
616 */ | |
617 void MPV_decode_defaults(MpegEncContext *s){ | |
618 MPV_common_defaults(s); | |
619 } | |
620 | |
621 /** | |
622 * sets the given MpegEncContext to defaults for encoding. | |
623 * the changed fields will not depend upon the prior state of the MpegEncContext. | |
624 */ | |
1902
a5588762c4fa
Compile fix by (Chip <szarlada at freemail dot hu>)
michael
parents:
1894
diff
changeset
|
625 |
a5588762c4fa
Compile fix by (Chip <szarlada at freemail dot hu>)
michael
parents:
1894
diff
changeset
|
626 #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
|
627 static void MPV_encode_defaults(MpegEncContext *s){ |
1892 | 628 static int done=0; |
2967 | 629 |
1892 | 630 MPV_common_defaults(s); |
2967 | 631 |
1892 | 632 if(!done){ |
633 int i; | |
634 done=1; | |
635 | |
636 for(i=-16; i<16; i++){ | |
637 default_fcode_tab[i + MAX_MV]= 1; | |
638 } | |
639 } | |
640 s->me.mv_penalty= default_mv_penalty; | |
641 s->fcode_tab= default_fcode_tab; | |
642 } | |
1902
a5588762c4fa
Compile fix by (Chip <szarlada at freemail dot hu>)
michael
parents:
1894
diff
changeset
|
643 #endif //CONFIG_ENCODERS |
1892 | 644 |
2967 | 645 /** |
1892 | 646 * init common structure for both encoder and decoder. |
647 * this assumes that some variables like width/height are already set | |
648 */ | |
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
|
649 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
|
650 { |
1708 | 651 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
|
652 |
3070 | 653 s->mb_height = (s->height + 15) / 16; |
654 | |
655 if(s->avctx->thread_count > MAX_THREADS || (s->avctx->thread_count > s->mb_height && s->mb_height)){ | |
1989 | 656 av_log(s->avctx, AV_LOG_ERROR, "too many threads\n"); |
657 return -1; | |
658 } | |
659 | |
2422 | 660 if((s->width || s->height) && avcodec_check_dimensions(s->avctx, s->width, s->height)) |
661 return -1; | |
662 | |
1092 | 663 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
|
664 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
|
665 |
754 | 666 s->flags= s->avctx->flags; |
1754
bdf3927bf8c5
closed gop support & flags2 as all bits in flags are used
michael
parents:
1751
diff
changeset
|
667 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
|
668 |
903 | 669 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
|
670 s->mb_stride = s->mb_width + 1; |
1655 | 671 s->b8_stride = s->mb_width*2 + 1; |
672 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
|
673 mb_array_size= s->mb_height * s->mb_stride; |
1708 | 674 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
|
675 |
2074
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
676 /* set chroma shifts */ |
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
677 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
|
678 &(s->chroma_y_shift) ); |
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
679 |
853
eacc2dd8fd9d
* using DSPContext - so each codec could use its local (sub)set of CPU extension
kabi
parents:
847
diff
changeset
|
680 /* 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
|
681 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
|
682 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
|
683 |
eacc2dd8fd9d
* using DSPContext - so each codec could use its local (sub)set of CPU extension
kabi
parents:
847
diff
changeset
|
684 s->mb_num = s->mb_width * s->mb_height; |
2967 | 685 |
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
|
686 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
|
687 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
|
688 s->block_wrap[2]= |
1938
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1918
diff
changeset
|
689 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
|
690 s->block_wrap[4]= |
1938
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1918
diff
changeset
|
691 s->block_wrap[5]= s->mb_stride; |
2967 | 692 |
1938
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1918
diff
changeset
|
693 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
|
694 c_size = s->mb_stride * (s->mb_height + 1); |
756 | 695 yc_size = y_size + 2 * c_size; |
2967 | 696 |
701 | 697 /* 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
|
698 s->codec_tag= toupper( s->avctx->codec_tag &0xFF) |
1116 | 699 + (toupper((s->avctx->codec_tag>>8 )&0xFF)<<8 ) |
2967 | 700 + (toupper((s->avctx->codec_tag>>16)&0xFF)<<16) |
1116 | 701 + (toupper((s->avctx->codec_tag>>24)&0xFF)<<24); |
582
5132a4ee50cd
different edge positions fixed with edge emu / dr1
michaelni
parents:
575
diff
changeset
|
702 |
4155
0f28fc219799
add codec_tag and codec_stream_tag to MpegEncContext to not alter avctx values
bcoudurier
parents:
4122
diff
changeset
|
703 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
|
704 + (toupper((s->avctx->stream_codec_tag>>8 )&0xFF)<<8 ) |
2967 | 705 + (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
|
706 + (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
|
707 |
925 | 708 s->avctx->coded_frame= (AVFrame*)&s->current_picture; |
903 | 709 |
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
|
710 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
|
711 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
|
712 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
|
713 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
|
714 } |
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 } |
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 s->mb_index2xy[ s->mb_height*s->mb_width ] = (s->mb_height-1)*s->mb_stride + s->mb_width; //FIXME really needed? |
2967 | 717 |
232
b640ec5948b0
- Now the ME is done for the entire picture when enconding, the
pulento
parents:
231
diff
changeset
|
718 if (s->encoding) { |
324 | 719 /* 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
|
720 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
|
721 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
|
722 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
|
723 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
|
724 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
|
725 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
|
726 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
|
727 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
|
728 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
|
729 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
|
730 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
|
731 s->b_direct_mv_table = s->b_direct_mv_table_base + s->mb_stride + 1; |
324 | 732 |
650
ef4a33aad86e
reducing sizeof MpegEncContext to avoid stack overflow on crap M$ windo$
michaelni
parents:
635
diff
changeset
|
733 if(s->msmpeg4_version){ |
ef4a33aad86e
reducing sizeof MpegEncContext to avoid stack overflow on crap M$ windo$
michaelni
parents:
635
diff
changeset
|
734 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
|
735 } |
612 | 736 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
|
737 |
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
|
738 /* Allocate MB type table */ |
1708 | 739 CHECKED_ALLOCZ(s->mb_type , mb_array_size * sizeof(uint16_t)) //needed for encoding |
2967 | 740 |
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
|
741 CHECKED_ALLOCZ(s->lambda_table, mb_array_size * sizeof(int)) |
2967 | 742 |
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
|
743 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
|
744 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
|
745 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
|
746 CHECKED_ALLOCZ(s->q_inter_matrix16, 64*32*2 * sizeof(uint16_t)) |
1556 | 747 CHECKED_ALLOCZ(s->input_picture, MAX_PICTURE_COUNT * sizeof(Picture*)) |
748 CHECKED_ALLOCZ(s->reordered_input_picture, MAX_PICTURE_COUNT * sizeof(Picture*)) | |
2967 | 749 |
1597 | 750 if(s->avctx->noise_reduction){ |
751 CHECKED_ALLOCZ(s->dct_offset, 2 * 64 * sizeof(uint16_t)) | |
752 } | |
232
b640ec5948b0
- Now the ME is done for the entire picture when enconding, the
pulento
parents:
231
diff
changeset
|
753 } |
1552
26c6ecba99a1
dynamic alloc of picture structs instead of putting them in MpegEncContext
michael
parents:
1546
diff
changeset
|
754 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
|
755 |
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
|
756 CHECKED_ALLOCZ(s->error_status_table, mb_array_size*sizeof(uint8_t)) |
2967 | 757 |
1708 | 758 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
|
759 /* interlaced direct mode decoding tables */ |
1708 | 760 for(i=0; i<2; i++){ |
761 int j, k; | |
762 for(j=0; j<2; j++){ | |
763 for(k=0; k<2; k++){ | |
764 CHECKED_ALLOCZ(s->b_field_mv_table_base[i][j][k] , mv_table_size * 2 * sizeof(int16_t)) | |
765 s->b_field_mv_table[i][j][k] = s->b_field_mv_table_base[i][j][k] + s->mb_stride + 1; | |
766 } | |
767 CHECKED_ALLOCZ(s->b_field_select_table[i][j] , mb_array_size * 2 * sizeof(uint8_t)) | |
768 CHECKED_ALLOCZ(s->p_field_mv_table_base[i][j] , mv_table_size * 2 * sizeof(int16_t)) | |
769 s->p_field_mv_table[i][j] = s->p_field_mv_table_base[i][j] + s->mb_stride + 1; | |
770 } | |
771 CHECKED_ALLOCZ(s->p_field_select_table[i] , mb_array_size * 2 * sizeof(uint8_t)) | |
772 } | |
0 | 773 } |
767 | 774 if (s->out_format == FMT_H263) { |
0 | 775 /* ac values */ |
1938
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1918
diff
changeset
|
776 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
|
777 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
|
778 s->ac_val[1] = s->ac_val_base + y_size + s->mb_stride + 1; |
0 | 779 s->ac_val[2] = s->ac_val[1] + c_size; |
2967 | 780 |
0 | 781 /* cbp values */ |
1938
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1918
diff
changeset
|
782 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
|
783 s->coded_block= s->coded_block_base + s->b8_stride + 1; |
2967 | 784 |
456 | 785 /* 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
|
786 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
|
787 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
|
788 } |
2967 | 789 |
756 | 790 if (s->h263_pred || s->h263_plus || !s->encoding) { |
791 /* dc values */ | |
792 //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
|
793 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
|
794 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
|
795 s->dc_val[1] = s->dc_val_base + y_size + s->mb_stride + 1; |
756 | 796 s->dc_val[2] = s->dc_val[1] + c_size; |
797 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
|
798 s->dc_val_base[i] = 1024; |
756 | 799 } |
800 | |
611
3214d3f4519e
error concealment needs the mbintra_table so it should allways be allocated
michaelni
parents:
608
diff
changeset
|
801 /* 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
|
802 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
|
803 memset(s->mbintra_table, 1, mb_array_size); |
2967 | 804 |
7
1d3ac9654178
added skip macroblock optimization (big perf win on black regions for example)
glantau
parents:
0
diff
changeset
|
805 /* 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
|
806 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
|
807 //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
|
808 CHECKED_ALLOCZ(s->prev_pict_types, PREV_PICT_TYPES_BUFFER_SIZE); |
2967 | 809 |
842
e460775adb38
cleanup (breaks compatibility, requested by fabrice)
michaelni
parents:
828
diff
changeset
|
810 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
|
811 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
|
812 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
|
813 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
|
814 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
|
815 } |
842
e460775adb38
cleanup (breaks compatibility, requested by fabrice)
michaelni
parents:
828
diff
changeset
|
816 |
0 | 817 s->context_initialized = 1; |
1799 | 818 |
819 s->thread_context[0]= s; | |
820 for(i=1; i<s->avctx->thread_count; i++){ | |
821 s->thread_context[i]= av_malloc(sizeof(MpegEncContext)); | |
822 memcpy(s->thread_context[i], s, sizeof(MpegEncContext)); | |
823 } | |
824 | |
825 for(i=0; i<s->avctx->thread_count; i++){ | |
826 if(init_duplicate_context(s->thread_context[i], s) < 0) | |
827 goto fail; | |
828 s->thread_context[i]->start_mb_y= (s->mb_height*(i ) + s->avctx->thread_count/2) / s->avctx->thread_count; | |
829 s->thread_context[i]->end_mb_y = (s->mb_height*(i+1) + s->avctx->thread_count/2) / s->avctx->thread_count; | |
830 } | |
831 | |
0 | 832 return 0; |
833 fail: | |
244 | 834 MPV_common_end(s); |
835 return -1; | |
836 } | |
837 | |
838 /* init common structure for both encoder and decoder */ | |
839 void MPV_common_end(MpegEncContext *s) | |
840 { | |
1708 | 841 int i, j, k; |
244 | 842 |
1799 | 843 for(i=0; i<s->avctx->thread_count; i++){ |
844 free_duplicate_context(s->thread_context[i]); | |
845 } | |
846 for(i=1; i<s->avctx->thread_count; i++){ | |
847 av_freep(&s->thread_context[i]); | |
848 } | |
849 | |
1344
447b88b784ee
memleak fix by (Jake Page <jake at CS dot Stanford dot EDU>)
michaelni
parents:
1339
diff
changeset
|
850 av_freep(&s->parse_context.buffer); |
447b88b784ee
memleak fix by (Jake Page <jake at CS dot Stanford dot EDU>)
michaelni
parents:
1339
diff
changeset
|
851 s->parse_context.buffer_size=0; |
447b88b784ee
memleak fix by (Jake Page <jake at CS dot Stanford dot EDU>)
michaelni
parents:
1339
diff
changeset
|
852 |
396
fce0a2520551
removed useless header includes - use av memory functions
glantau
parents:
376
diff
changeset
|
853 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
|
854 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
|
855 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
|
856 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
|
857 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
|
858 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
|
859 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
|
860 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
|
861 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
|
862 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
|
863 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
|
864 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
|
865 s->b_direct_mv_table= NULL; |
1708 | 866 for(i=0; i<2; i++){ |
867 for(j=0; j<2; j++){ | |
868 for(k=0; k<2; k++){ | |
869 av_freep(&s->b_field_mv_table_base[i][j][k]); | |
870 s->b_field_mv_table[i][j][k]=NULL; | |
871 } | |
872 av_freep(&s->b_field_select_table[i][j]); | |
873 av_freep(&s->p_field_mv_table_base[i][j]); | |
874 s->p_field_mv_table[i][j]=NULL; | |
875 } | |
876 av_freep(&s->p_field_select_table[i]); | |
877 } | |
2967 | 878 |
1938
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1918
diff
changeset
|
879 av_freep(&s->dc_val_base); |
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1918
diff
changeset
|
880 av_freep(&s->ac_val_base); |
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1918
diff
changeset
|
881 av_freep(&s->coded_block_base); |
396
fce0a2520551
removed useless header includes - use av memory functions
glantau
parents:
376
diff
changeset
|
882 av_freep(&s->mbintra_table); |
456 | 883 av_freep(&s->cbp_table); |
884 av_freep(&s->pred_dir_table); | |
2967 | 885 |
396
fce0a2520551
removed useless header includes - use av memory functions
glantau
parents:
376
diff
changeset
|
886 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
|
887 av_freep(&s->prev_pict_types); |
396
fce0a2520551
removed useless header includes - use av memory functions
glantau
parents:
376
diff
changeset
|
888 av_freep(&s->bitstream_buffer); |
2422 | 889 s->allocated_bitstream_buffer_size=0; |
890 | |
612 | 891 av_freep(&s->avctx->stats_out); |
650
ef4a33aad86e
reducing sizeof MpegEncContext to avoid stack overflow on crap M$ windo$
michaelni
parents:
635
diff
changeset
|
892 av_freep(&s->ac_stats); |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
731
diff
changeset
|
893 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
|
894 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
|
895 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
|
896 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
|
897 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
|
898 av_freep(&s->q_intra_matrix16); |
d736e24bf303
move mmx quantizer matrixes out of MpegEncContext (23k -> 7k) (no meassureable slowdown)
michael
parents:
1553
diff
changeset
|
899 av_freep(&s->q_inter_matrix16); |
1556 | 900 av_freep(&s->input_picture); |
901 av_freep(&s->reordered_input_picture); | |
1597 | 902 av_freep(&s->dct_offset); |
903 | 903 |
1573 | 904 if(s->picture){ |
905 for(i=0; i<MAX_PICTURE_COUNT; i++){ | |
906 free_picture(s, &s->picture[i]); | |
907 } | |
0 | 908 } |
1552
26c6ecba99a1
dynamic alloc of picture structs instead of putting them in MpegEncContext
michael
parents:
1546
diff
changeset
|
909 av_freep(&s->picture); |
0 | 910 s->context_initialized = 0; |
1523 | 911 s->last_picture_ptr= |
912 s->next_picture_ptr= | |
913 s->current_picture_ptr= NULL; | |
2231 | 914 s->linesize= s->uvlinesize= 0; |
1918
ea20f38b8d57
nicer looking arrows for the motion vector vissualization
michael
parents:
1916
diff
changeset
|
915 |
1706
3ba5c493db6f
motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1705
diff
changeset
|
916 for(i=0; i<3; i++) |
1918
ea20f38b8d57
nicer looking arrows for the motion vector vissualization
michael
parents:
1916
diff
changeset
|
917 av_freep(&s->visualization_buffer[i]); |
2231 | 918 |
919 avcodec_default_free_buffers(s->avctx); | |
0 | 920 } |
921 | |
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
|
922 #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
|
923 |
0 | 924 /* init video encoder */ |
925 int MPV_encode_init(AVCodecContext *avctx) | |
926 { | |
927 MpegEncContext *s = avctx->priv_data; | |
2834 | 928 int i; |
1315
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1288
diff
changeset
|
929 int chroma_h_shift, chroma_v_shift; |
2967 | 930 |
1892 | 931 MPV_encode_defaults(s); |
315 | 932 |
3309 | 933 switch (avctx->codec_id) { |
934 case CODEC_ID_MPEG2VIDEO: | |
935 if(avctx->pix_fmt != PIX_FMT_YUV420P && avctx->pix_fmt != PIX_FMT_YUV422P){ | |
936 av_log(avctx, AV_LOG_ERROR, "only YUV420 and YUV422 are supported\n"); | |
937 return -1; | |
938 } | |
939 break; | |
940 case CODEC_ID_LJPEG: | |
941 case CODEC_ID_MJPEG: | |
3929 | 942 if(avctx->pix_fmt != PIX_FMT_YUVJ420P && avctx->pix_fmt != PIX_FMT_YUVJ422P && |
943 ((avctx->pix_fmt != PIX_FMT_YUV420P && avctx->pix_fmt != PIX_FMT_YUV422P) || avctx->strict_std_compliance>FF_COMPLIANCE_INOFFICIAL)){ | |
2442 | 944 av_log(avctx, AV_LOG_ERROR, "colorspace not supported in jpeg\n"); |
945 return -1; | |
946 } | |
3309 | 947 break; |
948 default: | |
949 if(avctx->pix_fmt != PIX_FMT_YUV420P){ | |
950 av_log(avctx, AV_LOG_ERROR, "only YUV420 is supported\n"); | |
2442 | 951 return -1; |
952 } | |
953 } | |
1402
f662e9c86cf2
* fixing a regression in mpeg encoder (not setting pix_fmt),
romansh
parents:
1397
diff
changeset
|
954 |
3309 | 955 switch (avctx->pix_fmt) { |
956 case PIX_FMT_YUVJ422P: | |
957 case PIX_FMT_YUV422P: | |
958 s->chroma_format = CHROMA_422; | |
959 break; | |
960 case PIX_FMT_YUVJ420P: | |
961 case PIX_FMT_YUV420P: | |
962 default: | |
963 s->chroma_format = CHROMA_420; | |
964 break; | |
965 } | |
966 | |
0 | 967 s->bit_rate = avctx->bit_rate; |
968 s->width = avctx->width; | |
969 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
|
970 if(avctx->gop_size > 600 && avctx->strict_std_compliance>FF_COMPLIANCE_EXPERIMENTAL){ |
2979 | 971 av_log(avctx, AV_LOG_ERROR, "Warning keyframe interval too large! reducing it ...\n"); |
456 | 972 avctx->gop_size=600; |
973 } | |
0 | 974 s->gop_size = avctx->gop_size; |
194
27d1773552c9
mpeg4 encoder fix by Michael Niedermayer <michaelni@gmx.at>
arpi_esp
parents:
191
diff
changeset
|
975 s->avctx = avctx; |
294 | 976 s->flags= avctx->flags; |
1754
bdf3927bf8c5
closed gop support & flags2 as all bits in flags are used
michael
parents:
1751
diff
changeset
|
977 s->flags2= avctx->flags2; |
324 | 978 s->max_b_frames= avctx->max_b_frames; |
344 | 979 s->codec_id= avctx->codec->id; |
456 | 980 s->luma_elim_threshold = avctx->luma_elim_threshold; |
981 s->chroma_elim_threshold= avctx->chroma_elim_threshold; | |
982 s->strict_std_compliance= avctx->strict_std_compliance; | |
983 s->data_partitioning= avctx->flags & CODEC_FLAG_PART; | |
936 | 984 s->quarter_sample= (avctx->flags & CODEC_FLAG_QPEL)!=0; |
599 | 985 s->mpeg_quant= avctx->mpeg_quant; |
1661 | 986 s->rtp_mode= !!avctx->rtp_payload_size; |
1992 | 987 s->intra_dc_precision= avctx->intra_dc_precision; |
2243
b8bad8bbbc64
check if the user specified timestamps are strictly monotone
michael
parents:
2235
diff
changeset
|
988 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
|
989 |
0 | 990 if (s->gop_size <= 1) { |
991 s->intra_only = 1; | |
992 s->gop_size = 12; | |
993 } else { | |
994 s->intra_only = 0; | |
995 } | |
693
b6a7ff92df57
darkness masking (lumi masking does only bright stuff now)
michaelni
parents:
690
diff
changeset
|
996 |
936 | 997 s->me_method = avctx->me_method; |
693
b6a7ff92df57
darkness masking (lumi masking does only bright stuff now)
michaelni
parents:
690
diff
changeset
|
998 |
320
cda7d0857baf
- ME setting moved to AVCodecContext/MpegEncContext, no longer a global.
pulento
parents:
315
diff
changeset
|
999 /* Fixed QSCALE */ |
1708 | 1000 s->fixed_qscale = !!(avctx->flags & CODEC_FLAG_QSCALE); |
2967 | 1001 |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
673
diff
changeset
|
1002 s->adaptive_quant= ( s->avctx->lumi_masking |
693
b6a7ff92df57
darkness masking (lumi masking does only bright stuff now)
michaelni
parents:
690
diff
changeset
|
1003 || s->avctx->dark_masking |
2967 | 1004 || s->avctx->temporal_cplx_masking |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
673
diff
changeset
|
1005 || s->avctx->spatial_cplx_masking |
1616 | 1006 || s->avctx->p_masking |
2493
258120c61eea
Border processing adaptive quant patch by (Christophe Massiot |cmassiot freebox fr)
michael
parents:
2492
diff
changeset
|
1007 || s->avctx->border_masking |
1616 | 1008 || (s->flags&CODEC_FLAG_QP_RD)) |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
673
diff
changeset
|
1009 && !s->fixed_qscale; |
2967 | 1010 |
1708 | 1011 s->obmc= !!(s->flags & CODEC_FLAG_OBMC); |
1012 s->loop_filter= !!(s->flags & CODEC_FLAG_LOOP_FILTER); | |
1013 s->alternate_scan= !!(s->flags & CODEC_FLAG_ALT_SCAN); | |
3305 | 1014 s->intra_vlc_format= !!(s->flags2 & CODEC_FLAG2_INTRA_VLC); |
4621 | 1015 s->q_scale_type= !!(s->flags2 & CODEC_FLAG2_NON_LINEAR_QUANT); |
1633 | 1016 |
1711 | 1017 if(avctx->rc_max_rate && !avctx->rc_buffer_size){ |
1018 av_log(avctx, AV_LOG_ERROR, "a vbv buffer size is needed, for encoding with a maximum bitrate\n"); | |
1019 return -1; | |
2967 | 1020 } |
1711 | 1021 |
1022 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
|
1023 av_log(avctx, AV_LOG_INFO, "Warning min_rate > 0 but min_rate != max_rate isn't recommended!\n"); |
1907 | 1024 } |
2967 | 1025 |
2063 | 1026 if(avctx->rc_min_rate && avctx->rc_min_rate > avctx->bit_rate){ |
1027 av_log(avctx, AV_LOG_INFO, "bitrate below min bitrate\n"); | |
1028 return -1; | |
1029 } | |
2967 | 1030 |
2063 | 1031 if(avctx->rc_max_rate && avctx->rc_max_rate < avctx->bit_rate){ |
1032 av_log(avctx, AV_LOG_INFO, "bitrate above max bitrate\n"); | |
1033 return -1; | |
1034 } | |
2967 | 1035 |
1036 if( s->avctx->rc_max_rate && s->avctx->rc_min_rate == s->avctx->rc_max_rate | |
1907 | 1037 && (s->codec_id == CODEC_ID_MPEG1VIDEO || s->codec_id == CODEC_ID_MPEG2VIDEO) |
1038 && 90000LL * (avctx->rc_buffer_size-1) > s->avctx->rc_max_rate*0xFFFFLL){ | |
2967 | 1039 |
1907 | 1040 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"); |
1041 } | |
2967 | 1042 |
1043 if((s->flags & CODEC_FLAG_4MV) && s->codec_id != CODEC_ID_MPEG4 | |
1790 | 1044 && 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
|
1045 av_log(avctx, AV_LOG_ERROR, "4MV not supported by codec\n"); |
1188 | 1046 return -1; |
1047 } | |
2967 | 1048 |
1633 | 1049 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
|
1050 av_log(avctx, AV_LOG_ERROR, "OBMC is only supported with simple mb decision\n"); |
1633 | 1051 return -1; |
1052 } | |
2967 | 1053 |
1644 | 1054 if(s->obmc && s->codec_id != CODEC_ID_H263 && s->codec_id != CODEC_ID_H263P){ |
1055 av_log(avctx, AV_LOG_ERROR, "OBMC is only supported with H263(+)\n"); | |
1056 return -1; | |
1057 } | |
2967 | 1058 |
1188 | 1059 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
|
1060 av_log(avctx, AV_LOG_ERROR, "qpel not supported by codec\n"); |
1188 | 1061 return -1; |
1062 } | |
1063 | |
1064 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
|
1065 av_log(avctx, AV_LOG_ERROR, "data partitioning not supported by codec\n"); |
1188 | 1066 return -1; |
1067 } | |
2967 | 1068 |
1421 | 1069 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
|
1070 av_log(avctx, AV_LOG_ERROR, "b frames not supported by codec\n"); |
1188 | 1071 return -1; |
1072 } | |
1958 | 1073 |
2967 | 1074 if((s->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME|CODEC_FLAG_ALT_SCAN)) |
1958 | 1075 && s->codec_id != CODEC_ID_MPEG4 && s->codec_id != CODEC_ID_MPEG2VIDEO){ |
1076 av_log(avctx, AV_LOG_ERROR, "interlacing not supported by codec\n"); | |
1077 return -1; | |
1078 } | |
2967 | 1079 |
1188 | 1080 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
|
1081 av_log(avctx, AV_LOG_ERROR, "mpeg2 style quantization not supported by codec\n"); |
1188 | 1082 return -1; |
1083 } | |
2967 | 1084 |
1490
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1480
diff
changeset
|
1085 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
|
1086 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
|
1087 return -1; |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1480
diff
changeset
|
1088 } |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1480
diff
changeset
|
1089 |
1622 | 1090 if((s->flags & CODEC_FLAG_QP_RD) && s->avctx->mb_decision != FF_MB_DECISION_RD){ |
1091 av_log(avctx, AV_LOG_ERROR, "QP RD needs mbd=2\n"); | |
1092 return -1; | |
1093 } | |
2967 | 1094 |
1754
bdf3927bf8c5
closed gop support & flags2 as all bits in flags are used
michael
parents:
1751
diff
changeset
|
1095 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
|
1096 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
|
1097 return -1; |
bdf3927bf8c5
closed gop support & flags2 as all bits in flags are used
michael
parents:
1751
diff
changeset
|
1098 } |
2967 | 1099 |
3305 | 1100 if((s->flags2 & CODEC_FLAG2_INTRA_VLC) && s->codec_id != CODEC_ID_MPEG2VIDEO){ |
1101 av_log(avctx, AV_LOG_ERROR, "intra vlc table not supported by codec\n"); | |
1102 return -1; | |
1103 } | |
1104 | |
4189
3c98b0938897
add low delay forcing option for mpeg1/2 encoding
bcoudurier
parents:
4179
diff
changeset
|
1105 if(s->flags & CODEC_FLAG_LOW_DELAY){ |
3c98b0938897
add low delay forcing option for mpeg1/2 encoding
bcoudurier
parents:
4179
diff
changeset
|
1106 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
|
1107 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
|
1108 return -1; |
3c98b0938897
add low delay forcing option for mpeg1/2 encoding
bcoudurier
parents:
4179
diff
changeset
|
1109 } |
3c98b0938897
add low delay forcing option for mpeg1/2 encoding
bcoudurier
parents:
4179
diff
changeset
|
1110 if (s->max_b_frames != 0){ |
3c98b0938897
add low delay forcing option for mpeg1/2 encoding
bcoudurier
parents:
4179
diff
changeset
|
1111 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
|
1112 return -1; |
3c98b0938897
add low delay forcing option for mpeg1/2 encoding
bcoudurier
parents:
4179
diff
changeset
|
1113 } |
3c98b0938897
add low delay forcing option for mpeg1/2 encoding
bcoudurier
parents:
4179
diff
changeset
|
1114 } |
3c98b0938897
add low delay forcing option for mpeg1/2 encoding
bcoudurier
parents:
4179
diff
changeset
|
1115 |
4621 | 1116 if(s->q_scale_type == 1){ |
1117 if(s->codec_id != CODEC_ID_MPEG2VIDEO){ | |
1118 av_log(avctx, AV_LOG_ERROR, "non linear quant is only available for mpeg2\n"); | |
1119 return -1; | |
1120 } | |
1121 if(avctx->qmax > 12){ | |
1122 av_log(avctx, AV_LOG_ERROR, "non linear quant only supports qmax <= 12 currently\n"); | |
1123 return -1; | |
1124 } | |
1125 } | |
1126 | |
2967 | 1127 if(s->avctx->thread_count > 1 && s->codec_id != CODEC_ID_MPEG4 |
1128 && s->codec_id != CODEC_ID_MPEG1VIDEO && s->codec_id != CODEC_ID_MPEG2VIDEO | |
1799 | 1129 && (s->codec_id != CODEC_ID_H263P || !(s->flags & CODEC_FLAG_H263P_SLICE_STRUCT))){ |
1130 av_log(avctx, AV_LOG_ERROR, "multi threaded encoding not supported by codec\n"); | |
1131 return -1; | |
1132 } | |
2967 | 1133 |
1799 | 1134 if(s->avctx->thread_count > 1) |
1135 s->rtp_mode= 1; | |
1760 | 1136 |
2637 | 1137 if(!avctx->time_base.den || !avctx->time_base.num){ |
2450 | 1138 av_log(avctx, AV_LOG_ERROR, "framerate not set\n"); |
1139 return -1; | |
1140 } | |
2967 | 1141 |
2576
e237d9bd0f8c
check mb/me_threshold range, fixes assertion failure
michael
parents:
2570
diff
changeset
|
1142 i= (INT_MAX/2+128)>>8; |
e237d9bd0f8c
check mb/me_threshold range, fixes assertion failure
michael
parents:
2570
diff
changeset
|
1143 if(avctx->me_threshold >= i){ |
e237d9bd0f8c
check mb/me_threshold range, fixes assertion failure
michael
parents:
2570
diff
changeset
|
1144 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
|
1145 return -1; |
e237d9bd0f8c
check mb/me_threshold range, fixes assertion failure
michael
parents:
2570
diff
changeset
|
1146 } |
e237d9bd0f8c
check mb/me_threshold range, fixes assertion failure
michael
parents:
2570
diff
changeset
|
1147 if(avctx->mb_threshold >= i){ |
e237d9bd0f8c
check mb/me_threshold range, fixes assertion failure
michael
parents:
2570
diff
changeset
|
1148 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
|
1149 return -1; |
e237d9bd0f8c
check mb/me_threshold range, fixes assertion failure
michael
parents:
2570
diff
changeset
|
1150 } |
2967 | 1151 |
2668 | 1152 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
|
1153 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
|
1154 avctx->b_frame_strategy = 0; |
2668 | 1155 } |
1156 | |
2637 | 1157 i= ff_gcd(avctx->time_base.den, avctx->time_base.num); |
1760 | 1158 if(i > 1){ |
1159 av_log(avctx, AV_LOG_INFO, "removing common factors from framerate\n"); | |
2637 | 1160 avctx->time_base.den /= i; |
1161 avctx->time_base.num /= i; | |
1760 | 1162 // return -1; |
1163 } | |
2967 | 1164 |
1150 | 1165 if(s->codec_id==CODEC_ID_MJPEG){ |
1166 s->intra_quant_bias= 1<<(QUANT_BIAS_SHIFT-1); //(a + x/2)/x | |
1167 s->inter_quant_bias= 0; | |
1421 | 1168 }else if(s->mpeg_quant || s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO){ |
1150 | 1169 s->intra_quant_bias= 3<<(QUANT_BIAS_SHIFT-3); //(a + x*3/8)/x |
1170 s->inter_quant_bias= 0; | |
1171 }else{ | |
1172 s->intra_quant_bias=0; | |
1173 s->inter_quant_bias=-(1<<(QUANT_BIAS_SHIFT-2)); //(a - x/4)/x | |
1174 } | |
2967 | 1175 |
1150 | 1176 if(avctx->intra_quant_bias != FF_DEFAULT_QUANT_BIAS) |
1177 s->intra_quant_bias= avctx->intra_quant_bias; | |
1178 if(avctx->inter_quant_bias != FF_DEFAULT_QUANT_BIAS) | |
1179 s->inter_quant_bias= avctx->inter_quant_bias; | |
2967 | 1180 |
1315
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1288
diff
changeset
|
1181 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
|
1182 |
2653
2515af7d3238
complain about mpeg4 limits only if codec_id == MPEG4
michael
parents:
2639
diff
changeset
|
1183 if(avctx->codec_id == CODEC_ID_MPEG4 && s->avctx->time_base.den > (1<<16)-1){ |
2637 | 1184 av_log(avctx, AV_LOG_ERROR, "timebase not supported by mpeg 4 standard\n"); |
2967 | 1185 return -1; |
2637 | 1186 } |
1187 s->time_increment_bits = av_log2(s->avctx->time_base.den - 1) + 1; | |
1424 | 1188 |
0 | 1189 switch(avctx->codec->id) { |
1190 case CODEC_ID_MPEG1VIDEO: | |
1191 s->out_format = FMT_MPEG1; | |
4189
3c98b0938897
add low delay forcing option for mpeg1/2 encoding
bcoudurier
parents:
4179
diff
changeset
|
1192 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
|
1193 avctx->delay= s->low_delay ? 0 : (s->max_b_frames + 1); |
0 | 1194 break; |
1421 | 1195 case CODEC_ID_MPEG2VIDEO: |
1196 s->out_format = FMT_MPEG1; | |
4189
3c98b0938897
add low delay forcing option for mpeg1/2 encoding
bcoudurier
parents:
4179
diff
changeset
|
1197 s->low_delay= !!(s->flags & CODEC_FLAG_LOW_DELAY); |
1421 | 1198 avctx->delay= s->low_delay ? 0 : (s->max_b_frames + 1); |
1661 | 1199 s->rtp_mode= 1; |
1421 | 1200 break; |
1315
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1288
diff
changeset
|
1201 case CODEC_ID_LJPEG: |
2973 | 1202 case CODEC_ID_JPEGLS: |
0 | 1203 case CODEC_ID_MJPEG: |
1204 s->out_format = FMT_MJPEG; | |
1205 s->intra_only = 1; /* force intra only for jpeg */ | |
2973 | 1206 s->mjpeg_write_tables = avctx->codec->id != CODEC_ID_JPEGLS; |
2979 | 1207 s->mjpeg_data_only_frames = 0; /* write all the needed headers */ |
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; | |
0 | 1214 if (mjpeg_init(s) < 0) |
1215 return -1; | |
336 | 1216 avctx->delay=0; |
924 | 1217 s->low_delay=1; |
0 | 1218 break; |
4219 | 1219 #ifdef CONFIG_H261_ENCODER |
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: |
4206
be94e97ecb6e
throw error if unsupported resolution is used with h261
bcoudurier
parents:
4189
diff
changeset
|
1221 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
|
1222 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
|
1223 return -1; |
be94e97ecb6e
throw error if unsupported resolution is used with h261
bcoudurier
parents:
4189
diff
changeset
|
1224 } |
2327
5e5cf598a48b
H.261 encoder by (Maarten Daniels <maarten dot daniels at luc dot ac dot be>)
michael
parents:
2298
diff
changeset
|
1225 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
|
1226 avctx->delay=0; |
5e5cf598a48b
H.261 encoder by (Maarten Daniels <maarten dot daniels at luc dot ac dot be>)
michael
parents:
2298
diff
changeset
|
1227 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
|
1228 break; |
4219 | 1229 #endif |
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 |
2639 | 1357 #ifdef CONFIG_H261_ENCODER |
2327
5e5cf598a48b
H.261 encoder by (Maarten Daniels <maarten dot daniels at luc dot ac dot be>)
michael
parents:
2298
diff
changeset
|
1358 if (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
|
1359 ff_h261_encode_init(s); |
2639 | 1360 #endif |
706
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
1361 if (s->out_format == FMT_H263) |
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
1362 h263_encode_init(s); |
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
1363 if(s->msmpeg4_version) |
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
1364 ff_msmpeg4_encode_init(s); |
1042 | 1365 if (s->out_format == FMT_MPEG1) |
1366 ff_mpeg1_encode_init(s); | |
706
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
1367 |
1892 | 1368 /* init q matrix */ |
60 | 1369 for(i=0;i<64;i++) { |
1092 | 1370 int j= s->dsp.idct_permutation[i]; |
599 | 1371 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
|
1372 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
|
1373 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
|
1374 }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
|
1375 s->intra_matrix[j] = |
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
1376 s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i]; |
1042 | 1377 }else |
1421 | 1378 { /* mpeg1/2 */ |
706
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
1379 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
|
1380 s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i]; |
599 | 1381 } |
1411 | 1382 if(s->avctx->intra_matrix) |
1383 s->intra_matrix[j] = s->avctx->intra_matrix[i]; | |
1384 if(s->avctx->inter_matrix) | |
1385 s->inter_matrix[j] = s->avctx->inter_matrix[i]; | |
344 | 1386 } |
1387 | |
1388 /* precompute matrix */ | |
350
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
347
diff
changeset
|
1389 /* for mjpeg, we do include qscale in the matrix */ |
344 | 1390 if (s->out_format != FMT_MJPEG) { |
2967 | 1391 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
|
1392 s->intra_matrix, s->intra_quant_bias, avctx->qmin, 31, 1); |
2967 | 1393 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
|
1394 s->inter_matrix, s->inter_quant_bias, avctx->qmin, 31, 0); |
60 | 1395 } |
1396 | |
329 | 1397 if(ff_rate_control_init(s) < 0) |
1398 return -1; | |
2967 | 1399 |
0 | 1400 return 0; |
1401 } | |
1402 | |
1403 int MPV_encode_end(AVCodecContext *avctx) | |
1404 { | |
1405 MpegEncContext *s = avctx->priv_data; | |
1406 | |
329 | 1407 ff_rate_control_uninit(s); |
1408 | |
0 | 1409 MPV_common_end(s); |
1410 if (s->out_format == FMT_MJPEG) | |
1411 mjpeg_close(s); | |
1458
40b69d238beb
AVI stream header FCC / more reliable detection of old xvid files
michaelni
parents:
1451
diff
changeset
|
1412 |
1424 | 1413 av_freep(&avctx->extradata); |
2967 | 1414 |
0 | 1415 return 0; |
1416 } | |
1417 | |
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
|
1418 #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
|
1419 |
2370
26560d4fdb1f
Memory leak fix patch by (Burkhard Plaum <plaum >at< ipf.uni-stuttgart )dot( de>)
michael
parents:
2364
diff
changeset
|
1420 void init_rl(RLTable *rl, int use_static) |
1042 | 1421 { |
1064 | 1422 int8_t max_level[MAX_RUN+1], max_run[MAX_LEVEL+1]; |
1423 uint8_t index_run[MAX_RUN+1]; | |
1042 | 1424 int last, run, level, start, end, i; |
1425 | |
2370
26560d4fdb1f
Memory leak fix patch by (Burkhard Plaum <plaum >at< ipf.uni-stuttgart )dot( de>)
michael
parents:
2364
diff
changeset
|
1426 /* If table is static, we can quit if rl->max_level[0] is not NULL */ |
26560d4fdb1f
Memory leak fix patch by (Burkhard Plaum <plaum >at< ipf.uni-stuttgart )dot( de>)
michael
parents:
2364
diff
changeset
|
1427 if(use_static && rl->max_level[0]) |
26560d4fdb1f
Memory leak fix patch by (Burkhard Plaum <plaum >at< ipf.uni-stuttgart )dot( de>)
michael
parents:
2364
diff
changeset
|
1428 return; |
26560d4fdb1f
Memory leak fix patch by (Burkhard Plaum <plaum >at< ipf.uni-stuttgart )dot( de>)
michael
parents:
2364
diff
changeset
|
1429 |
1042 | 1430 /* compute max_level[], max_run[] and index_run[] */ |
1431 for(last=0;last<2;last++) { | |
1432 if (last == 0) { | |
1433 start = 0; | |
1434 end = rl->last; | |
1435 } else { | |
1436 start = rl->last; | |
1437 end = rl->n; | |
1438 } | |
1439 | |
1440 memset(max_level, 0, MAX_RUN + 1); | |
1441 memset(max_run, 0, MAX_LEVEL + 1); | |
1442 memset(index_run, rl->n, MAX_RUN + 1); | |
1443 for(i=start;i<end;i++) { | |
1444 run = rl->table_run[i]; | |
1445 level = rl->table_level[i]; | |
1446 if (index_run[run] == rl->n) | |
1447 index_run[run] = i; | |
1448 if (level > max_level[run]) | |
1449 max_level[run] = level; | |
1450 if (run > max_run[level]) | |
1451 max_run[level] = run; | |
1452 } | |
2370
26560d4fdb1f
Memory leak fix patch by (Burkhard Plaum <plaum >at< ipf.uni-stuttgart )dot( de>)
michael
parents:
2364
diff
changeset
|
1453 if(use_static) |
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_mallocz_static(MAX_RUN + 1); |
26560d4fdb1f
Memory leak fix patch by (Burkhard Plaum <plaum >at< ipf.uni-stuttgart )dot( de>)
michael
parents:
2364
diff
changeset
|
1455 else |
26560d4fdb1f
Memory leak fix patch by (Burkhard Plaum <plaum >at< ipf.uni-stuttgart )dot( de>)
michael
parents:
2364
diff
changeset
|
1456 rl->max_level[last] = av_malloc(MAX_RUN + 1); |
1042 | 1457 memcpy(rl->max_level[last], max_level, 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 if(use_static) |
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_mallocz_static(MAX_LEVEL + 1); |
26560d4fdb1f
Memory leak fix patch by (Burkhard Plaum <plaum >at< ipf.uni-stuttgart )dot( de>)
michael
parents:
2364
diff
changeset
|
1460 else |
26560d4fdb1f
Memory leak fix patch by (Burkhard Plaum <plaum >at< ipf.uni-stuttgart )dot( de>)
michael
parents:
2364
diff
changeset
|
1461 rl->max_run[last] = av_malloc(MAX_LEVEL + 1); |
1042 | 1462 memcpy(rl->max_run[last], max_run, MAX_LEVEL + 1); |
2370
26560d4fdb1f
Memory leak fix patch by (Burkhard Plaum <plaum >at< ipf.uni-stuttgart )dot( de>)
michael
parents:
2364
diff
changeset
|
1463 if(use_static) |
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_mallocz_static(MAX_RUN + 1); |
26560d4fdb1f
Memory leak fix patch by (Burkhard Plaum <plaum >at< ipf.uni-stuttgart )dot( de>)
michael
parents:
2364
diff
changeset
|
1465 else |
26560d4fdb1f
Memory leak fix patch by (Burkhard Plaum <plaum >at< ipf.uni-stuttgart )dot( de>)
michael
parents:
2364
diff
changeset
|
1466 rl->index_run[last] = av_malloc(MAX_RUN + 1); |
1042 | 1467 memcpy(rl->index_run[last], index_run, MAX_RUN + 1); |
1468 } | |
1469 } | |
1470 | |
0 | 1471 /* 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
|
1472 //FIXME check that this is ok for mpeg4 interlaced |
1064 | 1473 static void draw_edges_c(uint8_t *buf, int wrap, int width, int height, int w) |
0 | 1474 { |
1064 | 1475 uint8_t *ptr, *last_line; |
0 | 1476 int i; |
1477 | |
1478 last_line = buf + (height - 1) * wrap; | |
1479 for(i=0;i<w;i++) { | |
1480 /* top and bottom */ | |
1481 memcpy(buf - (i + 1) * wrap, buf, width); | |
1482 memcpy(last_line + (i + 1) * wrap, last_line, width); | |
1483 } | |
1484 /* left and right */ | |
1485 ptr = buf; | |
1486 for(i=0;i<height;i++) { | |
1487 memset(ptr - w, ptr[0], w); | |
1488 memset(ptr + width, ptr[width-1], w); | |
1489 ptr += wrap; | |
1490 } | |
1491 /* corners */ | |
1492 for(i=0;i<w;i++) { | |
1493 memset(buf - (i + 1) * wrap - w, buf[0], w); /* top left */ | |
1494 memset(buf - (i + 1) * wrap + width, buf[width-1], w); /* top right */ | |
1495 memset(last_line + (i + 1) * wrap - w, last_line[0], w); /* top left */ | |
1496 memset(last_line + (i + 1) * wrap + width, last_line[width-1], w); /* top right */ | |
1497 } | |
1498 } | |
1499 | |
1586 | 1500 int ff_find_unused_picture(MpegEncContext *s, int shared){ |
924 | 1501 int i; |
2967 | 1502 |
924 | 1503 if(shared){ |
1504 for(i=0; i<MAX_PICTURE_COUNT; i++){ | |
1586 | 1505 if(s->picture[i].data[0]==NULL && s->picture[i].type==0) return i; |
924 | 1506 } |
1507 }else{ | |
1508 for(i=0; i<MAX_PICTURE_COUNT; i++){ | |
1586 | 1509 if(s->picture[i].data[0]==NULL && s->picture[i].type!=0) return i; //FIXME |
924 | 1510 } |
1511 for(i=0; i<MAX_PICTURE_COUNT; i++){ | |
1586 | 1512 if(s->picture[i].data[0]==NULL) return i; |
924 | 1513 } |
1514 } | |
1515 | |
1586 | 1516 assert(0); |
1517 return -1; | |
924 | 1518 } |
1519 | |
1597 | 1520 static void update_noise_reduction(MpegEncContext *s){ |
1521 int intra, i; | |
1522 | |
1523 for(intra=0; intra<2; intra++){ | |
1524 if(s->dct_count[intra] > (1<<16)){ | |
1525 for(i=0; i<64; i++){ | |
1526 s->dct_error_sum[intra][i] >>=1; | |
1527 } | |
1528 s->dct_count[intra] >>= 1; | |
1529 } | |
2967 | 1530 |
1597 | 1531 for(i=0; i<64; i++){ |
1532 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); | |
1533 } | |
1534 } | |
1535 } | |
1536 | |
1586 | 1537 /** |
1538 * generic function for encode/decode called after coding/decoding the header and before a frame is coded/decoded | |
1539 */ | |
771
d4cc92144266
handle direct rendering buffer allocation failure
michaelni
parents:
768
diff
changeset
|
1540 int MPV_frame_start(MpegEncContext *s, AVCodecContext *avctx) |
0 | 1541 { |
924 | 1542 int i; |
925 | 1543 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
|
1544 s->mb_skipped = 0; |
1168 | 1545 |
1234 | 1546 assert(s->last_picture_ptr==NULL || s->out_format != FMT_H264 || s->codec_id == CODEC_ID_SVQ3); |
1228 | 1547 |
903 | 1548 /* mark&release old frames */ |
1944 | 1549 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
|
1550 if(s->out_format != FMT_H264 || s->codec_id == CODEC_ID_SVQ3){ |
1138 | 1551 avctx->release_buffer(avctx, (AVFrame*)s->last_picture_ptr); |
903 | 1552 |
1553 /* release forgotten pictures */ | |
1554 /* if(mpeg124/h263) */ | |
1555 if(!s->encoding){ | |
1556 for(i=0; i<MAX_PICTURE_COUNT; i++){ | |
1138 | 1557 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
|
1558 av_log(avctx, AV_LOG_ERROR, "releasing zombie picture\n"); |
2967 | 1559 avctx->release_buffer(avctx, (AVFrame*)&s->picture[i]); |
903 | 1560 } |
1561 } | |
1562 } | |
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
|
1563 } |
903 | 1564 } |
910
eb448df811be
fixing files where the first frame isn a keyframe
michaelni
parents:
909
diff
changeset
|
1565 alloc: |
eb448df811be
fixing files where the first frame isn a keyframe
michaelni
parents:
909
diff
changeset
|
1566 if(!s->encoding){ |
2764 | 1567 /* release non reference frames */ |
1228 | 1568 for(i=0; i<MAX_PICTURE_COUNT; i++){ |
1569 if(s->picture[i].data[0] && !s->picture[i].reference /*&& s->picture[i].type!=FF_BUFFER_TYPE_SHARED*/){ | |
1570 s->avctx->release_buffer(s->avctx, (AVFrame*)&s->picture[i]); | |
1571 } | |
1572 } | |
1573 | |
1586 | 1574 if(s->current_picture_ptr && s->current_picture_ptr->data[0]==NULL) |
1575 pic= (AVFrame*)s->current_picture_ptr; //we allready have a unused image (maybe it was set before reading the header) | |
1576 else{ | |
1577 i= ff_find_unused_picture(s, 0); | |
1578 pic= (AVFrame*)&s->picture[i]; | |
1579 } | |
1580 | |
2537
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2534
diff
changeset
|
1581 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
|
1582 && !s->dropable ? 3 : 0; |
1138 | 1583 |
1705 | 1584 pic->coded_picture_number= s->coded_picture_number++; |
2967 | 1585 |
1384 | 1586 if( alloc_picture(s, (Picture*)pic, 0) < 0) |
1587 return -1; | |
903 | 1588 |
1586 | 1589 s->current_picture_ptr= (Picture*)pic; |
1658 | 1590 s->current_picture_ptr->top_field_first= s->top_field_first; //FIXME use only the vars from current_pic |
1659 | 1591 s->current_picture_ptr->interlaced_frame= !s->progressive_frame && !s->progressive_sequence; |
903 | 1592 } |
456 | 1593 |
1173 | 1594 s->current_picture_ptr->pict_type= s->pict_type; |
2967 | 1595 // 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
|
1596 // 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
|
1597 s->current_picture_ptr->key_frame= s->pict_type == I_TYPE; |
1173 | 1598 |
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
|
1599 copy_picture(&s->current_picture, s->current_picture_ptr); |
2967 | 1600 |
903 | 1601 if (s->pict_type != B_TYPE) { |
1138 | 1602 s->last_picture_ptr= s->next_picture_ptr; |
1944 | 1603 if(!s->dropable) |
1604 s->next_picture_ptr= s->current_picture_ptr; | |
1605 } | |
1606 /* 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 | 1607 s->last_picture_ptr ? s->last_picture_ptr->data[0] : NULL, |
1608 s->next_picture_ptr ? s->next_picture_ptr->data[0] : NULL, | |
1944 | 1609 s->current_picture_ptr ? s->current_picture_ptr->data[0] : NULL, |
1610 s->pict_type, s->dropable);*/ | |
2967 | 1611 |
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
|
1612 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
|
1613 if(s->next_picture_ptr) copy_picture(&s->next_picture, s->next_picture_ptr); |
2967 | 1614 |
4413
371bb9f644da
fix inifnite loop with http://sam.zoy.org/zzuf/lol-mplayer.mpg
michael
parents:
4399
diff
changeset
|
1615 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
|
1616 av_log(avctx, AV_LOG_ERROR, "warning: first frame is no keyframe\n"); |
2764 | 1617 assert(s->pict_type != B_TYPE); //these should have been dropped if we don't have a reference |
1393 | 1618 goto alloc; |
1619 } | |
1620 | |
1621 assert(s->pict_type == I_TYPE || (s->last_picture_ptr && s->last_picture_ptr->data[0])); | |
1622 | |
1138 | 1623 if(s->picture_structure!=PICT_FRAME){ |
1624 int i; | |
1625 for(i=0; i<4; i++){ | |
1626 if(s->picture_structure == PICT_BOTTOM_FIELD){ | |
1627 s->current_picture.data[i] += s->current_picture.linesize[i]; | |
2967 | 1628 } |
1138 | 1629 s->current_picture.linesize[i] *= 2; |
1630 s->last_picture.linesize[i] *=2; | |
1631 s->next_picture.linesize[i] *=2; | |
1632 } | |
553 | 1633 } |
2967 | 1634 |
910
eb448df811be
fixing files where the first frame isn a keyframe
michaelni
parents:
909
diff
changeset
|
1635 s->hurry_up= s->avctx->hurry_up; |
eb448df811be
fixing files where the first frame isn a keyframe
michaelni
parents:
909
diff
changeset
|
1636 s->error_resilience= avctx->error_resilience; |
eb448df811be
fixing files where the first frame isn a keyframe
michaelni
parents:
909
diff
changeset
|
1637 |
2764 | 1638 /* set dequantizer, we can't do it during init as it might change for mpeg4 |
1639 and we can't do it in the header decode as init isnt called for mpeg4 there yet */ | |
1689 | 1640 if(s->mpeg_quant || s->codec_id == CODEC_ID_MPEG2VIDEO){ |
1641 s->dct_unquantize_intra = s->dct_unquantize_mpeg2_intra; | |
1642 s->dct_unquantize_inter = s->dct_unquantize_mpeg2_inter; | |
2345 | 1643 }else if(s->out_format == FMT_H263 || s->out_format == FMT_H261){ |
1689 | 1644 s->dct_unquantize_intra = s->dct_unquantize_h263_intra; |
1645 s->dct_unquantize_inter = s->dct_unquantize_h263_inter; | |
1646 }else{ | |
1647 s->dct_unquantize_intra = s->dct_unquantize_mpeg1_intra; | |
1648 s->dct_unquantize_inter = s->dct_unquantize_mpeg1_inter; | |
1649 } | |
771
d4cc92144266
handle direct rendering buffer allocation failure
michaelni
parents:
768
diff
changeset
|
1650 |
1597 | 1651 if(s->dct_error_sum){ |
1652 assert(s->avctx->noise_reduction && s->encoding); | |
1653 | |
1654 update_noise_reduction(s); | |
1655 } | |
2967 | 1656 |
1381 | 1657 #ifdef HAVE_XVMC |
1658 if(s->avctx->xvmc_acceleration) | |
1659 return XVMC_field_start(s, avctx); | |
1660 #endif | |
771
d4cc92144266
handle direct rendering buffer allocation failure
michaelni
parents:
768
diff
changeset
|
1661 return 0; |
0 | 1662 } |
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
|
1663 |
0 | 1664 /* generic function for encode/decode called after a frame has been coded/decoded */ |
1665 void MPV_frame_end(MpegEncContext *s) | |
1666 { | |
903 | 1667 int i; |
0 | 1668 /* draw edge for correct motion prediction if outside */ |
1381 | 1669 #ifdef HAVE_XVMC |
1670 //just to make sure that all data is rendered. | |
1671 if(s->avctx->xvmc_acceleration){ | |
1672 XVMC_field_end(s); | |
1673 }else | |
1674 #endif | |
2537
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2534
diff
changeset
|
1675 if(s->unrestricted_mv && s->current_picture.reference && !s->intra_only && !(s->flags&CODEC_FLAG_EMU_EDGE)) { |
903 | 1676 draw_edges(s->current_picture.data[0], s->linesize , s->h_edge_pos , s->v_edge_pos , EDGE_WIDTH ); |
1677 draw_edges(s->current_picture.data[1], s->uvlinesize, s->h_edge_pos>>1, s->v_edge_pos>>1, EDGE_WIDTH/2); | |
1678 draw_edges(s->current_picture.data[2], s->uvlinesize, s->h_edge_pos>>1, s->v_edge_pos>>1, EDGE_WIDTH/2); | |
0 | 1679 } |
207 | 1680 emms_c(); |
2967 | 1681 |
612 | 1682 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
|
1683 s->last_lambda_for[s->pict_type]= s->current_picture_ptr->quality; |
329 | 1684 if(s->pict_type!=B_TYPE){ |
1685 s->last_non_b_pict_type= s->pict_type; | |
1686 } | |
1138 | 1687 #if 0 |
1688 /* copy back current_picture variables */ | |
903 | 1689 for(i=0; i<MAX_PICTURE_COUNT; i++){ |
1690 if(s->picture[i].data[0] == s->current_picture.data[0]){ | |
1691 s->picture[i]= s->current_picture; | |
1692 break; | |
2967 | 1693 } |
903 | 1694 } |
1695 assert(i<MAX_PICTURE_COUNT); | |
2967 | 1696 #endif |
903 | 1697 |
1228 | 1698 if(s->encoding){ |
2764 | 1699 /* release non-reference frames */ |
1228 | 1700 for(i=0; i<MAX_PICTURE_COUNT; i++){ |
1701 if(s->picture[i].data[0] && !s->picture[i].reference /*&& s->picture[i].type!=FF_BUFFER_TYPE_SHARED*/){ | |
1702 s->avctx->release_buffer(s->avctx, (AVFrame*)&s->picture[i]); | |
1703 } | |
1704 } | |
324 | 1705 } |
1138 | 1706 // clear copies, to avoid confusion |
1707 #if 0 | |
1708 memset(&s->last_picture, 0, sizeof(Picture)); | |
1709 memset(&s->next_picture, 0, sizeof(Picture)); | |
1710 memset(&s->current_picture, 0, sizeof(Picture)); | |
1711 #endif | |
2213 | 1712 s->avctx->coded_frame= (AVFrame*)s->current_picture_ptr; |
903 | 1713 } |
1714 | |
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
|
1715 /** |
1285 | 1716 * draws an line from (ex, ey) -> (sx, sy). |
1717 * @param w width of the image | |
1718 * @param h height of the image | |
1719 * @param stride stride/linesize of the image | |
1720 * @param color color of the arrow | |
1721 */ | |
1722 static void draw_line(uint8_t *buf, int sx, int sy, int ex, int ey, int w, int h, int stride, int color){ | |
3595 | 1723 int x, y, fr, f; |
2967 | 1724 |
4594 | 1725 sx= av_clip(sx, 0, w-1); |
1726 sy= av_clip(sy, 0, h-1); | |
1727 ex= av_clip(ex, 0, w-1); | |
1728 ey= av_clip(ey, 0, h-1); | |
2967 | 1729 |
1285 | 1730 buf[sy*stride + sx]+= color; |
2967 | 1731 |
4001 | 1732 if(FFABS(ex - sx) > FFABS(ey - sy)){ |
1285 | 1733 if(sx > ex){ |
4120 | 1734 FFSWAP(int, sx, ex); |
1735 FFSWAP(int, sy, ey); | |
1285 | 1736 } |
1737 buf+= sx + sy*stride; | |
1738 ex-= sx; | |
1739 f= ((ey-sy)<<16)/ex; | |
1740 for(x= 0; x <= ex; x++){ | |
1918
ea20f38b8d57
nicer looking arrows for the motion vector vissualization
michael
parents:
1916
diff
changeset
|
1741 y = (x*f)>>16; |
ea20f38b8d57
nicer looking arrows for the motion vector vissualization
michael
parents:
1916
diff
changeset
|
1742 fr= (x*f)&0xFFFF; |
ea20f38b8d57
nicer looking arrows for the motion vector vissualization
michael
parents:
1916
diff
changeset
|
1743 buf[ y *stride + x]+= (color*(0x10000-fr))>>16; |
ea20f38b8d57
nicer looking arrows for the motion vector vissualization
michael
parents:
1916
diff
changeset
|
1744 buf[(y+1)*stride + x]+= (color* fr )>>16; |
1285 | 1745 } |
1746 }else{ | |
1747 if(sy > ey){ | |
4120 | 1748 FFSWAP(int, sx, ex); |
1749 FFSWAP(int, sy, ey); | |
1285 | 1750 } |
1751 buf+= sx + sy*stride; | |
1752 ey-= sy; | |
1753 if(ey) f= ((ex-sx)<<16)/ey; | |
1754 else f= 0; | |
1755 for(y= 0; y <= ey; y++){ | |
1918
ea20f38b8d57
nicer looking arrows for the motion vector vissualization
michael
parents:
1916
diff
changeset
|
1756 x = (y*f)>>16; |
ea20f38b8d57
nicer looking arrows for the motion vector vissualization
michael
parents:
1916
diff
changeset
|
1757 fr= (y*f)&0xFFFF; |
ea20f38b8d57
nicer looking arrows for the motion vector vissualization
michael
parents:
1916
diff
changeset
|
1758 buf[y*stride + x ]+= (color*(0x10000-fr))>>16;; |
ea20f38b8d57
nicer looking arrows for the motion vector vissualization
michael
parents:
1916
diff
changeset
|
1759 buf[y*stride + x+1]+= (color* fr )>>16;; |
1285 | 1760 } |
1761 } | |
1762 } | |
1763 | |
1764 /** | |
1765 * draws an arrow from (ex, ey) -> (sx, sy). | |
1766 * @param w width of the image | |
1767 * @param h height of the image | |
1768 * @param stride stride/linesize of the image | |
1769 * @param color color of the arrow | |
1770 */ | |
2967 | 1771 static void draw_arrow(uint8_t *buf, int sx, int sy, int ex, int ey, int w, int h, int stride, int color){ |
1285 | 1772 int dx,dy; |
1773 | |
4594 | 1774 sx= av_clip(sx, -100, w+100); |
1775 sy= av_clip(sy, -100, h+100); | |
1776 ex= av_clip(ex, -100, w+100); | |
1777 ey= av_clip(ey, -100, h+100); | |
2967 | 1778 |
1285 | 1779 dx= ex - sx; |
1780 dy= ey - sy; | |
2967 | 1781 |
1285 | 1782 if(dx*dx + dy*dy > 3*3){ |
1783 int rx= dx + dy; | |
1784 int ry= -dx + dy; | |
1785 int length= ff_sqrt((rx*rx + ry*ry)<<8); | |
2967 | 1786 |
1285 | 1787 //FIXME subpixel accuracy |
1788 rx= ROUNDED_DIV(rx*3<<4, length); | |
1789 ry= ROUNDED_DIV(ry*3<<4, length); | |
2967 | 1790 |
1285 | 1791 draw_line(buf, sx, sy, sx + rx, sy + ry, w, h, stride, color); |
1792 draw_line(buf, sx, sy, sx - ry, sy + rx, w, h, stride, color); | |
1793 } | |
1794 draw_line(buf, sx, sy, ex, ey, w, h, stride, color); | |
1795 } | |
1796 | |
1797 /** | |
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
|
1798 * 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
|
1799 */ |
1706
3ba5c493db6f
motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1705
diff
changeset
|
1800 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
|
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(!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
|
1803 |
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
|
1804 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
|
1805 int x,y; |
2967 | 1806 |
1706
3ba5c493db6f
motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1705
diff
changeset
|
1807 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
|
1808 switch (pict->pict_type) { |
3ba5c493db6f
motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1705
diff
changeset
|
1809 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
|
1810 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
|
1811 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
|
1812 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
|
1813 case FF_SI_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"SI\n"); break; |
2967 | 1814 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
|
1815 } |
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
|
1816 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
|
1817 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
|
1818 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
|
1819 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
|
1820 if(count>9) count=9; |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1597
diff
changeset
|
1821 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
|
1822 } |
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 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
|
1824 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
|
1825 } |
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 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
|
1827 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
|
1828 //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
|
1829 if(IS_PCM(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, "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
|
1831 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
|
1832 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
|
1833 else if(IS_INTRA4x4(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_INTRA16x16(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, "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
|
1837 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
|
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_DIRECT(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, "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
|
1841 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
|
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_GMC(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, "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
|
1845 else if(IS_SKIP(mb_type)) |
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, "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
|
1847 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
|
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 if(!USES_LIST(mb_type, 0)) |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1597
diff
changeset
|
1850 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
|
1851 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
|
1852 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
|
1853 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
|
1854 } |
2967 | 1855 |
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
|
1856 //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
|
1857 if(IS_8X8(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_16X8(mb_type)) |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1597
diff
changeset
|
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_8X16(mb_type)) |
2677 | 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 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
|
1864 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
|
1865 else |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1597
diff
changeset
|
1866 av_log(s->avctx, AV_LOG_DEBUG, "?"); |
2967 | 1867 |
1868 | |
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 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
|
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 else |
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, " "); |
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 } |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1597
diff
changeset
|
1876 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
|
1877 } |
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
|
1878 } |
1668
30746f429df6
move motion_val & mb_type to AVFrame patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1662
diff
changeset
|
1879 |
1706
3ba5c493db6f
motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1705
diff
changeset
|
1880 if((s->avctx->debug&(FF_DEBUG_VIS_QP|FF_DEBUG_VIS_MB_TYPE)) || (s->avctx->debug_mv)){ |
1285 | 1881 const int shift= 1 + s->quarter_sample; |
1882 int mb_y; | |
1706
3ba5c493db6f
motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1705
diff
changeset
|
1883 uint8_t *ptr; |
1707 | 1884 int i; |
1723
033d889d7c2c
non YV12 vissualization fix by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1722
diff
changeset
|
1885 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
|
1886 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
|
1887 const int height= s->avctx->height; |
2395 | 1888 const int mv_sample_log2= 4 - pict->motion_subsample_log2; |
3268 | 1889 const int mv_stride= (s->mb_width << mv_sample_log2) + (s->codec_id == CODEC_ID_H264 ? 0 : 1); |
1285 | 1890 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
|
1891 |
1723
033d889d7c2c
non YV12 vissualization fix by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1722
diff
changeset
|
1892 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
|
1893 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
|
1894 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
|
1895 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
|
1896 } |
3ba5c493db6f
motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1705
diff
changeset
|
1897 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
|
1898 ptr= pict->data[0]; |
1285 | 1899 |
1900 for(mb_y=0; mb_y<s->mb_height; mb_y++){ | |
1901 int mb_x; | |
1902 for(mb_x=0; mb_x<s->mb_width; mb_x++){ | |
1903 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
|
1904 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
|
1905 int type; |
3ba5c493db6f
motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1705
diff
changeset
|
1906 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
|
1907 int direction = 0; |
1706
3ba5c493db6f
motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1705
diff
changeset
|
1908 switch (type) { |
3ba5c493db6f
motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1705
diff
changeset
|
1909 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
|
1910 continue; |
3ba5c493db6f
motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1705
diff
changeset
|
1911 direction = 0; |
3ba5c493db6f
motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1705
diff
changeset
|
1912 break; |
3ba5c493db6f
motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1705
diff
changeset
|
1913 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
|
1914 continue; |
3ba5c493db6f
motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1705
diff
changeset
|
1915 direction = 0; |
3ba5c493db6f
motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1705
diff
changeset
|
1916 break; |
3ba5c493db6f
motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1705
diff
changeset
|
1917 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
|
1918 continue; |
3ba5c493db6f
motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1705
diff
changeset
|
1919 direction = 1; |
3ba5c493db6f
motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1705
diff
changeset
|
1920 break; |
3ba5c493db6f
motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1705
diff
changeset
|
1921 } |
1712 | 1922 if(!USES_LIST(pict->mb_type[mb_index], direction)) |
1923 continue; | |
1924 | |
1706
3ba5c493db6f
motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1705
diff
changeset
|
1925 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
|
1926 int i; |
3ba5c493db6f
motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1705
diff
changeset
|
1927 for(i=0; i<4; i++){ |
1285 | 1928 int sx= mb_x*16 + 4 + 8*(i&1); |
1929 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
|
1930 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
|
1931 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
|
1932 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
|
1933 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
|
1934 } |
3ba5c493db6f
motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1705
diff
changeset
|
1935 }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
|
1936 int i; |
3ba5c493db6f
motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1705
diff
changeset
|
1937 for(i=0; i<2; i++){ |
1629
74685a0ec851
16x8 MV vissualization by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1628
diff
changeset
|
1938 int sx=mb_x*16 + 8; |
74685a0ec851
16x8 MV vissualization by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1628
diff
changeset
|
1939 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
|
1940 int xy= (mb_x*2 + (mb_y*2 + i)*mv_stride) << (mv_sample_log2-1); |
2395 | 1941 int mx=(pict->motion_val[direction][xy][0]>>shift); |
1942 int my=(pict->motion_val[direction][xy][1]>>shift); | |
2967 | 1943 |
2395 | 1944 if(IS_INTERLACED(pict->mb_type[mb_index])) |
1945 my*=2; | |
2967 | 1946 |
2395 | 1947 draw_arrow(ptr, sx, sy, mx+sx, my+sy, width, height, s->linesize, 100); |
1948 } | |
1949 }else if(IS_8X16(pict->mb_type[mb_index])){ | |
1950 int i; | |
1951 for(i=0; i<2; i++){ | |
1952 int sx=mb_x*16 + 4 + 8*i; | |
1953 int sy=mb_y*16 + 8; | |
2522
e25782262d7d
kill warnings patch by (M«©ns Rullg«©rd <mru inprovide com>)
michael
parents:
2514
diff
changeset
|
1954 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
|
1955 int mx=(pict->motion_val[direction][xy][0]>>shift); |
b306574523ad
fix y scale of mv vissualization of interlaced MVs
michael
parents:
1945
diff
changeset
|
1956 int my=(pict->motion_val[direction][xy][1]>>shift); |
2967 | 1957 |
1947
b306574523ad
fix y scale of mv vissualization of interlaced MVs
michael
parents:
1945
diff
changeset
|
1958 if(IS_INTERLACED(pict->mb_type[mb_index])) |
b306574523ad
fix y scale of mv vissualization of interlaced MVs
michael
parents:
1945
diff
changeset
|
1959 my*=2; |
2967 | 1960 |
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
|
1961 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
|
1962 } |
3ba5c493db6f
motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1705
diff
changeset
|
1963 }else{ |
3ba5c493db6f
motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1705
diff
changeset
|
1964 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
|
1965 int sy= mb_y*16 + 8; |
2395 | 1966 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
|
1967 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
|
1968 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
|
1969 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
|
1970 } |
2967 | 1971 } |
1685 | 1972 } |
1973 if((s->avctx->debug&FF_DEBUG_VIS_QP) && pict->motion_val){ | |
1974 uint64_t c= (pict->qscale_table[mb_index]*128/31) * 0x0101010101010101ULL; | |
1975 int y; | |
1976 for(y=0; y<8; y++){ | |
1977 *(uint64_t*)(pict->data[1] + 8*mb_x + (8*mb_y + y)*pict->linesize[1])= c; | |
1978 *(uint64_t*)(pict->data[2] + 8*mb_x + (8*mb_y + y)*pict->linesize[2])= c; | |
1979 } | |
1980 } | |
1981 if((s->avctx->debug&FF_DEBUG_VIS_MB_TYPE) && pict->motion_val){ | |
1982 int mb_type= pict->mb_type[mb_index]; | |
1983 uint64_t u,v; | |
1984 int y; | |
1985 #define COLOR(theta, r)\ | |
1986 u= (int)(128 + r*cos(theta*3.141592/180));\ | |
1987 v= (int)(128 + r*sin(theta*3.141592/180)); | |
1988 | |
2967 | 1989 |
1685 | 1990 u=v=128; |
1991 if(IS_PCM(mb_type)){ | |
1992 COLOR(120,48) | |
1993 }else if((IS_INTRA(mb_type) && IS_ACPRED(mb_type)) || IS_INTRA16x16(mb_type)){ | |
1994 COLOR(30,48) | |
1995 }else if(IS_INTRA4x4(mb_type)){ | |
1996 COLOR(90,48) | |
1997 }else if(IS_DIRECT(mb_type) && IS_SKIP(mb_type)){ | |
1998 // COLOR(120,48) | |
1999 }else if(IS_DIRECT(mb_type)){ | |
2000 COLOR(150,48) | |
2001 }else if(IS_GMC(mb_type) && IS_SKIP(mb_type)){ | |
2002 COLOR(170,48) | |
2003 }else if(IS_GMC(mb_type)){ | |
2004 COLOR(190,48) | |
2005 }else if(IS_SKIP(mb_type)){ | |
2006 // COLOR(180,48) | |
2007 }else if(!USES_LIST(mb_type, 1)){ | |
2008 COLOR(240,48) | |
2009 }else if(!USES_LIST(mb_type, 0)){ | |
2010 COLOR(0,48) | |
2011 }else{ | |
2012 assert(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1)); | |
2013 COLOR(300,48) | |
2014 } | |
2015 | |
2016 u*= 0x0101010101010101ULL; | |
2017 v*= 0x0101010101010101ULL; | |
2018 for(y=0; y<8; y++){ | |
2019 *(uint64_t*)(pict->data[1] + 8*mb_x + (8*mb_y + y)*pict->linesize[1])= u; | |
2020 *(uint64_t*)(pict->data[2] + 8*mb_x + (8*mb_y + y)*pict->linesize[2])= v; | |
2021 } | |
2022 | |
2023 //segmentation | |
2024 if(IS_8X8(mb_type) || IS_16X8(mb_type)){ | |
2025 *(uint64_t*)(pict->data[0] + 16*mb_x + 0 + (16*mb_y + 8)*pict->linesize[0])^= 0x8080808080808080ULL; | |
2026 *(uint64_t*)(pict->data[0] + 16*mb_x + 8 + (16*mb_y + 8)*pict->linesize[0])^= 0x8080808080808080ULL; | |
2027 } | |
2028 if(IS_8X8(mb_type) || IS_8X16(mb_type)){ | |
2029 for(y=0; y<16; y++) | |
2030 pict->data[0][16*mb_x + 8 + (16*mb_y + y)*pict->linesize[0]]^= 0x80; | |
2031 } | |
2534 | 2032 if(IS_8X8(mb_type) && mv_sample_log2 >= 2){ |
2033 int dm= 1 << (mv_sample_log2-2); | |
2034 for(i=0; i<4; i++){ | |
2035 int sx= mb_x*16 + 8*(i&1); | |
2036 int sy= mb_y*16 + 8*(i>>1); | |
2037 int xy= (mb_x*2 + (i&1) + (mb_y*2 + (i>>1))*mv_stride) << (mv_sample_log2-1); | |
2038 //FIXME bidir | |
2039 int32_t *mv = (int32_t*)&pict->motion_val[0][xy]; | |
2040 if(mv[0] != mv[dm] || mv[dm*mv_stride] != mv[dm*(mv_stride+1)]) | |
2041 for(y=0; y<8; y++) | |
2042 pict->data[0][sx + 4 + (sy + y)*pict->linesize[0]]^= 0x80; | |
2043 if(mv[0] != mv[dm*mv_stride] || mv[dm] != mv[dm*(mv_stride+1)]) | |
2044 *(uint64_t*)(pict->data[0] + sx + (sy + 4)*pict->linesize[0])^= 0x8080808080808080ULL; | |
2045 } | |
2046 } | |
2967 | 2047 |
1685 | 2048 if(IS_INTERLACED(mb_type) && s->codec_id == CODEC_ID_H264){ |
2049 // hmm | |
2050 } | |
1285 | 2051 } |
2052 s->mbskip_table[mb_index]=0; | |
2053 } | |
2054 } | |
2055 } | |
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
|
2056 } |
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
|
2057 |
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
|
2058 #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
|
2059 |
915 | 2060 static int get_sae(uint8_t *src, int ref, int stride){ |
2061 int x,y; | |
2062 int acc=0; | |
2967 | 2063 |
915 | 2064 for(y=0; y<16; y++){ |
2065 for(x=0; x<16; x++){ | |
4001 | 2066 acc+= FFABS(src[x+y*stride] - ref); |
915 | 2067 } |
2068 } | |
2967 | 2069 |
915 | 2070 return acc; |
2071 } | |
2072 | |
2073 static int get_intra_count(MpegEncContext *s, uint8_t *src, uint8_t *ref, int stride){ | |
2074 int x, y, w, h; | |
2075 int acc=0; | |
2967 | 2076 |
915 | 2077 w= s->width &~15; |
2078 h= s->height&~15; | |
2967 | 2079 |
915 | 2080 for(y=0; y<h; y+=16){ |
2081 for(x=0; x<w; x+=16){ | |
2082 int offset= x + y*stride; | |
1708 | 2083 int sad = s->dsp.sad[0](NULL, src + offset, ref + offset, stride, 16); |
915 | 2084 int mean= (s->dsp.pix_sum(src + offset, stride) + 128)>>8; |
2085 int sae = get_sae(src + offset, mean, stride); | |
2967 | 2086 |
915 | 2087 acc+= sae + 500 < sad; |
2088 } | |
2089 } | |
2090 return acc; | |
2091 } | |
2092 | |
924 | 2093 |
925 | 2094 static int load_input_picture(MpegEncContext *s, AVFrame *pic_arg){ |
1373 | 2095 AVFrame *pic=NULL; |
2427 | 2096 int64_t pts; |
924 | 2097 int i; |
903 | 2098 const int encoding_delay= s->max_b_frames; |
924 | 2099 int direct=1; |
2967 | 2100 |
2419 | 2101 if(pic_arg){ |
2427 | 2102 pts= pic_arg->pts; |
2103 pic_arg->display_picture_number= s->input_picture_number++; | |
2104 | |
2967 | 2105 if(pts != AV_NOPTS_VALUE){ |
2419 | 2106 if(s->user_specified_pts != AV_NOPTS_VALUE){ |
2637 | 2107 int64_t time= pts; |
2108 int64_t last= s->user_specified_pts; | |
2967 | 2109 |
2110 if(time <= last){ | |
2962 | 2111 av_log(s->avctx, AV_LOG_ERROR, "Error, Invalid timestamp=%"PRId64", last=%"PRId64"\n", pts, s->user_specified_pts); |
2419 | 2112 return -1; |
2113 } | |
2114 } | |
2427 | 2115 s->user_specified_pts= pts; |
2419 | 2116 }else{ |
2117 if(s->user_specified_pts != AV_NOPTS_VALUE){ | |
2967 | 2118 s->user_specified_pts= |
2637 | 2119 pts= s->user_specified_pts + 1; |
2962 | 2120 av_log(s->avctx, AV_LOG_INFO, "Warning: AVFrame.pts=? trying to guess (%"PRId64")\n", pts); |
2419 | 2121 }else{ |
2637 | 2122 pts= pic_arg->display_picture_number; |
2419 | 2123 } |
2124 } | |
2125 } | |
2126 | |
1373 | 2127 if(pic_arg){ |
924 | 2128 if(encoding_delay && !(s->flags&CODEC_FLAG_INPUT_PRESERVED)) direct=0; |
2129 if(pic_arg->linesize[0] != s->linesize) direct=0; | |
2130 if(pic_arg->linesize[1] != s->uvlinesize) direct=0; | |
2131 if(pic_arg->linesize[2] != s->uvlinesize) direct=0; | |
2967 | 2132 |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1597
diff
changeset
|
2133 // av_log(AV_LOG_DEBUG, "%d %d %d %d\n",pic_arg->linesize[0], pic_arg->linesize[1], s->linesize, s->uvlinesize); |
2967 | 2134 |
924 | 2135 if(direct){ |
1586 | 2136 i= ff_find_unused_picture(s, 1); |
924 | 2137 |
925 | 2138 pic= (AVFrame*)&s->picture[i]; |
1168 | 2139 pic->reference= 3; |
2967 | 2140 |
924 | 2141 for(i=0; i<4; i++){ |
2142 pic->data[i]= pic_arg->data[i]; | |
2143 pic->linesize[i]= pic_arg->linesize[i]; | |
2144 } | |
2145 alloc_picture(s, (Picture*)pic, 1); | |
2146 }else{ | |
1586 | 2147 i= ff_find_unused_picture(s, 0); |
924 | 2148 |
925 | 2149 pic= (AVFrame*)&s->picture[i]; |
1168 | 2150 pic->reference= 3; |
924 | 2151 |
2152 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
|
2153 |
3068 | 2154 if( pic->data[0] + INPLACE_OFFSET == pic_arg->data[0] |
2155 && pic->data[1] + INPLACE_OFFSET == pic_arg->data[1] | |
2156 && pic->data[2] + INPLACE_OFFSET == pic_arg->data[2]){ | |
924 | 2157 // empty |
2158 }else{ | |
2159 int h_chroma_shift, v_chroma_shift; | |
2160 avcodec_get_chroma_sub_sample(s->avctx->pix_fmt, &h_chroma_shift, &v_chroma_shift); | |
2967 | 2161 |
924 | 2162 for(i=0; i<3; i++){ |
2163 int src_stride= pic_arg->linesize[i]; | |
2164 int dst_stride= i ? s->uvlinesize : s->linesize; | |
2165 int h_shift= i ? h_chroma_shift : 0; | |
2166 int v_shift= i ? v_chroma_shift : 0; | |
2167 int w= s->width >>h_shift; | |
2168 int h= s->height>>v_shift; | |
2169 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
|
2170 uint8_t *dst= pic->data[i]; |
16ace038f452
fix buffer underflows by reencoding the current frame with a higher QP
michael
parents:
3929
diff
changeset
|
2171 |
16ace038f452
fix buffer underflows by reencoding the current frame with a higher QP
michael
parents:
3929
diff
changeset
|
2172 if(!s->avctx->rc_buffer_size) |
16ace038f452
fix buffer underflows by reencoding the current frame with a higher QP
michael
parents:
3929
diff
changeset
|
2173 dst +=INPLACE_OFFSET; |
2967 | 2174 |
924 | 2175 if(src_stride==dst_stride) |
2176 memcpy(dst, src, src_stride*h); | |
2177 else{ | |
2178 while(h--){ | |
2179 memcpy(dst, src, w); | |
2180 dst += dst_stride; | |
2181 src += src_stride; | |
2182 } | |
2183 } | |
2184 } | |
2185 } | |
324 | 2186 } |
1938
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1918
diff
changeset
|
2187 copy_picture_attributes(s, pic, pic_arg); |
2427 | 2188 pic->pts= pts; //we set this here to avoid modifiying pic_arg |
1373 | 2189 } |
2967 | 2190 |
903 | 2191 /* shift buffer entries */ |
2192 for(i=1; i<MAX_PICTURE_COUNT /*s->encoding_delay+1*/; i++) | |
2193 s->input_picture[i-1]= s->input_picture[i]; | |
2967 | 2194 |
903 | 2195 s->input_picture[encoding_delay]= (Picture*)pic; |
2196 | |
2197 return 0; | |
2198 } | |
2199 | |
2381 | 2200 static int skip_check(MpegEncContext *s, Picture *p, Picture *ref){ |
2201 int x, y, plane; | |
2202 int score=0; | |
2382 | 2203 int64_t score64=0; |
2381 | 2204 |
2205 for(plane=0; plane<3; plane++){ | |
2206 const int stride= p->linesize[plane]; | |
2207 const int bw= plane ? 1 : 2; | |
2208 for(y=0; y<s->mb_height*bw; y++){ | |
2209 for(x=0; x<s->mb_width*bw; x++){ | |
2931 | 2210 int off= p->type == FF_BUFFER_TYPE_SHARED ? 0: 16; |
2211 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 | 2212 |
2382 | 2213 switch(s->avctx->frame_skip_exp){ |
2214 case 0: score= FFMAX(score, v); break; | |
4001 | 2215 case 1: score+= FFABS(v);break; |
2382 | 2216 case 2: score+= v*v;break; |
4001 | 2217 case 3: score64+= FFABS(v*v*(int64_t)v);break; |
2382 | 2218 case 4: score64+= v*v*(int64_t)(v*v);break; |
2219 } | |
2381 | 2220 } |
2221 } | |
2222 } | |
2967 | 2223 |
2382 | 2224 if(score) score64= score; |
2225 | |
2226 if(score64 < s->avctx->frame_skip_threshold) | |
2381 | 2227 return 1; |
2382 | 2228 if(score64 < ((s->avctx->frame_skip_factor * (int64_t)s->lambda)>>8)) |
2381 | 2229 return 1; |
2230 return 0; | |
2231 } | |
2232 | |
2988 | 2233 static int estimate_best_b_count(MpegEncContext *s){ |
2234 AVCodec *codec= avcodec_find_encoder(s->avctx->codec_id); | |
2235 AVCodecContext *c= avcodec_alloc_context(); | |
2236 AVFrame input[FF_MAX_B_FRAMES+2]; | |
2990
0300c2647bc3
support downscaling frames for dynamic b frame decission
michael
parents:
2988
diff
changeset
|
2237 const int scale= s->avctx->brd_scale; |
3068 | 2238 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
|
2239 int outbuf_size= s->width * s->height; //FIXME |
2988 | 2240 uint8_t *outbuf= av_malloc(outbuf_size); |
2241 int64_t best_rd= INT64_MAX; | |
2242 int best_b_count= -1; | |
3068 | 2243 |
3245 | 2244 assert(scale>=0 && scale <=3); |
2245 | |
3068 | 2246 // emms_c(); |
2247 p_lambda= s->last_lambda_for[P_TYPE]; //s->next_picture_ptr->quality; | |
4001 | 2248 b_lambda= s->last_lambda_for[B_TYPE]; //p_lambda *FFABS(s->avctx->b_quant_factor) + s->avctx->b_quant_offset; |
3068 | 2249 if(!b_lambda) b_lambda= p_lambda; //FIXME we should do this somewhere else |
2250 lambda2= (b_lambda*b_lambda + (1<<FF_LAMBDA_SHIFT)/2 ) >> FF_LAMBDA_SHIFT; | |
2988 | 2251 |
2252 c->width = s->width >> scale; | |
2253 c->height= s->height>> scale; | |
2254 c->flags= CODEC_FLAG_QSCALE | CODEC_FLAG_PSNR | CODEC_FLAG_INPUT_PRESERVED /*| CODEC_FLAG_EMU_EDGE*/; | |
2255 c->flags|= s->avctx->flags & CODEC_FLAG_QPEL; | |
2256 c->mb_decision= s->avctx->mb_decision; | |
2257 c->me_cmp= s->avctx->me_cmp; | |
2258 c->mb_cmp= s->avctx->mb_cmp; | |
2259 c->me_sub_cmp= s->avctx->me_sub_cmp; | |
2260 c->pix_fmt = PIX_FMT_YUV420P; | |
2261 c->time_base= s->avctx->time_base; | |
2262 c->max_b_frames= s->max_b_frames; | |
2263 | |
2264 if (avcodec_open(c, codec) < 0) | |
2265 return -1; | |
2266 | |
2267 for(i=0; i<s->max_b_frames+2; i++){ | |
2268 int ysize= c->width*c->height; | |
2269 int csize= (c->width/2)*(c->height/2); | |
3068 | 2270 Picture pre_input, *pre_input_ptr= i ? s->input_picture[i-1] : s->next_picture_ptr; |
2271 | |
2988 | 2272 avcodec_get_frame_defaults(&input[i]); |
2273 input[i].data[0]= av_malloc(ysize + 2*csize); | |
2274 input[i].data[1]= input[i].data[0] + ysize; | |
2275 input[i].data[2]= input[i].data[1] + csize; | |
2276 input[i].linesize[0]= c->width; | |
2277 input[i].linesize[1]= | |
2278 input[i].linesize[2]= c->width/2; | |
2279 | |
4416 | 2280 if(pre_input_ptr && (!i || s->input_picture[i-1])) { |
2281 pre_input= *pre_input_ptr; | |
2282 | |
2283 if(pre_input.type != FF_BUFFER_TYPE_SHARED && i) { | |
2284 pre_input.data[0]+=INPLACE_OFFSET; | |
2285 pre_input.data[1]+=INPLACE_OFFSET; | |
2286 pre_input.data[2]+=INPLACE_OFFSET; | |
2287 } | |
2288 | |
3245 | 2289 s->dsp.shrink[scale](input[i].data[0], input[i].linesize[0], pre_input.data[0], pre_input.linesize[0], c->width, c->height); |
2290 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); | |
2291 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); | |
2292 } | |
2988 | 2293 } |
2294 | |
2295 for(j=0; j<s->max_b_frames+1; j++){ | |
2296 int64_t rd=0; | |
2297 | |
2298 if(!s->input_picture[j]) | |
2299 break; | |
2300 | |
2301 c->error[0]= c->error[1]= c->error[2]= 0; | |
2302 | |
2303 input[0].pict_type= I_TYPE; | |
3068 | 2304 input[0].quality= 1 * FF_QP2LAMBDA; |
2988 | 2305 out_size = avcodec_encode_video(c, outbuf, outbuf_size, &input[0]); |
3068 | 2306 // rd += (out_size * lambda2) >> FF_LAMBDA_SHIFT; |
2988 | 2307 |
2308 for(i=0; i<s->max_b_frames+1; i++){ | |
2309 int is_p= i % (j+1) == j || i==s->max_b_frames; | |
2310 | |
2311 input[i+1].pict_type= is_p ? P_TYPE : B_TYPE; | |
3068 | 2312 input[i+1].quality= is_p ? p_lambda : b_lambda; |
2988 | 2313 out_size = avcodec_encode_video(c, outbuf, outbuf_size, &input[i+1]); |
3068 | 2314 rd += (out_size * lambda2) >> (FF_LAMBDA_SHIFT - 3); |
2988 | 2315 } |
2316 | |
2317 /* get the delayed frames */ | |
2318 while(out_size){ | |
2319 out_size = avcodec_encode_video(c, outbuf, outbuf_size, NULL); | |
3068 | 2320 rd += (out_size * lambda2) >> (FF_LAMBDA_SHIFT - 3); |
2988 | 2321 } |
2322 | |
2323 rd += c->error[0] + c->error[1] + c->error[2]; | |
2324 | |
2325 if(rd < best_rd){ | |
2326 best_rd= rd; | |
2327 best_b_count= j; | |
2328 } | |
2329 } | |
2330 | |
2331 av_freep(&outbuf); | |
2332 avcodec_close(c); | |
2333 av_freep(&c); | |
2334 | |
2335 for(i=0; i<s->max_b_frames+2; i++){ | |
2336 av_freep(&input[i].data[0]); | |
2337 } | |
2338 | |
2339 return best_b_count; | |
2340 } | |
2341 | |
903 | 2342 static void select_input_picture(MpegEncContext *s){ |
2343 int i; | |
924 | 2344 |
903 | 2345 for(i=1; i<MAX_PICTURE_COUNT; i++) |
2346 s->reordered_input_picture[i-1]= s->reordered_input_picture[i]; | |
2347 s->reordered_input_picture[MAX_PICTURE_COUNT-1]= NULL; | |
2348 | |
2764 | 2349 /* set next picture type & ordering */ |
903 | 2350 if(s->reordered_input_picture[0]==NULL && s->input_picture[0]){ |
1138 | 2351 if(/*s->picture_in_gop_number >= s->gop_size ||*/ s->next_picture_ptr==NULL || s->intra_only){ |
915 | 2352 s->reordered_input_picture[0]= s->input_picture[0]; |
2353 s->reordered_input_picture[0]->pict_type= I_TYPE; | |
1705 | 2354 s->reordered_input_picture[0]->coded_picture_number= s->coded_picture_number++; |
915 | 2355 }else{ |
2356 int b_frames; | |
2381 | 2357 |
2358 if(s->avctx->frame_skip_threshold || s->avctx->frame_skip_factor){ | |
2931 | 2359 if(s->picture_in_gop_number < s->gop_size && skip_check(s, s->input_picture[0], s->next_picture_ptr)){ |
2360 //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
|
2361 //av_log(NULL, AV_LOG_DEBUG, "skip %p %"PRId64"\n", s->input_picture[0]->data[0], s->input_picture[0]->pts); |
2967 | 2362 |
2381 | 2363 if(s->input_picture[0]->type == FF_BUFFER_TYPE_SHARED){ |
2364 for(i=0; i<4; i++) | |
2365 s->input_picture[0]->data[i]= NULL; | |
2967 | 2366 s->input_picture[0]->type= 0; |
2381 | 2367 }else{ |
2967 | 2368 assert( s->input_picture[0]->type==FF_BUFFER_TYPE_USER |
2381 | 2369 || s->input_picture[0]->type==FF_BUFFER_TYPE_INTERNAL); |
2967 | 2370 |
2381 | 2371 s->avctx->release_buffer(s->avctx, (AVFrame*)s->input_picture[0]); |
2372 } | |
2967 | 2373 |
2931 | 2374 emms_c(); |
2375 ff_vbv_update(s, 0); | |
2381 | 2376 |
2377 goto no_output_pic; | |
2378 } | |
2379 } | |
2380 | |
915 | 2381 if(s->flags&CODEC_FLAG_PASS2){ |
2382 for(i=0; i<s->max_b_frames+1; i++){ | |
2383 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
|
2384 |
2967 | 2385 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
|
2386 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
|
2387 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
|
2388 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
|
2389 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
|
2390 } |
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 |
2967 | 2392 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
|
2393 s->rc_context.entry[pict_num].new_pict_type; |
915 | 2394 } |
2395 } | |
924 | 2396 |
2297 | 2397 if(s->avctx->b_frame_strategy==0){ |
915 | 2398 b_frames= s->max_b_frames; |
1373 | 2399 while(b_frames && !s->input_picture[b_frames]) b_frames--; |
1687 | 2400 }else if(s->avctx->b_frame_strategy==1){ |
915 | 2401 for(i=1; i<s->max_b_frames+1; i++){ |
1373 | 2402 if(s->input_picture[i] && s->input_picture[i]->b_frame_score==0){ |
2967 | 2403 s->input_picture[i]->b_frame_score= |
2404 get_intra_count(s, s->input_picture[i ]->data[0], | |
924 | 2405 s->input_picture[i-1]->data[0], s->linesize) + 1; |
915 | 2406 } |
2407 } | |
2728 | 2408 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
|
2409 if(s->input_picture[i]==NULL || s->input_picture[i]->b_frame_score - 1 > s->mb_num/s->avctx->b_sensitivity) break; |
915 | 2410 } |
2967 | 2411 |
915 | 2412 b_frames= FFMAX(0, i-1); |
2967 | 2413 |
915 | 2414 /* reset scores */ |
2415 for(i=0; i<b_frames+1; i++){ | |
2416 s->input_picture[i]->b_frame_score=0; | |
2417 } | |
2988 | 2418 }else if(s->avctx->b_frame_strategy==2){ |
2419 b_frames= estimate_best_b_count(s); | |
915 | 2420 }else{ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1597
diff
changeset
|
2421 av_log(s->avctx, AV_LOG_ERROR, "illegal b frame strategy\n"); |
915 | 2422 b_frames=0; |
909
8ae1e4c24e91
new PSNR code (now works with chroma, b frames, ...)
michaelni
parents:
903
diff
changeset
|
2423 } |
915 | 2424 |
2425 emms_c(); | |
2426 //static int b_count=0; | |
2427 //b_count+= b_frames; | |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1597
diff
changeset
|
2428 //av_log(s->avctx, AV_LOG_DEBUG, "b_frames: %d\n", b_count); |
2297 | 2429 |
2430 for(i= b_frames - 1; i>=0; i--){ | |
2431 int type= s->input_picture[i]->pict_type; | |
2432 if(type && type != B_TYPE) | |
2433 b_frames= i; | |
2434 } | |
2435 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
|
2436 av_log(s->avctx, AV_LOG_ERROR, "warning, too many b frames in a row\n"); |
2297 | 2437 } |
2438 | |
1754
bdf3927bf8c5
closed gop support & flags2 as all bits in flags are used
michael
parents:
1751
diff
changeset
|
2439 if(s->picture_in_gop_number + b_frames >= s->gop_size){ |
2298 | 2440 if((s->flags2 & CODEC_FLAG2_STRICT_GOP) && s->gop_size > s->picture_in_gop_number){ |
2441 b_frames= s->gop_size - s->picture_in_gop_number - 1; | |
2442 }else{ | |
1754
bdf3927bf8c5
closed gop support & flags2 as all bits in flags are used
michael
parents:
1751
diff
changeset
|
2443 if(s->flags & CODEC_FLAG_CLOSED_GOP) |
bdf3927bf8c5
closed gop support & flags2 as all bits in flags are used
michael
parents:
1751
diff
changeset
|
2444 b_frames=0; |
bdf3927bf8c5
closed gop support & flags2 as all bits in flags are used
michael
parents:
1751
diff
changeset
|
2445 s->input_picture[b_frames]->pict_type= I_TYPE; |
2298 | 2446 } |
1754
bdf3927bf8c5
closed gop support & flags2 as all bits in flags are used
michael
parents:
1751
diff
changeset
|
2447 } |
2967 | 2448 |
1754
bdf3927bf8c5
closed gop support & flags2 as all bits in flags are used
michael
parents:
1751
diff
changeset
|
2449 if( (s->flags & CODEC_FLAG_CLOSED_GOP) |
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 && 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
|
2452 b_frames--; |
bdf3927bf8c5
closed gop support & flags2 as all bits in flags are used
michael
parents:
1751
diff
changeset
|
2453 |
915 | 2454 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
|
2455 if(s->reordered_input_picture[0]->pict_type != I_TYPE) |
915 | 2456 s->reordered_input_picture[0]->pict_type= P_TYPE; |
1705 | 2457 s->reordered_input_picture[0]->coded_picture_number= s->coded_picture_number++; |
915 | 2458 for(i=0; i<b_frames; i++){ |
2459 s->reordered_input_picture[i+1]= s->input_picture[i]; | |
2460 s->reordered_input_picture[i+1]->pict_type= B_TYPE; | |
1705 | 2461 s->reordered_input_picture[i+1]->coded_picture_number= s->coded_picture_number++; |
903 | 2462 } |
324 | 2463 } |
2464 } | |
2381 | 2465 no_output_pic: |
903 | 2466 if(s->reordered_input_picture[0]){ |
1168 | 2467 s->reordered_input_picture[0]->reference= s->reordered_input_picture[0]->pict_type!=B_TYPE ? 3 : 0; |
1138 | 2468 |
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
|
2469 copy_picture(&s->new_picture, s->reordered_input_picture[0]); |
924 | 2470 |
3939
16ace038f452
fix buffer underflows by reencoding the current frame with a higher QP
michael
parents:
3929
diff
changeset
|
2471 if(s->reordered_input_picture[0]->type == FF_BUFFER_TYPE_SHARED || s->avctx->rc_buffer_size){ |
2764 | 2472 // input is a shared pix, so we can't modifiy it -> alloc a new one & ensure that the shared one is reuseable |
2967 | 2473 |
1586 | 2474 int i= ff_find_unused_picture(s, 0); |
924 | 2475 Picture *pic= &s->picture[i]; |
2476 | |
3939
16ace038f452
fix buffer underflows by reencoding the current frame with a higher QP
michael
parents:
3929
diff
changeset
|
2477 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
|
2478 alloc_picture(s, pic, 0); |
16ace038f452
fix buffer underflows by reencoding the current frame with a higher QP
michael
parents:
3929
diff
changeset
|
2479 |
924 | 2480 /* 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
|
2481 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
|
2482 s->avctx->release_buffer(s->avctx, (AVFrame*)s->reordered_input_picture[0]); |
924 | 2483 for(i=0; i<4; i++) |
2484 s->reordered_input_picture[0]->data[i]= NULL; | |
2485 s->reordered_input_picture[0]->type= 0; | |
2967 | 2486 |
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
|
2487 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
|
2488 |
1138 | 2489 s->current_picture_ptr= pic; |
924 | 2490 }else{ |
1138 | 2491 // input is not a shared pix -> reuse buffer for current_pix |
2492 | |
2967 | 2493 assert( s->reordered_input_picture[0]->type==FF_BUFFER_TYPE_USER |
924 | 2494 || s->reordered_input_picture[0]->type==FF_BUFFER_TYPE_INTERNAL); |
2967 | 2495 |
1138 | 2496 s->current_picture_ptr= s->reordered_input_picture[0]; |
924 | 2497 for(i=0; i<4; i++){ |
3068 | 2498 s->new_picture.data[i]+= INPLACE_OFFSET; |
924 | 2499 } |
903 | 2500 } |
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
|
2501 copy_picture(&s->current_picture, s->current_picture_ptr); |
2967 | 2502 |
903 | 2503 s->picture_number= s->new_picture.display_picture_number; |
2504 //printf("dpn:%d\n", s->picture_number); | |
2505 }else{ | |
2506 memset(&s->new_picture, 0, sizeof(Picture)); | |
324 | 2507 } |
2508 } | |
2509 | |
0 | 2510 int MPV_encode_picture(AVCodecContext *avctx, |
2511 unsigned char *buf, int buf_size, void *data) | |
2512 { | |
2513 MpegEncContext *s = avctx->priv_data; | |
925 | 2514 AVFrame *pic_arg = data; |
1684 | 2515 int i, stuffing_count; |
0 | 2516 |
1799 | 2517 for(i=0; i<avctx->thread_count; i++){ |
1838 | 2518 int start_y= s->thread_context[i]->start_mb_y; |
2519 int end_y= s->thread_context[i]-> end_mb_y; | |
1799 | 2520 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
|
2521 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
|
2522 uint8_t *end = buf + (size_t)(((int64_t) buf_size)* end_y/h); |
1799 | 2523 |
2524 init_put_bits(&s->thread_context[i]->pb, start, end - start); | |
2525 } | |
0 | 2526 |
903 | 2527 s->picture_in_gop_number++; |
2528 | |
2243
b8bad8bbbc64
check if the user specified timestamps are strictly monotone
michael
parents:
2235
diff
changeset
|
2529 if(load_input_picture(s, pic_arg) < 0) |
b8bad8bbbc64
check if the user specified timestamps are strictly monotone
michael
parents:
2235
diff
changeset
|
2530 return -1; |
2967 | 2531 |
903 | 2532 select_input_picture(s); |
2967 | 2533 |
324 | 2534 /* output? */ |
903 | 2535 if(s->new_picture.data[0]){ |
2536 s->pict_type= s->new_picture.pict_type; | |
2537 //emms_c(); | |
2538 //printf("qs:%f %f %d\n", s->new_picture.quality, s->current_picture.quality, s->qscale); | |
553 | 2539 MPV_frame_start(s, avctx); |
3939
16ace038f452
fix buffer underflows by reencoding the current frame with a higher QP
michael
parents:
3929
diff
changeset
|
2540 vbv_retry: |
3766 | 2541 if (encode_picture(s, s->picture_number) < 0) |
2542 return -1; | |
2967 | 2543 |
376 | 2544 avctx->real_pict_num = s->picture_number; |
324 | 2545 avctx->header_bits = s->header_bits; |
2546 avctx->mv_bits = s->mv_bits; | |
2547 avctx->misc_bits = s->misc_bits; | |
2548 avctx->i_tex_bits = s->i_tex_bits; | |
2549 avctx->p_tex_bits = s->p_tex_bits; | |
2550 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
|
2551 avctx->p_count = s->mb_num - s->i_count - s->skip_count; //FIXME f/b_count in avctx |
324 | 2552 avctx->skip_count = s->skip_count; |
0 | 2553 |
324 | 2554 MPV_frame_end(s); |
2555 | |
2556 if (s->out_format == FMT_MJPEG) | |
2557 mjpeg_picture_trailer(s); | |
2967 | 2558 |
3939
16ace038f452
fix buffer underflows by reencoding the current frame with a higher QP
michael
parents:
3929
diff
changeset
|
2559 if(avctx->rc_buffer_size){ |
16ace038f452
fix buffer underflows by reencoding the current frame with a higher QP
michael
parents:
3929
diff
changeset
|
2560 RateControlContext *rcc= &s->rc_context; |
16ace038f452
fix buffer underflows by reencoding the current frame with a higher QP
michael
parents:
3929
diff
changeset
|
2561 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
|
2562 |
4096
99616a74260a
use lambda/lmax instead of qscale/qmax as end check for vbv retry
michael
parents:
4052
diff
changeset
|
2563 if(put_bits_count(&s->pb) > max_size && s->lambda < s->avctx->lmax){ |
4052 | 2564 s->next_lambda= FFMAX(s->lambda+1, s->lambda*(s->qscale+1) / s->qscale); |
4218 | 2565 if(s->adaptive_quant){ |
2566 int i; | |
4223 | 2567 for(i=0; i<s->mb_height*s->mb_stride; i++) |
4218 | 2568 s->lambda_table[i]= FFMAX(s->lambda_table[i]+1, s->lambda_table[i]*(s->qscale+1) / s->qscale); |
2569 } | |
3939
16ace038f452
fix buffer underflows by reencoding the current frame with a higher QP
michael
parents:
3929
diff
changeset
|
2570 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
|
2571 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
|
2572 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
|
2573 s->no_rounding ^= 1; |
16ace038f452
fix buffer underflows by reencoding the current frame with a higher QP
michael
parents:
3929
diff
changeset
|
2574 } |
4111 | 2575 if(s->pict_type!=B_TYPE){ |
2576 s->time_base= s->last_time_base; | |
2577 s->last_non_b_time= s->time - s->pp_time; | |
2578 } | |
3939
16ace038f452
fix buffer underflows by reencoding the current frame with a higher QP
michael
parents:
3929
diff
changeset
|
2579 // 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
|
2580 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
|
2581 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
|
2582 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
|
2583 } |
16ace038f452
fix buffer underflows by reencoding the current frame with a higher QP
michael
parents:
3929
diff
changeset
|
2584 goto vbv_retry; |
16ace038f452
fix buffer underflows by reencoding the current frame with a higher QP
michael
parents:
3929
diff
changeset
|
2585 } |
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 assert(s->avctx->rc_max_rate); |
16ace038f452
fix buffer underflows by reencoding the current frame with a higher QP
michael
parents:
3929
diff
changeset
|
2588 } |
16ace038f452
fix buffer underflows by reencoding the current frame with a higher QP
michael
parents:
3929
diff
changeset
|
2589 |
329 | 2590 if(s->flags&CODEC_FLAG_PASS1) |
2591 ff_write_pass1_stats(s); | |
1138 | 2592 |
2593 for(i=0; i<4; i++){ | |
2955 | 2594 s->current_picture_ptr->error[i]= s->current_picture.error[i]; |
1138 | 2595 avctx->error[i] += s->current_picture_ptr->error[i]; |
2596 } | |
1766 | 2597 |
2428
548c87c06dbb
assertion about bits statistic and minor bits stat fix
michael
parents:
2427
diff
changeset
|
2598 if(s->flags&CODEC_FLAG_PASS1) |
548c87c06dbb
assertion about bits statistic and minor bits stat fix
michael
parents:
2427
diff
changeset
|
2599 assert(avctx->header_bits + avctx->mv_bits + avctx->misc_bits + avctx->i_tex_bits + avctx->p_tex_bits == put_bits_count(&s->pb)); |
1684 | 2600 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
|
2601 s->frame_bits = put_bits_count(&s->pb); |
1766 | 2602 |
2603 stuffing_count= ff_vbv_update(s, s->frame_bits); | |
2604 if(stuffing_count){ | |
2422 | 2605 if(s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb)>>3) < stuffing_count + 50){ |
2606 av_log(s->avctx, AV_LOG_ERROR, "stuffing too large\n"); | |
2607 return -1; | |
2608 } | |
2609 | |
1766 | 2610 switch(s->codec_id){ |
2611 case CODEC_ID_MPEG1VIDEO: | |
2612 case CODEC_ID_MPEG2VIDEO: | |
2613 while(stuffing_count--){ | |
2614 put_bits(&s->pb, 8, 0); | |
2615 } | |
2616 break; | |
2617 case CODEC_ID_MPEG4: | |
2618 put_bits(&s->pb, 16, 0); | |
2619 put_bits(&s->pb, 16, 0x1C3); | |
2620 stuffing_count -= 4; | |
2621 while(stuffing_count--){ | |
2622 put_bits(&s->pb, 8, 0xFF); | |
2623 } | |
2624 break; | |
2625 default: | |
2626 av_log(s->avctx, AV_LOG_ERROR, "vbv buffer overflow\n"); | |
2627 } | |
2628 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
|
2629 s->frame_bits = put_bits_count(&s->pb); |
1766 | 2630 } |
2631 | |
2967 | 2632 /* update mpeg1/2 vbv_delay for CBR */ |
1907 | 2633 if(s->avctx->rc_max_rate && s->avctx->rc_min_rate == s->avctx->rc_max_rate && s->out_format == FMT_MPEG1 |
2634 && 90000LL * (avctx->rc_buffer_size-1) <= s->avctx->rc_max_rate*0xFFFFLL){ | |
1766 | 2635 int vbv_delay; |
2636 | |
2637 assert(s->repeat_first_field==0); | |
2967 | 2638 |
1766 | 2639 vbv_delay= lrintf(90000 * s->rc_context.buffer_index / s->avctx->rc_max_rate); |
2640 assert(vbv_delay < 0xFFFF); | |
2641 | |
2642 s->vbv_delay_ptr[0] &= 0xF8; | |
2643 s->vbv_delay_ptr[0] |= vbv_delay>>13; | |
2644 s->vbv_delay_ptr[1] = vbv_delay>>5; | |
2645 s->vbv_delay_ptr[2] &= 0x07; | |
2646 s->vbv_delay_ptr[2] |= vbv_delay<<3; | |
2647 } | |
2648 s->total_bits += s->frame_bits; | |
2649 avctx->frame_bits = s->frame_bits; | |
2650 }else{ | |
2651 assert((pbBufPtr(&s->pb) == s->pb.buf)); | |
2652 s->frame_bits=0; | |
1684 | 2653 } |
1766 | 2654 assert((s->frame_bits&7)==0); |
2967 | 2655 |
1684 | 2656 return s->frame_bits/8; |
0 | 2657 } |
2658 | |
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
|
2659 #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
|
2660 |
255 | 2661 static inline void gmc1_motion(MpegEncContext *s, |
1064 | 2662 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
|
2663 uint8_t **ref_picture) |
255 | 2664 { |
1064 | 2665 uint8_t *ptr; |
556 | 2666 int offset, src_x, src_y, linesize, uvlinesize; |
255 | 2667 int motion_x, motion_y; |
566 | 2668 int emu=0; |
255 | 2669 |
2670 motion_x= s->sprite_offset[0][0]; | |
2671 motion_y= s->sprite_offset[0][1]; | |
2672 src_x = s->mb_x * 16 + (motion_x >> (s->sprite_warping_accuracy+1)); | |
2673 src_y = s->mb_y * 16 + (motion_y >> (s->sprite_warping_accuracy+1)); | |
2674 motion_x<<=(3-s->sprite_warping_accuracy); | |
2675 motion_y<<=(3-s->sprite_warping_accuracy); | |
4594 | 2676 src_x = av_clip(src_x, -16, s->width); |
255 | 2677 if (src_x == s->width) |
2678 motion_x =0; | |
4594 | 2679 src_y = av_clip(src_y, -16, s->height); |
255 | 2680 if (src_y == s->height) |
2681 motion_y =0; | |
753 | 2682 |
255 | 2683 linesize = s->linesize; |
556 | 2684 uvlinesize = s->uvlinesize; |
2967 | 2685 |
1842
0d82db458a3c
interlaced mpeg4 + edge emu fix (fixes decoding of mermaid.avi)
michael
parents:
1838
diff
changeset
|
2686 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
|
2687 |
566 | 2688 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
|
2689 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
|
2690 || (unsigned)src_y >= s->v_edge_pos - 17){ |
1317
26c44d2433c1
make ff_emulated_edge_mc() independant of MpegEncContext
michaelni
parents:
1315
diff
changeset
|
2691 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 | 2692 ptr= s->edge_emu_buffer; |
2693 } | |
2694 } | |
2967 | 2695 |
753 | 2696 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
|
2697 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
|
2698 s->dsp.gmc1(dest_y+8, ptr+8, linesize, 16, motion_x&15, motion_y&15, 128 - s->no_rounding); |
753 | 2699 }else{ |
2700 int dxy; | |
2967 | 2701 |
753 | 2702 dxy= ((motion_x>>3)&1) | ((motion_y>>2)&2); |
2703 if (s->no_rounding){ | |
2979 | 2704 s->dsp.put_no_rnd_pixels_tab[0][dxy](dest_y, ptr, linesize, 16); |
753 | 2705 }else{ |
853
eacc2dd8fd9d
* using DSPContext - so each codec could use its local (sub)set of CPU extension
kabi
parents:
847
diff
changeset
|
2706 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
|
2707 } |
753 | 2708 } |
2967 | 2709 |
753 | 2710 if(s->flags&CODEC_FLAG_GRAY) return; |
255 | 2711 |
2712 motion_x= s->sprite_offset[1][0]; | |
2713 motion_y= s->sprite_offset[1][1]; | |
2714 src_x = s->mb_x * 8 + (motion_x >> (s->sprite_warping_accuracy+1)); | |
2715 src_y = s->mb_y * 8 + (motion_y >> (s->sprite_warping_accuracy+1)); | |
2716 motion_x<<=(3-s->sprite_warping_accuracy); | |
2717 motion_y<<=(3-s->sprite_warping_accuracy); | |
4594 | 2718 src_x = av_clip(src_x, -8, s->width>>1); |
255 | 2719 if (src_x == s->width>>1) |
2720 motion_x =0; | |
4594 | 2721 src_y = av_clip(src_y, -8, s->height>>1); |
255 | 2722 if (src_y == s->height>>1) |
2723 motion_y =0; | |
2724 | |
1842
0d82db458a3c
interlaced mpeg4 + edge emu fix (fixes decoding of mermaid.avi)
michael
parents:
1838
diff
changeset
|
2725 offset = (src_y * uvlinesize) + src_x; |
255 | 2726 ptr = ref_picture[1] + offset; |
1002 | 2727 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
|
2728 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
|
2729 || (unsigned)src_y >= (s->v_edge_pos>>1) - 9){ |
1317
26c44d2433c1
make ff_emulated_edge_mc() independant of MpegEncContext
michaelni
parents:
1315
diff
changeset
|
2730 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 | 2731 ptr= s->edge_emu_buffer; |
2732 emu=1; | |
2733 } | |
566 | 2734 } |
1842
0d82db458a3c
interlaced mpeg4 + edge emu fix (fixes decoding of mermaid.avi)
michael
parents:
1838
diff
changeset
|
2735 s->dsp.gmc1(dest_cb, ptr, uvlinesize, 8, motion_x&15, motion_y&15, 128 - s->no_rounding); |
2967 | 2736 |
255 | 2737 ptr = ref_picture[2] + offset; |
566 | 2738 if(emu){ |
1317
26c44d2433c1
make ff_emulated_edge_mc() independant of MpegEncContext
michaelni
parents:
1315
diff
changeset
|
2739 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 | 2740 ptr= s->edge_emu_buffer; |
2741 } | |
1842
0d82db458a3c
interlaced mpeg4 + edge emu fix (fixes decoding of mermaid.avi)
michael
parents:
1838
diff
changeset
|
2742 s->dsp.gmc1(dest_cr, ptr, uvlinesize, 8, motion_x&15, motion_y&15, 128 - s->no_rounding); |
2967 | 2743 |
255 | 2744 return; |
2745 } | |
2746 | |
753 | 2747 static inline void gmc_motion(MpegEncContext *s, |
1064 | 2748 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
|
2749 uint8_t **ref_picture) |
753 | 2750 { |
1064 | 2751 uint8_t *ptr; |
753 | 2752 int linesize, uvlinesize; |
2753 const int a= s->sprite_warping_accuracy; | |
2754 int ox, oy; | |
2755 | |
2756 linesize = s->linesize; | |
2757 uvlinesize = s->uvlinesize; | |
2758 | |
1842
0d82db458a3c
interlaced mpeg4 + edge emu fix (fixes decoding of mermaid.avi)
michael
parents:
1838
diff
changeset
|
2759 ptr = ref_picture[0]; |
0d82db458a3c
interlaced mpeg4 + edge emu fix (fixes decoding of mermaid.avi)
michael
parents:
1838
diff
changeset
|
2760 |
753 | 2761 ox= s->sprite_offset[0][0] + s->sprite_delta[0][0]*s->mb_x*16 + s->sprite_delta[0][1]*s->mb_y*16; |
2762 oy= s->sprite_offset[0][1] + s->sprite_delta[1][0]*s->mb_x*16 + s->sprite_delta[1][1]*s->mb_y*16; | |
2763 | |
853
eacc2dd8fd9d
* using DSPContext - so each codec could use its local (sub)set of CPU extension
kabi
parents:
847
diff
changeset
|
2764 s->dsp.gmc(dest_y, ptr, linesize, 16, |
2967 | 2765 ox, |
2766 oy, | |
753 | 2767 s->sprite_delta[0][0], s->sprite_delta[0][1], |
2967 | 2768 s->sprite_delta[1][0], s->sprite_delta[1][1], |
753 | 2769 a+1, (1<<(2*a+1)) - s->no_rounding, |
2770 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
|
2771 s->dsp.gmc(dest_y+8, ptr, linesize, 16, |
2967 | 2772 ox + s->sprite_delta[0][0]*8, |
2773 oy + s->sprite_delta[1][0]*8, | |
753 | 2774 s->sprite_delta[0][0], s->sprite_delta[0][1], |
2967 | 2775 s->sprite_delta[1][0], s->sprite_delta[1][1], |
753 | 2776 a+1, (1<<(2*a+1)) - s->no_rounding, |
2777 s->h_edge_pos, s->v_edge_pos); | |
2778 | |
2779 if(s->flags&CODEC_FLAG_GRAY) return; | |
2780 | |
2781 ox= s->sprite_offset[1][0] + s->sprite_delta[0][0]*s->mb_x*8 + s->sprite_delta[0][1]*s->mb_y*8; | |
2782 oy= s->sprite_offset[1][1] + s->sprite_delta[1][0]*s->mb_x*8 + s->sprite_delta[1][1]*s->mb_y*8; | |
2783 | |
1842
0d82db458a3c
interlaced mpeg4 + edge emu fix (fixes decoding of mermaid.avi)
michael
parents:
1838
diff
changeset
|
2784 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
|
2785 s->dsp.gmc(dest_cb, ptr, uvlinesize, 8, |
2967 | 2786 ox, |
2787 oy, | |
753 | 2788 s->sprite_delta[0][0], s->sprite_delta[0][1], |
2967 | 2789 s->sprite_delta[1][0], s->sprite_delta[1][1], |
753 | 2790 a+1, (1<<(2*a+1)) - s->no_rounding, |
2791 s->h_edge_pos>>1, s->v_edge_pos>>1); | |
2967 | 2792 |
1842
0d82db458a3c
interlaced mpeg4 + edge emu fix (fixes decoding of mermaid.avi)
michael
parents:
1838
diff
changeset
|
2793 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
|
2794 s->dsp.gmc(dest_cr, ptr, uvlinesize, 8, |
2967 | 2795 ox, |
2796 oy, | |
753 | 2797 s->sprite_delta[0][0], s->sprite_delta[0][1], |
2967 | 2798 s->sprite_delta[1][0], s->sprite_delta[1][1], |
753 | 2799 a+1, (1<<(2*a+1)) - s->no_rounding, |
2800 s->h_edge_pos>>1, s->v_edge_pos>>1); | |
2801 } | |
2802 | |
1317
26c44d2433c1
make ff_emulated_edge_mc() independant of MpegEncContext
michaelni
parents:
1315
diff
changeset
|
2803 /** |
26c44d2433c1
make ff_emulated_edge_mc() independant of MpegEncContext
michaelni
parents:
1315
diff
changeset
|
2804 * 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
|
2805 * @param buf destination buffer |
26c44d2433c1
make ff_emulated_edge_mc() independant of MpegEncContext
michaelni
parents:
1315
diff
changeset
|
2806 * @param src source buffer |
26c44d2433c1
make ff_emulated_edge_mc() independant of MpegEncContext
michaelni
parents:
1315
diff
changeset
|
2807 * @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
|
2808 * @param block_w width of block |
26c44d2433c1
make ff_emulated_edge_mc() independant of MpegEncContext
michaelni
parents:
1315
diff
changeset
|
2809 * @param block_h height of block |
26c44d2433c1
make ff_emulated_edge_mc() independant of MpegEncContext
michaelni
parents:
1315
diff
changeset
|
2810 * @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
|
2811 * @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
|
2812 * @param w width of the source buffer |
26c44d2433c1
make ff_emulated_edge_mc() independant of MpegEncContext
michaelni
parents:
1315
diff
changeset
|
2813 * @param h height of the source buffer |
26c44d2433c1
make ff_emulated_edge_mc() independant of MpegEncContext
michaelni
parents:
1315
diff
changeset
|
2814 */ |
2967 | 2815 void ff_emulated_edge_mc(uint8_t *buf, uint8_t *src, int linesize, int block_w, int block_h, |
553 | 2816 int src_x, int src_y, int w, int h){ |
2817 int x, y; | |
2818 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
|
2819 |
553 | 2820 if(src_y>= h){ |
2821 src+= (h-1-src_y)*linesize; | |
2822 src_y=h-1; | |
554 | 2823 }else if(src_y<=-block_h){ |
2824 src+= (1-block_h-src_y)*linesize; | |
2825 src_y=1-block_h; | |
553 | 2826 } |
2827 if(src_x>= w){ | |
2828 src+= (w-1-src_x); | |
2829 src_x=w-1; | |
554 | 2830 }else if(src_x<=-block_w){ |
2831 src+= (1-block_w-src_x); | |
2832 src_x=1-block_w; | |
553 | 2833 } |
2834 | |
847 | 2835 start_y= FFMAX(0, -src_y); |
2836 start_x= FFMAX(0, -src_x); | |
2837 end_y= FFMIN(block_h, h-src_y); | |
2838 end_x= FFMIN(block_w, w-src_x); | |
566 | 2839 |
553 | 2840 // copy existing part |
2841 for(y=start_y; y<end_y; y++){ | |
2842 for(x=start_x; x<end_x; x++){ | |
2843 buf[x + y*linesize]= src[x + y*linesize]; | |
2844 } | |
2845 } | |
2846 | |
2847 //top | |
2848 for(y=0; y<start_y; y++){ | |
2849 for(x=start_x; x<end_x; x++){ | |
2850 buf[x + y*linesize]= buf[x + start_y*linesize]; | |
2851 } | |
2852 } | |
2853 | |
2854 //bottom | |
2855 for(y=end_y; y<block_h; y++){ | |
2856 for(x=start_x; x<end_x; x++){ | |
2857 buf[x + y*linesize]= buf[x + (end_y-1)*linesize]; | |
2858 } | |
2859 } | |
2967 | 2860 |
553 | 2861 for(y=0; y<block_h; y++){ |
2862 //left | |
2863 for(x=0; x<start_x; x++){ | |
2864 buf[x + y*linesize]= buf[start_x + y*linesize]; | |
2865 } | |
2967 | 2866 |
553 | 2867 //right |
2868 for(x=end_x; x<block_w; x++){ | |
2869 buf[x + y*linesize]= buf[end_x - 1 + y*linesize]; | |
2870 } | |
2871 } | |
2872 } | |
2873 | |
2967 | 2874 static inline int hpel_motion(MpegEncContext *s, |
1842
0d82db458a3c
interlaced mpeg4 + edge emu fix (fixes decoding of mermaid.avi)
michael
parents:
1838
diff
changeset
|
2875 uint8_t *dest, uint8_t *src, |
0d82db458a3c
interlaced mpeg4 + edge emu fix (fixes decoding of mermaid.avi)
michael
parents:
1838
diff
changeset
|
2876 int field_based, int field_select, |
1633 | 2877 int src_x, int src_y, |
2878 int width, int height, int stride, | |
2879 int h_edge_pos, int v_edge_pos, | |
2880 int w, int h, op_pixels_func *pix_op, | |
2881 int motion_x, int motion_y) | |
2882 { | |
2883 int dxy; | |
2884 int emu=0; | |
2885 | |
2886 dxy = ((motion_y & 1) << 1) | (motion_x & 1); | |
2887 src_x += motion_x >> 1; | |
2888 src_y += motion_y >> 1; | |
2967 | 2889 |
1633 | 2890 /* WARNING: do no forget half pels */ |
4594 | 2891 src_x = av_clip(src_x, -16, width); //FIXME unneeded for emu? |
1633 | 2892 if (src_x == width) |
2893 dxy &= ~1; | |
4594 | 2894 src_y = av_clip(src_y, -16, height); |
1633 | 2895 if (src_y == height) |
2896 dxy &= ~2; | |
2897 src += src_y * stride + src_x; | |
2898 | |
2899 if(s->unrestricted_mv && (s->flags&CODEC_FLAG_EMU_EDGE)){ | |
2900 if( (unsigned)src_x > h_edge_pos - (motion_x&1) - w | |
2901 || (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
|
2902 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
|
2903 src_x, src_y<<field_based, h_edge_pos, s->v_edge_pos); |
1633 | 2904 src= s->edge_emu_buffer; |
2905 emu=1; | |
2906 } | |
2907 } | |
1842
0d82db458a3c
interlaced mpeg4 + edge emu fix (fixes decoding of mermaid.avi)
michael
parents:
1838
diff
changeset
|
2908 if(field_select) |
0d82db458a3c
interlaced mpeg4 + edge emu fix (fixes decoding of mermaid.avi)
michael
parents:
1838
diff
changeset
|
2909 src += s->linesize; |
1633 | 2910 pix_op[dxy](dest, src, stride, h); |
2911 return emu; | |
2912 } | |
553 | 2913 |
2967 | 2914 static inline int hpel_motion_lowres(MpegEncContext *s, |
2292 | 2915 uint8_t *dest, uint8_t *src, |
2916 int field_based, int field_select, | |
2917 int src_x, int src_y, | |
2918 int width, int height, int stride, | |
2919 int h_edge_pos, int v_edge_pos, | |
2920 int w, int h, h264_chroma_mc_func *pix_op, | |
2921 int motion_x, int motion_y) | |
2922 { | |
2923 const int lowres= s->avctx->lowres; | |
2924 const int s_mask= (2<<lowres)-1; | |
2925 int emu=0; | |
2926 int sx, sy; | |
2927 | |
2928 if(s->quarter_sample){ | |
2929 motion_x/=2; | |
2930 motion_y/=2; | |
2931 } | |
2932 | |
2933 sx= motion_x & s_mask; | |
2934 sy= motion_y & s_mask; | |
2935 src_x += motion_x >> (lowres+1); | |
2936 src_y += motion_y >> (lowres+1); | |
2967 | 2937 |
2292 | 2938 src += src_y * stride + src_x; |
2939 | |
2940 if( (unsigned)src_x > h_edge_pos - (!!sx) - w | |
2941 || (unsigned)src_y >(v_edge_pos >> field_based) - (!!sy) - h){ | |
2942 ff_emulated_edge_mc(s->edge_emu_buffer, src, s->linesize, w+1, (h+1)<<field_based, | |
2943 src_x, src_y<<field_based, h_edge_pos, v_edge_pos); | |
2944 src= s->edge_emu_buffer; | |
2945 emu=1; | |
2946 } | |
2947 | |
2948 sx <<= 2 - lowres; | |
2949 sy <<= 2 - lowres; | |
2950 if(field_select) | |
2951 src += s->linesize; | |
2952 pix_op[lowres](dest, src, stride, h, sx, sy); | |
2953 return emu; | |
2954 } | |
2955 | |
0 | 2956 /* 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
|
2957 static av_always_inline void mpeg_motion(MpegEncContext *s, |
1064 | 2958 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
|
2959 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
|
2960 uint8_t **ref_picture, op_pixels_func (*pix_op)[4], |
0 | 2961 int motion_x, int motion_y, int h) |
2962 { | |
1846 | 2963 uint8_t *ptr_y, *ptr_cb, *ptr_cr; |
2964 int dxy, uvdxy, mx, my, src_x, src_y, uvsrc_x, uvsrc_y, v_edge_pos, uvlinesize, linesize; | |
2967 | 2965 |
2966 #if 0 | |
255 | 2967 if(s->quarter_sample) |
2968 { | |
2969 motion_x>>=1; | |
2970 motion_y>>=1; | |
2971 } | |
651 | 2972 #endif |
1633 | 2973 |
582
5132a4ee50cd
different edge positions fixed with edge emu / dr1
michaelni
parents:
575
diff
changeset
|
2974 v_edge_pos = s->v_edge_pos >> field_based; |
1846 | 2975 linesize = s->current_picture.linesize[0] << field_based; |
1138 | 2976 uvlinesize = s->current_picture.linesize[1] << field_based; |
1633 | 2977 |
1846 | 2978 dxy = ((motion_y & 1) << 1) | (motion_x & 1); |
2979 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
|
2980 src_y =(s->mb_y<<(4-field_based)) + (motion_y >> 1); |
485 | 2981 |
0 | 2982 if (s->out_format == FMT_H263) { |
1916 | 2983 if((s->workaround_bugs & FF_BUG_HPEL_CHROMA) && field_based){ |
2984 mx = (motion_x>>1)|(motion_x&1); | |
2985 my = motion_y >>1; | |
2986 uvdxy = ((my & 1) << 1) | (mx & 1); | |
2987 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
|
2988 uvsrc_y = (s->mb_y<<(3-field_based)) + (my >> 1); |
1916 | 2989 }else{ |
2990 uvdxy = dxy | (motion_y & 2) | ((motion_x & 2) >> 1); | |
2991 uvsrc_x = src_x>>1; | |
2992 uvsrc_y = src_y>>1; | |
2993 } | |
2044
b6f2add2511e
h261 decoder by (Maarten Daniels <maarten.daniels at student dot luc dot ac dot be>)
michael
parents:
2042
diff
changeset
|
2994 }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
|
2995 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
|
2996 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
|
2997 uvdxy = 0; |
b6f2add2511e
h261 decoder by (Maarten Daniels <maarten.daniels at student dot luc dot ac dot be>)
michael
parents:
2042
diff
changeset
|
2998 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
|
2999 uvsrc_y = s->mb_y*8 + my; |
0 | 3000 } else { |
2074
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
3001 if(s->chroma_y_shift){ |
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
3002 mx = motion_x / 2; |
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
3003 my = motion_y / 2; |
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
3004 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
|
3005 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
|
3006 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
|
3007 } else { |
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
3008 if(s->chroma_x_shift){ |
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
3009 //Chroma422 |
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
3010 mx = motion_x / 2; |
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
3011 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
|
3012 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
|
3013 uvsrc_y = src_y; |
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
3014 } else { |
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
3015 //Chroma444 |
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
3016 uvdxy = dxy; |
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
3017 uvsrc_x = src_x; |
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
3018 uvsrc_y = src_y; |
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
3019 } |
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
3020 } |
1846 | 3021 } |
3022 | |
3023 ptr_y = ref_picture[0] + src_y * linesize + src_x; | |
3024 ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x; | |
3025 ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x; | |
3026 | |
3027 if( (unsigned)src_x > s->h_edge_pos - (motion_x&1) - 16 | |
3028 || (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
|
3029 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
|
3030 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
|
3031 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
|
3032 return ; |
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
3033 } |
1846 | 3034 ff_emulated_edge_mc(s->edge_emu_buffer, ptr_y, s->linesize, 17, 17+field_based, |
3035 src_x, src_y<<field_based, s->h_edge_pos, s->v_edge_pos); | |
3036 ptr_y = s->edge_emu_buffer; | |
3037 if(!(s->flags&CODEC_FLAG_GRAY)){ | |
1874 | 3038 uint8_t *uvbuf= s->edge_emu_buffer+18*s->linesize; |
2967 | 3039 ff_emulated_edge_mc(uvbuf , ptr_cb, s->uvlinesize, 9, 9+field_based, |
1846 | 3040 uvsrc_x, uvsrc_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1); |
2967 | 3041 ff_emulated_edge_mc(uvbuf+16, ptr_cr, s->uvlinesize, 9, 9+field_based, |
1846 | 3042 uvsrc_x, uvsrc_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1); |
3043 ptr_cb= uvbuf; | |
3044 ptr_cr= uvbuf+16; | |
3045 } | |
3046 } | |
3047 | |
3048 if(bottom_field){ //FIXME use this for field pix too instead of the obnoxious hack which changes picture.data | |
3049 dest_y += s->linesize; | |
3050 dest_cb+= s->uvlinesize; | |
3051 dest_cr+= s->uvlinesize; | |
3052 } | |
3053 | |
3054 if(field_select){ | |
3055 ptr_y += s->linesize; | |
3056 ptr_cb+= s->uvlinesize; | |
3057 ptr_cr+= s->uvlinesize; | |
3058 } | |
3059 | |
3060 pix_op[0][dxy](dest_y, ptr_y, linesize, h); | |
2967 | 3061 |
1846 | 3062 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
|
3063 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
|
3064 pix_op[s->chroma_x_shift][uvdxy](dest_cr, ptr_cr, uvlinesize, h >> s->chroma_y_shift); |
1846 | 3065 } |
2639 | 3066 #if defined(CONFIG_H261_ENCODER) || defined(CONFIG_H261_DECODER) |
2291 | 3067 if(s->out_format == FMT_H261){ |
3068 ff_h261_loop_filter(s); | |
3069 } | |
2639 | 3070 #endif |
0 | 3071 } |
2256 | 3072 |
3073 /* 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
|
3074 static av_always_inline void mpeg_motion_lowres(MpegEncContext *s, |
2256 | 3075 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr, |
3076 int field_based, int bottom_field, int field_select, | |
3077 uint8_t **ref_picture, h264_chroma_mc_func *pix_op, | |
3078 int motion_x, int motion_y, int h) | |
3079 { | |
3080 uint8_t *ptr_y, *ptr_cb, *ptr_cr; | |
3081 int mx, my, src_x, src_y, uvsrc_x, uvsrc_y, uvlinesize, linesize, sx, sy, uvsx, uvsy; | |
3082 const int lowres= s->avctx->lowres; | |
3083 const int block_s= 8>>lowres; | |
3084 const int s_mask= (2<<lowres)-1; | |
3085 const int h_edge_pos = s->h_edge_pos >> lowres; | |
3086 const int v_edge_pos = s->v_edge_pos >> lowres; | |
3087 linesize = s->current_picture.linesize[0] << field_based; | |
3088 uvlinesize = s->current_picture.linesize[1] << field_based; | |
3089 | |
2260 | 3090 if(s->quarter_sample){ //FIXME obviously not perfect but qpel wont work in lowres anyway |
3091 motion_x/=2; | |
3092 motion_y/=2; | |
3093 } | |
2967 | 3094 |
2260 | 3095 if(field_based){ |
3096 motion_y += (bottom_field - field_select)*((1<<lowres)-1); | |
3097 } | |
3098 | |
2256 | 3099 sx= motion_x & s_mask; |
3100 sy= motion_y & s_mask; | |
3101 src_x = s->mb_x*2*block_s + (motion_x >> (lowres+1)); | |
2260 | 3102 src_y =(s->mb_y*2*block_s>>field_based) + (motion_y >> (lowres+1)); |
2967 | 3103 |
2256 | 3104 if (s->out_format == FMT_H263) { |
2265 | 3105 uvsx = ((motion_x>>1) & s_mask) | (sx&1); |
3106 uvsy = ((motion_y>>1) & s_mask) | (sy&1); | |
2256 | 3107 uvsrc_x = src_x>>1; |
3108 uvsrc_y = src_y>>1; | |
3109 }else if(s->out_format == FMT_H261){//even chroma mv's are full pel in H261 | |
3110 mx = motion_x / 4; | |
3111 my = motion_y / 4; | |
3112 uvsx = (2*mx) & s_mask; | |
3113 uvsy = (2*my) & s_mask; | |
3114 uvsrc_x = s->mb_x*block_s + (mx >> lowres); | |
3115 uvsrc_y = s->mb_y*block_s + (my >> lowres); | |
3116 } else { | |
3117 mx = motion_x / 2; | |
3118 my = motion_y / 2; | |
3119 uvsx = mx & s_mask; | |
3120 uvsy = my & s_mask; | |
3121 uvsrc_x = s->mb_x*block_s + (mx >> (lowres+1)); | |
2260 | 3122 uvsrc_y =(s->mb_y*block_s>>field_based) + (my >> (lowres+1)); |
2256 | 3123 } |
3124 | |
3125 ptr_y = ref_picture[0] + src_y * linesize + src_x; | |
3126 ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x; | |
3127 ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x; | |
3128 | |
3129 if( (unsigned)src_x > h_edge_pos - (!!sx) - 2*block_s | |
3130 || (unsigned)src_y >(v_edge_pos >> field_based) - (!!sy) - h){ | |
3131 ff_emulated_edge_mc(s->edge_emu_buffer, ptr_y, s->linesize, 17, 17+field_based, | |
3132 src_x, src_y<<field_based, h_edge_pos, v_edge_pos); | |
3133 ptr_y = s->edge_emu_buffer; | |
3134 if(!(s->flags&CODEC_FLAG_GRAY)){ | |
3135 uint8_t *uvbuf= s->edge_emu_buffer+18*s->linesize; | |
2967 | 3136 ff_emulated_edge_mc(uvbuf , ptr_cb, s->uvlinesize, 9, 9+field_based, |
2256 | 3137 uvsrc_x, uvsrc_y<<field_based, h_edge_pos>>1, v_edge_pos>>1); |
2967 | 3138 ff_emulated_edge_mc(uvbuf+16, ptr_cr, s->uvlinesize, 9, 9+field_based, |
2256 | 3139 uvsrc_x, uvsrc_y<<field_based, h_edge_pos>>1, v_edge_pos>>1); |
3140 ptr_cb= uvbuf; | |
3141 ptr_cr= uvbuf+16; | |
3142 } | |
3143 } | |
3144 | |
2260 | 3145 if(bottom_field){ //FIXME use this for field pix too instead of the obnoxious hack which changes picture.data |
3146 dest_y += s->linesize; | |
3147 dest_cb+= s->uvlinesize; | |
3148 dest_cr+= s->uvlinesize; | |
3149 } | |
3150 | |
3151 if(field_select){ | |
3152 ptr_y += s->linesize; | |
3153 ptr_cb+= s->uvlinesize; | |
3154 ptr_cr+= s->uvlinesize; | |
3155 } | |
3156 | |
2256 | 3157 sx <<= 2 - lowres; |
3158 sy <<= 2 - lowres; | |
3159 pix_op[lowres-1](dest_y, ptr_y, linesize, h, sx, sy); | |
2967 | 3160 |
2256 | 3161 if(!(s->flags&CODEC_FLAG_GRAY)){ |
3162 uvsx <<= 2 - lowres; | |
3163 uvsy <<= 2 - lowres; | |
3164 pix_op[lowres](dest_cb, ptr_cb, uvlinesize, h >> s->chroma_y_shift, uvsx, uvsy); | |
3165 pix_op[lowres](dest_cr, ptr_cr, uvlinesize, h >> s->chroma_y_shift, uvsx, uvsy); | |
3166 } | |
2291 | 3167 //FIXME h261 lowres loop filter |
2256 | 3168 } |
3169 | |
1633 | 3170 //FIXME move to dsputil, avg variant, 16x16 version |
3171 static inline void put_obmc(uint8_t *dst, uint8_t *src[5], int stride){ | |
3172 int x; | |
3173 uint8_t * const top = src[1]; | |
3174 uint8_t * const left = src[2]; | |
3175 uint8_t * const mid = src[0]; | |
3176 uint8_t * const right = src[3]; | |
3177 uint8_t * const bottom= src[4]; | |
3178 #define OBMC_FILTER(x, t, l, m, r, b)\ | |
3179 dst[x]= (t*top[x] + l*left[x] + m*mid[x] + r*right[x] + b*bottom[x] + 4)>>3 | |
3180 #define OBMC_FILTER4(x, t, l, m, r, b)\ | |
3181 OBMC_FILTER(x , t, l, m, r, b);\ | |
3182 OBMC_FILTER(x+1 , t, l, m, r, b);\ | |
3183 OBMC_FILTER(x +stride, t, l, m, r, b);\ | |
3184 OBMC_FILTER(x+1+stride, t, l, m, r, b); | |
2967 | 3185 |
1633 | 3186 x=0; |
3187 OBMC_FILTER (x , 2, 2, 4, 0, 0); | |
3188 OBMC_FILTER (x+1, 2, 1, 5, 0, 0); | |
3189 OBMC_FILTER4(x+2, 2, 1, 5, 0, 0); | |
3190 OBMC_FILTER4(x+4, 2, 0, 5, 1, 0); | |
3191 OBMC_FILTER (x+6, 2, 0, 5, 1, 0); | |
3192 OBMC_FILTER (x+7, 2, 0, 4, 2, 0); | |
3193 x+= stride; | |
3194 OBMC_FILTER (x , 1, 2, 5, 0, 0); | |
3195 OBMC_FILTER (x+1, 1, 2, 5, 0, 0); | |
3196 OBMC_FILTER (x+6, 1, 0, 5, 2, 0); | |
3197 OBMC_FILTER (x+7, 1, 0, 5, 2, 0); | |
3198 x+= stride; | |
3199 OBMC_FILTER4(x , 1, 2, 5, 0, 0); | |
3200 OBMC_FILTER4(x+2, 1, 1, 6, 0, 0); | |
3201 OBMC_FILTER4(x+4, 1, 0, 6, 1, 0); | |
3202 OBMC_FILTER4(x+6, 1, 0, 5, 2, 0); | |
3203 x+= 2*stride; | |
3204 OBMC_FILTER4(x , 0, 2, 5, 0, 1); | |
3205 OBMC_FILTER4(x+2, 0, 1, 6, 0, 1); | |
3206 OBMC_FILTER4(x+4, 0, 0, 6, 1, 1); | |
3207 OBMC_FILTER4(x+6, 0, 0, 5, 2, 1); | |
3208 x+= 2*stride; | |
3209 OBMC_FILTER (x , 0, 2, 5, 0, 1); | |
3210 OBMC_FILTER (x+1, 0, 2, 5, 0, 1); | |
3211 OBMC_FILTER4(x+2, 0, 1, 5, 0, 2); | |
3212 OBMC_FILTER4(x+4, 0, 0, 5, 1, 2); | |
3213 OBMC_FILTER (x+6, 0, 0, 5, 2, 1); | |
3214 OBMC_FILTER (x+7, 0, 0, 5, 2, 1); | |
3215 x+= stride; | |
3216 OBMC_FILTER (x , 0, 2, 4, 0, 2); | |
3217 OBMC_FILTER (x+1, 0, 1, 5, 0, 2); | |
3218 OBMC_FILTER (x+6, 0, 0, 5, 1, 2); | |
3219 OBMC_FILTER (x+7, 0, 0, 4, 2, 2); | |
3220 } | |
3221 | |
3222 /* obmc for 1 8x8 luma block */ | |
3223 static inline void obmc_motion(MpegEncContext *s, | |
3224 uint8_t *dest, uint8_t *src, | |
3225 int src_x, int src_y, | |
3226 op_pixels_func *pix_op, | |
3227 int16_t mv[5][2]/* mid top left right bottom*/) | |
3228 #define MID 0 | |
3229 { | |
3230 int i; | |
3231 uint8_t *ptr[5]; | |
2967 | 3232 |
1633 | 3233 assert(s->quarter_sample==0); |
2967 | 3234 |
1633 | 3235 for(i=0; i<5; i++){ |
3236 if(i && mv[i][0]==mv[MID][0] && mv[i][1]==mv[MID][1]){ | |
3237 ptr[i]= ptr[MID]; | |
3238 }else{ | |
1799 | 3239 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
|
3240 hpel_motion(s, ptr[i], src, 0, 0, |
1633 | 3241 src_x, src_y, |
3242 s->width, s->height, s->linesize, | |
3243 s->h_edge_pos, s->v_edge_pos, | |
3244 8, 8, pix_op, | |
3245 mv[i][0], mv[i][1]); | |
3246 } | |
3247 } | |
3248 | |
2967 | 3249 put_obmc(dest, ptr, s->linesize); |
1633 | 3250 } |
0 | 3251 |
255 | 3252 static inline void qpel_motion(MpegEncContext *s, |
1064 | 3253 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
|
3254 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
|
3255 uint8_t **ref_picture, op_pixels_func (*pix_op)[4], |
651 | 3256 qpel_mc_func (*qpix_op)[16], |
255 | 3257 int motion_x, int motion_y, int h) |
3258 { | |
1846 | 3259 uint8_t *ptr_y, *ptr_cb, *ptr_cr; |
3260 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
|
3261 |
255 | 3262 dxy = ((motion_y & 3) << 2) | (motion_x & 3); |
1846 | 3263 src_x = s->mb_x * 16 + (motion_x >> 2); |
255 | 3264 src_y = s->mb_y * (16 >> field_based) + (motion_y >> 2); |
3265 | |
582
5132a4ee50cd
different edge positions fixed with edge emu / dr1
michaelni
parents:
575
diff
changeset
|
3266 v_edge_pos = s->v_edge_pos >> field_based; |
255 | 3267 linesize = s->linesize << field_based; |
671 | 3268 uvlinesize = s->uvlinesize << field_based; |
2967 | 3269 |
671 | 3270 if(field_based){ |
3271 mx= motion_x/2; | |
3272 my= motion_y>>1; | |
1048 | 3273 }else if(s->workaround_bugs&FF_BUG_QPEL_CHROMA2){ |
3274 static const int rtab[8]= {0,0,1,1,0,0,0,1}; | |
3275 mx= (motion_x>>1) + rtab[motion_x&7]; | |
3276 my= (motion_y>>1) + rtab[motion_y&7]; | |
760 | 3277 }else if(s->workaround_bugs&FF_BUG_QPEL_CHROMA){ |
671 | 3278 mx= (motion_x>>1)|(motion_x&1); |
3279 my= (motion_y>>1)|(motion_y&1); | |
3280 }else{ | |
3281 mx= motion_x/2; | |
3282 my= motion_y/2; | |
3283 } | |
3284 mx= (mx>>1)|(mx&1); | |
3285 my= (my>>1)|(my&1); | |
1048 | 3286 |
1846 | 3287 uvdxy= (mx&1) | ((my&1)<<1); |
671 | 3288 mx>>=1; |
3289 my>>=1; | |
255 | 3290 |
1846 | 3291 uvsrc_x = s->mb_x * 8 + mx; |
3292 uvsrc_y = s->mb_y * (8 >> field_based) + my; | |
3293 | |
3294 ptr_y = ref_picture[0] + src_y * linesize + src_x; | |
3295 ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x; | |
3296 ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x; | |
3297 | |
2967 | 3298 if( (unsigned)src_x > s->h_edge_pos - (motion_x&3) - 16 |
1846 | 3299 || (unsigned)src_y > v_edge_pos - (motion_y&3) - h ){ |
2967 | 3300 ff_emulated_edge_mc(s->edge_emu_buffer, ptr_y, s->linesize, 17, 17+field_based, |
1846 | 3301 src_x, src_y<<field_based, s->h_edge_pos, s->v_edge_pos); |
3302 ptr_y= s->edge_emu_buffer; | |
3303 if(!(s->flags&CODEC_FLAG_GRAY)){ | |
1874 | 3304 uint8_t *uvbuf= s->edge_emu_buffer + 18*s->linesize; |
2967 | 3305 ff_emulated_edge_mc(uvbuf, ptr_cb, s->uvlinesize, 9, 9 + field_based, |
1846 | 3306 uvsrc_x, uvsrc_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1); |
2967 | 3307 ff_emulated_edge_mc(uvbuf + 16, ptr_cr, s->uvlinesize, 9, 9 + field_based, |
1846 | 3308 uvsrc_x, uvsrc_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1); |
3309 ptr_cb= uvbuf; | |
3310 ptr_cr= uvbuf + 16; | |
3311 } | |
3312 } | |
3313 | |
3314 if(!field_based) | |
3315 qpix_op[0][dxy](dest_y, ptr_y, linesize); | |
3316 else{ | |
3317 if(bottom_field){ | |
3318 dest_y += s->linesize; | |
3319 dest_cb+= s->uvlinesize; | |
3320 dest_cr+= s->uvlinesize; | |
3321 } | |
3322 | |
3323 if(field_select){ | |
3324 ptr_y += s->linesize; | |
3325 ptr_cb += s->uvlinesize; | |
3326 ptr_cr += s->uvlinesize; | |
3327 } | |
3328 //damn interlaced mode | |
3329 //FIXME boundary mirroring is not exactly correct here | |
3330 qpix_op[1][dxy](dest_y , ptr_y , linesize); | |
3331 qpix_op[1][dxy](dest_y+8, ptr_y+8, linesize); | |
3332 } | |
3333 if(!(s->flags&CODEC_FLAG_GRAY)){ | |
3334 pix_op[1][uvdxy](dest_cr, ptr_cr, uvlinesize, h >> 1); | |
3335 pix_op[1][uvdxy](dest_cb, ptr_cb, uvlinesize, h >> 1); | |
3336 } | |
255 | 3337 } |
3338 | |
1013 | 3339 inline int ff_h263_round_chroma(int x){ |
3340 if (x >= 0) | |
3341 return (h263_chroma_roundtab[x & 0xf] + ((x >> 3) & ~1)); | |
3342 else { | |
3343 x = -x; | |
3344 return -(h263_chroma_roundtab[x & 0xf] + ((x >> 3) & ~1)); | |
3345 } | |
3346 } | |
255 | 3347 |
1225 | 3348 /** |
1633 | 3349 * h263 chorma 4mv motion compensation. |
3350 */ | |
3351 static inline void chroma_4mv_motion(MpegEncContext *s, | |
3352 uint8_t *dest_cb, uint8_t *dest_cr, | |
3353 uint8_t **ref_picture, | |
3354 op_pixels_func *pix_op, | |
3355 int mx, int my){ | |
3356 int dxy, emu=0, src_x, src_y, offset; | |
3357 uint8_t *ptr; | |
2967 | 3358 |
1633 | 3359 /* In case of 8X8, we construct a single chroma motion vector |
3360 with a special rounding */ | |
3361 mx= ff_h263_round_chroma(mx); | |
3362 my= ff_h263_round_chroma(my); | |
2967 | 3363 |
1633 | 3364 dxy = ((my & 1) << 1) | (mx & 1); |
3365 mx >>= 1; | |
3366 my >>= 1; | |
3367 | |
3368 src_x = s->mb_x * 8 + mx; | |
3369 src_y = s->mb_y * 8 + my; | |
4594 | 3370 src_x = av_clip(src_x, -8, s->width/2); |
1633 | 3371 if (src_x == s->width/2) |
3372 dxy &= ~1; | |
4594 | 3373 src_y = av_clip(src_y, -8, s->height/2); |
1633 | 3374 if (src_y == s->height/2) |
3375 dxy &= ~2; | |
2967 | 3376 |
1633 | 3377 offset = (src_y * (s->uvlinesize)) + src_x; |
3378 ptr = ref_picture[1] + offset; | |
3379 if(s->flags&CODEC_FLAG_EMU_EDGE){ | |
3380 if( (unsigned)src_x > (s->h_edge_pos>>1) - (dxy &1) - 8 | |
3381 || (unsigned)src_y > (s->v_edge_pos>>1) - (dxy>>1) - 8){ | |
3382 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); | |
3383 ptr= s->edge_emu_buffer; | |
3384 emu=1; | |
3385 } | |
3386 } | |
3387 pix_op[dxy](dest_cb, ptr, s->uvlinesize, 8); | |
3388 | |
3389 ptr = ref_picture[2] + offset; | |
3390 if(emu){ | |
3391 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); | |
3392 ptr= s->edge_emu_buffer; | |
3393 } | |
3394 pix_op[dxy](dest_cr, ptr, s->uvlinesize, 8); | |
3395 } | |
3396 | |
2292 | 3397 static inline void chroma_4mv_motion_lowres(MpegEncContext *s, |
3398 uint8_t *dest_cb, uint8_t *dest_cr, | |
3399 uint8_t **ref_picture, | |
3400 h264_chroma_mc_func *pix_op, | |
3401 int mx, int my){ | |
3402 const int lowres= s->avctx->lowres; | |
3403 const int block_s= 8>>lowres; | |
3404 const int s_mask= (2<<lowres)-1; | |
3405 const int h_edge_pos = s->h_edge_pos >> (lowres+1); | |
3406 const int v_edge_pos = s->v_edge_pos >> (lowres+1); | |
3407 int emu=0, src_x, src_y, offset, sx, sy; | |
3408 uint8_t *ptr; | |
2967 | 3409 |
2292 | 3410 if(s->quarter_sample){ |
3411 mx/=2; | |
3412 my/=2; | |
3413 } | |
3414 | |
3415 /* In case of 8X8, we construct a single chroma motion vector | |
3416 with a special rounding */ | |
3417 mx= ff_h263_round_chroma(mx); | |
3418 my= ff_h263_round_chroma(my); | |
2967 | 3419 |
2292 | 3420 sx= mx & s_mask; |
3421 sy= my & s_mask; | |
3422 src_x = s->mb_x*block_s + (mx >> (lowres+1)); | |
3423 src_y = s->mb_y*block_s + (my >> (lowres+1)); | |
2967 | 3424 |
2292 | 3425 offset = src_y * s->uvlinesize + src_x; |
3426 ptr = ref_picture[1] + offset; | |
3427 if(s->flags&CODEC_FLAG_EMU_EDGE){ | |
3428 if( (unsigned)src_x > h_edge_pos - (!!sx) - block_s | |
3429 || (unsigned)src_y > v_edge_pos - (!!sy) - block_s){ | |
3430 ff_emulated_edge_mc(s->edge_emu_buffer, ptr, s->uvlinesize, 9, 9, src_x, src_y, h_edge_pos, v_edge_pos); | |
3431 ptr= s->edge_emu_buffer; | |
3432 emu=1; | |
3433 } | |
2967 | 3434 } |
2292 | 3435 sx <<= 2 - lowres; |
3436 sy <<= 2 - lowres; | |
3437 pix_op[lowres](dest_cb, ptr, s->uvlinesize, block_s, sx, sy); | |
2967 | 3438 |
2292 | 3439 ptr = ref_picture[2] + offset; |
3440 if(emu){ | |
3441 ff_emulated_edge_mc(s->edge_emu_buffer, ptr, s->uvlinesize, 9, 9, src_x, src_y, h_edge_pos, v_edge_pos); | |
3442 ptr= s->edge_emu_buffer; | |
3443 } | |
3444 pix_op[lowres](dest_cr, ptr, s->uvlinesize, block_s, sx, sy); | |
3445 } | |
3446 | |
3216
4186eb8d29a1
prefetch pixels for future motion compensation. 4-10% faster mpeg1/2/4 decoding (on an athlon-xp).
lorenm
parents:
3145
diff
changeset
|
3447 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
|
3448 /* 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
|
3449 * 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
|
3450 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
|
3451 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
|
3452 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
|
3453 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
|
3454 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
|
3455 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
|
3456 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
|
3457 } |
4186eb8d29a1
prefetch pixels for future motion compensation. 4-10% faster mpeg1/2/4 decoding (on an athlon-xp).
lorenm
parents:
3145
diff
changeset
|
3458 |
1633 | 3459 /** |
2764 | 3460 * motion compensation of a single macroblock |
1225 | 3461 * @param s context |
3462 * @param dest_y luma destination pointer | |
3463 * @param dest_cb chroma cb/u destination pointer | |
3464 * @param dest_cr chroma cr/v destination pointer | |
3465 * @param dir direction (0->forward, 1->backward) | |
3466 * @param ref_picture array[3] of pointers to the 3 planes of the reference picture | |
3467 * @param pic_op halfpel motion compensation function (average or put normally) | |
3468 * @param pic_op qpel motion compensation function (average or put normally) | |
3469 * the motion vectors are taken from s->mv and the MV type from s->mv_type | |
3470 */ | |
2967 | 3471 static inline void MPV_motion(MpegEncContext *s, |
1064 | 3472 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr, |
2967 | 3473 int dir, uint8_t **ref_picture, |
651 | 3474 op_pixels_func (*pix_op)[4], qpel_mc_func (*qpix_op)[16]) |
0 | 3475 { |
1633 | 3476 int dxy, mx, my, src_x, src_y, motion_x, motion_y; |
0 | 3477 int mb_x, mb_y, i; |
1064 | 3478 uint8_t *ptr, *dest; |
0 | 3479 |
3480 mb_x = s->mb_x; | |
3481 mb_y = s->mb_y; | |
3482 | |
3216
4186eb8d29a1
prefetch pixels for future motion compensation. 4-10% faster mpeg1/2/4 decoding (on an athlon-xp).
lorenm
parents:
3145
diff
changeset
|
3483 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
|
3484 |
1655 | 3485 if(s->obmc && s->pict_type != B_TYPE){ |
1633 | 3486 int16_t mv_cache[4][4][2]; |
3487 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
|
3488 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
|
3489 const int mot_xy= mb_x*2 + mb_y*2*mot_stride; |
1633 | 3490 |
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
|
3491 assert(!s->mb_skipped); |
2967 | 3492 |
1668
30746f429df6
move motion_val & mb_type to AVFrame patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1662
diff
changeset
|
3493 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
|
3494 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
|
3495 memcpy(mv_cache[3][1], s->current_picture.motion_val[0][mot_xy+mot_stride], sizeof(int16_t)*4); |
1633 | 3496 |
3497 if(mb_y==0 || IS_INTRA(s->current_picture.mb_type[xy-s->mb_stride])){ | |
3498 memcpy(mv_cache[0][1], mv_cache[1][1], sizeof(int16_t)*4); | |
3499 }else{ | |
1668
30746f429df6
move motion_val & mb_type to AVFrame patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1662
diff
changeset
|
3500 memcpy(mv_cache[0][1], s->current_picture.motion_val[0][mot_xy-mot_stride], sizeof(int16_t)*4); |
1633 | 3501 } |
3502 | |
3503 if(mb_x==0 || IS_INTRA(s->current_picture.mb_type[xy-1])){ | |
3504 *(int32_t*)mv_cache[1][0]= *(int32_t*)mv_cache[1][1]; | |
3505 *(int32_t*)mv_cache[2][0]= *(int32_t*)mv_cache[2][1]; | |
3506 }else{ | |
1668
30746f429df6
move motion_val & mb_type to AVFrame patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1662
diff
changeset
|
3507 *(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
|
3508 *(int32_t*)mv_cache[2][0]= *(int32_t*)s->current_picture.motion_val[0][mot_xy-1+mot_stride]; |
1633 | 3509 } |
3510 | |
3511 if(mb_x+1>=s->mb_width || IS_INTRA(s->current_picture.mb_type[xy+1])){ | |
3512 *(int32_t*)mv_cache[1][3]= *(int32_t*)mv_cache[1][2]; | |
3513 *(int32_t*)mv_cache[2][3]= *(int32_t*)mv_cache[2][2]; | |
3514 }else{ | |
1668
30746f429df6
move motion_val & mb_type to AVFrame patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1662
diff
changeset
|
3515 *(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
|
3516 *(int32_t*)mv_cache[2][3]= *(int32_t*)s->current_picture.motion_val[0][mot_xy+2+mot_stride]; |
1633 | 3517 } |
2967 | 3518 |
1633 | 3519 mx = 0; |
3520 my = 0; | |
3521 for(i=0;i<4;i++) { | |
3522 const int x= (i&1)+1; | |
3523 const int y= (i>>1)+1; | |
3524 int16_t mv[5][2]= { | |
3525 {mv_cache[y][x ][0], mv_cache[y][x ][1]}, | |
3526 {mv_cache[y-1][x][0], mv_cache[y-1][x][1]}, | |
3527 {mv_cache[y][x-1][0], mv_cache[y][x-1][1]}, | |
3528 {mv_cache[y][x+1][0], mv_cache[y][x+1][1]}, | |
3529 {mv_cache[y+1][x][0], mv_cache[y+1][x][1]}}; | |
3530 //FIXME cleanup | |
3531 obmc_motion(s, dest_y + ((i & 1) * 8) + (i >> 1) * 8 * s->linesize, | |
3532 ref_picture[0], | |
3533 mb_x * 16 + (i & 1) * 8, mb_y * 16 + (i >>1) * 8, | |
3534 pix_op[1], | |
3535 mv); | |
3536 | |
3537 mx += mv[0][0]; | |
3538 my += mv[0][1]; | |
3539 } | |
3540 if(!(s->flags&CODEC_FLAG_GRAY)) | |
3541 chroma_4mv_motion(s, dest_cb, dest_cr, ref_picture, pix_op[1], mx, my); | |
3542 | |
3543 return; | |
3544 } | |
2967 | 3545 |
0 | 3546 switch(s->mv_type) { |
3547 case MV_TYPE_16X16: | |
255 | 3548 if(s->mcsel){ |
753 | 3549 if(s->real_sprite_warping_points==1){ |
1842
0d82db458a3c
interlaced mpeg4 + edge emu fix (fixes decoding of mermaid.avi)
michael
parents:
1838
diff
changeset
|
3550 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
|
3551 ref_picture); |
753 | 3552 }else{ |
1842
0d82db458a3c
interlaced mpeg4 + edge emu fix (fixes decoding of mermaid.avi)
michael
parents:
1838
diff
changeset
|
3553 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
|
3554 ref_picture); |
753 | 3555 } |
651 | 3556 }else if(s->quarter_sample){ |
2967 | 3557 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
|
3558 0, 0, 0, |
0d82db458a3c
interlaced mpeg4 + edge emu fix (fixes decoding of mermaid.avi)
michael
parents:
1838
diff
changeset
|
3559 ref_picture, pix_op, qpix_op, |
255 | 3560 s->mv[dir][0][0], s->mv[dir][0][1], 16); |
936 | 3561 }else if(s->mspel){ |
3562 ff_mspel_motion(s, dest_y, dest_cb, dest_cr, | |
3563 ref_picture, pix_op, | |
3564 s->mv[dir][0][0], s->mv[dir][0][1], 16); | |
1042 | 3565 }else |
3566 { | |
2967 | 3567 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
|
3568 0, 0, 0, |
0d82db458a3c
interlaced mpeg4 + edge emu fix (fixes decoding of mermaid.avi)
michael
parents:
1838
diff
changeset
|
3569 ref_picture, pix_op, |
255 | 3570 s->mv[dir][0][0], s->mv[dir][0][1], 16); |
2967 | 3571 } |
0 | 3572 break; |
3573 case MV_TYPE_8X8: | |
673 | 3574 mx = 0; |
3575 my = 0; | |
3576 if(s->quarter_sample){ | |
3577 for(i=0;i<4;i++) { | |
3578 motion_x = s->mv[dir][i][0]; | |
3579 motion_y = s->mv[dir][i][1]; | |
0 | 3580 |
673 | 3581 dxy = ((motion_y & 3) << 2) | (motion_x & 3); |
3582 src_x = mb_x * 16 + (motion_x >> 2) + (i & 1) * 8; | |
3583 src_y = mb_y * 16 + (motion_y >> 2) + (i >>1) * 8; | |
2967 | 3584 |
673 | 3585 /* WARNING: do no forget half pels */ |
4594 | 3586 src_x = av_clip(src_x, -16, s->width); |
673 | 3587 if (src_x == s->width) |
3588 dxy &= ~3; | |
4594 | 3589 src_y = av_clip(src_y, -16, s->height); |
673 | 3590 if (src_y == s->height) |
3591 dxy &= ~12; | |
2967 | 3592 |
673 | 3593 ptr = ref_picture[0] + (src_y * s->linesize) + (src_x); |
3594 if(s->flags&CODEC_FLAG_EMU_EDGE){ | |
2967 | 3595 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
|
3596 || (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
|
3597 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 | 3598 ptr= s->edge_emu_buffer; |
3599 } | |
3600 } | |
3601 dest = dest_y + ((i & 1) * 8) + (i >> 1) * 8 * s->linesize; | |
3602 qpix_op[1][dxy](dest, ptr, s->linesize); | |
3603 | |
3604 mx += s->mv[dir][i][0]/2; | |
3605 my += s->mv[dir][i][1]/2; | |
3606 } | |
3607 }else{ | |
3608 for(i=0;i<4;i++) { | |
1633 | 3609 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
|
3610 ref_picture[0], 0, 0, |
1633 | 3611 mb_x * 16 + (i & 1) * 8, mb_y * 16 + (i >>1) * 8, |
3612 s->width, s->height, s->linesize, | |
3613 s->h_edge_pos, s->v_edge_pos, | |
3614 8, 8, pix_op[1], | |
3615 s->mv[dir][i][0], s->mv[dir][i][1]); | |
673 | 3616 |
3617 mx += s->mv[dir][i][0]; | |
3618 my += s->mv[dir][i][1]; | |
554 | 3619 } |
0 | 3620 } |
673 | 3621 |
1633 | 3622 if(!(s->flags&CODEC_FLAG_GRAY)) |
3623 chroma_4mv_motion(s, dest_cb, dest_cr, ref_picture, pix_op[1], mx, my); | |
0 | 3624 break; |
3625 case MV_TYPE_FIELD: | |
3626 if (s->picture_structure == PICT_FRAME) { | |
671 | 3627 if(s->quarter_sample){ |
1843 | 3628 for(i=0; i<2; i++){ |
3629 qpel_motion(s, dest_y, dest_cb, dest_cr, | |
3630 1, i, s->field_select[dir][i], | |
3631 ref_picture, pix_op, qpix_op, | |
3632 s->mv[dir][i][0], s->mv[dir][i][1], 8); | |
3633 } | |
671 | 3634 }else{ |
2967 | 3635 /* top field */ |
1842
0d82db458a3c
interlaced mpeg4 + edge emu fix (fixes decoding of mermaid.avi)
michael
parents:
1838
diff
changeset
|
3636 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
|
3637 1, 0, s->field_select[dir][0], |
0d82db458a3c
interlaced mpeg4 + edge emu fix (fixes decoding of mermaid.avi)
michael
parents:
1838
diff
changeset
|
3638 ref_picture, pix_op, |
671 | 3639 s->mv[dir][0][0], s->mv[dir][0][1], 8); |
3640 /* bottom field */ | |
1842
0d82db458a3c
interlaced mpeg4 + edge emu fix (fixes decoding of mermaid.avi)
michael
parents:
1838
diff
changeset
|
3641 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
|
3642 1, 1, s->field_select[dir][1], |
0d82db458a3c
interlaced mpeg4 + edge emu fix (fixes decoding of mermaid.avi)
michael
parents:
1838
diff
changeset
|
3643 ref_picture, pix_op, |
671 | 3644 s->mv[dir][1][0], s->mv[dir][1][1], 8); |
3645 } | |
0 | 3646 } else { |
1842
0d82db458a3c
interlaced mpeg4 + edge emu fix (fixes decoding of mermaid.avi)
michael
parents:
1838
diff
changeset
|
3647 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
|
3648 ref_picture= s->current_picture_ptr->data; |
2967 | 3649 } |
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 |
1842
0d82db458a3c
interlaced mpeg4 + edge emu fix (fixes decoding of mermaid.avi)
michael
parents:
1838
diff
changeset
|
3651 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
|
3652 0, 0, s->field_select[dir][0], |
0d82db458a3c
interlaced mpeg4 + edge emu fix (fixes decoding of mermaid.avi)
michael
parents:
1838
diff
changeset
|
3653 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
|
3654 s->mv[dir][0][0], s->mv[dir][0][1], 16); |
0 | 3655 } |
3656 break; | |
1843 | 3657 case MV_TYPE_16X8: |
3658 for(i=0; i<2; i++){ | |
3659 uint8_t ** ref2picture; | |
3660 | |
3661 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
|
3662 ref2picture= ref_picture; |
338a2f6e6402
Mpeg2 16x8 Patch by ("Ivan Kalvachev" <ivan at cacad dot com>)
michaelni
parents:
1328
diff
changeset
|
3663 }else{ |
1842
0d82db458a3c
interlaced mpeg4 + edge emu fix (fixes decoding of mermaid.avi)
michael
parents:
1838
diff
changeset
|
3664 ref2picture= s->current_picture_ptr->data; |
2967 | 3665 } |
3666 | |
3667 mpeg_motion(s, dest_y, dest_cb, dest_cr, | |
1843 | 3668 0, 0, s->field_select[dir][i], |
1842
0d82db458a3c
interlaced mpeg4 + edge emu fix (fixes decoding of mermaid.avi)
michael
parents:
1838
diff
changeset
|
3669 ref2picture, pix_op, |
1843 | 3670 s->mv[dir][i][0], s->mv[dir][i][1] + 16*i, 8); |
2967 | 3671 |
1843 | 3672 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
|
3673 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
|
3674 dest_cr+= (16>>s->chroma_y_shift)*s->uvlinesize; |
2967 | 3675 } |
1339
338a2f6e6402
Mpeg2 16x8 Patch by ("Ivan Kalvachev" <ivan at cacad dot com>)
michaelni
parents:
1328
diff
changeset
|
3676 break; |
1326
6cdd3b8f4fd3
DMV support patch by ("Ivan Kalvachev" <ivan at cacad dot com>)
michaelni
parents:
1317
diff
changeset
|
3677 case MV_TYPE_DMV: |
6cdd3b8f4fd3
DMV support patch by ("Ivan Kalvachev" <ivan at cacad dot com>)
michaelni
parents:
1317
diff
changeset
|
3678 if(s->picture_structure == PICT_FRAME){ |
1843 | 3679 for(i=0; i<2; i++){ |
3680 int j; | |
3681 for(j=0; j<2; j++){ | |
3682 mpeg_motion(s, dest_y, dest_cb, dest_cr, | |
3683 1, j, j^i, | |
3684 ref_picture, pix_op, | |
3685 s->mv[dir][2*i + j][0], s->mv[dir][2*i + j][1], 8); | |
3686 } | |
2967 | 3687 pix_op = s->dsp.avg_pixels_tab; |
1843 | 3688 } |
1326
6cdd3b8f4fd3
DMV support patch by ("Ivan Kalvachev" <ivan at cacad dot com>)
michaelni
parents:
1317
diff
changeset
|
3689 }else{ |
1843 | 3690 for(i=0; i<2; i++){ |
2967 | 3691 mpeg_motion(s, dest_y, dest_cb, dest_cr, |
1843 | 3692 0, 0, s->picture_structure != i+1, |
3693 ref_picture, pix_op, | |
3694 s->mv[dir][2*i][0],s->mv[dir][2*i][1],16); | |
3695 | |
3696 // after put we make avg of the same block | |
2967 | 3697 pix_op=s->dsp.avg_pixels_tab; |
1843 | 3698 |
3699 //opposite parity is always in the same frame if this is second field | |
3700 if(!s->first_field){ | |
2967 | 3701 ref_picture = s->current_picture_ptr->data; |
1843 | 3702 } |
1842
0d82db458a3c
interlaced mpeg4 + edge emu fix (fixes decoding of mermaid.avi)
michael
parents:
1838
diff
changeset
|
3703 } |
1326
6cdd3b8f4fd3
DMV support patch by ("Ivan Kalvachev" <ivan at cacad dot com>)
michaelni
parents:
1317
diff
changeset
|
3704 } |
6cdd3b8f4fd3
DMV support patch by ("Ivan Kalvachev" <ivan at cacad dot com>)
michaelni
parents:
1317
diff
changeset
|
3705 break; |
1633 | 3706 default: assert(0); |
0 | 3707 } |
3708 } | |
3709 | |
2256 | 3710 /** |
2764 | 3711 * motion compensation of a single macroblock |
2256 | 3712 * @param s context |
3713 * @param dest_y luma destination pointer | |
3714 * @param dest_cb chroma cb/u destination pointer | |
3715 * @param dest_cr chroma cr/v destination pointer | |
3716 * @param dir direction (0->forward, 1->backward) | |
3717 * @param ref_picture array[3] of pointers to the 3 planes of the reference picture | |
3718 * @param pic_op halfpel motion compensation function (average or put normally) | |
3719 * the motion vectors are taken from s->mv and the MV type from s->mv_type | |
3720 */ | |
2967 | 3721 static inline void MPV_motion_lowres(MpegEncContext *s, |
2256 | 3722 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr, |
2967 | 3723 int dir, uint8_t **ref_picture, |
2256 | 3724 h264_chroma_mc_func *pix_op) |
3725 { | |
2292 | 3726 int mx, my; |
2260 | 3727 int mb_x, mb_y, i; |
3728 const int lowres= s->avctx->lowres; | |
2967 | 3729 const int block_s= 8>>lowres; |
2260 | 3730 |
3731 mb_x = s->mb_x; | |
3732 mb_y = s->mb_y; | |
3733 | |
3734 switch(s->mv_type) { | |
3735 case MV_TYPE_16X16: | |
2967 | 3736 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr, |
2260 | 3737 0, 0, 0, |
3738 ref_picture, pix_op, | |
3739 s->mv[dir][0][0], s->mv[dir][0][1], 2*block_s); | |
3740 break; | |
2292 | 3741 case MV_TYPE_8X8: |
2260 | 3742 mx = 0; |
3743 my = 0; | |
3744 for(i=0;i<4;i++) { | |
2292 | 3745 hpel_motion_lowres(s, dest_y + ((i & 1) + (i >> 1) * s->linesize)*block_s, |
2260 | 3746 ref_picture[0], 0, 0, |
2292 | 3747 (2*mb_x + (i & 1))*block_s, (2*mb_y + (i >>1))*block_s, |
2260 | 3748 s->width, s->height, s->linesize, |
2292 | 3749 s->h_edge_pos >> lowres, s->v_edge_pos >> lowres, |
3750 block_s, block_s, pix_op, | |
2260 | 3751 s->mv[dir][i][0], s->mv[dir][i][1]); |
3752 | |
3753 mx += s->mv[dir][i][0]; | |
3754 my += s->mv[dir][i][1]; | |
3755 } | |
3756 | |
3757 if(!(s->flags&CODEC_FLAG_GRAY)) | |
2292 | 3758 chroma_4mv_motion_lowres(s, dest_cb, dest_cr, ref_picture, pix_op, mx, my); |
3759 break; | |
2260 | 3760 case MV_TYPE_FIELD: |
3761 if (s->picture_structure == PICT_FRAME) { | |
2967 | 3762 /* top field */ |
2260 | 3763 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr, |
3764 1, 0, s->field_select[dir][0], | |
3765 ref_picture, pix_op, | |
3766 s->mv[dir][0][0], s->mv[dir][0][1], block_s); | |
3767 /* bottom field */ | |
3768 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr, | |
3769 1, 1, s->field_select[dir][1], | |
3770 ref_picture, pix_op, | |
3771 s->mv[dir][1][0], s->mv[dir][1][1], block_s); | |
3772 } else { | |
3773 if(s->picture_structure != s->field_select[dir][0] + 1 && s->pict_type != B_TYPE && !s->first_field){ | |
3774 ref_picture= s->current_picture_ptr->data; | |
2967 | 3775 } |
2260 | 3776 |
3777 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr, | |
3778 0, 0, s->field_select[dir][0], | |
3779 ref_picture, pix_op, | |
3780 s->mv[dir][0][0], s->mv[dir][0][1], 2*block_s); | |
3781 } | |
3782 break; | |
3783 case MV_TYPE_16X8: | |
3784 for(i=0; i<2; i++){ | |
3785 uint8_t ** ref2picture; | |
3786 | |
3787 if(s->picture_structure == s->field_select[dir][i] + 1 || s->pict_type == B_TYPE || s->first_field){ | |
3788 ref2picture= ref_picture; | |
3789 }else{ | |
3790 ref2picture= s->current_picture_ptr->data; | |
2967 | 3791 } |
3792 | |
3793 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr, | |
2260 | 3794 0, 0, s->field_select[dir][i], |
3795 ref2picture, pix_op, | |
3796 s->mv[dir][i][0], s->mv[dir][i][1] + 2*block_s*i, block_s); | |
2967 | 3797 |
2260 | 3798 dest_y += 2*block_s*s->linesize; |
3799 dest_cb+= (2*block_s>>s->chroma_y_shift)*s->uvlinesize; | |
3800 dest_cr+= (2*block_s>>s->chroma_y_shift)*s->uvlinesize; | |
2967 | 3801 } |
2260 | 3802 break; |
3803 case MV_TYPE_DMV: | |
3804 if(s->picture_structure == PICT_FRAME){ | |
3805 for(i=0; i<2; i++){ | |
3806 int j; | |
3807 for(j=0; j<2; j++){ | |
3808 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr, | |
3809 1, j, j^i, | |
3810 ref_picture, pix_op, | |
3811 s->mv[dir][2*i + j][0], s->mv[dir][2*i + j][1], block_s); | |
3812 } | |
3813 pix_op = s->dsp.avg_h264_chroma_pixels_tab; | |
3814 } | |
3815 }else{ | |
3816 for(i=0; i<2; i++){ | |
2967 | 3817 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr, |
2260 | 3818 0, 0, s->picture_structure != i+1, |
3819 ref_picture, pix_op, | |
3820 s->mv[dir][2*i][0],s->mv[dir][2*i][1],2*block_s); | |
3821 | |
3822 // after put we make avg of the same block | |
3823 pix_op = s->dsp.avg_h264_chroma_pixels_tab; | |
3824 | |
3825 //opposite parity is always in the same frame if this is second field | |
3826 if(!s->first_field){ | |
2967 | 3827 ref_picture = s->current_picture_ptr->data; |
2260 | 3828 } |
3829 } | |
3830 } | |
3831 break; | |
3832 default: assert(0); | |
3833 } | |
2256 | 3834 } |
0 | 3835 |
3836 /* put block[] to dest[] */ | |
2967 | 3837 static inline void put_dct(MpegEncContext *s, |
1651 | 3838 DCTELEM *block, int i, uint8_t *dest, int line_size, int qscale) |
0 | 3839 { |
1689 | 3840 s->dct_unquantize_intra(s, block, i, qscale); |
1092 | 3841 s->dsp.idct_put (dest, line_size, block); |
0 | 3842 } |
3843 | |
3844 /* add block[] to dest[] */ | |
2967 | 3845 static inline void add_dct(MpegEncContext *s, |
1064 | 3846 DCTELEM *block, int i, uint8_t *dest, int line_size) |
0 | 3847 { |
3848 if (s->block_last_index[i] >= 0) { | |
1092 | 3849 s->dsp.idct_add (dest, line_size, block); |
481 | 3850 } |
3851 } | |
3852 | |
2967 | 3853 static inline void add_dequant_dct(MpegEncContext *s, |
1644 | 3854 DCTELEM *block, int i, uint8_t *dest, int line_size, int qscale) |
481 | 3855 { |
3856 if (s->block_last_index[i] >= 0) { | |
1689 | 3857 s->dct_unquantize_inter(s, block, i, qscale); |
324 | 3858 |
1092 | 3859 s->dsp.idct_add (dest, line_size, block); |
0 | 3860 } |
3861 } | |
3862 | |
456 | 3863 /** |
3864 * cleans dc, ac, coded_block for the current non intra MB | |
3865 */ | |
3866 void ff_clean_intra_table_entries(MpegEncContext *s) | |
3867 { | |
1938
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1918
diff
changeset
|
3868 int wrap = s->b8_stride; |
456 | 3869 int xy = s->block_index[0]; |
2967 | 3870 |
3871 s->dc_val[0][xy ] = | |
3872 s->dc_val[0][xy + 1 ] = | |
456 | 3873 s->dc_val[0][xy + wrap] = |
3874 s->dc_val[0][xy + 1 + wrap] = 1024; | |
3875 /* ac pred */ | |
1064 | 3876 memset(s->ac_val[0][xy ], 0, 32 * sizeof(int16_t)); |
3877 memset(s->ac_val[0][xy + wrap], 0, 32 * sizeof(int16_t)); | |
456 | 3878 if (s->msmpeg4_version>=3) { |
3879 s->coded_block[xy ] = | |
3880 s->coded_block[xy + 1 ] = | |
3881 s->coded_block[xy + wrap] = | |
3882 s->coded_block[xy + 1 + wrap] = 0; | |
3883 } | |
3884 /* chroma */ | |
1938
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1918
diff
changeset
|
3885 wrap = s->mb_stride; |
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1918
diff
changeset
|
3886 xy = s->mb_x + s->mb_y * wrap; |
456 | 3887 s->dc_val[1][xy] = |
3888 s->dc_val[2][xy] = 1024; | |
3889 /* ac pred */ | |
1064 | 3890 memset(s->ac_val[1][xy], 0, 16 * sizeof(int16_t)); |
3891 memset(s->ac_val[2][xy], 0, 16 * sizeof(int16_t)); | |
2967 | 3892 |
1938
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1918
diff
changeset
|
3893 s->mbintra_table[xy]= 0; |
456 | 3894 } |
3895 | |
0 | 3896 /* generic function called after a macroblock has been parsed by the |
3897 decoder or after it has been encoded by the encoder. | |
3898 | |
3899 Important variables used: | |
3900 s->mb_intra : true if intra macroblock | |
3901 s->mv_dir : motion vector direction | |
3902 s->mv_type : motion vector type | |
3903 s->mv : motion vector | |
3904 s->interlaced_dct : true if interlaced dct used (mpeg2) | |
3905 */ | |
4283
d6f83e2f8804
rename always_inline to av_always_inline and move to common.h
mru
parents:
4281
diff
changeset
|
3906 static av_always_inline void MPV_decode_mb_internal(MpegEncContext *s, DCTELEM block[12][64], int lowres_flag) |
0 | 3907 { |
244 | 3908 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
|
3909 const int mb_xy = s->mb_y * s->mb_stride + s->mb_x; |
1381 | 3910 #ifdef HAVE_XVMC |
3911 if(s->avctx->xvmc_acceleration){ | |
1580
628bf341e099
XvMC speedup by removing one memcpy and doing MB packing
iive
parents:
1579
diff
changeset
|
3912 XVMC_decode_mb(s);//xvmc uses pblocks |
1381 | 3913 return; |
3914 } | |
3915 #endif | |
0 | 3916 |
3917 mb_x = s->mb_x; | |
3918 mb_y = s->mb_y; | |
3919 | |
1833
ba27ce284d07
export DCT coefficients patch by (Wolfgang Hesseler <wolfgang.hesseler at imk dot fraunhofer dot de>)
michael
parents:
1831
diff
changeset
|
3920 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
|
3921 /* save DCT coefficients */ |
ba27ce284d07
export DCT coefficients patch by (Wolfgang Hesseler <wolfgang.hesseler at imk dot fraunhofer dot de>)
michael
parents:
1831
diff
changeset
|
3922 int i,j; |
ba27ce284d07
export DCT coefficients patch by (Wolfgang Hesseler <wolfgang.hesseler at imk dot fraunhofer dot de>)
michael
parents:
1831
diff
changeset
|
3923 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
|
3924 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
|
3925 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
|
3926 *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
|
3927 } |
ba27ce284d07
export DCT coefficients patch by (Wolfgang Hesseler <wolfgang.hesseler at imk dot fraunhofer dot de>)
michael
parents:
1831
diff
changeset
|
3928 |
903 | 3929 s->current_picture.qscale_table[mb_xy]= s->qscale; |
108
1e4a4af694d1
exporting qscale data for postprocessing (for MPlayer)
arpi_esp
parents:
79
diff
changeset
|
3930 |
0 | 3931 /* update DC predictors for P macroblocks */ |
3932 if (!s->mb_intra) { | |
249
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
3933 if (s->h263_pred || s->h263_aic) { |
481 | 3934 if(s->mbintra_table[mb_xy]) |
456 | 3935 ff_clean_intra_table_entries(s); |
0 | 3936 } else { |
456 | 3937 s->last_dc[0] = |
3938 s->last_dc[1] = | |
0 | 3939 s->last_dc[2] = 128 << s->intra_dc_precision; |
3940 } | |
3941 } | |
249
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
3942 else if (s->h263_pred || s->h263_aic) |
481 | 3943 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
|
3944 |
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
|
3945 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 | 3946 uint8_t *dest_y, *dest_cb, *dest_cr; |
481 | 3947 int dct_linesize, dct_offset; |
651 | 3948 op_pixels_func (*op_pix)[4]; |
3949 qpel_mc_func (*op_qpix)[16]; | |
2627
bf158d23bbcc
Spelling errors patch by (Kevin Baragona | kevinmb500 gawab com)
michael
parents:
2620
diff
changeset
|
3950 const int linesize= s->current_picture.linesize[0]; //not s->linesize as this would be wrong for field pics |
1138 | 3951 const int uvlinesize= s->current_picture.linesize[1]; |
2256 | 3952 const int readable= s->pict_type != B_TYPE || s->encoding || s->avctx->draw_horiz_band || lowres_flag; |
3953 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
|
3954 |
903 | 3955 /* avoid copy if macroblock skipped in last frame too */ |
3956 /* skip only during decoding as we might trash the buffers during encoding a bit */ | |
3957 if(!s->encoding){ | |
1064 | 3958 uint8_t *mbskip_ptr = &s->mbskip_table[mb_xy]; |
903 | 3959 const int age= s->current_picture.age; |
3960 | |
3961 assert(age); | |
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 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
|
3964 s->mb_skipped= 0; |
903 | 3965 assert(s->pict_type!=I_TYPE); |
2967 | 3966 |
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
|
3967 (*mbskip_ptr) ++; /* indicate that this time we skipped it */ |
556 | 3968 if(*mbskip_ptr >99) *mbskip_ptr= 99; |
3969 | |
903 | 3970 /* 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
|
3971 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
|
3972 return; |
903 | 3973 } |
1021
2d7c9f5738de
trying to fix mb skip bug in mpeg1/2 if slices are not used
michaelni
parents:
1014
diff
changeset
|
3974 } 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
|
3975 (*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
|
3976 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
|
3977 } else{ |
7
1d3ac9654178
added skip macroblock optimization (big perf win on black regions for example)
glantau
parents:
0
diff
changeset
|
3978 *mbskip_ptr = 0; /* not skipped */ |
1d3ac9654178
added skip macroblock optimization (big perf win on black regions for example)
glantau
parents:
0
diff
changeset
|
3979 } |
717 | 3980 } |
2967 | 3981 |
2074
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
3982 dct_linesize = linesize << s->interlaced_dct; |
2256 | 3983 dct_offset =(s->interlaced_dct)? linesize : linesize*block_size; |
2967 | 3984 |
1632 | 3985 if(readable){ |
3986 dest_y= s->dest[0]; | |
3987 dest_cb= s->dest[1]; | |
3988 dest_cr= s->dest[2]; | |
3989 }else{ | |
1799 | 3990 dest_y = s->b_scratchpad; |
1834 | 3991 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
|
3992 dest_cr= s->b_scratchpad+32*linesize; |
1632 | 3993 } |
2256 | 3994 |
0 | 3995 if (!s->mb_intra) { |
3996 /* motion handling */ | |
2627
bf158d23bbcc
Spelling errors patch by (Kevin Baragona | kevinmb500 gawab com)
michael
parents:
2620
diff
changeset
|
3997 /* decoding or more than one mb_type (MC was already done otherwise) */ |
1389 | 3998 if(!s->encoding){ |
2256 | 3999 if(lowres_flag){ |
4000 h264_chroma_mc_func *op_pix = s->dsp.put_h264_chroma_pixels_tab; | |
4001 | |
4002 if (s->mv_dir & MV_DIR_FORWARD) { | |
4003 MPV_motion_lowres(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.data, op_pix); | |
4004 op_pix = s->dsp.avg_h264_chroma_pixels_tab; | |
4005 } | |
4006 if (s->mv_dir & MV_DIR_BACKWARD) { | |
4007 MPV_motion_lowres(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.data, op_pix); | |
4008 } | |
324 | 4009 }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
|
4010 op_qpix= s->me.qpel_put; |
2967 | 4011 if ((!s->no_rounding) || s->pict_type==B_TYPE){ |
2256 | 4012 op_pix = s->dsp.put_pixels_tab; |
4013 }else{ | |
4014 op_pix = s->dsp.put_no_rnd_pixels_tab; | |
4015 } | |
4016 if (s->mv_dir & MV_DIR_FORWARD) { | |
4017 MPV_motion(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.data, op_pix, op_qpix); | |
4018 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
|
4019 op_qpix= s->me.qpel_avg; |
2256 | 4020 } |
4021 if (s->mv_dir & MV_DIR_BACKWARD) { | |
4022 MPV_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.data, op_pix, op_qpix); | |
4023 } | |
324 | 4024 } |
0 | 4025 } |
4026 | |
481 | 4027 /* skip dequant / idct if we are really late ;) */ |
2792 | 4028 if(s->hurry_up>1) goto skip_idct; |
4029 if(s->avctx->skip_idct){ | |
4030 if( (s->avctx->skip_idct >= AVDISCARD_NONREF && s->pict_type == B_TYPE) | |
4031 ||(s->avctx->skip_idct >= AVDISCARD_NONKEY && s->pict_type != I_TYPE) | |
4032 || s->avctx->skip_idct >= AVDISCARD_ALL) | |
4033 goto skip_idct; | |
4034 } | |
481 | 4035 |
0 | 4036 /* add dct residue */ |
1421 | 4037 if(s->encoding || !( s->h263_msmpeg4 || s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO |
711 | 4038 || (s->codec_id==CODEC_ID_MPEG4 && !s->mpeg_quant))){ |
2256 | 4039 add_dequant_dct(s, block[0], 0, dest_y , dct_linesize, s->qscale); |
4040 add_dequant_dct(s, block[1], 1, dest_y + block_size, dct_linesize, s->qscale); | |
4041 add_dequant_dct(s, block[2], 2, dest_y + dct_offset , dct_linesize, s->qscale); | |
4042 add_dequant_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize, s->qscale); | |
0 | 4043 |
485 | 4044 if(!(s->flags&CODEC_FLAG_GRAY)){ |
3309 | 4045 if (s->chroma_y_shift){ |
4046 add_dequant_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale); | |
4047 add_dequant_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale); | |
4048 }else{ | |
4049 dct_linesize >>= 1; | |
4050 dct_offset >>=1; | |
4051 add_dequant_dct(s, block[4], 4, dest_cb, dct_linesize, s->chroma_qscale); | |
4052 add_dequant_dct(s, block[5], 5, dest_cr, dct_linesize, s->chroma_qscale); | |
4053 add_dequant_dct(s, block[6], 6, dest_cb + dct_offset, dct_linesize, s->chroma_qscale); | |
4054 add_dequant_dct(s, block[7], 7, dest_cr + dct_offset, dct_linesize, s->chroma_qscale); | |
4055 } | |
485 | 4056 } |
936 | 4057 } else if(s->codec_id != CODEC_ID_WMV2){ |
2256 | 4058 add_dct(s, block[0], 0, dest_y , dct_linesize); |
4059 add_dct(s, block[1], 1, dest_y + block_size, dct_linesize); | |
4060 add_dct(s, block[2], 2, dest_y + dct_offset , dct_linesize); | |
4061 add_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize); | |
481 | 4062 |
485 | 4063 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
|
4064 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
|
4065 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
|
4066 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
|
4067 }else{ |
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
4068 //chroma422 |
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
4069 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
|
4070 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
|
4071 |
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
4072 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
|
4073 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
|
4074 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
|
4075 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
|
4076 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
|
4077 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
|
4078 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
|
4079 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
|
4080 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
|
4081 } |
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
4082 } |
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
4083 }//fi gray |
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
4084 } |
1042 | 4085 else{ |
936 | 4086 ff_wmv2_add_mb(s, block, dest_y, dest_cb, dest_cr); |
481 | 4087 } |
0 | 4088 } else { |
4089 /* dct only in intra block */ | |
1421 | 4090 if(s->encoding || !(s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO)){ |
2256 | 4091 put_dct(s, block[0], 0, dest_y , dct_linesize, s->qscale); |
4092 put_dct(s, block[1], 1, dest_y + block_size, dct_linesize, s->qscale); | |
4093 put_dct(s, block[2], 2, dest_y + dct_offset , dct_linesize, s->qscale); | |
4094 put_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize, s->qscale); | |
0 | 4095 |
711 | 4096 if(!(s->flags&CODEC_FLAG_GRAY)){ |
3309 | 4097 if(s->chroma_y_shift){ |
4098 put_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale); | |
4099 put_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale); | |
4100 }else{ | |
4101 dct_offset >>=1; | |
4102 dct_linesize >>=1; | |
4103 put_dct(s, block[4], 4, dest_cb, dct_linesize, s->chroma_qscale); | |
4104 put_dct(s, block[5], 5, dest_cr, dct_linesize, s->chroma_qscale); | |
4105 put_dct(s, block[6], 6, dest_cb + dct_offset, dct_linesize, s->chroma_qscale); | |
4106 put_dct(s, block[7], 7, dest_cr + dct_offset, dct_linesize, s->chroma_qscale); | |
4107 } | |
711 | 4108 } |
4109 }else{ | |
2256 | 4110 s->dsp.idct_put(dest_y , dct_linesize, block[0]); |
4111 s->dsp.idct_put(dest_y + block_size, dct_linesize, block[1]); | |
4112 s->dsp.idct_put(dest_y + dct_offset , dct_linesize, block[2]); | |
4113 s->dsp.idct_put(dest_y + dct_offset + block_size, dct_linesize, block[3]); | |
711 | 4114 |
4115 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
|
4116 if(s->chroma_y_shift){ |
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
4117 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
|
4118 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
|
4119 }else{ |
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
4120 |
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
4121 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
|
4122 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
|
4123 |
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
4124 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
|
4125 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
|
4126 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
|
4127 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
|
4128 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
|
4129 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
|
4130 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
|
4131 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
|
4132 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
|
4133 } |
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
4134 } |
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
4135 }//gray |
485 | 4136 } |
0 | 4137 } |
2792 | 4138 skip_idct: |
1632 | 4139 if(!readable){ |
4140 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
|
4141 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
|
4142 s->dsp.put_pixels_tab[s->chroma_x_shift][0](s->dest[2], dest_cr, uvlinesize,16 >> s->chroma_y_shift); |
1632 | 4143 } |
0 | 4144 } |
294 | 4145 } |
4146 | |
2256 | 4147 void MPV_decode_mb(MpegEncContext *s, DCTELEM block[12][64]){ |
4148 if(s->avctx->lowres) MPV_decode_mb_internal(s, block, 1); | |
4149 else MPV_decode_mb_internal(s, block, 0); | |
4150 } | |
4151 | |
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
|
4152 #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
|
4153 |
605
40874804a5af
same dc skip behavior for chroma & luma elimination, its confusing otherwise imho
michaelni
parents:
604
diff
changeset
|
4154 static inline void dct_single_coeff_elimination(MpegEncContext *s, int n, int threshold) |
456 | 4155 { |
4156 static const char tab[64]= | |
4157 {3,2,2,1,1,1,1,1, | |
4158 1,1,1,1,1,1,1,1, | |
4159 1,1,1,1,1,1,1,1, | |
4160 0,0,0,0,0,0,0,0, | |
4161 0,0,0,0,0,0,0,0, | |
4162 0,0,0,0,0,0,0,0, | |
4163 0,0,0,0,0,0,0,0, | |
4164 0,0,0,0,0,0,0,0}; | |
4165 int score=0; | |
4166 int run=0; | |
4167 int i; | |
4168 DCTELEM *block= s->block[n]; | |
4169 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
|
4170 int skip_dc; |
456 | 4171 |
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
|
4172 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
|
4173 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
|
4174 threshold= -threshold; |
605
40874804a5af
same dc skip behavior for chroma & luma elimination, its confusing otherwise imho
michaelni
parents:
604
diff
changeset
|
4175 }else |
40874804a5af
same dc skip behavior for chroma & luma elimination, its confusing otherwise imho
michaelni
parents:
604
diff
changeset
|
4176 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
|
4177 |
456 | 4178 /* are all which we could set to zero are allready zero? */ |
4179 if(last_index<=skip_dc - 1) return; | |
4180 | |
4181 for(i=0; i<=last_index; i++){ | |
706
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
4182 const int j = s->intra_scantable.permutated[i]; |
4001 | 4183 const int level = FFABS(block[j]); |
456 | 4184 if(level==1){ |
4185 if(skip_dc && i==0) continue; | |
4186 score+= tab[run]; | |
4187 run=0; | |
4188 }else if(level>1){ | |
4189 return; | |
4190 }else{ | |
4191 run++; | |
4192 } | |
4193 } | |
4194 if(score >= threshold) return; | |
4195 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
|
4196 const int j = s->intra_scantable.permutated[i]; |
456 | 4197 block[j]=0; |
4198 } | |
4199 if(block[0]) s->block_last_index[n]= 0; | |
4200 else s->block_last_index[n]= -1; | |
4201 } | |
4202 | |
344 | 4203 static inline void clip_coeffs(MpegEncContext *s, DCTELEM *block, int last_index) |
4204 { | |
4205 int i; | |
4206 const int maxlevel= s->max_qcoeff; | |
4207 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
|
4208 int overflow=0; |
2967 | 4209 |
706
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
4210 if(s->mb_intra){ |
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
4211 i=1; //skip clipping of intra dc |
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
4212 }else |
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
4213 i=0; |
2967 | 4214 |
706
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
4215 for(;i<=last_index; i++){ |
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
4216 const int j= s->intra_scantable.permutated[i]; |
344 | 4217 int level = block[j]; |
2967 | 4218 |
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
|
4219 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
|
4220 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
|
4221 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
|
4222 }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
|
4223 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
|
4224 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
|
4225 } |
2967 | 4226 |
344 | 4227 block[j]= level; |
4228 } | |
2967 | 4229 |
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
|
4230 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
|
4231 av_log(s->avctx, AV_LOG_INFO, "warning, clipping %d dct coefficients to %d..%d\n", overflow, minlevel, maxlevel); |
344 | 4232 } |
324 | 4233 |
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
|
4234 #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
|
4235 |
1098
b7f267d168b7
mpeg2 field pictures + sliced mode (doesnt work with mplayer though, dunno why)
michaelni
parents:
1096
diff
changeset
|
4236 /** |
b7f267d168b7
mpeg2 field pictures + sliced mode (doesnt work with mplayer though, dunno why)
michaelni
parents:
1096
diff
changeset
|
4237 * |
b7f267d168b7
mpeg2 field pictures + sliced mode (doesnt work with mplayer though, dunno why)
michaelni
parents:
1096
diff
changeset
|
4238 * @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
|
4239 */ |
b7f267d168b7
mpeg2 field pictures + sliced mode (doesnt work with mplayer though, dunno why)
michaelni
parents:
1096
diff
changeset
|
4240 void ff_draw_horiz_band(MpegEncContext *s, int y, int h){ |
1368 | 4241 if (s->avctx->draw_horiz_band) { |
1370 | 4242 AVFrame *src; |
1368 | 4243 int offset[4]; |
2967 | 4244 |
1370 | 4245 if(s->picture_structure != PICT_FRAME){ |
4246 h <<= 1; | |
4247 y <<= 1; | |
4248 if(s->first_field && !(s->avctx->slice_flags&SLICE_FLAG_ALLOW_FIELD)) return; | |
4249 } | |
4250 | |
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
|
4251 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
|
4252 |
2967 | 4253 if(s->pict_type==B_TYPE || s->low_delay || (s->avctx->slice_flags&SLICE_FLAG_CODED_ORDER)) |
1370 | 4254 src= (AVFrame*)s->current_picture_ptr; |
4255 else if(s->last_picture_ptr) | |
4256 src= (AVFrame*)s->last_picture_ptr; | |
4257 else | |
4258 return; | |
2967 | 4259 |
1369 | 4260 if(s->pict_type==B_TYPE && s->picture_structure == PICT_FRAME && s->out_format != FMT_H264){ |
1368 | 4261 offset[0]= |
4262 offset[1]= | |
4263 offset[2]= | |
4264 offset[3]= 0; | |
4265 }else{ | |
4266 offset[0]= y * s->linesize;; | |
2967 | 4267 offset[1]= |
2074
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
4268 offset[2]= (y >> s->chroma_y_shift) * s->uvlinesize; |
1368 | 4269 offset[3]= 0; |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
731
diff
changeset
|
4270 } |
1368 | 4271 |
813 | 4272 emms_c(); |
4273 | |
1370 | 4274 s->avctx->draw_horiz_band(s->avctx, src, offset, |
4275 y, s->picture_structure, h); | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
731
diff
changeset
|
4276 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
731
diff
changeset
|
4277 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
731
diff
changeset
|
4278 |
1389 | 4279 void ff_init_block_index(MpegEncContext *s){ //FIXME maybe rename |
2764 | 4280 const int linesize= s->current_picture.linesize[0]; //not s->linesize as this would be wrong for field pics |
1389 | 4281 const int uvlinesize= s->current_picture.linesize[1]; |
2256 | 4282 const int mb_size= 4 - s->avctx->lowres; |
2967 | 4283 |
1938
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1918
diff
changeset
|
4284 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
|
4285 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
|
4286 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
|
4287 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
|
4288 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
|
4289 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
|
4290 //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
|
4291 |
2256 | 4292 s->dest[0] = s->current_picture.data[0] + ((s->mb_x - 1) << mb_size); |
4293 s->dest[1] = s->current_picture.data[1] + ((s->mb_x - 1) << (mb_size - s->chroma_x_shift)); | |
4294 s->dest[2] = s->current_picture.data[2] + ((s->mb_x - 1) << (mb_size - s->chroma_x_shift)); | |
2168 | 4295 |
2074
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
4296 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
|
4297 { |
2256 | 4298 s->dest[0] += s->mb_y * linesize << mb_size; |
4299 s->dest[1] += s->mb_y * uvlinesize << (mb_size - s->chroma_y_shift); | |
4300 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
|
4301 } |
1389 | 4302 } |
4303 | |
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
|
4304 #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
|
4305 |
1777 | 4306 static void get_vissual_weight(int16_t *weight, uint8_t *ptr, int stride){ |
4307 int x, y; | |
4308 //FIXME optimize | |
4309 for(y=0; y<8; y++){ | |
4310 for(x=0; x<8; x++){ | |
4311 int x2, y2; | |
4312 int sum=0; | |
4313 int sqr=0; | |
4314 int count=0; | |
4315 | |
4316 for(y2= FFMAX(y-1, 0); y2 < FFMIN(8, y+2); y2++){ | |
4317 for(x2= FFMAX(x-1, 0); x2 < FFMIN(8, x+2); x2++){ | |
4318 int v= ptr[x2 + y2*stride]; | |
4319 sum += v; | |
4320 sqr += v*v; | |
4321 count++; | |
4322 } | |
4323 } | |
4324 weight[x + 8*y]= (36*ff_sqrt(count*sqr - sum*sum)) / count; | |
4325 } | |
4326 } | |
4327 } | |
4328 | |
4283
d6f83e2f8804
rename always_inline to av_always_inline and move to common.h
mru
parents:
4281
diff
changeset
|
4329 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 | 4330 { |
3309 | 4331 int16_t weight[8][64]; |
4332 DCTELEM orig[8][64]; | |
294 | 4333 const int mb_x= s->mb_x; |
4334 const int mb_y= s->mb_y; | |
4335 int i; | |
3309 | 4336 int skip_dct[8]; |
697 | 4337 int dct_offset = s->linesize*8; //default for progressive frames |
1778 | 4338 uint8_t *ptr_y, *ptr_cb, *ptr_cr; |
4339 int wrap_y, wrap_c; | |
2967 | 4340 |
4327 | 4341 for(i=0; i<mb_block_count; i++) skip_dct[i]=s->skipdct; |
2967 | 4342 |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
673
diff
changeset
|
4343 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
|
4344 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
|
4345 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
|
4346 |
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
|
4347 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
|
4348 update_qscale(s); |
2967 | 4349 |
1616 | 4350 if(!(s->flags&CODEC_FLAG_QP_RD)){ |
4320 | 4351 s->qscale= s->current_picture_ptr->qscale_table[mb_xy]; |
1616 | 4352 s->dquant= s->qscale - last_qp; |
4353 | |
1805
5dd5b2052f5b
mpeg4 b frame + adaptive quantization assertion failure fix
michael
parents:
1804
diff
changeset
|
4354 if(s->out_format==FMT_H263){ |
4594 | 4355 s->dquant= av_clip(s->dquant, -2, 2); |
2967 | 4356 |
4357 if(s->codec_id==CODEC_ID_MPEG4){ | |
1805
5dd5b2052f5b
mpeg4 b frame + adaptive quantization assertion failure fix
michael
parents:
1804
diff
changeset
|
4358 if(!s->mb_intra){ |
5dd5b2052f5b
mpeg4 b frame + adaptive quantization assertion failure fix
michael
parents:
1804
diff
changeset
|
4359 if(s->pict_type == B_TYPE){ |
4324 | 4360 if(s->dquant&1 || s->mv_dir&MV_DIRECT) |
1805
5dd5b2052f5b
mpeg4 b frame + adaptive quantization assertion failure fix
michael
parents:
1804
diff
changeset
|
4361 s->dquant= 0; |
5dd5b2052f5b
mpeg4 b frame + adaptive quantization assertion failure fix
michael
parents:
1804
diff
changeset
|
4362 } |
5dd5b2052f5b
mpeg4 b frame + adaptive quantization assertion failure fix
michael
parents:
1804
diff
changeset
|
4363 if(s->mv_type==MV_TYPE_8X8) |
5dd5b2052f5b
mpeg4 b frame + adaptive quantization assertion failure fix
michael
parents:
1804
diff
changeset
|
4364 s->dquant=0; |
5dd5b2052f5b
mpeg4 b frame + adaptive quantization assertion failure fix
michael
parents:
1804
diff
changeset
|
4365 } |
1616 | 4366 } |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
673
diff
changeset
|
4367 } |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
673
diff
changeset
|
4368 } |
1652 | 4369 ff_set_qscale(s, last_qp + s->dquant); |
2054 | 4370 }else if(s->flags&CODEC_FLAG_QP_RD) |
4371 ff_set_qscale(s, s->qscale + s->dquant); | |
294 | 4372 |
1778 | 4373 wrap_y = s->linesize; |
4374 wrap_c = s->uvlinesize; | |
4375 ptr_y = s->new_picture.data[0] + (mb_y * 16 * wrap_y) + mb_x * 16; | |
3309 | 4376 ptr_cb = s->new_picture.data[1] + (mb_y * mb_block_height * wrap_c) + mb_x * 8; |
4377 ptr_cr = s->new_picture.data[2] + (mb_y * mb_block_height * wrap_c) + mb_x * 8; | |
1778 | 4378 |
4379 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
|
4380 uint8_t *ebuf= s->edge_emu_buffer + 32; |
5ca07515a309
10l (dont store 2 different things at the same place ...)
michael
parents:
2132
diff
changeset
|
4381 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
|
4382 ptr_y= ebuf; |
3309 | 4383 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
|
4384 ptr_cb= ebuf+18*wrap_y; |
3309 | 4385 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
|
4386 ptr_cr= ebuf+18*wrap_y+8; |
1778 | 4387 } |
4388 | |
324 | 4389 if (s->mb_intra) { |
697 | 4390 if(s->flags&CODEC_FLAG_INTERLACED_DCT){ |
4391 int progressive_score, interlaced_score; | |
1708 | 4392 |
1729 | 4393 s->interlaced_dct=0; |
2967 | 4394 progressive_score= s->dsp.ildct_cmp[4](s, ptr_y , NULL, wrap_y, 8) |
1777 | 4395 +s->dsp.ildct_cmp[4](s, ptr_y + wrap_y*8, NULL, wrap_y, 8) - 400; |
1729 | 4396 |
4397 if(progressive_score > 0){ | |
2967 | 4398 interlaced_score = s->dsp.ildct_cmp[4](s, ptr_y , NULL, wrap_y*2, 8) |
1777 | 4399 +s->dsp.ildct_cmp[4](s, ptr_y + wrap_y , NULL, wrap_y*2, 8); |
1729 | 4400 if(progressive_score > interlaced_score){ |
4401 s->interlaced_dct=1; | |
2967 | 4402 |
1729 | 4403 dct_offset= wrap_y; |
4404 wrap_y<<=1; | |
3309 | 4405 if (s->chroma_format == CHROMA_422) |
4406 wrap_c<<=1; | |
1729 | 4407 } |
4408 } | |
697 | 4409 } |
2967 | 4410 |
2979 | 4411 s->dsp.get_pixels(s->block[0], ptr_y , wrap_y); |
1777 | 4412 s->dsp.get_pixels(s->block[1], ptr_y + 8, wrap_y); |
4413 s->dsp.get_pixels(s->block[2], ptr_y + dct_offset , wrap_y); | |
4414 s->dsp.get_pixels(s->block[3], ptr_y + dct_offset + 8, wrap_y); | |
294 | 4415 |
487 | 4416 if(s->flags&CODEC_FLAG_GRAY){ |
4417 skip_dct[4]= 1; | |
4418 skip_dct[5]= 1; | |
4419 }else{ | |
2979 | 4420 s->dsp.get_pixels(s->block[4], ptr_cb, wrap_c); |
1777 | 4421 s->dsp.get_pixels(s->block[5], ptr_cr, wrap_c); |
3309 | 4422 if(!s->chroma_y_shift){ /* 422 */ |
4423 s->dsp.get_pixels(s->block[6], ptr_cb + (dct_offset>>1), wrap_c); | |
4424 s->dsp.get_pixels(s->block[7], ptr_cr + (dct_offset>>1), wrap_c); | |
4425 } | |
1777 | 4426 } |
324 | 4427 }else{ |
651 | 4428 op_pixels_func (*op_pix)[4]; |
4429 qpel_mc_func (*op_qpix)[16]; | |
1064 | 4430 uint8_t *dest_y, *dest_cb, *dest_cr; |
294 | 4431 |
1389 | 4432 dest_y = s->dest[0]; |
4433 dest_cb = s->dest[1]; | |
4434 dest_cr = s->dest[2]; | |
324 | 4435 |
327 | 4436 if ((!s->no_rounding) || s->pict_type==B_TYPE){ |
2979 | 4437 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
|
4438 op_qpix= s->dsp.put_qpel_pixels_tab; |
295 | 4439 }else{ |
853
eacc2dd8fd9d
* using DSPContext - so each codec could use its local (sub)set of CPU extension
kabi
parents:
847
diff
changeset
|
4440 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
|
4441 op_qpix= s->dsp.put_no_rnd_qpel_pixels_tab; |
324 | 4442 } |
295 | 4443 |
324 | 4444 if (s->mv_dir & MV_DIR_FORWARD) { |
903 | 4445 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
|
4446 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
|
4447 op_qpix= s->dsp.avg_qpel_pixels_tab; |
324 | 4448 } |
4449 if (s->mv_dir & MV_DIR_BACKWARD) { | |
903 | 4450 MPV_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.data, op_pix, op_qpix); |
324 | 4451 } |
295 | 4452 |
697 | 4453 if(s->flags&CODEC_FLAG_INTERLACED_DCT){ |
4454 int progressive_score, interlaced_score; | |
1729 | 4455 |
4456 s->interlaced_dct=0; | |
2967 | 4457 progressive_score= s->dsp.ildct_cmp[0](s, dest_y , ptr_y , wrap_y, 8) |
1729 | 4458 +s->dsp.ildct_cmp[0](s, dest_y + wrap_y*8, ptr_y + wrap_y*8, wrap_y, 8) - 400; |
2967 | 4459 |
1729 | 4460 if(s->avctx->ildct_cmp == FF_CMP_VSSE) progressive_score -= 400; |
4461 | |
4462 if(progressive_score>0){ | |
2967 | 4463 interlaced_score = s->dsp.ildct_cmp[0](s, dest_y , ptr_y , wrap_y*2, 8) |
1729 | 4464 +s->dsp.ildct_cmp[0](s, dest_y + wrap_y , ptr_y + wrap_y , wrap_y*2, 8); |
2967 | 4465 |
1729 | 4466 if(progressive_score > interlaced_score){ |
4467 s->interlaced_dct=1; | |
2967 | 4468 |
1729 | 4469 dct_offset= wrap_y; |
4470 wrap_y<<=1; | |
3309 | 4471 if (s->chroma_format == CHROMA_422) |
4472 wrap_c<<=1; | |
1729 | 4473 } |
4474 } | |
697 | 4475 } |
2967 | 4476 |
2979 | 4477 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
|
4478 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
|
4479 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
|
4480 s->dsp.diff_pixels(s->block[3], ptr_y + dct_offset + 8, dest_y + dct_offset + 8, wrap_y); |
2967 | 4481 |
487 | 4482 if(s->flags&CODEC_FLAG_GRAY){ |
4483 skip_dct[4]= 1; | |
4484 skip_dct[5]= 1; | |
4485 }else{ | |
853
eacc2dd8fd9d
* using DSPContext - so each codec could use its local (sub)set of CPU extension
kabi
parents:
847
diff
changeset
|
4486 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
|
4487 s->dsp.diff_pixels(s->block[5], ptr_cr, dest_cr, wrap_c); |
3309 | 4488 if(!s->chroma_y_shift){ /* 422 */ |
4489 s->dsp.diff_pixels(s->block[6], ptr_cb + (dct_offset>>1), dest_cb + (dct_offset>>1), wrap_c); | |
4490 s->dsp.diff_pixels(s->block[7], ptr_cr + (dct_offset>>1), dest_cr + (dct_offset>>1), wrap_c); | |
4491 } | |
487 | 4492 } |
2967 | 4493 /* 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
|
4494 if(s->current_picture.mc_mb_var[s->mb_stride*mb_y+ mb_x]<2*s->qscale*s->qscale){ |
697 | 4495 //FIXME optimize |
2979 | 4496 if(s->dsp.sad[1](NULL, ptr_y , dest_y , wrap_y, 8) < 20*s->qscale) skip_dct[0]= 1; |
1708 | 4497 if(s->dsp.sad[1](NULL, ptr_y + 8, dest_y + 8, wrap_y, 8) < 20*s->qscale) skip_dct[1]= 1; |
4498 if(s->dsp.sad[1](NULL, ptr_y +dct_offset , dest_y +dct_offset , wrap_y, 8) < 20*s->qscale) skip_dct[2]= 1; | |
4499 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; | |
4500 if(s->dsp.sad[1](NULL, ptr_cb , dest_cb , wrap_c, 8) < 20*s->qscale) skip_dct[4]= 1; | |
4501 if(s->dsp.sad[1](NULL, ptr_cr , dest_cr , wrap_c, 8) < 20*s->qscale) skip_dct[5]= 1; | |
3309 | 4502 if(!s->chroma_y_shift){ /* 422 */ |
4503 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; | |
4504 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; | |
4505 } | |
456 | 4506 } |
1778 | 4507 } |
4508 | |
4509 if(s->avctx->quantizer_noise_shaping){ | |
4510 if(!skip_dct[0]) get_vissual_weight(weight[0], ptr_y , wrap_y); | |
4511 if(!skip_dct[1]) get_vissual_weight(weight[1], ptr_y + 8, wrap_y); | |
4512 if(!skip_dct[2]) get_vissual_weight(weight[2], ptr_y + dct_offset , wrap_y); | |
4513 if(!skip_dct[3]) get_vissual_weight(weight[3], ptr_y + dct_offset + 8, wrap_y); | |
4514 if(!skip_dct[4]) get_vissual_weight(weight[4], ptr_cb , wrap_c); | |
4515 if(!skip_dct[5]) get_vissual_weight(weight[5], ptr_cr , wrap_c); | |
3309 | 4516 if(!s->chroma_y_shift){ /* 422 */ |
4517 if(!skip_dct[6]) get_vissual_weight(weight[6], ptr_cb + (dct_offset>>1), wrap_c); | |
4518 if(!skip_dct[7]) get_vissual_weight(weight[7], ptr_cr + (dct_offset>>1), wrap_c); | |
4519 } | |
4520 memcpy(orig[0], s->block[0], sizeof(DCTELEM)*64*mb_block_count); | |
294 | 4521 } |
2967 | 4522 |
294 | 4523 /* DCT & quantize */ |
1778 | 4524 assert(s->out_format!=FMT_MJPEG || s->qscale==8); |
4525 { | |
3309 | 4526 for(i=0;i<mb_block_count;i++) { |
456 | 4527 if(!skip_dct[i]){ |
4528 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
|
4529 s->block_last_index[i] = s->dct_quantize(s, s->block[i], i, s->qscale, &overflow); |
344 | 4530 // 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
|
4531 // 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
|
4532 // of improve it. Just INTRADC clipping deserves changes in quantizer |
456 | 4533 if (overflow) clip_coeffs(s, s->block[i], s->block_last_index[i]); |
4534 }else | |
4535 s->block_last_index[i]= -1; | |
344 | 4536 } |
1777 | 4537 if(s->avctx->quantizer_noise_shaping){ |
3309 | 4538 for(i=0;i<mb_block_count;i++) { |
1777 | 4539 if(!skip_dct[i]){ |
4540 s->block_last_index[i] = dct_quantize_refine(s, s->block[i], weight[i], orig[i], i, s->qscale); | |
4541 } | |
4542 } | |
4543 } | |
2967 | 4544 |
456 | 4545 if(s->luma_elim_threshold && !s->mb_intra) |
4546 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
|
4547 dct_single_coeff_elimination(s, i, s->luma_elim_threshold); |
456 | 4548 if(s->chroma_elim_threshold && !s->mb_intra) |
3309 | 4549 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
|
4550 dct_single_coeff_elimination(s, i, s->chroma_elim_threshold); |
1497 | 4551 |
4552 if(s->flags & CODEC_FLAG_CBP_RD){ | |
3309 | 4553 for(i=0;i<mb_block_count;i++) { |
1497 | 4554 if(s->block_last_index[i] == -1) |
4555 s->coded_score[i]= INT_MAX/256; | |
4556 } | |
4557 } | |
294 | 4558 } |
4559 | |
487 | 4560 if((s->flags&CODEC_FLAG_GRAY) && s->mb_intra){ |
4561 s->block_last_index[4]= | |
4562 s->block_last_index[5]= 0; | |
4563 s->block[4][0]= | |
1011 | 4564 s->block[5][0]= (1024 + s->c_dc_scale/2)/ s->c_dc_scale; |
487 | 4565 } |
4566 | |
1708 | 4567 //non c quantize code returns incorrect block_last_index FIXME |
4568 if(s->alternate_scan && s->dct_quantize != dct_quantize_c){ | |
3309 | 4569 for(i=0; i<mb_block_count; i++){ |
1708 | 4570 int j; |
4571 if(s->block_last_index[i]>0){ | |
4572 for(j=63; j>0; j--){ | |
4573 if(s->block[i][ s->intra_scantable.permutated[j] ]) break; | |
4574 } | |
4575 s->block_last_index[i]= j; | |
4576 } | |
4577 } | |
4578 } | |
4579 | |
294 | 4580 /* huffman encode */ |
936 | 4581 switch(s->codec_id){ //FIXME funct ptr could be slightly faster |
4582 case CODEC_ID_MPEG1VIDEO: | |
1421 | 4583 case CODEC_ID_MPEG2VIDEO: |
936 | 4584 mpeg1_encode_mb(s, s->block, motion_x, motion_y); break; |
4585 case CODEC_ID_MPEG4: | |
4586 mpeg4_encode_mb(s, s->block, motion_x, motion_y); break; | |
4587 case CODEC_ID_MSMPEG4V2: | |
4588 case CODEC_ID_MSMPEG4V3: | |
4589 case CODEC_ID_WMV1: | |
4590 msmpeg4_encode_mb(s, s->block, motion_x, motion_y); break; | |
4591 case CODEC_ID_WMV2: | |
4592 ff_wmv2_encode_mb(s, s->block, motion_x, motion_y); break; | |
2639 | 4593 #ifdef CONFIG_H261_ENCODER |
2327
5e5cf598a48b
H.261 encoder by (Maarten Daniels <maarten dot daniels at luc dot ac dot be>)
michael
parents:
2298
diff
changeset
|
4594 case CODEC_ID_H261: |
5e5cf598a48b
H.261 encoder by (Maarten Daniels <maarten dot daniels at luc dot ac dot be>)
michael
parents:
2298
diff
changeset
|
4595 ff_h261_encode_mb(s, s->block, motion_x, motion_y); break; |
2639 | 4596 #endif |
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: |
4604 mjpeg_encode_mb(s, s->block); break; | |
936 | 4605 default: |
4606 assert(0); | |
294 | 4607 } |
4608 } | |
4609 | |
4283
d6f83e2f8804
rename always_inline to av_always_inline and move to common.h
mru
parents:
4281
diff
changeset
|
4610 static av_always_inline void encode_mb(MpegEncContext *s, int motion_x, int motion_y) |
3309 | 4611 { |
4612 if (s->chroma_format == CHROMA_420) encode_mb_internal(s, motion_x, motion_y, 8, 6); | |
4613 else encode_mb_internal(s, motion_x, motion_y, 16, 8); | |
4614 } | |
4615 | |
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
|
4616 #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
|
4617 |
1368 | 4618 void ff_mpeg_flush(AVCodecContext *avctx){ |
4619 int i; | |
4620 MpegEncContext *s = avctx->priv_data; | |
2967 | 4621 |
4622 if(s==NULL || s->picture==NULL) | |
1751 | 4623 return; |
2967 | 4624 |
1368 | 4625 for(i=0; i<MAX_PICTURE_COUNT; i++){ |
4626 if(s->picture[i].data[0] && ( s->picture[i].type == FF_BUFFER_TYPE_INTERNAL | |
4627 || s->picture[i].type == FF_BUFFER_TYPE_USER)) | |
4628 avctx->release_buffer(avctx, (AVFrame*)&s->picture[i]); | |
4629 } | |
1601 | 4630 s->current_picture_ptr = s->last_picture_ptr = s->next_picture_ptr = NULL; |
2967 | 4631 |
2380 | 4632 s->mb_x= s->mb_y= 0; |
2967 | 4633 |
1395 | 4634 s->parse_context.state= -1; |
4635 s->parse_context.frame_start_found= 0; | |
4636 s->parse_context.overread= 0; | |
4637 s->parse_context.overread_index= 0; | |
4638 s->parse_context.index= 0; | |
4639 s->parse_context.last_index= 0; | |
1851 | 4640 s->bitstream_buffer_size=0; |
4346 | 4641 s->pp_time=0; |
1368 | 4642 } |
4643 | |
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
|
4644 #ifdef CONFIG_ENCODERS |
1064 | 4645 void ff_copy_bits(PutBitContext *pb, uint8_t *src, int length) |
294 | 4646 { |
1810 | 4647 const uint16_t *srcw= (uint16_t*)src; |
1799 | 4648 int words= length>>4; |
326 | 4649 int bits= length&15; |
4650 int i; | |
4651 | |
456 | 4652 if(length==0) return; |
2967 | 4653 |
1803 | 4654 if(words < 16){ |
4655 for(i=0; i<words; i++) put_bits(pb, 16, be2me_16(srcw[i])); | |
4656 }else if(put_bits_count(pb)&7){ | |
4657 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
|
4658 }else{ |
1803 | 4659 for(i=0; put_bits_count(pb)&31; i++) |
4660 put_bits(pb, 8, src[i]); | |
1799 | 4661 flush_put_bits(pb); |
1803 | 4662 memcpy(pbBufPtr(pb), src+i, 2*words-i); |
4663 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
|
4664 } |
2967 | 4665 |
1803 | 4666 put_bits(pb, bits, be2me_16(srcw[words])>>(16-bits)); |
0 | 4667 } |
4668 | |
456 | 4669 static inline void copy_context_before_encode(MpegEncContext *d, MpegEncContext *s, int type){ |
326 | 4670 int i; |
4671 | |
4672 memcpy(d->last_mv, s->last_mv, 2*2*2*sizeof(int)); //FIXME is memcpy faster then a loop? | |
4673 | |
4674 /* mpeg1 */ | |
1160 | 4675 d->mb_skip_run= s->mb_skip_run; |
326 | 4676 for(i=0; i<3; i++) |
4677 d->last_dc[i]= s->last_dc[i]; | |
2967 | 4678 |
326 | 4679 /* statistics */ |
4680 d->mv_bits= s->mv_bits; | |
4681 d->i_tex_bits= s->i_tex_bits; | |
4682 d->p_tex_bits= s->p_tex_bits; | |
4683 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
|
4684 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
|
4685 d->b_count= s->b_count; |
326 | 4686 d->skip_count= s->skip_count; |
4687 d->misc_bits= s->misc_bits; | |
329 | 4688 d->last_bits= 0; |
327 | 4689 |
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
|
4690 d->mb_skipped= 0; |
912 | 4691 d->qscale= s->qscale; |
1616 | 4692 d->dquant= s->dquant; |
326 | 4693 } |
4694 | |
456 | 4695 static inline void copy_context_after_encode(MpegEncContext *d, MpegEncContext *s, int type){ |
326 | 4696 int i; |
4697 | |
2967 | 4698 memcpy(d->mv, s->mv, 2*4*2*sizeof(int)); |
326 | 4699 memcpy(d->last_mv, s->last_mv, 2*2*2*sizeof(int)); //FIXME is memcpy faster then a loop? |
2967 | 4700 |
326 | 4701 /* mpeg1 */ |
1160 | 4702 d->mb_skip_run= s->mb_skip_run; |
326 | 4703 for(i=0; i<3; i++) |
4704 d->last_dc[i]= s->last_dc[i]; | |
2967 | 4705 |
326 | 4706 /* statistics */ |
4707 d->mv_bits= s->mv_bits; | |
4708 d->i_tex_bits= s->i_tex_bits; | |
4709 d->p_tex_bits= s->p_tex_bits; | |
4710 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
|
4711 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
|
4712 d->b_count= s->b_count; |
326 | 4713 d->skip_count= s->skip_count; |
4714 d->misc_bits= s->misc_bits; | |
4715 | |
4716 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
|
4717 d->mb_skipped= s->mb_skipped; |
326 | 4718 d->mv_type= s->mv_type; |
4719 d->mv_dir= s->mv_dir; | |
4720 d->pb= s->pb; | |
456 | 4721 if(s->data_partitioning){ |
4722 d->pb2= s->pb2; | |
4723 d->tex_pb= s->tex_pb; | |
4724 } | |
326 | 4725 d->block= s->block; |
3309 | 4726 for(i=0; i<8; i++) |
326 | 4727 d->block_last_index[i]= s->block_last_index[i]; |
755 | 4728 d->interlaced_dct= s->interlaced_dct; |
912 | 4729 d->qscale= s->qscale; |
326 | 4730 } |
4731 | |
2967 | 4732 static inline void encode_mb_hq(MpegEncContext *s, MpegEncContext *backup, MpegEncContext *best, int type, |
456 | 4733 PutBitContext pb[2], PutBitContext pb2[2], PutBitContext tex_pb[2], |
4734 int *dmin, int *next_block, int motion_x, int motion_y) | |
4735 { | |
1389 | 4736 int score; |
4737 uint8_t *dest_backup[3]; | |
2967 | 4738 |
456 | 4739 copy_context_before_encode(s, backup, type); |
4740 | |
4741 s->block= s->blocks[*next_block]; | |
4742 s->pb= pb[*next_block]; | |
4743 if(s->data_partitioning){ | |
4744 s->pb2 = pb2 [*next_block]; | |
4745 s->tex_pb= tex_pb[*next_block]; | |
4746 } | |
2967 | 4747 |
1389 | 4748 if(*next_block){ |
4749 memcpy(dest_backup, s->dest, sizeof(s->dest)); | |
1799 | 4750 s->dest[0] = s->rd_scratchpad; |
4751 s->dest[1] = s->rd_scratchpad + 16*s->linesize; | |
4752 s->dest[2] = s->rd_scratchpad + 16*s->linesize + 8; | |
4753 assert(s->linesize >= 32); //FIXME | |
1389 | 4754 } |
456 | 4755 |
4756 encode_mb(s, motion_x, motion_y); | |
2967 | 4757 |
1786 | 4758 score= put_bits_count(&s->pb); |
456 | 4759 if(s->data_partitioning){ |
1786 | 4760 score+= put_bits_count(&s->pb2); |
4761 score+= put_bits_count(&s->tex_pb); | |
456 | 4762 } |
2967 | 4763 |
1389 | 4764 if(s->avctx->mb_decision == FF_MB_DECISION_RD){ |
4765 MPV_decode_mb(s, s->block); | |
4766 | |
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
|
4767 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
|
4768 score += sse_mb(s) << FF_LAMBDA_SHIFT; |
1389 | 4769 } |
2967 | 4770 |
1389 | 4771 if(*next_block){ |
4772 memcpy(s->dest, dest_backup, sizeof(s->dest)); | |
4773 } | |
4774 | |
4775 if(score<*dmin){ | |
4776 *dmin= score; | |
456 | 4777 *next_block^=1; |
4778 | |
4779 copy_context_after_encode(best, s, type); | |
4780 } | |
4781 } | |
2967 | 4782 |
1389 | 4783 static int sse(MpegEncContext *s, uint8_t *src1, uint8_t *src2, int w, int h, int stride){ |
4179 | 4784 uint32_t *sq = ff_squareTbl + 256; |
909
8ae1e4c24e91
new PSNR code (now works with chroma, b frames, ...)
michaelni
parents:
903
diff
changeset
|
4785 int acc=0; |
8ae1e4c24e91
new PSNR code (now works with chroma, b frames, ...)
michaelni
parents:
903
diff
changeset
|
4786 int x,y; |
2967 | 4787 |
4788 if(w==16 && h==16) | |
1708 | 4789 return s->dsp.sse[0](NULL, src1, src2, stride, 16); |
936 | 4790 else if(w==8 && h==8) |
1708 | 4791 return s->dsp.sse[1](NULL, src1, src2, stride, 8); |
2967 | 4792 |
909
8ae1e4c24e91
new PSNR code (now works with chroma, b frames, ...)
michaelni
parents:
903
diff
changeset
|
4793 for(y=0; y<h; y++){ |
8ae1e4c24e91
new PSNR code (now works with chroma, b frames, ...)
michaelni
parents:
903
diff
changeset
|
4794 for(x=0; x<w; x++){ |
8ae1e4c24e91
new PSNR code (now works with chroma, b frames, ...)
michaelni
parents:
903
diff
changeset
|
4795 acc+= sq[src1[x + y*stride] - src2[x + y*stride]]; |
2967 | 4796 } |
4797 } | |
4798 | |
936 | 4799 assert(acc>=0); |
2967 | 4800 |
909
8ae1e4c24e91
new PSNR code (now works with chroma, b frames, ...)
michaelni
parents:
903
diff
changeset
|
4801 return acc; |
8ae1e4c24e91
new PSNR code (now works with chroma, b frames, ...)
michaelni
parents:
903
diff
changeset
|
4802 } |
326 | 4803 |
1389 | 4804 static int sse_mb(MpegEncContext *s){ |
4805 int w= 16; | |
4806 int h= 16; | |
4807 | |
4808 if(s->mb_x*16 + 16 > s->width ) w= s->width - s->mb_x*16; | |
4809 if(s->mb_y*16 + 16 > s->height) h= s->height- s->mb_y*16; | |
4810 | |
4811 if(w==16 && h==16) | |
2065
9e4bebc39ade
noise preserving sum of squares comparission function
michael
parents:
2063
diff
changeset
|
4812 if(s->avctx->mb_cmp == FF_CMP_NSSE){ |
2066 | 4813 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) |
4814 +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) | |
4815 +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
|
4816 }else{ |
1708 | 4817 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) |
4818 +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) | |
4819 +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
|
4820 } |
1389 | 4821 else |
4822 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) | |
4823 +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) | |
4824 +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); | |
4825 } | |
4826 | |
1799 | 4827 static int pre_estimate_motion_thread(AVCodecContext *c, void *arg){ |
4828 MpegEncContext *s= arg; | |
4829 | |
2967 | 4830 |
1799 | 4831 s->me.pre_pass=1; |
4832 s->me.dia_size= s->avctx->pre_dia_size; | |
4833 s->first_slice_line=1; | |
4834 for(s->mb_y= s->end_mb_y-1; s->mb_y >= s->start_mb_y; s->mb_y--) { | |
4835 for(s->mb_x=s->mb_width-1; s->mb_x >=0 ;s->mb_x--) { | |
4836 ff_pre_estimate_p_frame_motion(s, s->mb_x, s->mb_y); | |
4837 } | |
4838 s->first_slice_line=0; | |
4839 } | |
2967 | 4840 |
1799 | 4841 s->me.pre_pass=0; |
2967 | 4842 |
1799 | 4843 return 0; |
4844 } | |
4845 | |
4846 static int estimate_motion_thread(AVCodecContext *c, void *arg){ | |
4847 MpegEncContext *s= arg; | |
4848 | |
4281
de525a2b41db
ff_check_alignment to warn the user about a missaligned stack
michael
parents:
4274
diff
changeset
|
4849 ff_check_alignment(); |
de525a2b41db
ff_check_alignment to warn the user about a missaligned stack
michael
parents:
4274
diff
changeset
|
4850 |
1799 | 4851 s->me.dia_size= s->avctx->dia_size; |
4852 s->first_slice_line=1; | |
4853 for(s->mb_y= s->start_mb_y; s->mb_y < s->end_mb_y; s->mb_y++) { | |
4854 s->mb_x=0; //for block init below | |
4855 ff_init_block_index(s); | |
4856 for(s->mb_x=0; s->mb_x < s->mb_width; s->mb_x++) { | |
4857 s->block_index[0]+=2; | |
4858 s->block_index[1]+=2; | |
4859 s->block_index[2]+=2; | |
4860 s->block_index[3]+=2; | |
2967 | 4861 |
1799 | 4862 /* compute motion vector & mb_type and store in context */ |
4863 if(s->pict_type==B_TYPE) | |
4864 ff_estimate_b_frame_motion(s, s->mb_x, s->mb_y); | |
4865 else | |
4866 ff_estimate_p_frame_motion(s, s->mb_x, s->mb_y); | |
4867 } | |
4868 s->first_slice_line=0; | |
4869 } | |
4870 return 0; | |
4871 } | |
4872 | |
1804
cc0a15943a87
multithreaded spatial complexity calculation for i frames
michael
parents:
1803
diff
changeset
|
4873 static int mb_var_thread(AVCodecContext *c, void *arg){ |
cc0a15943a87
multithreaded spatial complexity calculation for i frames
michael
parents:
1803
diff
changeset
|
4874 MpegEncContext *s= arg; |
cc0a15943a87
multithreaded spatial complexity calculation for i frames
michael
parents:
1803
diff
changeset
|
4875 int mb_x, mb_y; |
cc0a15943a87
multithreaded spatial complexity calculation for i frames
michael
parents:
1803
diff
changeset
|
4876 |
4281
de525a2b41db
ff_check_alignment to warn the user about a missaligned stack
michael
parents:
4274
diff
changeset
|
4877 ff_check_alignment(); |
de525a2b41db
ff_check_alignment to warn the user about a missaligned stack
michael
parents:
4274
diff
changeset
|
4878 |
1804
cc0a15943a87
multithreaded spatial complexity calculation for i frames
michael
parents:
1803
diff
changeset
|
4879 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
|
4880 for(mb_x=0; mb_x < s->mb_width; mb_x++) { |
cc0a15943a87
multithreaded spatial complexity calculation for i frames
michael
parents:
1803
diff
changeset
|
4881 int xx = mb_x * 16; |
cc0a15943a87
multithreaded spatial complexity calculation for i frames
michael
parents:
1803
diff
changeset
|
4882 int yy = mb_y * 16; |
cc0a15943a87
multithreaded spatial complexity calculation for i frames
michael
parents:
1803
diff
changeset
|
4883 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
|
4884 int varc; |
cc0a15943a87
multithreaded spatial complexity calculation for i frames
michael
parents:
1803
diff
changeset
|
4885 int sum = s->dsp.pix_sum(pix, s->linesize); |
2967 | 4886 |
1804
cc0a15943a87
multithreaded spatial complexity calculation for i frames
michael
parents:
1803
diff
changeset
|
4887 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
|
4888 |
cc0a15943a87
multithreaded spatial complexity calculation for i frames
michael
parents:
1803
diff
changeset
|
4889 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
|
4890 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
|
4891 s->me.mb_var_sum_temp += varc; |
1804
cc0a15943a87
multithreaded spatial complexity calculation for i frames
michael
parents:
1803
diff
changeset
|
4892 } |
cc0a15943a87
multithreaded spatial complexity calculation for i frames
michael
parents:
1803
diff
changeset
|
4893 } |
1805
5dd5b2052f5b
mpeg4 b frame + adaptive quantization assertion failure fix
michael
parents:
1804
diff
changeset
|
4894 return 0; |
1804
cc0a15943a87
multithreaded spatial complexity calculation for i frames
michael
parents:
1803
diff
changeset
|
4895 } |
cc0a15943a87
multithreaded spatial complexity calculation for i frames
michael
parents:
1803
diff
changeset
|
4896 |
1799 | 4897 static void write_slice_end(MpegEncContext *s){ |
4898 if(s->codec_id==CODEC_ID_MPEG4){ | |
4899 if(s->partitioned_frame){ | |
4900 ff_mpeg4_merge_partitions(s); | |
4901 } | |
2967 | 4902 |
1799 | 4903 ff_mpeg4_stuffing(&s->pb); |
4904 }else if(s->out_format == FMT_MJPEG){ | |
4905 ff_mjpeg_stuffing(&s->pb); | |
4906 } | |
4907 | |
4908 align_put_bits(&s->pb); | |
4909 flush_put_bits(&s->pb); | |
2967 | 4910 |
2428
548c87c06dbb
assertion about bits statistic and minor bits stat fix
michael
parents:
2427
diff
changeset
|
4911 if((s->flags&CODEC_FLAG_PASS1) && !s->partitioned_frame) |
548c87c06dbb
assertion about bits statistic and minor bits stat fix
michael
parents:
2427
diff
changeset
|
4912 s->misc_bits+= get_bits_diff(s); |
1799 | 4913 } |
4914 | |
4915 static int encode_thread(AVCodecContext *c, void *arg){ | |
4916 MpegEncContext *s= arg; | |
766 | 4917 int mb_x, mb_y, pdif = 0; |
1708 | 4918 int i, j; |
326 | 4919 MpegEncContext best_s, backup_s; |
2422 | 4920 uint8_t bit_buf[2][MAX_MB_BYTES]; |
4921 uint8_t bit_buf2[2][MAX_MB_BYTES]; | |
4922 uint8_t bit_buf_tex[2][MAX_MB_BYTES]; | |
456 | 4923 PutBitContext pb[2], pb2[2], tex_pb[2]; |
1799 | 4924 //printf("%d->%d\n", s->resync_mb_y, s->end_mb_y); |
456 | 4925 |
4281
de525a2b41db
ff_check_alignment to warn the user about a missaligned stack
michael
parents:
4274
diff
changeset
|
4926 ff_check_alignment(); |
de525a2b41db
ff_check_alignment to warn the user about a missaligned stack
michael
parents:
4274
diff
changeset
|
4927 |
456 | 4928 for(i=0; i<2; i++){ |
2422 | 4929 init_put_bits(&pb [i], bit_buf [i], MAX_MB_BYTES); |
4930 init_put_bits(&pb2 [i], bit_buf2 [i], MAX_MB_BYTES); | |
4931 init_put_bits(&tex_pb[i], bit_buf_tex[i], MAX_MB_BYTES); | |
456 | 4932 } |
0 | 4933 |
1786 | 4934 s->last_bits= put_bits_count(&s->pb); |
286 | 4935 s->mv_bits=0; |
4936 s->misc_bits=0; | |
4937 s->i_tex_bits=0; | |
4938 s->p_tex_bits=0; | |
4939 s->i_count=0; | |
656
e47fa3e3f2d5
statistics for forw & back p-MBs instead of just one counter for both
michaelni
parents:
652
diff
changeset
|
4940 s->f_count=0; |
e47fa3e3f2d5
statistics for forw & back p-MBs instead of just one counter for both
michaelni
parents:
652
diff
changeset
|
4941 s->b_count=0; |
286 | 4942 s->skip_count=0; |
4943 | |
909
8ae1e4c24e91
new PSNR code (now works with chroma, b frames, ...)
michaelni
parents:
903
diff
changeset
|
4944 for(i=0; i<3; i++){ |
8ae1e4c24e91
new PSNR code (now works with chroma, b frames, ...)
michaelni
parents:
903
diff
changeset
|
4945 /* init last dc values */ |
8ae1e4c24e91
new PSNR code (now works with chroma, b frames, ...)
michaelni
parents:
903
diff
changeset
|
4946 /* note: quant matrix value (8) is implied here */ |
1992 | 4947 s->last_dc[i] = 128 << s->intra_dc_precision; |
2967 | 4948 |
2955 | 4949 s->current_picture.error[i] = 0; |
909
8ae1e4c24e91
new PSNR code (now works with chroma, b frames, ...)
michaelni
parents:
903
diff
changeset
|
4950 } |
1160 | 4951 s->mb_skip_run = 0; |
1708 | 4952 memset(s->last_mv, 0, sizeof(s->last_mv)); |
2967 | 4953 |
1051
e5a9dbf597d4
mpeg1 bframe encoding patch by (Rapha«³l LEGRAND) with some modifications by me
michaelni
parents:
1048
diff
changeset
|
4954 s->last_mv_dir = 0; |
0 | 4955 |
1353
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1344
diff
changeset
|
4956 switch(s->codec_id){ |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1344
diff
changeset
|
4957 case CODEC_ID_H263: |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1344
diff
changeset
|
4958 case CODEC_ID_H263P: |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1344
diff
changeset
|
4959 case CODEC_ID_FLV1: |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
731
diff
changeset
|
4960 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
|
4961 break; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1344
diff
changeset
|
4962 case CODEC_ID_MPEG4: |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1344
diff
changeset
|
4963 if(s->partitioned_frame) |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1344
diff
changeset
|
4964 ff_mpeg4_init_partitions(s); |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1344
diff
changeset
|
4965 break; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1344
diff
changeset
|
4966 } |
456 | 4967 |
4968 s->resync_mb_x=0; | |
2967 | 4969 s->resync_mb_y=0; |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
731
diff
changeset
|
4970 s->first_slice_line = 1; |
766 | 4971 s->ptr_lastgob = s->pb.buf; |
1799 | 4972 for(mb_y= s->start_mb_y; mb_y < s->end_mb_y; mb_y++) { |
4973 // printf("row %d at %X\n", s->mb_y, (int)s); | |
1389 | 4974 s->mb_x=0; |
4975 s->mb_y= mb_y; | |
4976 | |
1652 | 4977 ff_set_qscale(s, s->qscale); |
1389 | 4978 ff_init_block_index(s); |
2967 | 4979 |
232
b640ec5948b0
- Now the ME is done for the entire picture when enconding, the
pulento
parents:
231
diff
changeset
|
4980 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
|
4981 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
|
4982 int mb_type= s->mb_type[xy]; |
456 | 4983 // int d; |
1389 | 4984 int dmin= INT_MAX; |
1708 | 4985 int dir; |
0 | 4986 |
2422 | 4987 if(s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb)>>3) < MAX_MB_BYTES){ |
4988 av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n"); | |
4989 return -1; | |
4990 } | |
4991 if(s->data_partitioning){ | |
4992 if( s->pb2 .buf_end - s->pb2 .buf - (put_bits_count(&s-> pb2)>>3) < MAX_MB_BYTES | |
4993 || s->tex_pb.buf_end - s->tex_pb.buf - (put_bits_count(&s->tex_pb )>>3) < MAX_MB_BYTES){ | |
4994 av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n"); | |
4995 return -1; | |
4996 } | |
4997 } | |
4998 | |
232
b640ec5948b0
- Now the ME is done for the entire picture when enconding, the
pulento
parents:
231
diff
changeset
|
4999 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
|
5000 s->mb_y = mb_y; // moved into loop, can get changed by H.261 |
1389 | 5001 ff_update_block_index(s); |
456 | 5002 |
2639 | 5003 #ifdef CONFIG_H261_ENCODER |
2327
5e5cf598a48b
H.261 encoder by (Maarten Daniels <maarten dot daniels at luc dot ac dot be>)
michael
parents:
2298
diff
changeset
|
5004 if(s->codec_id == CODEC_ID_H261){ |
5e5cf598a48b
H.261 encoder by (Maarten Daniels <maarten dot daniels at luc dot ac dot be>)
michael
parents:
2298
diff
changeset
|
5005 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
|
5006 xy= s->mb_y*s->mb_stride + s->mb_x; |
2345 | 5007 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
|
5008 } |
2639 | 5009 #endif |
2327
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 |
456 | 5517 if (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: | |
5773 mjpeg_picture_header(s); | |
5774 break; | |
2639 | 5775 #ifdef CONFIG_H261_ENCODER |
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: |
5e5cf598a48b
H.261 encoder by (Maarten Daniels <maarten dot daniels at luc dot ac dot be>)
michael
parents:
2298
diff
changeset
|
5777 ff_h261_encode_picture_header(s, picture_number); |
5e5cf598a48b
H.261 encoder by (Maarten Daniels <maarten dot daniels at luc dot ac dot be>)
michael
parents:
2298
diff
changeset
|
5778 break; |
2639 | 5779 #endif |
1799 | 5780 case FMT_H263: |
2967 | 5781 if (s->codec_id == CODEC_ID_WMV2) |
1799 | 5782 ff_wmv2_encode_picture_header(s, picture_number); |
2967 | 5783 else if (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); | |
2639 | 5787 #ifdef CONFIG_RV10_ENCODER |
2967 | 5788 else if (s->codec_id == CODEC_ID_RV10) |
1799 | 5789 rv10_encode_picture_header(s, picture_number); |
2639 | 5790 #endif |
5791 #ifdef CONFIG_RV20_ENCODER | |
2967 | 5792 else if (s->codec_id == CODEC_ID_RV20) |
2380 | 5793 rv20_encode_picture_header(s, picture_number); |
2639 | 5794 #endif |
1799 | 5795 else if (s->codec_id == CODEC_ID_FLV1) |
5796 ff_flv_encode_picture_header(s, picture_number); | |
5797 else | |
5798 h263_encode_picture_header(s, picture_number); | |
5799 break; | |
5800 case FMT_MPEG1: | |
5801 mpeg1_encode_picture_header(s, picture_number); | |
5802 break; | |
5803 case FMT_H264: | |
5804 break; | |
5805 default: | |
5806 assert(0); | |
5807 } | |
5808 bits= put_bits_count(&s->pb); | |
5809 s->header_bits= bits - s->last_bits; | |
2967 | 5810 |
1799 | 5811 for(i=1; i<s->avctx->thread_count; i++){ |
5812 update_duplicate_context_after_me(s->thread_context[i], s); | |
5813 } | |
5814 s->avctx->execute(s->avctx, encode_thread, (void**)&(s->thread_context[0]), NULL, s->avctx->thread_count); | |
5815 for(i=1; i<s->avctx->thread_count; i++){ | |
5816 merge_context_after_encode(s, s->thread_context[i]); | |
5817 } | |
5818 emms_c(); | |
3780
6741c0e88310
return 0 from encode_picture() and estimate_qp() on success
mru
parents:
3777
diff
changeset
|
5819 return 0; |
0 | 5820 } |
5821 | |
1719 | 5822 static void denoise_dct_c(MpegEncContext *s, DCTELEM *block){ |
1597 | 5823 const int intra= s->mb_intra; |
5824 int i; | |
5825 | |
1599 | 5826 s->dct_count[intra]++; |
5827 | |
1597 | 5828 for(i=0; i<64; i++){ |
5829 int level= block[i]; | |
5830 | |
5831 if(level){ | |
5832 if(level>0){ | |
5833 s->dct_error_sum[intra][i] += level; | |
5834 level -= s->dct_offset[intra][i]; | |
5835 if(level<0) level=0; | |
5836 }else{ | |
5837 s->dct_error_sum[intra][i] -= level; | |
5838 level += s->dct_offset[intra][i]; | |
5839 if(level>0) level=0; | |
5840 } | |
5841 block[i]= level; | |
5842 } | |
5843 } | |
5844 } | |
5845 | |
2967 | 5846 static int dct_quantize_trellis_c(MpegEncContext *s, |
945 | 5847 DCTELEM *block, int n, |
5848 int qscale, int *overflow){ | |
5849 const int *qmat; | |
1064 | 5850 const uint8_t *scantable= s->intra_scantable.scantable; |
1718 | 5851 const uint8_t *perm_scantable= s->intra_scantable.permutated; |
945 | 5852 int max=0; |
5853 unsigned int threshold1, threshold2; | |
5854 int bias=0; | |
5855 int run_tab[65]; | |
5856 int level_tab[65]; | |
5857 int score_tab[65]; | |
1718 | 5858 int survivor[65]; |
5859 int survivor_count; | |
946 | 5860 int last_run=0; |
5861 int last_level=0; | |
5862 int last_score= 0; | |
1718 | 5863 int last_i; |
1715 | 5864 int coeff[2][64]; |
945 | 5865 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
|
5866 int qmul, qadd, start_i, last_non_zero, i, dc; |
945 | 5867 const int esc_length= s->ac_esc_length; |
5868 uint8_t * length; | |
5869 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
|
5870 const int lambda= s->lambda2 >> (FF_LAMBDA_SHIFT - 6); |
2967 | 5871 |
1092 | 5872 s->dsp.fdct (block); |
2967 | 5873 |
1597 | 5874 if(s->dct_error_sum) |
1719 | 5875 s->denoise_dct(s, block); |
945 | 5876 qmul= qscale*16; |
5877 qadd= ((qscale-1)|1)*8; | |
946 | 5878 |
945 | 5879 if (s->mb_intra) { |
5880 int q; | |
5881 if (!s->h263_aic) { | |
5882 if (n < 4) | |
5883 q = s->y_dc_scale; | |
5884 else | |
5885 q = s->c_dc_scale; | |
5886 q = q << 3; | |
5887 } else{ | |
5888 /* For AIC we skip quant/dequant of INTRADC */ | |
5889 q = 1 << 3; | |
5890 qadd=0; | |
5891 } | |
2967 | 5892 |
945 | 5893 /* note: block[0] is assumed to be positive */ |
5894 block[0] = (block[0] + (q >> 1)) / q; | |
5895 start_i = 1; | |
5896 last_non_zero = 0; | |
5897 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
|
5898 if(s->mpeg_quant || s->out_format == FMT_MPEG1) |
945 | 5899 bias= 1<<(QMAT_SHIFT-1); |
5900 length = s->intra_ac_vlc_length; | |
5901 last_length= s->intra_ac_vlc_last_length; | |
5902 } else { | |
5903 start_i = 0; | |
5904 last_non_zero = -1; | |
5905 qmat = s->q_inter_matrix[qscale]; | |
5906 length = s->inter_ac_vlc_length; | |
5907 last_length= s->inter_ac_vlc_last_length; | |
5908 } | |
1718 | 5909 last_i= start_i; |
945 | 5910 |
5911 threshold1= (1<<QMAT_SHIFT) - bias - 1; | |
5912 threshold2= (threshold1<<1); | |
946 | 5913 |
1715 | 5914 for(i=63; i>=start_i; i--) { |
5915 const int j = scantable[i]; | |
5916 int level = block[j] * qmat[j]; | |
5917 | |
5918 if(((unsigned)(level+threshold1))>threshold2){ | |
5919 last_non_zero = i; | |
5920 break; | |
5921 } | |
5922 } | |
5923 | |
5924 for(i=start_i; i<=last_non_zero; i++) { | |
945 | 5925 const int j = scantable[i]; |
1715 | 5926 int level = block[j] * qmat[j]; |
945 | 5927 |
5928 // if( bias+level >= (1<<(QMAT_SHIFT - 3)) | |
5929 // || bias-level >= (1<<(QMAT_SHIFT - 3))){ | |
5930 if(((unsigned)(level+threshold1))>threshold2){ | |
5931 if(level>0){ | |
5932 level= (bias + level)>>QMAT_SHIFT; | |
1718 | 5933 coeff[0][i]= level; |
5934 coeff[1][i]= level-1; | |
946 | 5935 // coeff[2][k]= level-2; |
945 | 5936 }else{ |
5937 level= (bias - level)>>QMAT_SHIFT; | |
1718 | 5938 coeff[0][i]= -level; |
5939 coeff[1][i]= -level+1; | |
946 | 5940 // coeff[2][k]= -level+2; |
945 | 5941 } |
1718 | 5942 coeff_count[i]= FFMIN(level, 2); |
5943 assert(coeff_count[i]); | |
945 | 5944 max |=level; |
5945 }else{ | |
1718 | 5946 coeff[0][i]= (level>>31)|1; |
5947 coeff_count[i]= 1; | |
945 | 5948 } |
5949 } | |
2967 | 5950 |
2627
bf158d23bbcc
Spelling errors patch by (Kevin Baragona | kevinmb500 gawab com)
michael
parents:
2620
diff
changeset
|
5951 *overflow= s->max_qcoeff < max; //overflow might have happened |
2967 | 5952 |
945 | 5953 if(last_non_zero < start_i){ |
5954 memset(block + start_i, 0, (64-start_i)*sizeof(DCTELEM)); | |
5955 return last_non_zero; | |
5956 } | |
5957 | |
1718 | 5958 score_tab[start_i]= 0; |
5959 survivor[0]= start_i; | |
5960 survivor_count= 1; | |
2967 | 5961 |
1718 | 5962 for(i=start_i; i<=last_non_zero; i++){ |
5963 int level_index, j; | |
4001 | 5964 const int dct_coeff= FFABS(block[ scantable[i] ]); |
945 | 5965 const int zero_distoration= dct_coeff*dct_coeff; |
946 | 5966 int best_score=256*256*256*120; |
945 | 5967 for(level_index=0; level_index < coeff_count[i]; level_index++){ |
5968 int distoration; | |
5969 int level= coeff[level_index][i]; | |
4001 | 5970 const int alevel= FFABS(level); |
945 | 5971 int unquant_coeff; |
2967 | 5972 |
945 | 5973 assert(level); |
5974 | |
5975 if(s->out_format == FMT_H263){ | |
1716 | 5976 unquant_coeff= alevel*qmul + qadd; |
947 | 5977 }else{ //MPEG1 |
1718 | 5978 j= s->dsp.idct_permutation[ scantable[i] ]; //FIXME optimize |
947 | 5979 if(s->mb_intra){ |
1716 | 5980 unquant_coeff = (int)( alevel * qscale * s->intra_matrix[j]) >> 3; |
947 | 5981 unquant_coeff = (unquant_coeff - 1) | 1; |
5982 }else{ | |
1716 | 5983 unquant_coeff = ((( alevel << 1) + 1) * qscale * ((int) s->inter_matrix[j])) >> 4; |
947 | 5984 unquant_coeff = (unquant_coeff - 1) | 1; |
5985 } | |
5986 unquant_coeff<<= 3; | |
5987 } | |
946 | 5988 |
1715 | 5989 distoration= (unquant_coeff - dct_coeff) * (unquant_coeff - dct_coeff) - zero_distoration; |
945 | 5990 level+=64; |
5991 if((level&(~127)) == 0){ | |
1718 | 5992 for(j=survivor_count-1; j>=0; j--){ |
5993 int run= i - survivor[j]; | |
947 | 5994 int score= distoration + length[UNI_AC_ENC_INDEX(run, level)]*lambda; |
945 | 5995 score += score_tab[i-run]; |
2967 | 5996 |
945 | 5997 if(score < best_score){ |
1718 | 5998 best_score= score; |
945 | 5999 run_tab[i+1]= run; |
6000 level_tab[i+1]= level-64; | |
6001 } | |
6002 } | |
6003 | |
6004 if(s->out_format == FMT_H263){ | |
1718 | 6005 for(j=survivor_count-1; j>=0; j--){ |
6006 int run= i - survivor[j]; | |
947 | 6007 int score= distoration + last_length[UNI_AC_ENC_INDEX(run, level)]*lambda; |
945 | 6008 score += score_tab[i-run]; |
946 | 6009 if(score < last_score){ |
6010 last_score= score; | |
6011 last_run= run; | |
6012 last_level= level-64; | |
6013 last_i= i+1; | |
945 | 6014 } |
6015 } | |
6016 } | |
6017 }else{ | |
6018 distoration += esc_length*lambda; | |
1718 | 6019 for(j=survivor_count-1; j>=0; j--){ |
6020 int run= i - survivor[j]; | |
945 | 6021 int score= distoration + score_tab[i-run]; |
2967 | 6022 |
945 | 6023 if(score < best_score){ |
1718 | 6024 best_score= score; |
945 | 6025 run_tab[i+1]= run; |
6026 level_tab[i+1]= level-64; | |
6027 } | |
6028 } | |
6029 | |
6030 if(s->out_format == FMT_H263){ | |
1718 | 6031 for(j=survivor_count-1; j>=0; j--){ |
6032 int run= i - survivor[j]; | |
945 | 6033 int score= distoration + score_tab[i-run]; |
946 | 6034 if(score < last_score){ |
6035 last_score= score; | |
6036 last_run= run; | |
6037 last_level= level-64; | |
6038 last_i= i+1; | |
945 | 6039 } |
6040 } | |
6041 } | |
6042 } | |
6043 } | |
2967 | 6044 |
1718 | 6045 score_tab[i+1]= best_score; |
6046 | |
946 | 6047 //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 | 6048 if(last_non_zero <= 27){ |
6049 for(; survivor_count; survivor_count--){ | |
6050 if(score_tab[ survivor[survivor_count-1] ] <= best_score) | |
6051 break; | |
6052 } | |
6053 }else{ | |
6054 for(; survivor_count; survivor_count--){ | |
6055 if(score_tab[ survivor[survivor_count-1] ] <= best_score + lambda) | |
6056 break; | |
6057 } | |
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
|
6058 } |
1718 | 6059 |
6060 survivor[ survivor_count++ ]= i+1; | |
945 | 6061 } |
946 | 6062 |
945 | 6063 if(s->out_format != FMT_H263){ |
946 | 6064 last_score= 256*256*256*120; |
1718 | 6065 for(i= survivor[0]; i<=last_non_zero + 1; i++){ |
946 | 6066 int score= score_tab[i]; |
947 | 6067 if(i) score += lambda*2; //FIXME exacter? |
6068 | |
946 | 6069 if(score < last_score){ |
6070 last_score= score; | |
6071 last_i= i; | |
6072 last_level= level_tab[i]; | |
6073 last_run= run_tab[i]; | |
6074 } | |
945 | 6075 } |
6076 } | |
1490
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1480
diff
changeset
|
6077 |
1715 | 6078 s->coded_score[n] = last_score; |
2967 | 6079 |
4001 | 6080 dc= FFABS(block[0]); |
1718 | 6081 last_non_zero= last_i - 1; |
945 | 6082 memset(block + start_i, 0, (64-start_i)*sizeof(DCTELEM)); |
2967 | 6083 |
945 | 6084 if(last_non_zero < start_i) |
6085 return last_non_zero; | |
1490
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1480
diff
changeset
|
6086 |
1480
8657d6800d15
slight quality improvement ( < +0.04 PSNR) for high bitrate videos with trellis quantization
michaelni
parents:
1471
diff
changeset
|
6087 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
|
6088 int best_level= 0; |
8657d6800d15
slight quality improvement ( < +0.04 PSNR) for high bitrate videos with trellis quantization
michaelni
parents:
1471
diff
changeset
|
6089 int best_score= dc * dc; |
2967 | 6090 |
1480
8657d6800d15
slight quality improvement ( < +0.04 PSNR) for high bitrate videos with trellis quantization
michaelni
parents:
1471
diff
changeset
|
6091 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
|
6092 int level= coeff[i][0]; |
4001 | 6093 int alevel= FFABS(level); |
1716 | 6094 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
|
6095 |
8657d6800d15
slight quality improvement ( < +0.04 PSNR) for high bitrate videos with trellis quantization
michaelni
parents:
1471
diff
changeset
|
6096 if(s->out_format == FMT_H263){ |
1716 | 6097 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
|
6098 }else{ //MPEG1 |
1716 | 6099 unquant_coeff = ((( alevel << 1) + 1) * qscale * ((int) s->inter_matrix[0])) >> 4; |
6100 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
|
6101 } |
8657d6800d15
slight quality improvement ( < +0.04 PSNR) for high bitrate videos with trellis quantization
michaelni
parents:
1471
diff
changeset
|
6102 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
|
6103 unquant_coeff<<= 3 + 3; |
8657d6800d15
slight quality improvement ( < +0.04 PSNR) for high bitrate videos with trellis quantization
michaelni
parents:
1471
diff
changeset
|
6104 |
1716 | 6105 distortion= (unquant_coeff - dc) * (unquant_coeff - dc); |
1490
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1480
diff
changeset
|
6106 level+=64; |
1716 | 6107 if((level&(~127)) == 0) score= distortion + last_length[UNI_AC_ENC_INDEX(0, level)]*lambda; |
6108 else score= distortion + esc_length*lambda; | |
1490
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1480
diff
changeset
|
6109 |
1480
8657d6800d15
slight quality improvement ( < +0.04 PSNR) for high bitrate videos with trellis quantization
michaelni
parents:
1471
diff
changeset
|
6110 if(score < best_score){ |
8657d6800d15
slight quality improvement ( < +0.04 PSNR) for high bitrate videos with trellis quantization
michaelni
parents:
1471
diff
changeset
|
6111 best_score= score; |
1490
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1480
diff
changeset
|
6112 best_level= level - 64; |
1480
8657d6800d15
slight quality improvement ( < +0.04 PSNR) for high bitrate videos with trellis quantization
michaelni
parents:
1471
diff
changeset
|
6113 } |
8657d6800d15
slight quality improvement ( < +0.04 PSNR) for high bitrate videos with trellis quantization
michaelni
parents:
1471
diff
changeset
|
6114 } |
8657d6800d15
slight quality improvement ( < +0.04 PSNR) for high bitrate videos with trellis quantization
michaelni
parents:
1471
diff
changeset
|
6115 block[0]= best_level; |
1490
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1480
diff
changeset
|
6116 s->coded_score[n] = best_score - dc*dc; |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1480
diff
changeset
|
6117 if(best_level == 0) return -1; |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1480
diff
changeset
|
6118 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
|
6119 } |
1490
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1480
diff
changeset
|
6120 |
946 | 6121 i= last_i; |
6122 assert(last_level); | |
1718 | 6123 |
6124 block[ perm_scantable[last_non_zero] ]= last_level; | |
946 | 6125 i -= last_run + 1; |
2967 | 6126 |
1718 | 6127 for(; i>start_i; i -= run_tab[i] + 1){ |
6128 block[ perm_scantable[i-1] ]= level_tab[i]; | |
945 | 6129 } |
6130 | |
6131 return last_non_zero; | |
6132 } | |
6133 | |
1777 | 6134 //#define REFINE_STATS 1 |
6135 static int16_t basis[64][64]; | |
6136 | |
6137 static void build_basis(uint8_t *perm){ | |
6138 int i, j, x, y; | |
6139 emms_c(); | |
6140 for(i=0; i<8; i++){ | |
6141 for(j=0; j<8; j++){ | |
6142 for(y=0; y<8; y++){ | |
6143 for(x=0; x<8; x++){ | |
6144 double s= 0.25*(1<<BASIS_SHIFT); | |
6145 int index= 8*i + j; | |
6146 int perm_index= perm[index]; | |
6147 if(i==0) s*= sqrt(0.5); | |
6148 if(j==0) s*= sqrt(0.5); | |
6149 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))); | |
6150 } | |
6151 } | |
6152 } | |
6153 } | |
6154 } | |
6155 | |
6156 static int dct_quantize_refine(MpegEncContext *s, //FIXME breaks denoise? | |
6157 DCTELEM *block, int16_t *weight, DCTELEM *orig, | |
6158 int n, int qscale){ | |
6159 int16_t rem[64]; | |
3089 | 6160 DECLARE_ALIGNED_16(DCTELEM, d1[64]); |
1777 | 6161 const int *qmat; |
6162 const uint8_t *scantable= s->intra_scantable.scantable; | |
6163 const uint8_t *perm_scantable= s->intra_scantable.permutated; | |
6164 // unsigned int threshold1, threshold2; | |
6165 // int bias=0; | |
6166 int run_tab[65]; | |
6167 int prev_run=0; | |
6168 int prev_level=0; | |
6169 int qmul, qadd, start_i, last_non_zero, i, dc; | |
6170 uint8_t * length; | |
6171 uint8_t * last_length; | |
6172 int lambda; | |
4416 | 6173 int rle_index, run, q = 1, sum; //q is only used when s->mb_intra is true |
1777 | 6174 #ifdef REFINE_STATS |
6175 static int count=0; | |
6176 static int after_last=0; | |
6177 static int to_zero=0; | |
6178 static int from_zero=0; | |
6179 static int raise=0; | |
6180 static int lower=0; | |
6181 static int messed_sign=0; | |
6182 #endif | |
6183 | |
6184 if(basis[0][0] == 0) | |
6185 build_basis(s->dsp.idct_permutation); | |
2967 | 6186 |
1777 | 6187 qmul= qscale*2; |
6188 qadd= (qscale-1)|1; | |
6189 if (s->mb_intra) { | |
6190 if (!s->h263_aic) { | |
6191 if (n < 4) | |
6192 q = s->y_dc_scale; | |
6193 else | |
6194 q = s->c_dc_scale; | |
6195 } else{ | |
6196 /* For AIC we skip quant/dequant of INTRADC */ | |
6197 q = 1; | |
6198 qadd=0; | |
6199 } | |
6200 q <<= RECON_SHIFT-3; | |
6201 /* note: block[0] is assumed to be positive */ | |
6202 dc= block[0]*q; | |
6203 // block[0] = (block[0] + (q >> 1)) / q; | |
6204 start_i = 1; | |
6205 qmat = s->q_intra_matrix[qscale]; | |
6206 // if(s->mpeg_quant || s->out_format == FMT_MPEG1) | |
6207 // bias= 1<<(QMAT_SHIFT-1); | |
6208 length = s->intra_ac_vlc_length; | |
6209 last_length= s->intra_ac_vlc_last_length; | |
6210 } else { | |
6211 dc= 0; | |
6212 start_i = 0; | |
6213 qmat = s->q_inter_matrix[qscale]; | |
6214 length = s->inter_ac_vlc_length; | |
6215 last_length= s->inter_ac_vlc_last_length; | |
6216 } | |
6217 last_non_zero = s->block_last_index[n]; | |
6218 | |
6219 #ifdef REFINE_STATS | |
6220 {START_TIMER | |
6221 #endif | |
1784 | 6222 dc += (1<<(RECON_SHIFT-1)); |
6223 for(i=0; i<64; i++){ | |
2627
bf158d23bbcc
Spelling errors patch by (Kevin Baragona | kevinmb500 gawab com)
michael
parents:
2620
diff
changeset
|
6224 rem[i]= dc - (orig[i]<<RECON_SHIFT); //FIXME use orig dirrectly instead of copying to rem[] |
1777 | 6225 } |
6226 #ifdef REFINE_STATS | |
6227 STOP_TIMER("memset rem[]")} | |
6228 #endif | |
6229 sum=0; | |
6230 for(i=0; i<64; i++){ | |
6231 int one= 36; | |
6232 int qns=4; | |
6233 int w; | |
6234 | |
4001 | 6235 w= FFABS(weight[i]) + qns*one; |
1777 | 6236 w= 15 + (48*qns*one + w/2)/w; // 16 .. 63 |
6237 | |
6238 weight[i] = w; | |
6239 // w=weight[i] = (63*qns + (w/2)) / w; | |
2967 | 6240 |
1777 | 6241 assert(w>0); |
6242 assert(w<(1<<6)); | |
6243 sum += w*w; | |
6244 } | |
6245 lambda= sum*(uint64_t)s->lambda2 >> (FF_LAMBDA_SHIFT - 6 + 6 + 6 + 6); | |
6246 #ifdef REFINE_STATS | |
6247 {START_TIMER | |
6248 #endif | |
6249 run=0; | |
6250 rle_index=0; | |
6251 for(i=start_i; i<=last_non_zero; i++){ | |
6252 int j= perm_scantable[i]; | |
6253 const int level= block[j]; | |
6254 int coeff; | |
2967 | 6255 |
1777 | 6256 if(level){ |
6257 if(level<0) coeff= qmul*level - qadd; | |
6258 else coeff= qmul*level + qadd; | |
6259 run_tab[rle_index++]=run; | |
6260 run=0; | |
6261 | |
1784 | 6262 s->dsp.add_8x8basis(rem, basis[j], coeff); |
1777 | 6263 }else{ |
6264 run++; | |
6265 } | |
6266 } | |
6267 #ifdef REFINE_STATS | |
6268 if(last_non_zero>0){ | |
6269 STOP_TIMER("init rem[]") | |
6270 } | |
6271 } | |
6272 | |
6273 {START_TIMER | |
6274 #endif | |
6275 for(;;){ | |
1784 | 6276 int best_score=s->dsp.try_8x8basis(rem, weight, basis[0], 0); |
1777 | 6277 int best_coeff=0; |
6278 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
|
6279 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
|
6280 #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
|
6281 {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
|
6282 #endif |
14d918d0ef42
analyze the gradient of the error surface to avoid a few checks in the quantizing noise shaper
michael
parents:
1784
diff
changeset
|
6283 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
|
6284 |
14d918d0ef42
analyze the gradient of the error surface to avoid a few checks in the quantizing noise shaper
michael
parents:
1784
diff
changeset
|
6285 if(analyze_gradient){ |
1777 | 6286 #ifdef REFINE_STATS |
6287 {START_TIMER | |
6288 #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
|
6289 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
|
6290 int w= weight[i]; |
2967 | 6291 |
1785
14d918d0ef42
analyze the gradient of the error surface to avoid a few checks in the quantizing noise shaper
michael
parents:
1784
diff
changeset
|
6292 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
|
6293 } |
14d918d0ef42
analyze the gradient of the error surface to avoid a few checks in the quantizing noise shaper
michael
parents:
1784
diff
changeset
|
6294 #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
|
6295 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
|
6296 {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
|
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 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
|
6299 #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
|
6300 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
|
6301 #endif |
14d918d0ef42
analyze the gradient of the error surface to avoid a few checks in the quantizing noise shaper
michael
parents:
1784
diff
changeset
|
6302 } |
14d918d0ef42
analyze the gradient of the error surface to avoid a few checks in the quantizing noise shaper
michael
parents:
1784
diff
changeset
|
6303 |
1777 | 6304 if(start_i){ |
6305 const int level= block[0]; | |
6306 int change, old_coeff; | |
6307 | |
6308 assert(s->mb_intra); | |
2967 | 6309 |
1777 | 6310 old_coeff= q*level; |
2967 | 6311 |
1777 | 6312 for(change=-1; change<=1; change+=2){ |
6313 int new_level= level + change; | |
6314 int score, new_coeff; | |
2967 | 6315 |
1777 | 6316 new_coeff= q*new_level; |
6317 if(new_coeff >= 2048 || new_coeff < 0) | |
6318 continue; | |
6319 | |
1784 | 6320 score= s->dsp.try_8x8basis(rem, weight, basis[0], new_coeff - old_coeff); |
1777 | 6321 if(score<best_score){ |
6322 best_score= score; | |
6323 best_coeff= 0; | |
6324 best_change= change; | |
6325 best_unquant_change= new_coeff - old_coeff; | |
6326 } | |
6327 } | |
6328 } | |
2967 | 6329 |
1777 | 6330 run=0; |
6331 rle_index=0; | |
6332 run2= run_tab[rle_index++]; | |
6333 prev_level=0; | |
6334 prev_run=0; | |
6335 | |
6336 for(i=start_i; i<64; i++){ | |
6337 int j= perm_scantable[i]; | |
6338 const int level= block[j]; | |
6339 int change, old_coeff; | |
6340 | |
6341 if(s->avctx->quantizer_noise_shaping < 3 && i > last_non_zero + 1) | |
6342 break; | |
6343 | |
6344 if(level){ | |
6345 if(level<0) old_coeff= qmul*level - qadd; | |
6346 else old_coeff= qmul*level + qadd; | |
6347 run2= run_tab[rle_index++]; //FIXME ! maybe after last | |
6348 }else{ | |
6349 old_coeff=0; | |
6350 run2--; | |
6351 assert(run2>=0 || i >= last_non_zero ); | |
6352 } | |
2967 | 6353 |
1777 | 6354 for(change=-1; change<=1; change+=2){ |
6355 int new_level= level + change; | |
6356 int score, new_coeff, unquant_change; | |
2967 | 6357 |
1777 | 6358 score=0; |
4001 | 6359 if(s->avctx->quantizer_noise_shaping < 2 && FFABS(new_level) > FFABS(level)) |
1777 | 6360 continue; |
6361 | |
6362 if(new_level){ | |
6363 if(new_level<0) new_coeff= qmul*new_level - qadd; | |
6364 else new_coeff= qmul*new_level + qadd; | |
6365 if(new_coeff >= 2048 || new_coeff <= -2048) | |
6366 continue; | |
6367 //FIXME check for overflow | |
2967 | 6368 |
1777 | 6369 if(level){ |
6370 if(level < 63 && level > -63){ | |
6371 if(i < last_non_zero) | |
6372 score += length[UNI_AC_ENC_INDEX(run, new_level+64)] | |
6373 - length[UNI_AC_ENC_INDEX(run, level+64)]; | |
6374 else | |
6375 score += last_length[UNI_AC_ENC_INDEX(run, new_level+64)] | |
6376 - last_length[UNI_AC_ENC_INDEX(run, level+64)]; | |
6377 } | |
6378 }else{ | |
4001 | 6379 assert(FFABS(new_level)==1); |
2967 | 6380 |
1785
14d918d0ef42
analyze the gradient of the error surface to avoid a few checks in the quantizing noise shaper
michael
parents:
1784
diff
changeset
|
6381 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
|
6382 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
|
6383 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
|
6384 continue; |
14d918d0ef42
analyze the gradient of the error surface to avoid a few checks in the quantizing noise shaper
michael
parents:
1784
diff
changeset
|
6385 } |
14d918d0ef42
analyze the gradient of the error surface to avoid a few checks in the quantizing noise shaper
michael
parents:
1784
diff
changeset
|
6386 |
1777 | 6387 if(i < last_non_zero){ |
6388 int next_i= i + run2 + 1; | |
6389 int next_level= block[ perm_scantable[next_i] ] + 64; | |
2967 | 6390 |
1777 | 6391 if(next_level&(~127)) |
6392 next_level= 0; | |
6393 | |
6394 if(next_i < last_non_zero) | |
6395 score += length[UNI_AC_ENC_INDEX(run, 65)] | |
6396 + length[UNI_AC_ENC_INDEX(run2, next_level)] | |
6397 - length[UNI_AC_ENC_INDEX(run + run2 + 1, next_level)]; | |
6398 else | |
6399 score += length[UNI_AC_ENC_INDEX(run, 65)] | |
6400 + last_length[UNI_AC_ENC_INDEX(run2, next_level)] | |
6401 - last_length[UNI_AC_ENC_INDEX(run + run2 + 1, next_level)]; | |
6402 }else{ | |
6403 score += last_length[UNI_AC_ENC_INDEX(run, 65)]; | |
6404 if(prev_level){ | |
6405 score += length[UNI_AC_ENC_INDEX(prev_run, prev_level)] | |
6406 - last_length[UNI_AC_ENC_INDEX(prev_run, prev_level)]; | |
6407 } | |
6408 } | |
6409 } | |
6410 }else{ | |
6411 new_coeff=0; | |
4001 | 6412 assert(FFABS(level)==1); |
1777 | 6413 |
6414 if(i < last_non_zero){ | |
6415 int next_i= i + run2 + 1; | |
6416 int next_level= block[ perm_scantable[next_i] ] + 64; | |
2967 | 6417 |
1777 | 6418 if(next_level&(~127)) |
6419 next_level= 0; | |
6420 | |
6421 if(next_i < last_non_zero) | |
6422 score += length[UNI_AC_ENC_INDEX(run + run2 + 1, next_level)] | |
6423 - 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 + run2 + 1, next_level)] | |
6427 - last_length[UNI_AC_ENC_INDEX(run2, next_level)] | |
6428 - length[UNI_AC_ENC_INDEX(run, 65)]; | |
6429 }else{ | |
6430 score += -last_length[UNI_AC_ENC_INDEX(run, 65)]; | |
6431 if(prev_level){ | |
6432 score += last_length[UNI_AC_ENC_INDEX(prev_run, prev_level)] | |
6433 - length[UNI_AC_ENC_INDEX(prev_run, prev_level)]; | |
6434 } | |
6435 } | |
6436 } | |
2967 | 6437 |
1777 | 6438 score *= lambda; |
6439 | |
6440 unquant_change= new_coeff - old_coeff; | |
6441 assert((score < 100*lambda && score > -100*lambda) || lambda==0); | |
2967 | 6442 |
1784 | 6443 score+= s->dsp.try_8x8basis(rem, weight, basis[j], unquant_change); |
1777 | 6444 if(score<best_score){ |
6445 best_score= score; | |
6446 best_coeff= i; | |
6447 best_change= change; | |
6448 best_unquant_change= unquant_change; | |
6449 } | |
6450 } | |
6451 if(level){ | |
6452 prev_level= level + 64; | |
6453 if(prev_level&(~127)) | |
6454 prev_level= 0; | |
6455 prev_run= run; | |
6456 run=0; | |
6457 }else{ | |
6458 run++; | |
6459 } | |
6460 } | |
6461 #ifdef REFINE_STATS | |
6462 STOP_TIMER("iterative step")} | |
6463 #endif | |
6464 | |
6465 if(best_change){ | |
6466 int j= perm_scantable[ best_coeff ]; | |
2967 | 6467 |
1777 | 6468 block[j] += best_change; |
2967 | 6469 |
1777 | 6470 if(best_coeff > last_non_zero){ |
6471 last_non_zero= best_coeff; | |
6472 assert(block[j]); | |
6473 #ifdef REFINE_STATS | |
6474 after_last++; | |
6475 #endif | |
6476 }else{ | |
6477 #ifdef REFINE_STATS | |
6478 if(block[j]){ | |
6479 if(block[j] - best_change){ | |
4001 | 6480 if(FFABS(block[j]) > FFABS(block[j] - best_change)){ |
1777 | 6481 raise++; |
6482 }else{ | |
6483 lower++; | |
6484 } | |
6485 }else{ | |
6486 from_zero++; | |
6487 } | |
6488 }else{ | |
6489 to_zero++; | |
6490 } | |
6491 #endif | |
6492 for(; last_non_zero>=start_i; last_non_zero--){ | |
6493 if(block[perm_scantable[last_non_zero]]) | |
6494 break; | |
6495 } | |
6496 } | |
6497 #ifdef REFINE_STATS | |
6498 count++; | |
6499 if(256*256*256*64 % count == 0){ | |
6500 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); | |
6501 } | |
6502 #endif | |
6503 run=0; | |
6504 rle_index=0; | |
6505 for(i=start_i; i<=last_non_zero; i++){ | |
6506 int j= perm_scantable[i]; | |
6507 const int level= block[j]; | |
2967 | 6508 |
1777 | 6509 if(level){ |
6510 run_tab[rle_index++]=run; | |
6511 run=0; | |
6512 }else{ | |
6513 run++; | |
6514 } | |
6515 } | |
2967 | 6516 |
1784 | 6517 s->dsp.add_8x8basis(rem, basis[j], best_unquant_change); |
1777 | 6518 }else{ |
6519 break; | |
6520 } | |
6521 } | |
6522 #ifdef REFINE_STATS | |
6523 if(last_non_zero>0){ | |
6524 STOP_TIMER("iterative search") | |
6525 } | |
6526 } | |
6527 #endif | |
6528 | |
6529 return last_non_zero; | |
6530 } | |
6531 | |
2967 | 6532 static int dct_quantize_c(MpegEncContext *s, |
0 | 6533 DCTELEM *block, int n, |
344 | 6534 int qscale, int *overflow) |
0 | 6535 { |
1715 | 6536 int i, j, level, last_non_zero, q, start_i; |
0 | 6537 const int *qmat; |
1064 | 6538 const uint8_t *scantable= s->intra_scantable.scantable; |
344 | 6539 int bias; |
6540 int max=0; | |
6541 unsigned int threshold1, threshold2; | |
828
ace3ccd18dd2
Altivec Patch (Mark III) by (Dieter Shirley <dieters at schemasoft dot com>)
michaelni
parents:
815
diff
changeset
|
6542 |
1092 | 6543 s->dsp.fdct (block); |
0 | 6544 |
1597 | 6545 if(s->dct_error_sum) |
1719 | 6546 s->denoise_dct(s, block); |
1597 | 6547 |
0 | 6548 if (s->mb_intra) { |
350
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
347
diff
changeset
|
6549 if (!s->h263_aic) { |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
347
diff
changeset
|
6550 if (n < 4) |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
347
diff
changeset
|
6551 q = s->y_dc_scale; |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
347
diff
changeset
|
6552 else |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
347
diff
changeset
|
6553 q = s->c_dc_scale; |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
347
diff
changeset
|
6554 q = q << 3; |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
347
diff
changeset
|
6555 } else |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
347
diff
changeset
|
6556 /* 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
|
6557 q = 1 << 3; |
2967 | 6558 |
0 | 6559 /* note: block[0] is assumed to be positive */ |
6560 block[0] = (block[0] + (q >> 1)) / q; | |
1715 | 6561 start_i = 1; |
0 | 6562 last_non_zero = 0; |
344 | 6563 qmat = s->q_intra_matrix[qscale]; |
635 | 6564 bias= s->intra_quant_bias<<(QMAT_SHIFT - QUANT_BIAS_SHIFT); |
0 | 6565 } else { |
1715 | 6566 start_i = 0; |
0 | 6567 last_non_zero = -1; |
344 | 6568 qmat = s->q_inter_matrix[qscale]; |
635 | 6569 bias= s->inter_quant_bias<<(QMAT_SHIFT - QUANT_BIAS_SHIFT); |
0 | 6570 } |
635 | 6571 threshold1= (1<<QMAT_SHIFT) - bias - 1; |
6572 threshold2= (threshold1<<1); | |
1715 | 6573 for(i=63;i>=start_i;i--) { |
764 | 6574 j = scantable[i]; |
1715 | 6575 level = block[j] * qmat[j]; |
6576 | |
6577 if(((unsigned)(level+threshold1))>threshold2){ | |
6578 last_non_zero = i; | |
6579 break; | |
6580 }else{ | |
6581 block[j]=0; | |
6582 } | |
6583 } | |
6584 for(i=start_i; i<=last_non_zero; i++) { | |
6585 j = scantable[i]; | |
6586 level = block[j] * qmat[j]; | |
344 | 6587 |
1215 | 6588 // if( bias+level >= (1<<QMAT_SHIFT) |
6589 // || bias-level >= (1<<QMAT_SHIFT)){ | |
344 | 6590 if(((unsigned)(level+threshold1))>threshold2){ |
6591 if(level>0){ | |
635 | 6592 level= (bias + level)>>QMAT_SHIFT; |
344 | 6593 block[j]= level; |
6594 }else{ | |
635 | 6595 level= (bias - level)>>QMAT_SHIFT; |
344 | 6596 block[j]= -level; |
0 | 6597 } |
344 | 6598 max |=level; |
6599 }else{ | |
6600 block[j]=0; | |
0 | 6601 } |
6602 } | |
2627
bf158d23bbcc
Spelling errors patch by (Kevin Baragona | kevinmb500 gawab com)
michael
parents:
2620
diff
changeset
|
6603 *overflow= s->max_qcoeff < max; //overflow might have happened |
2967 | 6604 |
764 | 6605 /* we need this permutation so that we correct the IDCT, we only permute the !=0 elements */ |
1092 | 6606 if (s->dsp.idct_permutation_type != FF_NO_IDCT_PERM) |
2979 | 6607 ff_block_permute(block, s->dsp.idct_permutation, scantable, last_non_zero); |
764 | 6608 |
0 | 6609 return last_non_zero; |
6610 } | |
6611 | |
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
|
6612 #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
|
6613 |
2967 | 6614 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
|
6615 DCTELEM *block, int n, int qscale) |
0 | 6616 { |
200 | 6617 int i, level, nCoeffs; |
1064 | 6618 const uint16_t *quant_matrix; |
0 | 6619 |
706
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
6620 nCoeffs= s->block_last_index[n]; |
2967 | 6621 |
6622 if (n < 4) | |
1689 | 6623 block[0] = block[0] * s->y_dc_scale; |
6624 else | |
6625 block[0] = block[0] * s->c_dc_scale; | |
6626 /* XXX: only mpeg1 */ | |
6627 quant_matrix = s->intra_matrix; | |
6628 for(i=1;i<=nCoeffs;i++) { | |
6629 int j= s->intra_scantable.permutated[i]; | |
6630 level = block[j]; | |
6631 if (level) { | |
6632 if (level < 0) { | |
6633 level = -level; | |
6634 level = (int)(level * qscale * quant_matrix[j]) >> 3; | |
6635 level = (level - 1) | 1; | |
6636 level = -level; | |
6637 } else { | |
6638 level = (int)(level * qscale * quant_matrix[j]) >> 3; | |
6639 level = (level - 1) | 1; | |
0 | 6640 } |
1689 | 6641 block[j] = level; |
0 | 6642 } |
6643 } | |
6644 } | |
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
|
6645 |
2967 | 6646 static void dct_unquantize_mpeg1_inter_c(MpegEncContext *s, |
1689 | 6647 DCTELEM *block, int n, int qscale) |
6648 { | |
6649 int i, level, nCoeffs; | |
6650 const uint16_t *quant_matrix; | |
6651 | |
6652 nCoeffs= s->block_last_index[n]; | |
2967 | 6653 |
1689 | 6654 quant_matrix = s->inter_matrix; |
6655 for(i=0; i<=nCoeffs; i++) { | |
6656 int j= s->intra_scantable.permutated[i]; | |
6657 level = block[j]; | |
6658 if (level) { | |
6659 if (level < 0) { | |
6660 level = -level; | |
6661 level = (((level << 1) + 1) * qscale * | |
6662 ((int) (quant_matrix[j]))) >> 4; | |
6663 level = (level - 1) | 1; | |
6664 level = -level; | |
6665 } else { | |
6666 level = (((level << 1) + 1) * qscale * | |
6667 ((int) (quant_matrix[j]))) >> 4; | |
6668 level = (level - 1) | 1; | |
6669 } | |
6670 block[j] = level; | |
6671 } | |
6672 } | |
6673 } | |
6674 | |
2967 | 6675 static void dct_unquantize_mpeg2_intra_c(MpegEncContext *s, |
325 | 6676 DCTELEM *block, int n, int qscale) |
6677 { | |
6678 int i, level, nCoeffs; | |
1064 | 6679 const uint16_t *quant_matrix; |
325 | 6680 |
706
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
6681 if(s->alternate_scan) nCoeffs= 63; |
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
6682 else nCoeffs= s->block_last_index[n]; |
2967 | 6683 |
6684 if (n < 4) | |
1689 | 6685 block[0] = block[0] * s->y_dc_scale; |
6686 else | |
6687 block[0] = block[0] * s->c_dc_scale; | |
6688 quant_matrix = s->intra_matrix; | |
6689 for(i=1;i<=nCoeffs;i++) { | |
6690 int j= s->intra_scantable.permutated[i]; | |
6691 level = block[j]; | |
6692 if (level) { | |
6693 if (level < 0) { | |
6694 level = -level; | |
6695 level = (int)(level * qscale * quant_matrix[j]) >> 3; | |
6696 level = -level; | |
6697 } else { | |
6698 level = (int)(level * qscale * quant_matrix[j]) >> 3; | |
6699 } | |
6700 block[j] = level; | |
6701 } | |
6702 } | |
6703 } | |
6704 | |
3281
7fac25904a8b
missmatch control for mpeg2 intra dequantization if bitexact=1
michael
parents:
3268
diff
changeset
|
6705 static void dct_unquantize_mpeg2_intra_bitexact(MpegEncContext *s, |
7fac25904a8b
missmatch control for mpeg2 intra dequantization if bitexact=1
michael
parents:
3268
diff
changeset
|
6706 DCTELEM *block, int n, int qscale) |
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 int i, level, nCoeffs; |
7fac25904a8b
missmatch control for mpeg2 intra dequantization if bitexact=1
michael
parents:
3268
diff
changeset
|
6709 const uint16_t *quant_matrix; |
7fac25904a8b
missmatch control for mpeg2 intra dequantization if bitexact=1
michael
parents:
3268
diff
changeset
|
6710 int sum=-1; |
7fac25904a8b
missmatch control for mpeg2 intra dequantization if bitexact=1
michael
parents:
3268
diff
changeset
|
6711 |
7fac25904a8b
missmatch control for mpeg2 intra dequantization if bitexact=1
michael
parents:
3268
diff
changeset
|
6712 if(s->alternate_scan) nCoeffs= 63; |
7fac25904a8b
missmatch control for mpeg2 intra dequantization if bitexact=1
michael
parents:
3268
diff
changeset
|
6713 else nCoeffs= s->block_last_index[n]; |
7fac25904a8b
missmatch control for mpeg2 intra dequantization if bitexact=1
michael
parents:
3268
diff
changeset
|
6714 |
7fac25904a8b
missmatch control for mpeg2 intra dequantization if bitexact=1
michael
parents:
3268
diff
changeset
|
6715 if (n < 4) |
7fac25904a8b
missmatch control for mpeg2 intra dequantization if bitexact=1
michael
parents:
3268
diff
changeset
|
6716 block[0] = block[0] * s->y_dc_scale; |
7fac25904a8b
missmatch control for mpeg2 intra dequantization if bitexact=1
michael
parents:
3268
diff
changeset
|
6717 else |
7fac25904a8b
missmatch control for mpeg2 intra dequantization if bitexact=1
michael
parents:
3268
diff
changeset
|
6718 block[0] = block[0] * s->c_dc_scale; |
7fac25904a8b
missmatch control for mpeg2 intra dequantization if bitexact=1
michael
parents:
3268
diff
changeset
|
6719 quant_matrix = s->intra_matrix; |
7fac25904a8b
missmatch control for mpeg2 intra dequantization if bitexact=1
michael
parents:
3268
diff
changeset
|
6720 for(i=1;i<=nCoeffs;i++) { |
7fac25904a8b
missmatch control for mpeg2 intra dequantization if bitexact=1
michael
parents:
3268
diff
changeset
|
6721 int j= s->intra_scantable.permutated[i]; |
7fac25904a8b
missmatch control for mpeg2 intra dequantization if bitexact=1
michael
parents:
3268
diff
changeset
|
6722 level = block[j]; |
7fac25904a8b
missmatch control for mpeg2 intra dequantization if bitexact=1
michael
parents:
3268
diff
changeset
|
6723 if (level) { |
7fac25904a8b
missmatch control for mpeg2 intra dequantization if bitexact=1
michael
parents:
3268
diff
changeset
|
6724 if (level < 0) { |
7fac25904a8b
missmatch control for mpeg2 intra dequantization if bitexact=1
michael
parents:
3268
diff
changeset
|
6725 level = -level; |
7fac25904a8b
missmatch control for mpeg2 intra dequantization if bitexact=1
michael
parents:
3268
diff
changeset
|
6726 level = (int)(level * qscale * quant_matrix[j]) >> 3; |
7fac25904a8b
missmatch control for mpeg2 intra dequantization if bitexact=1
michael
parents:
3268
diff
changeset
|
6727 level = -level; |
7fac25904a8b
missmatch control for mpeg2 intra dequantization if bitexact=1
michael
parents:
3268
diff
changeset
|
6728 } else { |
7fac25904a8b
missmatch control for mpeg2 intra dequantization if bitexact=1
michael
parents:
3268
diff
changeset
|
6729 level = (int)(level * qscale * quant_matrix[j]) >> 3; |
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[j] = level; |
7fac25904a8b
missmatch control for mpeg2 intra dequantization if bitexact=1
michael
parents:
3268
diff
changeset
|
6732 sum+=level; |
7fac25904a8b
missmatch control for mpeg2 intra dequantization if bitexact=1
michael
parents:
3268
diff
changeset
|
6733 } |
7fac25904a8b
missmatch control for mpeg2 intra dequantization if bitexact=1
michael
parents:
3268
diff
changeset
|
6734 } |
7fac25904a8b
missmatch control for mpeg2 intra dequantization if bitexact=1
michael
parents:
3268
diff
changeset
|
6735 block[63]^=sum&1; |
7fac25904a8b
missmatch control for mpeg2 intra dequantization if bitexact=1
michael
parents:
3268
diff
changeset
|
6736 } |
7fac25904a8b
missmatch control for mpeg2 intra dequantization if bitexact=1
michael
parents:
3268
diff
changeset
|
6737 |
2967 | 6738 static void dct_unquantize_mpeg2_inter_c(MpegEncContext *s, |
1689 | 6739 DCTELEM *block, int n, int qscale) |
6740 { | |
6741 int i, level, nCoeffs; | |
6742 const uint16_t *quant_matrix; | |
6743 int sum=-1; | |
6744 | |
6745 if(s->alternate_scan) nCoeffs= 63; | |
6746 else nCoeffs= s->block_last_index[n]; | |
2967 | 6747 |
1689 | 6748 quant_matrix = s->inter_matrix; |
6749 for(i=0; i<=nCoeffs; i++) { | |
6750 int j= s->intra_scantable.permutated[i]; | |
6751 level = block[j]; | |
6752 if (level) { | |
6753 if (level < 0) { | |
6754 level = -level; | |
6755 level = (((level << 1) + 1) * qscale * | |
6756 ((int) (quant_matrix[j]))) >> 4; | |
6757 level = -level; | |
6758 } else { | |
6759 level = (((level << 1) + 1) * qscale * | |
6760 ((int) (quant_matrix[j]))) >> 4; | |
6761 } | |
6762 block[j] = level; | |
6763 sum+=level; | |
6764 } | |
6765 } | |
6766 block[63]^=sum&1; | |
6767 } | |
6768 | |
2967 | 6769 static void dct_unquantize_h263_intra_c(MpegEncContext *s, |
1689 | 6770 DCTELEM *block, int n, int qscale) |
6771 { | |
6772 int i, level, qmul, qadd; | |
6773 int nCoeffs; | |
2967 | 6774 |
1689 | 6775 assert(s->block_last_index[n]>=0); |
2967 | 6776 |
1689 | 6777 qmul = qscale << 1; |
2967 | 6778 |
1689 | 6779 if (!s->h263_aic) { |
2967 | 6780 if (n < 4) |
325 | 6781 block[0] = block[0] * s->y_dc_scale; |
6782 else | |
6783 block[0] = block[0] * s->c_dc_scale; | |
1689 | 6784 qadd = (qscale - 1) | 1; |
6785 }else{ | |
6786 qadd = 0; | |
6787 } | |
6788 if(s->ac_pred) | |
6789 nCoeffs=63; | |
6790 else | |
6791 nCoeffs= s->inter_scantable.raster_end[ s->block_last_index[n] ]; | |
6792 | |
6793 for(i=1; i<=nCoeffs; i++) { | |
6794 level = block[i]; | |
6795 if (level) { | |
6796 if (level < 0) { | |
6797 level = level * qmul - qadd; | |
6798 } else { | |
6799 level = level * qmul + qadd; | |
325 | 6800 } |
1689 | 6801 block[i] = level; |
325 | 6802 } |
6803 } | |
6804 } | |
6805 | |
2967 | 6806 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
|
6807 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
|
6808 { |
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
|
6809 int i, level, qmul, qadd; |
200 | 6810 int nCoeffs; |
2967 | 6811 |
706
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
6812 assert(s->block_last_index[n]>=0); |
2967 | 6813 |
706
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
6814 qadd = (qscale - 1) | 1; |
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
6815 qmul = qscale << 1; |
2967 | 6816 |
1689 | 6817 nCoeffs= s->inter_scantable.raster_end[ s->block_last_index[n] ]; |
6818 | |
6819 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
|
6820 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
|
6821 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
|
6822 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
|
6823 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
|
6824 } 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
|
6825 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
|
6826 } |
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
|
6827 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
|
6828 } |
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
|
6829 } |
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
|
6830 } |
0 | 6831 |
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
|
6832 #ifdef CONFIG_ENCODERS |
0 | 6833 AVCodec h263_encoder = { |
6834 "h263", | |
6835 CODEC_TYPE_VIDEO, | |
6836 CODEC_ID_H263, | |
6837 sizeof(MpegEncContext), | |
6838 MPV_encode_init, | |
6839 MPV_encode_picture, | |
6840 MPV_encode_end, | |
2524 | 6841 .pix_fmts= (enum PixelFormat[]){PIX_FMT_YUV420P, -1}, |
0 | 6842 }; |
6843 | |
6844 AVCodec h263p_encoder = { | |
6845 "h263p", | |
6846 CODEC_TYPE_VIDEO, | |
6847 CODEC_ID_H263P, | |
6848 sizeof(MpegEncContext), | |
6849 MPV_encode_init, | |
6850 MPV_encode_picture, | |
6851 MPV_encode_end, | |
2524 | 6852 .pix_fmts= (enum PixelFormat[]){PIX_FMT_YUV420P, -1}, |
0 | 6853 }; |
6854 | |
1353
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1344
diff
changeset
|
6855 AVCodec flv_encoder = { |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1344
diff
changeset
|
6856 "flv", |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1344
diff
changeset
|
6857 CODEC_TYPE_VIDEO, |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1344
diff
changeset
|
6858 CODEC_ID_FLV1, |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1344
diff
changeset
|
6859 sizeof(MpegEncContext), |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1344
diff
changeset
|
6860 MPV_encode_init, |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1344
diff
changeset
|
6861 MPV_encode_picture, |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1344
diff
changeset
|
6862 MPV_encode_end, |
2524 | 6863 .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
|
6864 }; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1344
diff
changeset
|
6865 |
0 | 6866 AVCodec rv10_encoder = { |
6867 "rv10", | |
6868 CODEC_TYPE_VIDEO, | |
6869 CODEC_ID_RV10, | |
6870 sizeof(MpegEncContext), | |
6871 MPV_encode_init, | |
6872 MPV_encode_picture, | |
6873 MPV_encode_end, | |
2524 | 6874 .pix_fmts= (enum PixelFormat[]){PIX_FMT_YUV420P, -1}, |
0 | 6875 }; |
6876 | |
2380 | 6877 AVCodec rv20_encoder = { |
6878 "rv20", | |
6879 CODEC_TYPE_VIDEO, | |
6880 CODEC_ID_RV20, | |
6881 sizeof(MpegEncContext), | |
6882 MPV_encode_init, | |
6883 MPV_encode_picture, | |
6884 MPV_encode_end, | |
2524 | 6885 .pix_fmts= (enum PixelFormat[]){PIX_FMT_YUV420P, -1}, |
2380 | 6886 }; |
6887 | |
71 | 6888 AVCodec mpeg4_encoder = { |
6889 "mpeg4", | |
0 | 6890 CODEC_TYPE_VIDEO, |
71 | 6891 CODEC_ID_MPEG4, |
0 | 6892 sizeof(MpegEncContext), |
6893 MPV_encode_init, | |
6894 MPV_encode_picture, | |
6895 MPV_encode_end, | |
2524 | 6896 .pix_fmts= (enum PixelFormat[]){PIX_FMT_YUV420P, -1}, |
2111 | 6897 .capabilities= CODEC_CAP_DELAY, |
0 | 6898 }; |
6899 | |
307 | 6900 AVCodec msmpeg4v1_encoder = { |
6901 "msmpeg4v1", | |
0 | 6902 CODEC_TYPE_VIDEO, |
307 | 6903 CODEC_ID_MSMPEG4V1, |
0 | 6904 sizeof(MpegEncContext), |
6905 MPV_encode_init, | |
6906 MPV_encode_picture, | |
6907 MPV_encode_end, | |
2524 | 6908 .pix_fmts= (enum PixelFormat[]){PIX_FMT_YUV420P, -1}, |
0 | 6909 }; |
307 | 6910 |
6911 AVCodec msmpeg4v2_encoder = { | |
6912 "msmpeg4v2", | |
6913 CODEC_TYPE_VIDEO, | |
6914 CODEC_ID_MSMPEG4V2, | |
6915 sizeof(MpegEncContext), | |
6916 MPV_encode_init, | |
6917 MPV_encode_picture, | |
6918 MPV_encode_end, | |
2524 | 6919 .pix_fmts= (enum PixelFormat[]){PIX_FMT_YUV420P, -1}, |
307 | 6920 }; |
6921 | |
6922 AVCodec msmpeg4v3_encoder = { | |
6923 "msmpeg4", | |
6924 CODEC_TYPE_VIDEO, | |
6925 CODEC_ID_MSMPEG4V3, | |
6926 sizeof(MpegEncContext), | |
6927 MPV_encode_init, | |
6928 MPV_encode_picture, | |
6929 MPV_encode_end, | |
2524 | 6930 .pix_fmts= (enum PixelFormat[]){PIX_FMT_YUV420P, -1}, |
307 | 6931 }; |
499 | 6932 |
6933 AVCodec wmv1_encoder = { | |
6934 "wmv1", | |
6935 CODEC_TYPE_VIDEO, | |
6936 CODEC_ID_WMV1, | |
6937 sizeof(MpegEncContext), | |
6938 MPV_encode_init, | |
6939 MPV_encode_picture, | |
6940 MPV_encode_end, | |
2524 | 6941 .pix_fmts= (enum PixelFormat[]){PIX_FMT_YUV420P, -1}, |
499 | 6942 }; |
6943 | |
1042 | 6944 AVCodec mjpeg_encoder = { |
6945 "mjpeg", | |
6946 CODEC_TYPE_VIDEO, | |
6947 CODEC_ID_MJPEG, | |
6948 sizeof(MpegEncContext), | |
6949 MPV_encode_init, | |
6950 MPV_encode_picture, | |
6951 MPV_encode_end, | |
3929 | 6952 .pix_fmts= (enum PixelFormat[]){PIX_FMT_YUVJ420P, PIX_FMT_YUVJ422P, -1}, |
1042 | 6953 }; |
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
|
6954 |
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
|
6955 #endif //CONFIG_ENCODERS |