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