Mercurial > libavcodec.hg
annotate mpegvideo.c @ 4635:2ba8d13a66bc libavcodec
bitrate sanity check (fixes assertion failure)
author | michael |
---|---|
date | Thu, 08 Mar 2007 10:25:06 +0000 |
parents | 5464e5021a67 |
children | f0ce30e115ac |
rev | line source |
---|---|
0 | 1 /* |
2 * The simplest mpeg encoder (well, it was the simplest!) | |
429 | 3 * Copyright (c) 2000,2001 Fabrice Bellard. |
1739
07a484280a82
copyright year update of the files i touched and remembered, things look annoyingly unmaintained otherwise
michael
parents:
1729
diff
changeset
|
4 * Copyright (c) 2002-2004 Michael Niedermayer <michaelni@gmx.at> |
0 | 5 * |
3947
c8c591fe26f8
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
3939
diff
changeset
|
6 * This file is part of FFmpeg. |
c8c591fe26f8
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
3939
diff
changeset
|
7 * |
c8c591fe26f8
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
3939
diff
changeset
|
8 * FFmpeg is free software; you can redistribute it and/or |
429 | 9 * modify it under the terms of the GNU Lesser General Public |
10 * License as published by the Free Software Foundation; either | |
3947
c8c591fe26f8
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
3939
diff
changeset
|
11 * version 2.1 of the License, or (at your option) any later version. |
0 | 12 * |
3947
c8c591fe26f8
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
3939
diff
changeset
|
13 * FFmpeg is distributed in the hope that it will be useful, |
0 | 14 * but WITHOUT ANY WARRANTY; without even the implied warranty of |
429 | 15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
16 * Lesser General Public License for more details. | |
0 | 17 * |
429 | 18 * You should have received a copy of the GNU Lesser General Public |
3947
c8c591fe26f8
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
3939
diff
changeset
|
19 * License along with FFmpeg; if not, write to the Free Software |
3036
0b546eab515d
Update licensing information: The FSF changed postal address.
diego
parents:
3011
diff
changeset
|
20 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA |
295 | 21 * |
325 | 22 * 4MV & hq & b-frame encoding stuff by Michael Niedermayer <michaelni@gmx.at> |
0 | 23 */ |
2967 | 24 |
1106 | 25 /** |
26 * @file mpegvideo.c | |
27 * The simplest mpeg encoder (well, it was the simplest!). | |
2967 | 28 */ |
29 | |
0 | 30 #include "avcodec.h" |
31 #include "dsputil.h" | |
32 #include "mpegvideo.h" | |
1557 | 33 #include "faandct.h" |
2024
f65d87bfdd5a
some of the warning fixes by (Michael Roitzsch <mroi at users dot sourceforge dot net>)
michael
parents:
2015
diff
changeset
|
34 #include <limits.h> |
0 | 35 |
17
b69fe46fd708
Adding fastmemcpy stuff to speedup mplayer project
nickols_k
parents:
13
diff
changeset
|
36 #ifdef USE_FASTMEMCPY |
3589 | 37 #include "libvo/fastmemcpy.h" |
17
b69fe46fd708
Adding fastmemcpy stuff to speedup mplayer project
nickols_k
parents:
13
diff
changeset
|
38 #endif |
b69fe46fd708
Adding fastmemcpy stuff to speedup mplayer project
nickols_k
parents:
13
diff
changeset
|
39 |
1422
efeed6e29f9b
oooooops, having 2 Eterms open and doing cvs diff in one and cvs commit in the other sucks, especially if they are in different directories (MPlayer/main/libavcodec vs. ffmpeg/libavcodec)
michaelni
parents:
1421
diff
changeset
|
40 //#undef NDEBUG |
efeed6e29f9b
oooooops, having 2 Eterms open and doing cvs diff in one and cvs commit in the other sucks, especially if they are in different directories (MPlayer/main/libavcodec vs. ffmpeg/libavcodec)
michaelni
parents:
1421
diff
changeset
|
41 //#include <assert.h> |
706
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
42 |
1070
6da5ae9ee199
more #ifdef CONFIG_ENCODERS patch by (Wolfgang Hesseler <qv at multimediaware dot com>) with modifications by me (s/WOLFGANG/CONFIG_ENCODERS/ and some other fixes)
michaelni
parents:
1064
diff
changeset
|
43 #ifdef CONFIG_ENCODERS |
3766 | 44 static int encode_picture(MpegEncContext *s, int picture_number); |
1070
6da5ae9ee199
more #ifdef CONFIG_ENCODERS patch by (Wolfgang Hesseler <qv at multimediaware dot com>) with modifications by me (s/WOLFGANG/CONFIG_ENCODERS/ and some other fixes)
michaelni
parents:
1064
diff
changeset
|
45 #endif //CONFIG_ENCODERS |
2967 | 46 static void dct_unquantize_mpeg1_intra_c(MpegEncContext *s, |
1689 | 47 DCTELEM *block, int n, int qscale); |
2967 | 48 static void dct_unquantize_mpeg1_inter_c(MpegEncContext *s, |
1689 | 49 DCTELEM *block, int n, int qscale); |
50 static void dct_unquantize_mpeg2_intra_c(MpegEncContext *s, | |
13
174ef88f619a
use block[] in structure to have it aligned on 8 bytes for mmx optimizations - dct_unquantize is always a function pointer - added specialized dct_unquantize_h263
glantau
parents:
8
diff
changeset
|
51 DCTELEM *block, int n, int qscale); |
3281
7fac25904a8b
missmatch control for mpeg2 intra dequantization if bitexact=1
michael
parents:
3268
diff
changeset
|
52 static void dct_unquantize_mpeg2_intra_bitexact(MpegEncContext *s, |
7fac25904a8b
missmatch control for mpeg2 intra dequantization if bitexact=1
michael
parents:
3268
diff
changeset
|
53 DCTELEM *block, int n, int qscale); |
1689 | 54 static void dct_unquantize_mpeg2_inter_c(MpegEncContext *s, |
325 | 55 DCTELEM *block, int n, int qscale); |
2967 | 56 static void dct_unquantize_h263_intra_c(MpegEncContext *s, |
1689 | 57 DCTELEM *block, int n, int qscale); |
2967 | 58 static void dct_unquantize_h263_inter_c(MpegEncContext *s, |
13
174ef88f619a
use block[] in structure to have it aligned on 8 bytes for mmx optimizations - dct_unquantize is always a function pointer - added specialized dct_unquantize_h263
glantau
parents:
8
diff
changeset
|
59 DCTELEM *block, int n, int qscale); |
1064 | 60 static void draw_edges_c(uint8_t *buf, int wrap, int width, int height, int w); |
1070
6da5ae9ee199
more #ifdef CONFIG_ENCODERS patch by (Wolfgang Hesseler <qv at multimediaware dot com>) with modifications by me (s/WOLFGANG/CONFIG_ENCODERS/ and some other fixes)
michaelni
parents:
1064
diff
changeset
|
61 #ifdef CONFIG_ENCODERS |
344 | 62 static int dct_quantize_c(MpegEncContext *s, DCTELEM *block, int n, int qscale, int *overflow); |
945 | 63 static int dct_quantize_trellis_c(MpegEncContext *s, DCTELEM *block, int n, int qscale, int *overflow); |
1777 | 64 static int dct_quantize_refine(MpegEncContext *s, DCTELEM *block, int16_t *weight, DCTELEM *orig, int n, int qscale); |
1389 | 65 static int sse_mb(MpegEncContext *s); |
1719 | 66 static void denoise_dct_c(MpegEncContext *s, DCTELEM *block); |
1070
6da5ae9ee199
more #ifdef CONFIG_ENCODERS patch by (Wolfgang Hesseler <qv at multimediaware dot com>) with modifications by me (s/WOLFGANG/CONFIG_ENCODERS/ and some other fixes)
michaelni
parents:
1064
diff
changeset
|
67 #endif //CONFIG_ENCODERS |
206 | 68 |
1381 | 69 #ifdef HAVE_XVMC |
70 extern int XVMC_field_start(MpegEncContext*s, AVCodecContext *avctx); | |
71 extern void XVMC_field_end(MpegEncContext *s); | |
1580
628bf341e099
XvMC speedup by removing one memcpy and doing MB packing
iive
parents:
1579
diff
changeset
|
72 extern void XVMC_decode_mb(MpegEncContext *s); |
1381 | 73 #endif |
74 | |
1064 | 75 void (*draw_edges)(uint8_t *buf, int wrap, int width, int height, int w)= draw_edges_c; |
206 | 76 |
0 | 77 |
78 /* enable all paranoid tests for rounding, overflows, etc... */ | |
79 //#define PARANOID | |
80 | |
81 //#define DEBUG | |
82 | |
321 | 83 |
0 | 84 /* for jpeg fast DCT */ |
85 #define CONST_BITS 14 | |
86 | |
853
eacc2dd8fd9d
* using DSPContext - so each codec could use its local (sub)set of CPU extension
kabi
parents:
847
diff
changeset
|
87 static const uint16_t aanscales[64] = { |
0 | 88 /* precomputed values scaled up by 14 bits */ |
89 16384, 22725, 21407, 19266, 16384, 12873, 8867, 4520, | |
90 22725, 31521, 29692, 26722, 22725, 17855, 12299, 6270, | |
91 21407, 29692, 27969, 25172, 21407, 16819, 11585, 5906, | |
92 19266, 26722, 25172, 22654, 19266, 15137, 10426, 5315, | |
93 16384, 22725, 21407, 19266, 16384, 12873, 8867, 4520, | |
94 12873, 17855, 16819, 15137, 12873, 10114, 6967, 3552, | |
936 | 95 8867 , 12299, 11585, 10426, 8867, 6967, 4799, 2446, |
96 4520 , 6270, 5906, 5315, 4520, 3552, 2446, 1247 | |
0 | 97 }; |
98 | |
853
eacc2dd8fd9d
* using DSPContext - so each codec could use its local (sub)set of CPU extension
kabi
parents:
847
diff
changeset
|
99 static const uint8_t h263_chroma_roundtab[16] = { |
1013 | 100 // 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
0 | 101 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, |
102 }; | |
103 | |
1644 | 104 static const uint8_t ff_default_chroma_qscale_table[32]={ |
105 // 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 | |
106 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31 | |
107 }; | |
108 | |
1070
6da5ae9ee199
more #ifdef CONFIG_ENCODERS patch by (Wolfgang Hesseler <qv at multimediaware dot com>) with modifications by me (s/WOLFGANG/CONFIG_ENCODERS/ and some other fixes)
michaelni
parents:
1064
diff
changeset
|
109 #ifdef CONFIG_ENCODERS |
1162 | 110 static uint8_t (*default_mv_penalty)[MAX_MV*2+1]=NULL; |
1064 | 111 static uint8_t default_fcode_tab[MAX_MV*2+1]; |
277
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
271
diff
changeset
|
112 |
998 | 113 enum PixelFormat ff_yuv420p_list[2]= {PIX_FMT_YUV420P, -1}; |
114 | |
1579
039cb2296de2
make convert_matrix() independant of MpegEncContext
michael
parents:
1573
diff
changeset
|
115 static void convert_matrix(DSPContext *dsp, int (*qmat)[64], uint16_t (*qmat16)[2][64], |
2385
4605a8b188c3
warn the user if the quantization code could overflow with the selected custom matrix and qp limits
michael
parents:
2382
diff
changeset
|
116 const uint16_t *quant_matrix, int bias, int qmin, int qmax, int intra) |
0 | 117 { |
344 | 118 int qscale; |
2385
4605a8b188c3
warn the user if the quantization code could overflow with the selected custom matrix and qp limits
michael
parents:
2382
diff
changeset
|
119 int shift=0; |
0 | 120 |
709
afeff6ccb7f5
convert only needed matrixes in convert_matrix() (mjpeg calls it for every frame)
michaelni
parents:
706
diff
changeset
|
121 for(qscale=qmin; qscale<=qmax; qscale++){ |
344 | 122 int i; |
2967 | 123 if (dsp->fdct == ff_jpeg_fdct_islow |
1562
bf452704100f
optionally merge postscale into quantization table for the float aan dct
michael
parents:
1557
diff
changeset
|
124 #ifdef FAAN_POSTSCALE |
1579
039cb2296de2
make convert_matrix() independant of MpegEncContext
michael
parents:
1573
diff
changeset
|
125 || dsp->fdct == ff_faandct |
1562
bf452704100f
optionally merge postscale into quantization table for the float aan dct
michael
parents:
1557
diff
changeset
|
126 #endif |
bf452704100f
optionally merge postscale into quantization table for the float aan dct
michael
parents:
1557
diff
changeset
|
127 ) { |
625
bb6a69f9d409
slow but accurate integer dct from IJG (should be ok with the LGPL as the old DCT is the fast integer DCT from IJG)
michaelni
parents:
619
diff
changeset
|
128 for(i=0;i<64;i++) { |
1579
039cb2296de2
make convert_matrix() independant of MpegEncContext
michael
parents:
1573
diff
changeset
|
129 const int j= dsp->idct_permutation[i]; |
625
bb6a69f9d409
slow but accurate integer dct from IJG (should be ok with the LGPL as the old DCT is the fast integer DCT from IJG)
michaelni
parents:
619
diff
changeset
|
130 /* 16 <= qscale * quant_matrix[i] <= 7905 */ |
bb6a69f9d409
slow but accurate integer dct from IJG (should be ok with the LGPL as the old DCT is the fast integer DCT from IJG)
michaelni
parents:
619
diff
changeset
|
131 /* 19952 <= aanscales[i] * qscale * quant_matrix[i] <= 249205026 */ |
bb6a69f9d409
slow but accurate integer dct from IJG (should be ok with the LGPL as the old DCT is the fast integer DCT from IJG)
michaelni
parents:
619
diff
changeset
|
132 /* (1<<36)/19952 >= (1<<36)/(aanscales[i] * qscale * quant_matrix[i]) >= (1<<36)/249205026 */ |
bb6a69f9d409
slow but accurate integer dct from IJG (should be ok with the LGPL as the old DCT is the fast integer DCT from IJG)
michaelni
parents:
619
diff
changeset
|
133 /* 3444240 >= (1<<36)/(aanscales[i] * qscale * quant_matrix[i]) >= 275 */ |
2967 | 134 |
4274 | 135 qmat[qscale][i] = (int)((UINT64_C(1) << QMAT_SHIFT) / |
625
bb6a69f9d409
slow but accurate integer dct from IJG (should be ok with the LGPL as the old DCT is the fast integer DCT from IJG)
michaelni
parents:
619
diff
changeset
|
136 (qscale * quant_matrix[j])); |
bb6a69f9d409
slow but accurate integer dct from IJG (should be ok with the LGPL as the old DCT is the fast integer DCT from IJG)
michaelni
parents:
619
diff
changeset
|
137 } |
1579
039cb2296de2
make convert_matrix() independant of MpegEncContext
michael
parents:
1573
diff
changeset
|
138 } else if (dsp->fdct == fdct_ifast |
1562
bf452704100f
optionally merge postscale into quantization table for the float aan dct
michael
parents:
1557
diff
changeset
|
139 #ifndef FAAN_POSTSCALE |
1579
039cb2296de2
make convert_matrix() independant of MpegEncContext
michael
parents:
1573
diff
changeset
|
140 || dsp->fdct == ff_faandct |
1562
bf452704100f
optionally merge postscale into quantization table for the float aan dct
michael
parents:
1557
diff
changeset
|
141 #endif |
bf452704100f
optionally merge postscale into quantization table for the float aan dct
michael
parents:
1557
diff
changeset
|
142 ) { |
344 | 143 for(i=0;i<64;i++) { |
1579
039cb2296de2
make convert_matrix() independant of MpegEncContext
michael
parents:
1573
diff
changeset
|
144 const int j= dsp->idct_permutation[i]; |
344 | 145 /* 16 <= qscale * quant_matrix[i] <= 7905 */ |
146 /* 19952 <= aanscales[i] * qscale * quant_matrix[i] <= 249205026 */ | |
147 /* (1<<36)/19952 >= (1<<36)/(aanscales[i] * qscale * quant_matrix[i]) >= (1<<36)/249205026 */ | |
148 /* 3444240 >= (1<<36)/(aanscales[i] * qscale * quant_matrix[i]) >= 275 */ | |
2967 | 149 |
4274 | 150 qmat[qscale][i] = (int)((UINT64_C(1) << (QMAT_SHIFT + 14)) / |
344 | 151 (aanscales[i] * qscale * quant_matrix[j])); |
152 } | |
153 } else { | |
154 for(i=0;i<64;i++) { | |
1579
039cb2296de2
make convert_matrix() independant of MpegEncContext
michael
parents:
1573
diff
changeset
|
155 const int j= dsp->idct_permutation[i]; |
344 | 156 /* We can safely suppose that 16 <= quant_matrix[i] <= 255 |
157 So 16 <= qscale * quant_matrix[i] <= 7905 | |
158 so (1<<19) / 16 >= (1<<19) / (qscale * quant_matrix[i]) >= (1<<19) / 7905 | |
159 so 32768 >= (1<<19) / (qscale * quant_matrix[i]) >= 67 | |
160 */ | |
4274 | 161 qmat[qscale][i] = (int)((UINT64_C(1) << QMAT_SHIFT) / (qscale * quant_matrix[j])); |
945 | 162 // qmat [qscale][i] = (1 << QMAT_SHIFT_MMX) / (qscale * quant_matrix[i]); |
1554
d736e24bf303
move mmx quantizer matrixes out of MpegEncContext (23k -> 7k) (no meassureable slowdown)
michael
parents:
1553
diff
changeset
|
163 qmat16[qscale][0][i] = (1 << QMAT_SHIFT_MMX) / (qscale * quant_matrix[j]); |
d736e24bf303
move mmx quantizer matrixes out of MpegEncContext (23k -> 7k) (no meassureable slowdown)
michael
parents:
1553
diff
changeset
|
164 |
d736e24bf303
move mmx quantizer matrixes out of MpegEncContext (23k -> 7k) (no meassureable slowdown)
michael
parents:
1553
diff
changeset
|
165 if(qmat16[qscale][0][i]==0 || qmat16[qscale][0][i]==128*256) qmat16[qscale][0][i]=128*256-1; |
d736e24bf303
move mmx quantizer matrixes out of MpegEncContext (23k -> 7k) (no meassureable slowdown)
michael
parents:
1553
diff
changeset
|
166 qmat16[qscale][1][i]= ROUNDED_DIV(bias<<(16-QUANT_BIAS_SHIFT), qmat16[qscale][0][i]); |
344 | 167 } |
0 | 168 } |
2967 | 169 |
2385
4605a8b188c3
warn the user if the quantization code could overflow with the selected custom matrix and qp limits
michael
parents:
2382
diff
changeset
|
170 for(i=intra; i<64; i++){ |
2390 | 171 int64_t max= 8191; |
172 if (dsp->fdct == fdct_ifast | |
173 #ifndef FAAN_POSTSCALE | |
174 || dsp->fdct == ff_faandct | |
175 #endif | |
176 ) { | |
177 max= (8191LL*aanscales[i]) >> 14; | |
178 } | |
2967 | 179 while(((max * qmat[qscale][i]) >> shift) > INT_MAX){ |
2385
4605a8b188c3
warn the user if the quantization code could overflow with the selected custom matrix and qp limits
michael
parents:
2382
diff
changeset
|
180 shift++; |
4605a8b188c3
warn the user if the quantization code could overflow with the selected custom matrix and qp limits
michael
parents:
2382
diff
changeset
|
181 } |
4605a8b188c3
warn the user if the quantization code could overflow with the selected custom matrix and qp limits
michael
parents:
2382
diff
changeset
|
182 } |
4605a8b188c3
warn the user if the quantization code could overflow with the selected custom matrix and qp limits
michael
parents:
2382
diff
changeset
|
183 } |
4605a8b188c3
warn the user if the quantization code could overflow with the selected custom matrix and qp limits
michael
parents:
2382
diff
changeset
|
184 if(shift){ |
4525 | 185 av_log(NULL, AV_LOG_INFO, "Warning, QMAT_SHIFT is larger than %d, overflows possible\n", QMAT_SHIFT - shift); |
0 | 186 } |
187 } | |
1505
010f76d07a27
use lagrange multipler instead of qp for ratecontrol, this may break some things, tell me ASAP if u notice anything broken
michaelni
parents:
1497
diff
changeset
|
188 |
010f76d07a27
use lagrange multipler instead of qp for ratecontrol, this may break some things, tell me ASAP if u notice anything broken
michaelni
parents:
1497
diff
changeset
|
189 static inline void update_qscale(MpegEncContext *s){ |
010f76d07a27
use lagrange multipler instead of qp for ratecontrol, this may break some things, tell me ASAP if u notice anything broken
michaelni
parents:
1497
diff
changeset
|
190 s->qscale= (s->lambda*139 + FF_LAMBDA_SCALE*64) >> (FF_LAMBDA_SHIFT + 7); |
4594 | 191 s->qscale= av_clip(s->qscale, s->avctx->qmin, s->avctx->qmax); |
2967 | 192 |
1505
010f76d07a27
use lagrange multipler instead of qp for ratecontrol, this may break some things, tell me ASAP if u notice anything broken
michaelni
parents:
1497
diff
changeset
|
193 s->lambda2= (s->lambda*s->lambda + FF_LAMBDA_SCALE/2) >> FF_LAMBDA_SHIFT; |
010f76d07a27
use lagrange multipler instead of qp for ratecontrol, this may break some things, tell me ASAP if u notice anything broken
michaelni
parents:
1497
diff
changeset
|
194 } |
1070
6da5ae9ee199
more #ifdef CONFIG_ENCODERS patch by (Wolfgang Hesseler <qv at multimediaware dot com>) with modifications by me (s/WOLFGANG/CONFIG_ENCODERS/ and some other fixes)
michaelni
parents:
1064
diff
changeset
|
195 #endif //CONFIG_ENCODERS |
6da5ae9ee199
more #ifdef CONFIG_ENCODERS patch by (Wolfgang Hesseler <qv at multimediaware dot com>) with modifications by me (s/WOLFGANG/CONFIG_ENCODERS/ and some other fixes)
michaelni
parents:
1064
diff
changeset
|
196 |
1273 | 197 void ff_init_scantable(uint8_t *permutation, ScanTable *st, const uint8_t *src_scantable){ |
706
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
198 int i; |
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
199 int end; |
2967 | 200 |
764 | 201 st->scantable= src_scantable; |
706
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
202 |
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
203 for(i=0; i<64; i++){ |
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
204 int j; |
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
205 j = src_scantable[i]; |
1273 | 206 st->permutated[i] = permutation[j]; |
828
ace3ccd18dd2
Altivec Patch (Mark III) by (Dieter Shirley <dieters at schemasoft dot com>)
michaelni
parents:
815
diff
changeset
|
207 #ifdef ARCH_POWERPC |
ace3ccd18dd2
Altivec Patch (Mark III) by (Dieter Shirley <dieters at schemasoft dot com>)
michaelni
parents:
815
diff
changeset
|
208 st->inverse[j] = i; |
ace3ccd18dd2
Altivec Patch (Mark III) by (Dieter Shirley <dieters at schemasoft dot com>)
michaelni
parents:
815
diff
changeset
|
209 #endif |
706
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
210 } |
2967 | 211 |
706
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
212 end=-1; |
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
213 for(i=0; i<64; i++){ |
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
214 int j; |
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
215 j = st->permutated[i]; |
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
216 if(j>end) end=j; |
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
217 st->raster_end[i]= end; |
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
218 } |
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
219 } |
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
220 |
1530
3b31998fe22f
disable encoders where appropriate (patch courtesy of BERO
melanson
parents:
1523
diff
changeset
|
221 #ifdef CONFIG_ENCODERS |
3776 | 222 void ff_write_quant_matrix(PutBitContext *pb, uint16_t *matrix){ |
1411 | 223 int i; |
224 | |
225 if(matrix){ | |
226 put_bits(pb, 1, 1); | |
227 for(i=0;i<64;i++) { | |
228 put_bits(pb, 8, matrix[ ff_zigzag_direct[i] ]); | |
229 } | |
230 }else | |
231 put_bits(pb, 1, 0); | |
232 } | |
1530
3b31998fe22f
disable encoders where appropriate (patch courtesy of BERO
melanson
parents:
1523
diff
changeset
|
233 #endif //CONFIG_ENCODERS |
1411 | 234 |
3086 | 235 const uint8_t *ff_find_start_code(const uint8_t * restrict p, const uint8_t *end, uint32_t * restrict state){ |
236 int i; | |
237 | |
3092 | 238 assert(p<=end); |
239 if(p>=end) | |
240 return end; | |
241 | |
3086 | 242 for(i=0; i<3; i++){ |
243 uint32_t tmp= *state << 8; | |
244 *state= tmp + *(p++); | |
245 if(tmp == 0x100 || p==end) | |
246 return p; | |
247 } | |
248 | |
249 while(p<end){ | |
3087 | 250 if (p[-1] > 1 ) p+= 3; |
251 else if(p[-2] ) p+= 2; | |
252 else if(p[-3]|(p[-1]-1)) p++; | |
3086 | 253 else{ |
254 p++; | |
255 break; | |
256 } | |
257 } | |
258 | |
3087 | 259 p= FFMIN(p, end)-4; |
3086 | 260 *state= be2me_32(unaligned32(p)); |
261 | |
262 return p+4; | |
263 } | |
264 | |
726
a91203b34e71
moved dct init out from mpv_common_init to dct_common_init (for less-uglier way for dv)
al3x
parents:
721
diff
changeset
|
265 /* init common dct for both encoder and decoder */ |
a91203b34e71
moved dct init out from mpv_common_init to dct_common_init (for less-uglier way for dv)
al3x
parents:
721
diff
changeset
|
266 int DCT_common_init(MpegEncContext *s) |
0 | 267 { |
1689 | 268 s->dct_unquantize_h263_intra = dct_unquantize_h263_intra_c; |
269 s->dct_unquantize_h263_inter = dct_unquantize_h263_inter_c; | |
270 s->dct_unquantize_mpeg1_intra = dct_unquantize_mpeg1_intra_c; | |
271 s->dct_unquantize_mpeg1_inter = dct_unquantize_mpeg1_inter_c; | |
272 s->dct_unquantize_mpeg2_intra = dct_unquantize_mpeg2_intra_c; | |
3281
7fac25904a8b
missmatch control for mpeg2 intra dequantization if bitexact=1
michael
parents:
3268
diff
changeset
|
273 if(s->flags & CODEC_FLAG_BITEXACT) |
7fac25904a8b
missmatch control for mpeg2 intra dequantization if bitexact=1
michael
parents:
3268
diff
changeset
|
274 s->dct_unquantize_mpeg2_intra = dct_unquantize_mpeg2_intra_bitexact; |
1689 | 275 s->dct_unquantize_mpeg2_inter = dct_unquantize_mpeg2_inter_c; |
1092 | 276 |
1070
6da5ae9ee199
more #ifdef CONFIG_ENCODERS patch by (Wolfgang Hesseler <qv at multimediaware dot com>) with modifications by me (s/WOLFGANG/CONFIG_ENCODERS/ and some other fixes)
michaelni
parents:
1064
diff
changeset
|
277 #ifdef CONFIG_ENCODERS |
625
bb6a69f9d409
slow but accurate integer dct from IJG (should be ok with the LGPL as the old DCT is the fast integer DCT from IJG)
michaelni
parents:
619
diff
changeset
|
278 s->dct_quantize= dct_quantize_c; |
1719 | 279 s->denoise_dct= denoise_dct_c; |
2616
ba6530ae8e34
remove superfluous CONFIG_ENCODERS (entire function is already wrapped)
melanson
parents:
2584
diff
changeset
|
280 #endif //CONFIG_ENCODERS |
2967 | 281 |
13
174ef88f619a
use block[] in structure to have it aligned on 8 bytes for mmx optimizations - dct_unquantize is always a function pointer - added specialized dct_unquantize_h263
glantau
parents:
8
diff
changeset
|
282 #ifdef HAVE_MMX |
1422
efeed6e29f9b
oooooops, having 2 Eterms open and doing cvs diff in one and cvs commit in the other sucks, especially if they are in different directories (MPlayer/main/libavcodec vs. ffmpeg/libavcodec)
michaelni
parents:
1421
diff
changeset
|
283 MPV_common_init_mmx(s); |
8 | 284 #endif |
514
c9f724e3a797
Update and activate dct_unquantize_h263_mvi. Thanks to M«©ns Rullg«©rd
mellum
parents:
506
diff
changeset
|
285 #ifdef ARCH_ALPHA |
c9f724e3a797
Update and activate dct_unquantize_h263_mvi. Thanks to M«©ns Rullg«©rd
mellum
parents:
506
diff
changeset
|
286 MPV_common_init_axp(s); |
c9f724e3a797
Update and activate dct_unquantize_h263_mvi. Thanks to M«©ns Rullg«©rd
mellum
parents:
506
diff
changeset
|
287 #endif |
628
f596db4aa871
sun solaris compilation bugfix, patch by (Martin Olschewski <olschewski at zpr dot uni-koeln dot de>)
michaelni
parents:
625
diff
changeset
|
288 #ifdef HAVE_MLIB |
f596db4aa871
sun solaris compilation bugfix, patch by (Martin Olschewski <olschewski at zpr dot uni-koeln dot de>)
michaelni
parents:
625
diff
changeset
|
289 MPV_common_init_mlib(s); |
f596db4aa871
sun solaris compilation bugfix, patch by (Martin Olschewski <olschewski at zpr dot uni-koeln dot de>)
michaelni
parents:
625
diff
changeset
|
290 #endif |
721
71f669e9f633
ps2 optimizations update patch by (Leon van Stuivenberg <leonvs at iae dot nl>)
michaelni
parents:
717
diff
changeset
|
291 #ifdef HAVE_MMI |
71f669e9f633
ps2 optimizations update patch by (Leon van Stuivenberg <leonvs at iae dot nl>)
michaelni
parents:
717
diff
changeset
|
292 MPV_common_init_mmi(s); |
71f669e9f633
ps2 optimizations update patch by (Leon van Stuivenberg <leonvs at iae dot nl>)
michaelni
parents:
717
diff
changeset
|
293 #endif |
730 | 294 #ifdef ARCH_ARMV4L |
874 | 295 MPV_common_init_armv4l(s); |
730 | 296 #endif |
828
ace3ccd18dd2
Altivec Patch (Mark III) by (Dieter Shirley <dieters at schemasoft dot com>)
michaelni
parents:
815
diff
changeset
|
297 #ifdef ARCH_POWERPC |
ace3ccd18dd2
Altivec Patch (Mark III) by (Dieter Shirley <dieters at schemasoft dot com>)
michaelni
parents:
815
diff
changeset
|
298 MPV_common_init_ppc(s); |
ace3ccd18dd2
Altivec Patch (Mark III) by (Dieter Shirley <dieters at schemasoft dot com>)
michaelni
parents:
815
diff
changeset
|
299 #endif |
730 | 300 |
1070
6da5ae9ee199
more #ifdef CONFIG_ENCODERS patch by (Wolfgang Hesseler <qv at multimediaware dot com>) with modifications by me (s/WOLFGANG/CONFIG_ENCODERS/ and some other fixes)
michaelni
parents:
1064
diff
changeset
|
301 #ifdef CONFIG_ENCODERS |
1007 | 302 s->fast_dct_quantize= s->dct_quantize; |
303 | |
945 | 304 if(s->flags&CODEC_FLAG_TRELLIS_QUANT){ |
305 s->dct_quantize= dct_quantize_trellis_c; //move before MPV_common_init_* | |
306 } | |
307 | |
1070
6da5ae9ee199
more #ifdef CONFIG_ENCODERS patch by (Wolfgang Hesseler <qv at multimediaware dot com>) with modifications by me (s/WOLFGANG/CONFIG_ENCODERS/ and some other fixes)
michaelni
parents:
1064
diff
changeset
|
308 #endif //CONFIG_ENCODERS |
6da5ae9ee199
more #ifdef CONFIG_ENCODERS patch by (Wolfgang Hesseler <qv at multimediaware dot com>) with modifications by me (s/WOLFGANG/CONFIG_ENCODERS/ and some other fixes)
michaelni
parents:
1064
diff
changeset
|
309 |
706
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
310 /* load & permutate scantables |
2967 | 311 note: only wmv uses different ones |
706
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
312 */ |
1708 | 313 if(s->alternate_scan){ |
314 ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable , ff_alternate_vertical_scan); | |
315 ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable , ff_alternate_vertical_scan); | |
316 }else{ | |
317 ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable , ff_zigzag_direct); | |
318 ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable , ff_zigzag_direct); | |
319 } | |
1273 | 320 ff_init_scantable(s->dsp.idct_permutation, &s->intra_h_scantable, ff_alternate_horizontal_scan); |
321 ff_init_scantable(s->dsp.idct_permutation, &s->intra_v_scantable, ff_alternate_vertical_scan); | |
591 | 322 |
726
a91203b34e71
moved dct init out from mpv_common_init to dct_common_init (for less-uglier way for dv)
al3x
parents:
721
diff
changeset
|
323 return 0; |
a91203b34e71
moved dct init out from mpv_common_init to dct_common_init (for less-uglier way for dv)
al3x
parents:
721
diff
changeset
|
324 } |
a91203b34e71
moved dct init out from mpv_common_init to dct_common_init (for less-uglier way for dv)
al3x
parents:
721
diff
changeset
|
325 |
1539
14d01ccc0081
picture buffer cleanup, this fixes a assertion failure (if assertion checking was manualy enabled for utils.c) and a memleak at least
michael
parents:
1530
diff
changeset
|
326 static void copy_picture(Picture *dst, Picture *src){ |
14d01ccc0081
picture buffer cleanup, this fixes a assertion failure (if assertion checking was manualy enabled for utils.c) and a memleak at least
michael
parents:
1530
diff
changeset
|
327 *dst = *src; |
14d01ccc0081
picture buffer cleanup, this fixes a assertion failure (if assertion checking was manualy enabled for utils.c) and a memleak at least
michael
parents:
1530
diff
changeset
|
328 dst->type= FF_BUFFER_TYPE_COPY; |
14d01ccc0081
picture buffer cleanup, this fixes a assertion failure (if assertion checking was manualy enabled for utils.c) and a memleak at least
michael
parents:
1530
diff
changeset
|
329 } |
14d01ccc0081
picture buffer cleanup, this fixes a assertion failure (if assertion checking was manualy enabled for utils.c) and a memleak at least
michael
parents:
1530
diff
changeset
|
330 |
3777 | 331 #ifdef CONFIG_ENCODERS |
1938
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1918
diff
changeset
|
332 static void copy_picture_attributes(MpegEncContext *s, AVFrame *dst, AVFrame *src){ |
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1918
diff
changeset
|
333 int i; |
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1918
diff
changeset
|
334 |
1702 | 335 dst->pict_type = src->pict_type; |
336 dst->quality = src->quality; | |
337 dst->coded_picture_number = src->coded_picture_number; | |
338 dst->display_picture_number = src->display_picture_number; | |
339 // dst->reference = src->reference; | |
340 dst->pts = src->pts; | |
341 dst->interlaced_frame = src->interlaced_frame; | |
342 dst->top_field_first = src->top_field_first; | |
1938
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1918
diff
changeset
|
343 |
1945
32f68745c431
passing AVFrame instead of AVPicture around in ffmpeg, that way stuff like motion vectors can be passed from the decoder to the encoder
michael
parents:
1944
diff
changeset
|
344 if(s->avctx->me_threshold){ |
32f68745c431
passing AVFrame instead of AVPicture around in ffmpeg, that way stuff like motion vectors can be passed from the decoder to the encoder
michael
parents:
1944
diff
changeset
|
345 if(!src->motion_val[0]) |
32f68745c431
passing AVFrame instead of AVPicture around in ffmpeg, that way stuff like motion vectors can be passed from the decoder to the encoder
michael
parents:
1944
diff
changeset
|
346 av_log(s->avctx, AV_LOG_ERROR, "AVFrame.motion_val not set!\n"); |
32f68745c431
passing AVFrame instead of AVPicture around in ffmpeg, that way stuff like motion vectors can be passed from the decoder to the encoder
michael
parents:
1944
diff
changeset
|
347 if(!src->mb_type) |
32f68745c431
passing AVFrame instead of AVPicture around in ffmpeg, that way stuff like motion vectors can be passed from the decoder to the encoder
michael
parents:
1944
diff
changeset
|
348 av_log(s->avctx, AV_LOG_ERROR, "AVFrame.mb_type not set!\n"); |
32f68745c431
passing AVFrame instead of AVPicture around in ffmpeg, that way stuff like motion vectors can be passed from the decoder to the encoder
michael
parents:
1944
diff
changeset
|
349 if(!src->ref_index[0]) |
32f68745c431
passing AVFrame instead of AVPicture around in ffmpeg, that way stuff like motion vectors can be passed from the decoder to the encoder
michael
parents:
1944
diff
changeset
|
350 av_log(s->avctx, AV_LOG_ERROR, "AVFrame.ref_index not set!\n"); |
1938
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1918
diff
changeset
|
351 if(src->motion_subsample_log2 != dst->motion_subsample_log2) |
2627
bf158d23bbcc
Spelling errors patch by (Kevin Baragona | kevinmb500 gawab com)
michael
parents:
2620
diff
changeset
|
352 av_log(s->avctx, AV_LOG_ERROR, "AVFrame.motion_subsample_log2 doesn't match! (%d!=%d)\n", |
1955
5dafb10e0252
reuse motion vectors/mb types/field select values of the source video, if the SSE for a macroblock which is predicted with these values is below me_threshold
michael
parents:
1948
diff
changeset
|
353 src->motion_subsample_log2, dst->motion_subsample_log2); |
1945
32f68745c431
passing AVFrame instead of AVPicture around in ffmpeg, that way stuff like motion vectors can be passed from the decoder to the encoder
michael
parents:
1944
diff
changeset
|
354 |
32f68745c431
passing AVFrame instead of AVPicture around in ffmpeg, that way stuff like motion vectors can be passed from the decoder to the encoder
michael
parents:
1944
diff
changeset
|
355 memcpy(dst->mb_type, src->mb_type, s->mb_stride * s->mb_height * sizeof(dst->mb_type[0])); |
2967 | 356 |
1945
32f68745c431
passing AVFrame instead of AVPicture around in ffmpeg, that way stuff like motion vectors can be passed from the decoder to the encoder
michael
parents:
1944
diff
changeset
|
357 for(i=0; i<2; i++){ |
1938
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1918
diff
changeset
|
358 int stride= ((16*s->mb_width )>>src->motion_subsample_log2) + 1; |
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1918
diff
changeset
|
359 int height= ((16*s->mb_height)>>src->motion_subsample_log2); |
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1918
diff
changeset
|
360 |
1945
32f68745c431
passing AVFrame instead of AVPicture around in ffmpeg, that way stuff like motion vectors can be passed from the decoder to the encoder
michael
parents:
1944
diff
changeset
|
361 if(src->motion_val[i] && src->motion_val[i] != dst->motion_val[i]){ |
32f68745c431
passing AVFrame instead of AVPicture around in ffmpeg, that way stuff like motion vectors can be passed from the decoder to the encoder
michael
parents:
1944
diff
changeset
|
362 memcpy(dst->motion_val[i], src->motion_val[i], 2*stride*height*sizeof(int16_t)); |
32f68745c431
passing AVFrame instead of AVPicture around in ffmpeg, that way stuff like motion vectors can be passed from the decoder to the encoder
michael
parents:
1944
diff
changeset
|
363 } |
32f68745c431
passing AVFrame instead of AVPicture around in ffmpeg, that way stuff like motion vectors can be passed from the decoder to the encoder
michael
parents:
1944
diff
changeset
|
364 if(src->ref_index[i] && src->ref_index[i] != dst->ref_index[i]){ |
1948 | 365 memcpy(dst->ref_index[i], src->ref_index[i], s->b8_stride*2*s->mb_height*sizeof(int8_t)); |
1945
32f68745c431
passing AVFrame instead of AVPicture around in ffmpeg, that way stuff like motion vectors can be passed from the decoder to the encoder
michael
parents:
1944
diff
changeset
|
366 } |
1938
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1918
diff
changeset
|
367 } |
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1918
diff
changeset
|
368 } |
1702 | 369 } |
3777 | 370 #endif |
1702 | 371 |
903 | 372 /** |
924 | 373 * allocates a Picture |
374 * The pixels are allocated/set by calling get_buffer() if shared=0 | |
903 | 375 */ |
924 | 376 static int alloc_picture(MpegEncContext *s, Picture *pic, int shared){ |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1173
diff
changeset
|
377 const int big_mb_num= s->mb_stride*(s->mb_height+1) + 1; //the +1 is needed so memset(,,stride*height) doesnt sig11 |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1173
diff
changeset
|
378 const int mb_array_size= s->mb_stride*s->mb_height; |
1655 | 379 const int b8_array_size= s->b8_stride*s->mb_height*2; |
380 const int b4_array_size= s->b4_stride*s->mb_height*4; | |
1168 | 381 int i; |
2967 | 382 |
924 | 383 if(shared){ |
384 assert(pic->data[0]); | |
385 assert(pic->type == 0 || pic->type == FF_BUFFER_TYPE_SHARED); | |
386 pic->type= FF_BUFFER_TYPE_SHARED; | |
387 }else{ | |
388 int r; | |
2967 | 389 |
924 | 390 assert(!pic->data[0]); |
2967 | 391 |
925 | 392 r= s->avctx->get_buffer(s->avctx, (AVFrame*)pic); |
2967 | 393 |
924 | 394 if(r<0 || !pic->age || !pic->type || !pic->data[0]){ |
2979 | 395 av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed (%d %d %d %p)\n", r, pic->age, pic->type, pic->data[0]); |
924 | 396 return -1; |
397 } | |
398 | |
399 if(s->linesize && (s->linesize != pic->linesize[0] || s->uvlinesize != pic->linesize[1])){ | |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1597
diff
changeset
|
400 av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed (stride changed)\n"); |
924 | 401 return -1; |
402 } | |
403 | |
404 if(pic->linesize[1] != pic->linesize[2]){ | |
2764 | 405 av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed (uv stride mismatch)\n"); |
924 | 406 return -1; |
407 } | |
408 | |
409 s->linesize = pic->linesize[0]; | |
410 s->uvlinesize= pic->linesize[1]; | |
903 | 411 } |
2967 | 412 |
924 | 413 if(pic->qscale_table==NULL){ |
2967 | 414 if (s->encoding) { |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1173
diff
changeset
|
415 CHECKED_ALLOCZ(pic->mb_var , mb_array_size * sizeof(int16_t)) |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1173
diff
changeset
|
416 CHECKED_ALLOCZ(pic->mc_mb_var, mb_array_size * sizeof(int16_t)) |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1173
diff
changeset
|
417 CHECKED_ALLOCZ(pic->mb_mean , mb_array_size * sizeof(int8_t)) |
924 | 418 } |
419 | |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1173
diff
changeset
|
420 CHECKED_ALLOCZ(pic->mbskip_table , mb_array_size * sizeof(uint8_t)+2) //the +2 is for the slice end check |
1422
efeed6e29f9b
oooooops, having 2 Eterms open and doing cvs diff in one and cvs commit in the other sucks, especially if they are in different directories (MPlayer/main/libavcodec vs. ffmpeg/libavcodec)
michaelni
parents:
1421
diff
changeset
|
421 CHECKED_ALLOCZ(pic->qscale_table , mb_array_size * sizeof(uint8_t)) |
1742 | 422 CHECKED_ALLOCZ(pic->mb_type_base , big_mb_num * sizeof(uint32_t)) |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1173
diff
changeset
|
423 pic->mb_type= pic->mb_type_base + s->mb_stride+1; |
1168 | 424 if(s->out_format == FMT_H264){ |
425 for(i=0; i<2; i++){ | |
2570 | 426 CHECKED_ALLOCZ(pic->motion_val_base[i], 2 * (b4_array_size+4) * sizeof(int16_t)) |
427 pic->motion_val[i]= pic->motion_val_base[i]+4; | |
1948 | 428 CHECKED_ALLOCZ(pic->ref_index[i], b8_array_size * sizeof(uint8_t)) |
1655 | 429 } |
1669 | 430 pic->motion_subsample_log2= 2; |
1706
3ba5c493db6f
motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1705
diff
changeset
|
431 }else if(s->out_format == FMT_H263 || s->encoding || (s->avctx->debug&FF_DEBUG_MV) || (s->avctx->debug_mv)){ |
1655 | 432 for(i=0; i<2; i++){ |
2570 | 433 CHECKED_ALLOCZ(pic->motion_val_base[i], 2 * (b8_array_size+4) * sizeof(int16_t)) |
434 pic->motion_val[i]= pic->motion_val_base[i]+4; | |
1948 | 435 CHECKED_ALLOCZ(pic->ref_index[i], b8_array_size * sizeof(uint8_t)) |
1168 | 436 } |
1669 | 437 pic->motion_subsample_log2= 3; |
1168 | 438 } |
1833
ba27ce284d07
export DCT coefficients patch by (Wolfgang Hesseler <wolfgang.hesseler at imk dot fraunhofer dot de>)
michael
parents:
1831
diff
changeset
|
439 if(s->avctx->debug&FF_DEBUG_DCT_COEFF) { |
ba27ce284d07
export DCT coefficients patch by (Wolfgang Hesseler <wolfgang.hesseler at imk dot fraunhofer dot de>)
michael
parents:
1831
diff
changeset
|
440 CHECKED_ALLOCZ(pic->dct_coeff, 64 * mb_array_size * sizeof(DCTELEM)*6) |
ba27ce284d07
export DCT coefficients patch by (Wolfgang Hesseler <wolfgang.hesseler at imk dot fraunhofer dot de>)
michael
parents:
1831
diff
changeset
|
441 } |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1173
diff
changeset
|
442 pic->qstride= s->mb_stride; |
1546 | 443 CHECKED_ALLOCZ(pic->pan_scan , 1 * sizeof(AVPanScan)) |
924 | 444 } |
1168 | 445 |
1021
2d7c9f5738de
trying to fix mb skip bug in mpeg1/2 if slices are not used
michaelni
parents:
1014
diff
changeset
|
446 //it might be nicer if the application would keep track of these but it would require a API change |
2d7c9f5738de
trying to fix mb skip bug in mpeg1/2 if slices are not used
michaelni
parents:
1014
diff
changeset
|
447 memmove(s->prev_pict_types+1, s->prev_pict_types, PREV_PICT_TYPES_BUFFER_SIZE-1); |
2d7c9f5738de
trying to fix mb skip bug in mpeg1/2 if slices are not used
michaelni
parents:
1014
diff
changeset
|
448 s->prev_pict_types[0]= s->pict_type; |
2d7c9f5738de
trying to fix mb skip bug in mpeg1/2 if slices are not used
michaelni
parents:
1014
diff
changeset
|
449 if(pic->age < PREV_PICT_TYPES_BUFFER_SIZE && s->prev_pict_types[pic->age] == B_TYPE) |
2628
511e3afc43e1
Ministry of English Composition, reporting for duty (and the word is "skipped", not "skiped"; "skiped" would rhyme with "hyped")
melanson
parents:
2627
diff
changeset
|
450 pic->age= INT_MAX; // skipped MBs in b frames are quite rare in mpeg1/2 and its a bit tricky to skip them anyway |
2967 | 451 |
903 | 452 return 0; |
453 fail: //for the CHECKED_ALLOCZ macro | |
454 return -1; | |
455 } | |
456 | |
924 | 457 /** |
458 * deallocates a picture | |
459 */ | |
903 | 460 static void free_picture(MpegEncContext *s, Picture *pic){ |
461 int i; | |
924 | 462 |
463 if(pic->data[0] && pic->type!=FF_BUFFER_TYPE_SHARED){ | |
925 | 464 s->avctx->release_buffer(s->avctx, (AVFrame*)pic); |
924 | 465 } |
466 | |
903 | 467 av_freep(&pic->mb_var); |
468 av_freep(&pic->mc_mb_var); | |
469 av_freep(&pic->mb_mean); | |
470 av_freep(&pic->mbskip_table); | |
471 av_freep(&pic->qscale_table); | |
1168 | 472 av_freep(&pic->mb_type_base); |
1833
ba27ce284d07
export DCT coefficients patch by (Wolfgang Hesseler <wolfgang.hesseler at imk dot fraunhofer dot de>)
michael
parents:
1831
diff
changeset
|
473 av_freep(&pic->dct_coeff); |
1546 | 474 av_freep(&pic->pan_scan); |
1168 | 475 pic->mb_type= NULL; |
476 for(i=0; i<2; i++){ | |
1655 | 477 av_freep(&pic->motion_val_base[i]); |
1168 | 478 av_freep(&pic->ref_index[i]); |
479 } | |
2967 | 480 |
1214 | 481 if(pic->type == FF_BUFFER_TYPE_SHARED){ |
924 | 482 for(i=0; i<4; i++){ |
483 pic->base[i]= | |
484 pic->data[i]= NULL; | |
485 } | |
2967 | 486 pic->type= 0; |
903 | 487 } |
488 } | |
489 | |
1799 | 490 static int init_duplicate_context(MpegEncContext *s, MpegEncContext *base){ |
491 int i; | |
492 | |
2967 | 493 // edge emu needs blocksize + filter length - 1 (=17x17 for halfpel / 21x21 for h264) |
3316 | 494 CHECKED_ALLOCZ(s->allocated_edge_emu_buffer, (s->width+64)*2*21*2); //(width + edge + align)*interlaced*MBsize*tolerance |
495 s->edge_emu_buffer= s->allocated_edge_emu_buffer + (s->width+64)*2*21; | |
1799 | 496 |
497 //FIXME should be linesize instead of s->width*2 but that isnt known before get_buffer() | |
2967 | 498 CHECKED_ALLOCZ(s->me.scratchpad, (s->width+64)*4*16*2*sizeof(uint8_t)) |
1799 | 499 s->rd_scratchpad= s->me.scratchpad; |
500 s->b_scratchpad= s->me.scratchpad; | |
501 s->obmc_scratchpad= s->me.scratchpad + 16; | |
502 if (s->encoding) { | |
503 CHECKED_ALLOCZ(s->me.map , ME_MAP_SIZE*sizeof(uint32_t)) | |
504 CHECKED_ALLOCZ(s->me.score_map, ME_MAP_SIZE*sizeof(uint32_t)) | |
505 if(s->avctx->noise_reduction){ | |
506 CHECKED_ALLOCZ(s->dct_error_sum, 2 * 64 * sizeof(int)) | |
507 } | |
2967 | 508 } |
1848
c72589baee53
initial chroma_format changes,xvmc tweaks and codec_cap
iive
parents:
1846
diff
changeset
|
509 CHECKED_ALLOCZ(s->blocks, 64*12*2 * sizeof(DCTELEM)) |
1799 | 510 s->block= s->blocks[0]; |
511 | |
512 for(i=0;i<12;i++){ | |
513 s->pblocks[i] = (short *)(&s->block[i]); | |
514 } | |
515 return 0; | |
516 fail: | |
517 return -1; //free() through MPV_common_end() | |
518 } | |
519 | |
520 static void free_duplicate_context(MpegEncContext *s){ | |
521 if(s==NULL) return; | |
522 | |
523 av_freep(&s->allocated_edge_emu_buffer); s->edge_emu_buffer= NULL; | |
524 av_freep(&s->me.scratchpad); | |
2967 | 525 s->rd_scratchpad= |
526 s->b_scratchpad= | |
1799 | 527 s->obmc_scratchpad= NULL; |
2967 | 528 |
1799 | 529 av_freep(&s->dct_error_sum); |
530 av_freep(&s->me.map); | |
531 av_freep(&s->me.score_map); | |
532 av_freep(&s->blocks); | |
533 s->block= NULL; | |
534 } | |
535 | |
536 static void backup_duplicate_context(MpegEncContext *bak, MpegEncContext *src){ | |
537 #define COPY(a) bak->a= src->a | |
538 COPY(allocated_edge_emu_buffer); | |
539 COPY(edge_emu_buffer); | |
540 COPY(me.scratchpad); | |
541 COPY(rd_scratchpad); | |
542 COPY(b_scratchpad); | |
543 COPY(obmc_scratchpad); | |
544 COPY(me.map); | |
545 COPY(me.score_map); | |
546 COPY(blocks); | |
547 COPY(block); | |
548 COPY(start_mb_y); | |
549 COPY(end_mb_y); | |
550 COPY(me.map_generation); | |
551 COPY(pb); | |
552 COPY(dct_error_sum); | |
1810 | 553 COPY(dct_count[0]); |
554 COPY(dct_count[1]); | |
1799 | 555 #undef COPY |
556 } | |
557 | |
1827 | 558 void ff_update_duplicate_context(MpegEncContext *dst, MpegEncContext *src){ |
1799 | 559 MpegEncContext bak; |
1827 | 560 int i; |
1799 | 561 //FIXME copy only needed parts |
562 //START_TIMER | |
563 backup_duplicate_context(&bak, dst); | |
564 memcpy(dst, src, sizeof(MpegEncContext)); | |
565 backup_duplicate_context(dst, &bak); | |
1827 | 566 for(i=0;i<12;i++){ |
567 dst->pblocks[i] = (short *)(&dst->block[i]); | |
568 } | |
1799 | 569 //STOP_TIMER("update_duplicate_context") //about 10k cycles / 0.01 sec for 1000frames on 1ghz with 2 threads |
570 } | |
571 | |
3777 | 572 #ifdef CONFIG_ENCODERS |
1799 | 573 static void update_duplicate_context_after_me(MpegEncContext *dst, MpegEncContext *src){ |
574 #define COPY(a) dst->a= src->a | |
575 COPY(pict_type); | |
576 COPY(current_picture); | |
577 COPY(f_code); | |
578 COPY(b_code); | |
579 COPY(qscale); | |
580 COPY(lambda); | |
581 COPY(lambda2); | |
582 COPY(picture_in_gop_number); | |
583 COPY(gop_picture_number); | |
2764 | 584 COPY(frame_pred_frame_dct); //FIXME don't set in encode_header |
585 COPY(progressive_frame); //FIXME don't set in encode_header | |
586 COPY(partitioned_frame); //FIXME don't set in encode_header | |
1799 | 587 #undef COPY |
588 } | |
3777 | 589 #endif |
1799 | 590 |
1892 | 591 /** |
592 * sets the given MpegEncContext to common defaults (same for encoding and decoding). | |
593 * the changed fields will not depend upon the prior state of the MpegEncContext. | |
594 */ | |
595 static void MPV_common_defaults(MpegEncContext *s){ | |
596 s->y_dc_scale_table= | |
597 s->c_dc_scale_table= ff_mpeg1_dc_scale_table; | |
598 s->chroma_qscale_table= ff_default_chroma_qscale_table; | |
599 s->progressive_frame= 1; | |
600 s->progressive_sequence= 1; | |
601 s->picture_structure= PICT_FRAME; | |
602 | |
603 s->coded_picture_number = 0; | |
604 s->picture_number = 0; | |
605 s->input_picture_number = 0; | |
606 | |
607 s->picture_in_gop_number = 0; | |
1894 | 608 |
609 s->f_code = 1; | |
610 s->b_code = 1; | |
1892 | 611 } |
612 | |
613 /** | |
614 * sets the given MpegEncContext to defaults for decoding. | |
615 * the changed fields will not depend upon the prior state of the MpegEncContext. | |
616 */ | |
617 void MPV_decode_defaults(MpegEncContext *s){ | |
618 MPV_common_defaults(s); | |
619 } | |
620 | |
621 /** | |
622 * sets the given MpegEncContext to defaults for encoding. | |
623 * the changed fields will not depend upon the prior state of the MpegEncContext. | |
624 */ | |
1902
a5588762c4fa
Compile fix by (Chip <szarlada at freemail dot hu>)
michael
parents:
1894
diff
changeset
|
625 |
a5588762c4fa
Compile fix by (Chip <szarlada at freemail dot hu>)
michael
parents:
1894
diff
changeset
|
626 #ifdef CONFIG_ENCODERS |
2024
f65d87bfdd5a
some of the warning fixes by (Michael Roitzsch <mroi at users dot sourceforge dot net>)
michael
parents:
2015
diff
changeset
|
627 static void MPV_encode_defaults(MpegEncContext *s){ |
1892 | 628 static int done=0; |
2967 | 629 |
1892 | 630 MPV_common_defaults(s); |
2967 | 631 |
1892 | 632 if(!done){ |
633 int i; | |
634 done=1; | |
635 | |
636 default_mv_penalty= av_mallocz( sizeof(uint8_t)*(MAX_FCODE+1)*(2*MAX_MV+1) ); | |
637 memset(default_fcode_tab , 0, sizeof(uint8_t)*(2*MAX_MV+1)); | |
638 | |
639 for(i=-16; i<16; i++){ | |
640 default_fcode_tab[i + MAX_MV]= 1; | |
641 } | |
642 } | |
643 s->me.mv_penalty= default_mv_penalty; | |
644 s->fcode_tab= default_fcode_tab; | |
645 } | |
1902
a5588762c4fa
Compile fix by (Chip <szarlada at freemail dot hu>)
michael
parents:
1894
diff
changeset
|
646 #endif //CONFIG_ENCODERS |
1892 | 647 |
2967 | 648 /** |
1892 | 649 * init common structure for both encoder and decoder. |
650 * this assumes that some variables like width/height are already set | |
651 */ | |
726
a91203b34e71
moved dct init out from mpv_common_init to dct_common_init (for less-uglier way for dv)
al3x
parents:
721
diff
changeset
|
652 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
|
653 { |
1708 | 654 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
|
655 |
3070 | 656 s->mb_height = (s->height + 15) / 16; |
657 | |
658 if(s->avctx->thread_count > MAX_THREADS || (s->avctx->thread_count > s->mb_height && s->mb_height)){ | |
1989 | 659 av_log(s->avctx, AV_LOG_ERROR, "too many threads\n"); |
660 return -1; | |
661 } | |
662 | |
2422 | 663 if((s->width || s->height) && avcodec_check_dimensions(s->avctx, s->width, s->height)) |
664 return -1; | |
665 | |
1092 | 666 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
|
667 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
|
668 |
754 | 669 s->flags= s->avctx->flags; |
1754
bdf3927bf8c5
closed gop support & flags2 as all bits in flags are used
michael
parents:
1751
diff
changeset
|
670 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
|
671 |
903 | 672 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
|
673 s->mb_stride = s->mb_width + 1; |
1655 | 674 s->b8_stride = s->mb_width*2 + 1; |
675 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
|
676 mb_array_size= s->mb_height * s->mb_stride; |
1708 | 677 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
|
678 |
2074
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
679 /* set chroma shifts */ |
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
680 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
|
681 &(s->chroma_y_shift) ); |
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
682 |
853
eacc2dd8fd9d
* using DSPContext - so each codec could use its local (sub)set of CPU extension
kabi
parents:
847
diff
changeset
|
683 /* 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
|
684 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
|
685 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
|
686 |
eacc2dd8fd9d
* using DSPContext - so each codec could use its local (sub)set of CPU extension
kabi
parents:
847
diff
changeset
|
687 s->mb_num = s->mb_width * s->mb_height; |
2967 | 688 |
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
|
689 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
|
690 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
|
691 s->block_wrap[2]= |
1938
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1918
diff
changeset
|
692 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
|
693 s->block_wrap[4]= |
1938
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1918
diff
changeset
|
694 s->block_wrap[5]= s->mb_stride; |
2967 | 695 |
1938
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1918
diff
changeset
|
696 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
|
697 c_size = s->mb_stride * (s->mb_height + 1); |
756 | 698 yc_size = y_size + 2 * c_size; |
2967 | 699 |
701 | 700 /* 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
|
701 s->codec_tag= toupper( s->avctx->codec_tag &0xFF) |
1116 | 702 + (toupper((s->avctx->codec_tag>>8 )&0xFF)<<8 ) |
2967 | 703 + (toupper((s->avctx->codec_tag>>16)&0xFF)<<16) |
1116 | 704 + (toupper((s->avctx->codec_tag>>24)&0xFF)<<24); |
582
5132a4ee50cd
different edge positions fixed with edge emu / dr1
michaelni
parents:
575
diff
changeset
|
705 |
4155
0f28fc219799
add codec_tag and codec_stream_tag to MpegEncContext to not alter avctx values
bcoudurier
parents:
4122
diff
changeset
|
706 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
|
707 + (toupper((s->avctx->stream_codec_tag>>8 )&0xFF)<<8 ) |
2967 | 708 + (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
|
709 + (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
|
710 |
925 | 711 s->avctx->coded_frame= (AVFrame*)&s->current_picture; |
903 | 712 |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1173
diff
changeset
|
713 CHECKED_ALLOCZ(s->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
|
714 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
|
715 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
|
716 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
|
717 } |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead 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 } |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1173
diff
changeset
|
719 s->mb_index2xy[ s->mb_height*s->mb_width ] = (s->mb_height-1)*s->mb_stride + s->mb_width; //FIXME really needed? |
2967 | 720 |
232
b640ec5948b0
- Now the ME is done for the entire picture when enconding, the
pulento
parents:
231
diff
changeset
|
721 if (s->encoding) { |
324 | 722 /* 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
|
723 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
|
724 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
|
725 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
|
726 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
|
727 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
|
728 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
|
729 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
|
730 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
|
731 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
|
732 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
|
733 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
|
734 s->b_direct_mv_table = s->b_direct_mv_table_base + s->mb_stride + 1; |
324 | 735 |
650
ef4a33aad86e
reducing sizeof MpegEncContext to avoid stack overflow on crap M$ windo$
michaelni
parents:
635
diff
changeset
|
736 if(s->msmpeg4_version){ |
ef4a33aad86e
reducing sizeof MpegEncContext to avoid stack overflow on crap M$ windo$
michaelni
parents:
635
diff
changeset
|
737 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
|
738 } |
612 | 739 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
|
740 |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1173
diff
changeset
|
741 /* Allocate MB type table */ |
1708 | 742 CHECKED_ALLOCZ(s->mb_type , mb_array_size * sizeof(uint16_t)) //needed for encoding |
2967 | 743 |
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
|
744 CHECKED_ALLOCZ(s->lambda_table, mb_array_size * sizeof(int)) |
2967 | 745 |
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
|
746 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
|
747 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
|
748 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
|
749 CHECKED_ALLOCZ(s->q_inter_matrix16, 64*32*2 * sizeof(uint16_t)) |
1556 | 750 CHECKED_ALLOCZ(s->input_picture, MAX_PICTURE_COUNT * sizeof(Picture*)) |
751 CHECKED_ALLOCZ(s->reordered_input_picture, MAX_PICTURE_COUNT * sizeof(Picture*)) | |
2967 | 752 |
1597 | 753 if(s->avctx->noise_reduction){ |
754 CHECKED_ALLOCZ(s->dct_offset, 2 * 64 * sizeof(uint16_t)) | |
755 } | |
232
b640ec5948b0
- Now the ME is done for the entire picture when enconding, the
pulento
parents:
231
diff
changeset
|
756 } |
1552
26c6ecba99a1
dynamic alloc of picture structs instead of putting them in MpegEncContext
michael
parents:
1546
diff
changeset
|
757 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
|
758 |
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
|
759 CHECKED_ALLOCZ(s->error_status_table, mb_array_size*sizeof(uint8_t)) |
2967 | 760 |
1708 | 761 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
|
762 /* interlaced direct mode decoding tables */ |
1708 | 763 for(i=0; i<2; i++){ |
764 int j, k; | |
765 for(j=0; j<2; j++){ | |
766 for(k=0; k<2; k++){ | |
767 CHECKED_ALLOCZ(s->b_field_mv_table_base[i][j][k] , mv_table_size * 2 * sizeof(int16_t)) | |
768 s->b_field_mv_table[i][j][k] = s->b_field_mv_table_base[i][j][k] + s->mb_stride + 1; | |
769 } | |
770 CHECKED_ALLOCZ(s->b_field_select_table[i][j] , mb_array_size * 2 * sizeof(uint8_t)) | |
771 CHECKED_ALLOCZ(s->p_field_mv_table_base[i][j] , mv_table_size * 2 * sizeof(int16_t)) | |
772 s->p_field_mv_table[i][j] = s->p_field_mv_table_base[i][j] + s->mb_stride + 1; | |
773 } | |
774 CHECKED_ALLOCZ(s->p_field_select_table[i] , mb_array_size * 2 * sizeof(uint8_t)) | |
775 } | |
0 | 776 } |
767 | 777 if (s->out_format == FMT_H263) { |
0 | 778 /* ac values */ |
1938
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1918
diff
changeset
|
779 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
|
780 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
|
781 s->ac_val[1] = s->ac_val_base + y_size + s->mb_stride + 1; |
0 | 782 s->ac_val[2] = s->ac_val[1] + c_size; |
2967 | 783 |
0 | 784 /* cbp values */ |
1938
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1918
diff
changeset
|
785 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
|
786 s->coded_block= s->coded_block_base + s->b8_stride + 1; |
2967 | 787 |
456 | 788 /* 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
|
789 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
|
790 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
|
791 } |
2967 | 792 |
756 | 793 if (s->h263_pred || s->h263_plus || !s->encoding) { |
794 /* dc values */ | |
795 //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
|
796 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
|
797 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
|
798 s->dc_val[1] = s->dc_val_base + y_size + s->mb_stride + 1; |
756 | 799 s->dc_val[2] = s->dc_val[1] + c_size; |
800 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
|
801 s->dc_val_base[i] = 1024; |
756 | 802 } |
803 | |
611
3214d3f4519e
error concealment needs the mbintra_table so it should allways be allocated
michaelni
parents:
608
diff
changeset
|
804 /* 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
|
805 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
|
806 memset(s->mbintra_table, 1, mb_array_size); |
2967 | 807 |
7
1d3ac9654178
added skip macroblock optimization (big perf win on black regions for example)
glantau
parents:
0
diff
changeset
|
808 /* 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
|
809 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
|
810 //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
|
811 CHECKED_ALLOCZ(s->prev_pict_types, PREV_PICT_TYPES_BUFFER_SIZE); |
2967 | 812 |
842
e460775adb38
cleanup (breaks compatibility, requested by fabrice)
michaelni
parents:
828
diff
changeset
|
813 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
|
814 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
|
815 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
|
816 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
|
817 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
|
818 } |
842
e460775adb38
cleanup (breaks compatibility, requested by fabrice)
michaelni
parents:
828
diff
changeset
|
819 |
0 | 820 s->context_initialized = 1; |
1799 | 821 |
822 s->thread_context[0]= s; | |
823 for(i=1; i<s->avctx->thread_count; i++){ | |
824 s->thread_context[i]= av_malloc(sizeof(MpegEncContext)); | |
825 memcpy(s->thread_context[i], s, sizeof(MpegEncContext)); | |
826 } | |
827 | |
828 for(i=0; i<s->avctx->thread_count; i++){ | |
829 if(init_duplicate_context(s->thread_context[i], s) < 0) | |
830 goto fail; | |
831 s->thread_context[i]->start_mb_y= (s->mb_height*(i ) + s->avctx->thread_count/2) / s->avctx->thread_count; | |
832 s->thread_context[i]->end_mb_y = (s->mb_height*(i+1) + s->avctx->thread_count/2) / s->avctx->thread_count; | |
833 } | |
834 | |
0 | 835 return 0; |
836 fail: | |
244 | 837 MPV_common_end(s); |
838 return -1; | |
839 } | |
840 | |
841 /* init common structure for both encoder and decoder */ | |
842 void MPV_common_end(MpegEncContext *s) | |
843 { | |
1708 | 844 int i, j, k; |
244 | 845 |
1799 | 846 for(i=0; i<s->avctx->thread_count; i++){ |
847 free_duplicate_context(s->thread_context[i]); | |
848 } | |
849 for(i=1; i<s->avctx->thread_count; i++){ | |
850 av_freep(&s->thread_context[i]); | |
851 } | |
852 | |
1344
447b88b784ee
memleak fix by (Jake Page <jake at CS dot Stanford dot EDU>)
michaelni
parents:
1339
diff
changeset
|
853 av_freep(&s->parse_context.buffer); |
447b88b784ee
memleak fix by (Jake Page <jake at CS dot Stanford dot EDU>)
michaelni
parents:
1339
diff
changeset
|
854 s->parse_context.buffer_size=0; |
447b88b784ee
memleak fix by (Jake Page <jake at CS dot Stanford dot EDU>)
michaelni
parents:
1339
diff
changeset
|
855 |
396
fce0a2520551
removed useless header includes - use av memory functions
glantau
parents:
376
diff
changeset
|
856 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
|
857 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
|
858 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
|
859 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
|
860 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
|
861 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
|
862 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
|
863 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
|
864 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
|
865 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
|
866 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
|
867 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
|
868 s->b_direct_mv_table= NULL; |
1708 | 869 for(i=0; i<2; i++){ |
870 for(j=0; j<2; j++){ | |
871 for(k=0; k<2; k++){ | |
872 av_freep(&s->b_field_mv_table_base[i][j][k]); | |
873 s->b_field_mv_table[i][j][k]=NULL; | |
874 } | |
875 av_freep(&s->b_field_select_table[i][j]); | |
876 av_freep(&s->p_field_mv_table_base[i][j]); | |
877 s->p_field_mv_table[i][j]=NULL; | |
878 } | |
879 av_freep(&s->p_field_select_table[i]); | |
880 } | |
2967 | 881 |
1938
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1918
diff
changeset
|
882 av_freep(&s->dc_val_base); |
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1918
diff
changeset
|
883 av_freep(&s->ac_val_base); |
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1918
diff
changeset
|
884 av_freep(&s->coded_block_base); |
396
fce0a2520551
removed useless header includes - use av memory functions
glantau
parents:
376
diff
changeset
|
885 av_freep(&s->mbintra_table); |
456 | 886 av_freep(&s->cbp_table); |
887 av_freep(&s->pred_dir_table); | |
2967 | 888 |
396
fce0a2520551
removed useless header includes - use av memory functions
glantau
parents:
376
diff
changeset
|
889 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
|
890 av_freep(&s->prev_pict_types); |
396
fce0a2520551
removed useless header includes - use av memory functions
glantau
parents:
376
diff
changeset
|
891 av_freep(&s->bitstream_buffer); |
2422 | 892 s->allocated_bitstream_buffer_size=0; |
893 | |
612 | 894 av_freep(&s->avctx->stats_out); |
650
ef4a33aad86e
reducing sizeof MpegEncContext to avoid stack overflow on crap M$ windo$
michaelni
parents:
635
diff
changeset
|
895 av_freep(&s->ac_stats); |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
731
diff
changeset
|
896 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
|
897 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
|
898 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
|
899 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
|
900 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
|
901 av_freep(&s->q_intra_matrix16); |
d736e24bf303
move mmx quantizer matrixes out of MpegEncContext (23k -> 7k) (no meassureable slowdown)
michael
parents:
1553
diff
changeset
|
902 av_freep(&s->q_inter_matrix16); |
1556 | 903 av_freep(&s->input_picture); |
904 av_freep(&s->reordered_input_picture); | |
1597 | 905 av_freep(&s->dct_offset); |
903 | 906 |
1573 | 907 if(s->picture){ |
908 for(i=0; i<MAX_PICTURE_COUNT; i++){ | |
909 free_picture(s, &s->picture[i]); | |
910 } | |
0 | 911 } |
1552
26c6ecba99a1
dynamic alloc of picture structs instead of putting them in MpegEncContext
michael
parents:
1546
diff
changeset
|
912 av_freep(&s->picture); |
0 | 913 s->context_initialized = 0; |
1523 | 914 s->last_picture_ptr= |
915 s->next_picture_ptr= | |
916 s->current_picture_ptr= NULL; | |
2231 | 917 s->linesize= s->uvlinesize= 0; |
1918
ea20f38b8d57
nicer looking arrows for the motion vector vissualization
michael
parents:
1916
diff
changeset
|
918 |
1706
3ba5c493db6f
motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1705
diff
changeset
|
919 for(i=0; i<3; i++) |
1918
ea20f38b8d57
nicer looking arrows for the motion vector vissualization
michael
parents:
1916
diff
changeset
|
920 av_freep(&s->visualization_buffer[i]); |
2231 | 921 |
922 avcodec_default_free_buffers(s->avctx); | |
0 | 923 } |
924 | |
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
|
925 #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
|
926 |
0 | 927 /* init video encoder */ |
928 int MPV_encode_init(AVCodecContext *avctx) | |
929 { | |
930 MpegEncContext *s = avctx->priv_data; | |
2834 | 931 int i; |
1315
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1288
diff
changeset
|
932 int chroma_h_shift, chroma_v_shift; |
2967 | 933 |
1892 | 934 MPV_encode_defaults(s); |
315 | 935 |
3309 | 936 switch (avctx->codec_id) { |
937 case CODEC_ID_MPEG2VIDEO: | |
938 if(avctx->pix_fmt != PIX_FMT_YUV420P && avctx->pix_fmt != PIX_FMT_YUV422P){ | |
939 av_log(avctx, AV_LOG_ERROR, "only YUV420 and YUV422 are supported\n"); | |
940 return -1; | |
941 } | |
942 break; | |
943 case CODEC_ID_LJPEG: | |
944 case CODEC_ID_MJPEG: | |
3929 | 945 if(avctx->pix_fmt != PIX_FMT_YUVJ420P && avctx->pix_fmt != PIX_FMT_YUVJ422P && |
946 ((avctx->pix_fmt != PIX_FMT_YUV420P && avctx->pix_fmt != PIX_FMT_YUV422P) || avctx->strict_std_compliance>FF_COMPLIANCE_INOFFICIAL)){ | |
2442 | 947 av_log(avctx, AV_LOG_ERROR, "colorspace not supported in jpeg\n"); |
948 return -1; | |
949 } | |
3309 | 950 break; |
951 default: | |
952 if(avctx->pix_fmt != PIX_FMT_YUV420P){ | |
953 av_log(avctx, AV_LOG_ERROR, "only YUV420 is supported\n"); | |
2442 | 954 return -1; |
955 } | |
956 } | |
1402
f662e9c86cf2
* fixing a regression in mpeg encoder (not setting pix_fmt),
romansh
parents:
1397
diff
changeset
|
957 |
3309 | 958 switch (avctx->pix_fmt) { |
959 case PIX_FMT_YUVJ422P: | |
960 case PIX_FMT_YUV422P: | |
961 s->chroma_format = CHROMA_422; | |
962 break; | |
963 case PIX_FMT_YUVJ420P: | |
964 case PIX_FMT_YUV420P: | |
965 default: | |
966 s->chroma_format = CHROMA_420; | |
967 break; | |
968 } | |
969 | |
0 | 970 s->bit_rate = avctx->bit_rate; |
971 s->width = avctx->width; | |
972 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
|
973 if(avctx->gop_size > 600 && avctx->strict_std_compliance>FF_COMPLIANCE_EXPERIMENTAL){ |
2979 | 974 av_log(avctx, AV_LOG_ERROR, "Warning keyframe interval too large! reducing it ...\n"); |
456 | 975 avctx->gop_size=600; |
976 } | |
0 | 977 s->gop_size = avctx->gop_size; |
194
27d1773552c9
mpeg4 encoder fix by Michael Niedermayer <michaelni@gmx.at>
arpi_esp
parents:
191
diff
changeset
|
978 s->avctx = avctx; |
294 | 979 s->flags= avctx->flags; |
1754
bdf3927bf8c5
closed gop support & flags2 as all bits in flags are used
michael
parents:
1751
diff
changeset
|
980 s->flags2= avctx->flags2; |
324 | 981 s->max_b_frames= avctx->max_b_frames; |
344 | 982 s->codec_id= avctx->codec->id; |
456 | 983 s->luma_elim_threshold = avctx->luma_elim_threshold; |
984 s->chroma_elim_threshold= avctx->chroma_elim_threshold; | |
985 s->strict_std_compliance= avctx->strict_std_compliance; | |
986 s->data_partitioning= avctx->flags & CODEC_FLAG_PART; | |
936 | 987 s->quarter_sample= (avctx->flags & CODEC_FLAG_QPEL)!=0; |
599 | 988 s->mpeg_quant= avctx->mpeg_quant; |
1661 | 989 s->rtp_mode= !!avctx->rtp_payload_size; |
1992 | 990 s->intra_dc_precision= avctx->intra_dc_precision; |
2243
b8bad8bbbc64
check if the user specified timestamps are strictly monotone
michael
parents:
2235
diff
changeset
|
991 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
|
992 |
0 | 993 if (s->gop_size <= 1) { |
994 s->intra_only = 1; | |
995 s->gop_size = 12; | |
996 } else { | |
997 s->intra_only = 0; | |
998 } | |
693
b6a7ff92df57
darkness masking (lumi masking does only bright stuff now)
michaelni
parents:
690
diff
changeset
|
999 |
936 | 1000 s->me_method = avctx->me_method; |
693
b6a7ff92df57
darkness masking (lumi masking does only bright stuff now)
michaelni
parents:
690
diff
changeset
|
1001 |
320
cda7d0857baf
- ME setting moved to AVCodecContext/MpegEncContext, no longer a global.
pulento
parents:
315
diff
changeset
|
1002 /* Fixed QSCALE */ |
1708 | 1003 s->fixed_qscale = !!(avctx->flags & CODEC_FLAG_QSCALE); |
2967 | 1004 |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
673
diff
changeset
|
1005 s->adaptive_quant= ( s->avctx->lumi_masking |
693
b6a7ff92df57
darkness masking (lumi masking does only bright stuff now)
michaelni
parents:
690
diff
changeset
|
1006 || s->avctx->dark_masking |
2967 | 1007 || s->avctx->temporal_cplx_masking |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
673
diff
changeset
|
1008 || s->avctx->spatial_cplx_masking |
1616 | 1009 || s->avctx->p_masking |
2493
258120c61eea
Border processing adaptive quant patch by (Christophe Massiot |cmassiot freebox fr)
michael
parents:
2492
diff
changeset
|
1010 || s->avctx->border_masking |
1616 | 1011 || (s->flags&CODEC_FLAG_QP_RD)) |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
673
diff
changeset
|
1012 && !s->fixed_qscale; |
2967 | 1013 |
1708 | 1014 s->obmc= !!(s->flags & CODEC_FLAG_OBMC); |
1015 s->loop_filter= !!(s->flags & CODEC_FLAG_LOOP_FILTER); | |
1016 s->alternate_scan= !!(s->flags & CODEC_FLAG_ALT_SCAN); | |
3305 | 1017 s->intra_vlc_format= !!(s->flags2 & CODEC_FLAG2_INTRA_VLC); |
4621 | 1018 s->q_scale_type= !!(s->flags2 & CODEC_FLAG2_NON_LINEAR_QUANT); |
1633 | 1019 |
1711 | 1020 if(avctx->rc_max_rate && !avctx->rc_buffer_size){ |
1021 av_log(avctx, AV_LOG_ERROR, "a vbv buffer size is needed, for encoding with a maximum bitrate\n"); | |
1022 return -1; | |
2967 | 1023 } |
1711 | 1024 |
1025 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
|
1026 av_log(avctx, AV_LOG_INFO, "Warning min_rate > 0 but min_rate != max_rate isn't recommended!\n"); |
1907 | 1027 } |
2967 | 1028 |
2063 | 1029 if(avctx->rc_min_rate && avctx->rc_min_rate > avctx->bit_rate){ |
1030 av_log(avctx, AV_LOG_INFO, "bitrate below min bitrate\n"); | |
1031 return -1; | |
1032 } | |
2967 | 1033 |
2063 | 1034 if(avctx->rc_max_rate && avctx->rc_max_rate < avctx->bit_rate){ |
1035 av_log(avctx, AV_LOG_INFO, "bitrate above max bitrate\n"); | |
1036 return -1; | |
1037 } | |
2967 | 1038 |
1039 if( s->avctx->rc_max_rate && s->avctx->rc_min_rate == s->avctx->rc_max_rate | |
1907 | 1040 && (s->codec_id == CODEC_ID_MPEG1VIDEO || s->codec_id == CODEC_ID_MPEG2VIDEO) |
1041 && 90000LL * (avctx->rc_buffer_size-1) > s->avctx->rc_max_rate*0xFFFFLL){ | |
2967 | 1042 |
1907 | 1043 av_log(avctx, AV_LOG_INFO, "Warning vbv_delay will be set to 0xFFFF (=VBR) as the specified vbv buffer is too large for the given bitrate!\n"); |
1044 } | |
2967 | 1045 |
1046 if((s->flags & CODEC_FLAG_4MV) && s->codec_id != CODEC_ID_MPEG4 | |
1790 | 1047 && s->codec_id != CODEC_ID_H263 && s->codec_id != CODEC_ID_H263P && s->codec_id != CODEC_ID_FLV1){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1597
diff
changeset
|
1048 av_log(avctx, AV_LOG_ERROR, "4MV not supported by codec\n"); |
1188 | 1049 return -1; |
1050 } | |
2967 | 1051 |
1633 | 1052 if(s->obmc && s->avctx->mb_decision != FF_MB_DECISION_SIMPLE){ |
2627
bf158d23bbcc
Spelling errors patch by (Kevin Baragona | kevinmb500 gawab com)
michael
parents:
2620
diff
changeset
|
1053 av_log(avctx, AV_LOG_ERROR, "OBMC is only supported with simple mb decision\n"); |
1633 | 1054 return -1; |
1055 } | |
2967 | 1056 |
1644 | 1057 if(s->obmc && s->codec_id != CODEC_ID_H263 && s->codec_id != CODEC_ID_H263P){ |
1058 av_log(avctx, AV_LOG_ERROR, "OBMC is only supported with H263(+)\n"); | |
1059 return -1; | |
1060 } | |
2967 | 1061 |
1188 | 1062 if(s->quarter_sample && s->codec_id != CODEC_ID_MPEG4){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1597
diff
changeset
|
1063 av_log(avctx, AV_LOG_ERROR, "qpel not supported by codec\n"); |
1188 | 1064 return -1; |
1065 } | |
1066 | |
1067 if(s->data_partitioning && s->codec_id != CODEC_ID_MPEG4){ | |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1597
diff
changeset
|
1068 av_log(avctx, AV_LOG_ERROR, "data partitioning not supported by codec\n"); |
1188 | 1069 return -1; |
1070 } | |
2967 | 1071 |
1421 | 1072 if(s->max_b_frames && s->codec_id != CODEC_ID_MPEG4 && s->codec_id != CODEC_ID_MPEG1VIDEO && s->codec_id != CODEC_ID_MPEG2VIDEO){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1597
diff
changeset
|
1073 av_log(avctx, AV_LOG_ERROR, "b frames not supported by codec\n"); |
1188 | 1074 return -1; |
1075 } | |
1958 | 1076 |
2967 | 1077 if((s->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME|CODEC_FLAG_ALT_SCAN)) |
1958 | 1078 && s->codec_id != CODEC_ID_MPEG4 && s->codec_id != CODEC_ID_MPEG2VIDEO){ |
1079 av_log(avctx, AV_LOG_ERROR, "interlacing not supported by codec\n"); | |
1080 return -1; | |
1081 } | |
2967 | 1082 |
1188 | 1083 if(s->mpeg_quant && s->codec_id != CODEC_ID_MPEG4){ //FIXME mpeg2 uses that too |
2627
bf158d23bbcc
Spelling errors patch by (Kevin Baragona | kevinmb500 gawab com)
michael
parents:
2620
diff
changeset
|
1084 av_log(avctx, AV_LOG_ERROR, "mpeg2 style quantization not supported by codec\n"); |
1188 | 1085 return -1; |
1086 } | |
2967 | 1087 |
1490
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1480
diff
changeset
|
1088 if((s->flags & CODEC_FLAG_CBP_RD) && !(s->flags & CODEC_FLAG_TRELLIS_QUANT)){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1597
diff
changeset
|
1089 av_log(avctx, AV_LOG_ERROR, "CBP RD needs trellis quant\n"); |
1490
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1480
diff
changeset
|
1090 return -1; |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1480
diff
changeset
|
1091 } |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1480
diff
changeset
|
1092 |
1622 | 1093 if((s->flags & CODEC_FLAG_QP_RD) && s->avctx->mb_decision != FF_MB_DECISION_RD){ |
1094 av_log(avctx, AV_LOG_ERROR, "QP RD needs mbd=2\n"); | |
1095 return -1; | |
1096 } | |
2967 | 1097 |
1754
bdf3927bf8c5
closed gop support & flags2 as all bits in flags are used
michael
parents:
1751
diff
changeset
|
1098 if(s->avctx->scenechange_threshold < 1000000000 && (s->flags & CODEC_FLAG_CLOSED_GOP)){ |
4399
daa2a095181d
add hint for closed gop and sc threshold error message
bcoudurier
parents:
4396
diff
changeset
|
1099 av_log(avctx, AV_LOG_ERROR, "closed gop with scene change detection arent supported yet, set threshold to 1000000000\n"); |
1754
bdf3927bf8c5
closed gop support & flags2 as all bits in flags are used
michael
parents:
1751
diff
changeset
|
1100 return -1; |
bdf3927bf8c5
closed gop support & flags2 as all bits in flags are used
michael
parents:
1751
diff
changeset
|
1101 } |
2967 | 1102 |
3305 | 1103 if((s->flags2 & CODEC_FLAG2_INTRA_VLC) && s->codec_id != CODEC_ID_MPEG2VIDEO){ |
1104 av_log(avctx, AV_LOG_ERROR, "intra vlc table not supported by codec\n"); | |
1105 return -1; | |
1106 } | |
1107 | |
4189
3c98b0938897
add low delay forcing option for mpeg1/2 encoding
bcoudurier
parents:
4179
diff
changeset
|
1108 if(s->flags & CODEC_FLAG_LOW_DELAY){ |
3c98b0938897
add low delay forcing option for mpeg1/2 encoding
bcoudurier
parents:
4179
diff
changeset
|
1109 if (s->codec_id != CODEC_ID_MPEG2VIDEO && s->codec_id != CODEC_ID_MPEG1VIDEO){ |
3c98b0938897
add low delay forcing option for mpeg1/2 encoding
bcoudurier
parents:
4179
diff
changeset
|
1110 av_log(avctx, AV_LOG_ERROR, "low delay forcing is only available for mpeg1/2\n"); |
3c98b0938897
add low delay forcing option for mpeg1/2 encoding
bcoudurier
parents:
4179
diff
changeset
|
1111 return -1; |
3c98b0938897
add low delay forcing option for mpeg1/2 encoding
bcoudurier
parents:
4179
diff
changeset
|
1112 } |
3c98b0938897
add low delay forcing option for mpeg1/2 encoding
bcoudurier
parents:
4179
diff
changeset
|
1113 if (s->max_b_frames != 0){ |
3c98b0938897
add low delay forcing option for mpeg1/2 encoding
bcoudurier
parents:
4179
diff
changeset
|
1114 av_log(avctx, AV_LOG_ERROR, "b frames cannot be used with low delay\n"); |
3c98b0938897
add low delay forcing option for mpeg1/2 encoding
bcoudurier
parents:
4179
diff
changeset
|
1115 return -1; |
3c98b0938897
add low delay forcing option for mpeg1/2 encoding
bcoudurier
parents:
4179
diff
changeset
|
1116 } |
3c98b0938897
add low delay forcing option for mpeg1/2 encoding
bcoudurier
parents:
4179
diff
changeset
|
1117 } |
3c98b0938897
add low delay forcing option for mpeg1/2 encoding
bcoudurier
parents:
4179
diff
changeset
|
1118 |
4621 | 1119 if(s->q_scale_type == 1){ |
1120 if(s->codec_id != CODEC_ID_MPEG2VIDEO){ | |
1121 av_log(avctx, AV_LOG_ERROR, "non linear quant is only available for mpeg2\n"); | |
1122 return -1; | |
1123 } | |
1124 if(avctx->qmax > 12){ | |
1125 av_log(avctx, AV_LOG_ERROR, "non linear quant only supports qmax <= 12 currently\n"); | |
1126 return -1; | |
1127 } | |
1128 } | |
1129 | |
2967 | 1130 if(s->avctx->thread_count > 1 && s->codec_id != CODEC_ID_MPEG4 |
1131 && s->codec_id != CODEC_ID_MPEG1VIDEO && s->codec_id != CODEC_ID_MPEG2VIDEO | |
1799 | 1132 && (s->codec_id != CODEC_ID_H263P || !(s->flags & CODEC_FLAG_H263P_SLICE_STRUCT))){ |
1133 av_log(avctx, AV_LOG_ERROR, "multi threaded encoding not supported by codec\n"); | |
1134 return -1; | |
1135 } | |
2967 | 1136 |
1799 | 1137 if(s->avctx->thread_count > 1) |
1138 s->rtp_mode= 1; | |
1760 | 1139 |
2637 | 1140 if(!avctx->time_base.den || !avctx->time_base.num){ |
2450 | 1141 av_log(avctx, AV_LOG_ERROR, "framerate not set\n"); |
1142 return -1; | |
1143 } | |
2967 | 1144 |
2576
e237d9bd0f8c
check mb/me_threshold range, fixes assertion failure
michael
parents:
2570
diff
changeset
|
1145 i= (INT_MAX/2+128)>>8; |
e237d9bd0f8c
check mb/me_threshold range, fixes assertion failure
michael
parents:
2570
diff
changeset
|
1146 if(avctx->me_threshold >= i){ |
e237d9bd0f8c
check mb/me_threshold range, fixes assertion failure
michael
parents:
2570
diff
changeset
|
1147 av_log(avctx, AV_LOG_ERROR, "me_threshold too large, max is %d\n", i - 1); |
e237d9bd0f8c
check mb/me_threshold range, fixes assertion failure
michael
parents:
2570
diff
changeset
|
1148 return -1; |
e237d9bd0f8c
check mb/me_threshold range, fixes assertion failure
michael
parents:
2570
diff
changeset
|
1149 } |
e237d9bd0f8c
check mb/me_threshold range, fixes assertion failure
michael
parents:
2570
diff
changeset
|
1150 if(avctx->mb_threshold >= i){ |
e237d9bd0f8c
check mb/me_threshold range, fixes assertion failure
michael
parents:
2570
diff
changeset
|
1151 av_log(avctx, AV_LOG_ERROR, "mb_threshold too large, max is %d\n", i - 1); |
e237d9bd0f8c
check mb/me_threshold range, fixes assertion failure
michael
parents:
2570
diff
changeset
|
1152 return -1; |
e237d9bd0f8c
check mb/me_threshold range, fixes assertion failure
michael
parents:
2570
diff
changeset
|
1153 } |
2967 | 1154 |
2668 | 1155 if(avctx->b_frame_strategy && (avctx->flags&CODEC_FLAG_PASS2)){ |
3321
8869b4dd2ffe
Make b_frame_strategy not fail on pass 2, but still print a notice.
corey
parents:
3316
diff
changeset
|
1156 av_log(avctx, AV_LOG_INFO, "notice: b_frame_strategy only affects the first pass\n"); |
8869b4dd2ffe
Make b_frame_strategy not fail on pass 2, but still print a notice.
corey
parents:
3316
diff
changeset
|
1157 avctx->b_frame_strategy = 0; |
2668 | 1158 } |
1159 | |
2637 | 1160 i= ff_gcd(avctx->time_base.den, avctx->time_base.num); |
1760 | 1161 if(i > 1){ |
1162 av_log(avctx, AV_LOG_INFO, "removing common factors from framerate\n"); | |
2637 | 1163 avctx->time_base.den /= i; |
1164 avctx->time_base.num /= i; | |
1760 | 1165 // return -1; |
1166 } | |
2967 | 1167 |
1150 | 1168 if(s->codec_id==CODEC_ID_MJPEG){ |
1169 s->intra_quant_bias= 1<<(QUANT_BIAS_SHIFT-1); //(a + x/2)/x | |
1170 s->inter_quant_bias= 0; | |
1421 | 1171 }else if(s->mpeg_quant || s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO){ |
1150 | 1172 s->intra_quant_bias= 3<<(QUANT_BIAS_SHIFT-3); //(a + x*3/8)/x |
1173 s->inter_quant_bias= 0; | |
1174 }else{ | |
1175 s->intra_quant_bias=0; | |
1176 s->inter_quant_bias=-(1<<(QUANT_BIAS_SHIFT-2)); //(a - x/4)/x | |
1177 } | |
2967 | 1178 |
1150 | 1179 if(avctx->intra_quant_bias != FF_DEFAULT_QUANT_BIAS) |
1180 s->intra_quant_bias= avctx->intra_quant_bias; | |
1181 if(avctx->inter_quant_bias != FF_DEFAULT_QUANT_BIAS) | |
1182 s->inter_quant_bias= avctx->inter_quant_bias; | |
2967 | 1183 |
1315
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1288
diff
changeset
|
1184 avcodec_get_chroma_sub_sample(avctx->pix_fmt, &chroma_h_shift, &chroma_v_shift); |
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1288
diff
changeset
|
1185 |
2653
2515af7d3238
complain about mpeg4 limits only if codec_id == MPEG4
michael
parents:
2639
diff
changeset
|
1186 if(avctx->codec_id == CODEC_ID_MPEG4 && s->avctx->time_base.den > (1<<16)-1){ |
2637 | 1187 av_log(avctx, AV_LOG_ERROR, "timebase not supported by mpeg 4 standard\n"); |
2967 | 1188 return -1; |
2637 | 1189 } |
1190 s->time_increment_bits = av_log2(s->avctx->time_base.den - 1) + 1; | |
1424 | 1191 |
0 | 1192 switch(avctx->codec->id) { |
1193 case CODEC_ID_MPEG1VIDEO: | |
1194 s->out_format = FMT_MPEG1; | |
4189
3c98b0938897
add low delay forcing option for mpeg1/2 encoding
bcoudurier
parents:
4179
diff
changeset
|
1195 s->low_delay= !!(s->flags & CODEC_FLAG_LOW_DELAY); |
1126
77ccf7fe3bd0
per context frame_rate_base, this should finally fix frame_rate related av sync issues
michaelni
parents:
1124
diff
changeset
|
1196 avctx->delay= s->low_delay ? 0 : (s->max_b_frames + 1); |
0 | 1197 break; |
1421 | 1198 case CODEC_ID_MPEG2VIDEO: |
1199 s->out_format = FMT_MPEG1; | |
4189
3c98b0938897
add low delay forcing option for mpeg1/2 encoding
bcoudurier
parents:
4179
diff
changeset
|
1200 s->low_delay= !!(s->flags & CODEC_FLAG_LOW_DELAY); |
1421 | 1201 avctx->delay= s->low_delay ? 0 : (s->max_b_frames + 1); |
1661 | 1202 s->rtp_mode= 1; |
1421 | 1203 break; |
1315
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1288
diff
changeset
|
1204 case CODEC_ID_LJPEG: |
2973 | 1205 case CODEC_ID_JPEGLS: |
0 | 1206 case CODEC_ID_MJPEG: |
1207 s->out_format = FMT_MJPEG; | |
1208 s->intra_only = 1; /* force intra only for jpeg */ | |
2973 | 1209 s->mjpeg_write_tables = avctx->codec->id != CODEC_ID_JPEGLS; |
2979 | 1210 s->mjpeg_data_only_frames = 0; /* write all the needed headers */ |
3929 | 1211 s->mjpeg_vsample[0] = 2; |
1212 s->mjpeg_vsample[1] = 2>>chroma_v_shift; | |
1213 s->mjpeg_vsample[2] = 2>>chroma_v_shift; | |
1214 s->mjpeg_hsample[0] = 2; | |
1215 s->mjpeg_hsample[1] = 2>>chroma_h_shift; | |
1216 s->mjpeg_hsample[2] = 2>>chroma_h_shift; | |
0 | 1217 if (mjpeg_init(s) < 0) |
1218 return -1; | |
336 | 1219 avctx->delay=0; |
924 | 1220 s->low_delay=1; |
0 | 1221 break; |
4219 | 1222 #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
|
1223 case CODEC_ID_H261: |
4206
be94e97ecb6e
throw error if unsupported resolution is used with h261
bcoudurier
parents:
4189
diff
changeset
|
1224 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
|
1225 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
|
1226 return -1; |
be94e97ecb6e
throw error if unsupported resolution is used with h261
bcoudurier
parents:
4189
diff
changeset
|
1227 } |
2327
5e5cf598a48b
H.261 encoder by (Maarten Daniels <maarten dot daniels at luc dot ac dot be>)
michael
parents:
2298
diff
changeset
|
1228 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
|
1229 avctx->delay=0; |
5e5cf598a48b
H.261 encoder by (Maarten Daniels <maarten dot daniels at luc dot ac dot be>)
michael
parents:
2298
diff
changeset
|
1230 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
|
1231 break; |
4219 | 1232 #endif |
0 | 1233 case CODEC_ID_H263: |
232
b640ec5948b0
- Now the ME is done for the entire picture when enconding, the
pulento
parents:
231
diff
changeset
|
1234 if (h263_get_picture_format(s->width, s->height) == 7) { |
3011 | 1235 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 | 1236 return -1; |
232
b640ec5948b0
- Now the ME is done for the entire picture when enconding, the
pulento
parents:
231
diff
changeset
|
1237 } |
0 | 1238 s->out_format = FMT_H263; |
2979 | 1239 s->obmc= (avctx->flags & CODEC_FLAG_OBMC) ? 1:0; |
336 | 1240 avctx->delay=0; |
924 | 1241 s->low_delay=1; |
0 | 1242 break; |
1243 case CODEC_ID_H263P: | |
1244 s->out_format = FMT_H263; | |
1245 s->h263_plus = 1; | |
2979 | 1246 /* Fx */ |
1644 | 1247 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
|
1248 s->h263_aic= (avctx->flags & CODEC_FLAG_AC_PRED) ? 1:0; |
2979 | 1249 s->modified_quant= s->h263_aic; |
1250 s->alt_inter_vlc= (avctx->flags & CODEC_FLAG_H263P_AIV) ? 1:0; | |
1251 s->obmc= (avctx->flags & CODEC_FLAG_OBMC) ? 1:0; | |
1252 s->loop_filter= (avctx->flags & CODEC_FLAG_LOOP_FILTER) ? 1:0; | |
1253 s->unrestricted_mv= s->obmc || s->loop_filter || s->umvplus; | |
1661 | 1254 s->h263_slice_structured= (s->flags & CODEC_FLAG_H263P_SLICE_STRUCT) ? 1:0; |
1644 | 1255 |
2979 | 1256 /* /Fx */ |
79
82e579c37bc3
Moved some H.263+ variables to MpegEncContext to be thread-safe.
pulento
parents:
78
diff
changeset
|
1257 /* These are just to be sure */ |
336 | 1258 avctx->delay=0; |
924 | 1259 s->low_delay=1; |
0 | 1260 break; |
1353
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1344
diff
changeset
|
1261 case CODEC_ID_FLV1: |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1344
diff
changeset
|
1262 s->out_format = FMT_H263; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1344
diff
changeset
|
1263 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
|
1264 s->unrestricted_mv = 1; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1344
diff
changeset
|
1265 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
|
1266 avctx->delay=0; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1344
diff
changeset
|
1267 s->low_delay=1; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1344
diff
changeset
|
1268 break; |
0 | 1269 case CODEC_ID_RV10: |
1270 s->out_format = FMT_H263; | |
336 | 1271 avctx->delay=0; |
924 | 1272 s->low_delay=1; |
0 | 1273 break; |
2380 | 1274 case CODEC_ID_RV20: |
1275 s->out_format = FMT_H263; | |
1276 avctx->delay=0; | |
1277 s->low_delay=1; | |
1278 s->modified_quant=1; | |
1279 s->h263_aic=1; | |
1280 s->h263_plus=1; | |
1281 s->loop_filter=1; | |
1282 s->unrestricted_mv= s->obmc || s->loop_filter || s->umvplus; | |
1283 break; | |
71 | 1284 case CODEC_ID_MPEG4: |
0 | 1285 s->out_format = FMT_H263; |
1286 s->h263_pred = 1; | |
1287 s->unrestricted_mv = 1; | |
924 | 1288 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
|
1289 avctx->delay= s->low_delay ? 0 : (s->max_b_frames + 1); |
0 | 1290 break; |
307 | 1291 case CODEC_ID_MSMPEG4V1: |
0 | 1292 s->out_format = FMT_H263; |
1293 s->h263_msmpeg4 = 1; | |
1294 s->h263_pred = 1; | |
1295 s->unrestricted_mv = 1; | |
307 | 1296 s->msmpeg4_version= 1; |
336 | 1297 avctx->delay=0; |
924 | 1298 s->low_delay=1; |
307 | 1299 break; |
1300 case CODEC_ID_MSMPEG4V2: | |
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= 2; | |
336 | 1306 avctx->delay=0; |
924 | 1307 s->low_delay=1; |
307 | 1308 break; |
1309 case CODEC_ID_MSMPEG4V3: | |
1310 s->out_format = FMT_H263; | |
1311 s->h263_msmpeg4 = 1; | |
1312 s->h263_pred = 1; | |
1313 s->unrestricted_mv = 1; | |
1314 s->msmpeg4_version= 3; | |
1163 | 1315 s->flipflop_rounding=1; |
336 | 1316 avctx->delay=0; |
924 | 1317 s->low_delay=1; |
0 | 1318 break; |
499 | 1319 case CODEC_ID_WMV1: |
1320 s->out_format = FMT_H263; | |
1321 s->h263_msmpeg4 = 1; | |
1322 s->h263_pred = 1; | |
1323 s->unrestricted_mv = 1; | |
1324 s->msmpeg4_version= 4; | |
1163 | 1325 s->flipflop_rounding=1; |
499 | 1326 avctx->delay=0; |
924 | 1327 s->low_delay=1; |
499 | 1328 break; |
1329 case CODEC_ID_WMV2: | |
1330 s->out_format = FMT_H263; | |
1331 s->h263_msmpeg4 = 1; | |
1332 s->h263_pred = 1; | |
1333 s->unrestricted_mv = 1; | |
1334 s->msmpeg4_version= 5; | |
1163 | 1335 s->flipflop_rounding=1; |
499 | 1336 avctx->delay=0; |
924 | 1337 s->low_delay=1; |
499 | 1338 break; |
0 | 1339 default: |
1340 return -1; | |
1341 } | |
2967 | 1342 |
2042 | 1343 avctx->has_b_frames= !s->low_delay; |
1749
7b11032507e2
removing broken framerate conversation hack in mpeg1/2
michael
parents:
1742
diff
changeset
|
1344 |
7
1d3ac9654178
added skip macroblock optimization (big perf win on black regions for example)
glantau
parents:
0
diff
changeset
|
1345 s->encoding = 1; |
1d3ac9654178
added skip macroblock optimization (big perf win on black regions for example)
glantau
parents:
0
diff
changeset
|
1346 |
0 | 1347 /* init */ |
1348 if (MPV_common_init(s) < 0) | |
1349 return -1; | |
1678 | 1350 |
1351 if(s->modified_quant) | |
1352 s->chroma_qscale_table= ff_h263_chroma_qscale_table; | |
2967 | 1353 s->progressive_frame= |
4121 | 1354 s->progressive_sequence= !(avctx->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME|CODEC_FLAG_ALT_SCAN)); |
1799 | 1355 s->quant_precision=5; |
2967 | 1356 |
1729 | 1357 ff_set_cmp(&s->dsp, s->dsp.ildct_cmp, s->avctx->ildct_cmp); |
2382 | 1358 ff_set_cmp(&s->dsp, s->dsp.frame_skip_cmp, s->avctx->frame_skip_cmp); |
2967 | 1359 |
2639 | 1360 #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
|
1361 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
|
1362 ff_h261_encode_init(s); |
2639 | 1363 #endif |
706
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
1364 if (s->out_format == FMT_H263) |
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
1365 h263_encode_init(s); |
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
1366 if(s->msmpeg4_version) |
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
1367 ff_msmpeg4_encode_init(s); |
1042 | 1368 if (s->out_format == FMT_MPEG1) |
1369 ff_mpeg1_encode_init(s); | |
706
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
1370 |
1892 | 1371 /* init q matrix */ |
60 | 1372 for(i=0;i<64;i++) { |
1092 | 1373 int j= s->dsp.idct_permutation[i]; |
599 | 1374 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
|
1375 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
|
1376 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
|
1377 }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
|
1378 s->intra_matrix[j] = |
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
1379 s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i]; |
1042 | 1380 }else |
1421 | 1381 { /* mpeg1/2 */ |
706
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
1382 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
|
1383 s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i]; |
599 | 1384 } |
1411 | 1385 if(s->avctx->intra_matrix) |
1386 s->intra_matrix[j] = s->avctx->intra_matrix[i]; | |
1387 if(s->avctx->inter_matrix) | |
1388 s->inter_matrix[j] = s->avctx->inter_matrix[i]; | |
344 | 1389 } |
1390 | |
1391 /* precompute matrix */ | |
350
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
347
diff
changeset
|
1392 /* for mjpeg, we do include qscale in the matrix */ |
344 | 1393 if (s->out_format != FMT_MJPEG) { |
2967 | 1394 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
|
1395 s->intra_matrix, s->intra_quant_bias, avctx->qmin, 31, 1); |
2967 | 1396 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
|
1397 s->inter_matrix, s->inter_quant_bias, avctx->qmin, 31, 0); |
60 | 1398 } |
1399 | |
329 | 1400 if(ff_rate_control_init(s) < 0) |
1401 return -1; | |
2967 | 1402 |
0 | 1403 return 0; |
1404 } | |
1405 | |
1406 int MPV_encode_end(AVCodecContext *avctx) | |
1407 { | |
1408 MpegEncContext *s = avctx->priv_data; | |
1409 | |
329 | 1410 ff_rate_control_uninit(s); |
1411 | |
0 | 1412 MPV_common_end(s); |
1413 if (s->out_format == FMT_MJPEG) | |
1414 mjpeg_close(s); | |
1458
40b69d238beb
AVI stream header FCC / more reliable detection of old xvid files
michaelni
parents:
1451
diff
changeset
|
1415 |
1424 | 1416 av_freep(&avctx->extradata); |
2967 | 1417 |
0 | 1418 return 0; |
1419 } | |
1420 | |
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
|
1421 #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
|
1422 |
2370
26560d4fdb1f
Memory leak fix patch by (Burkhard Plaum <plaum >at< ipf.uni-stuttgart )dot( de>)
michael
parents:
2364
diff
changeset
|
1423 void init_rl(RLTable *rl, int use_static) |
1042 | 1424 { |
1064 | 1425 int8_t max_level[MAX_RUN+1], max_run[MAX_LEVEL+1]; |
1426 uint8_t index_run[MAX_RUN+1]; | |
1042 | 1427 int last, run, level, start, end, i; |
1428 | |
2370
26560d4fdb1f
Memory leak fix patch by (Burkhard Plaum <plaum >at< ipf.uni-stuttgart )dot( de>)
michael
parents:
2364
diff
changeset
|
1429 /* If table is static, we can quit if rl->max_level[0] is not NULL */ |
26560d4fdb1f
Memory leak fix patch by (Burkhard Plaum <plaum >at< ipf.uni-stuttgart )dot( de>)
michael
parents:
2364
diff
changeset
|
1430 if(use_static && rl->max_level[0]) |
26560d4fdb1f
Memory leak fix patch by (Burkhard Plaum <plaum >at< ipf.uni-stuttgart )dot( de>)
michael
parents:
2364
diff
changeset
|
1431 return; |
26560d4fdb1f
Memory leak fix patch by (Burkhard Plaum <plaum >at< ipf.uni-stuttgart )dot( de>)
michael
parents:
2364
diff
changeset
|
1432 |
1042 | 1433 /* compute max_level[], max_run[] and index_run[] */ |
1434 for(last=0;last<2;last++) { | |
1435 if (last == 0) { | |
1436 start = 0; | |
1437 end = rl->last; | |
1438 } else { | |
1439 start = rl->last; | |
1440 end = rl->n; | |
1441 } | |
1442 | |
1443 memset(max_level, 0, MAX_RUN + 1); | |
1444 memset(max_run, 0, MAX_LEVEL + 1); | |
1445 memset(index_run, rl->n, MAX_RUN + 1); | |
1446 for(i=start;i<end;i++) { | |
1447 run = rl->table_run[i]; | |
1448 level = rl->table_level[i]; | |
1449 if (index_run[run] == rl->n) | |
1450 index_run[run] = i; | |
1451 if (level > max_level[run]) | |
1452 max_level[run] = level; | |
1453 if (run > max_run[level]) | |
1454 max_run[level] = run; | |
1455 } | |
2370
26560d4fdb1f
Memory leak fix patch by (Burkhard Plaum <plaum >at< ipf.uni-stuttgart )dot( de>)
michael
parents:
2364
diff
changeset
|
1456 if(use_static) |
26560d4fdb1f
Memory leak fix patch by (Burkhard Plaum <plaum >at< ipf.uni-stuttgart )dot( de>)
michael
parents:
2364
diff
changeset
|
1457 rl->max_level[last] = av_mallocz_static(MAX_RUN + 1); |
26560d4fdb1f
Memory leak fix patch by (Burkhard Plaum <plaum >at< ipf.uni-stuttgart )dot( de>)
michael
parents:
2364
diff
changeset
|
1458 else |
26560d4fdb1f
Memory leak fix patch by (Burkhard Plaum <plaum >at< ipf.uni-stuttgart )dot( de>)
michael
parents:
2364
diff
changeset
|
1459 rl->max_level[last] = av_malloc(MAX_RUN + 1); |
1042 | 1460 memcpy(rl->max_level[last], max_level, MAX_RUN + 1); |
2370
26560d4fdb1f
Memory leak fix patch by (Burkhard Plaum <plaum >at< ipf.uni-stuttgart )dot( de>)
michael
parents:
2364
diff
changeset
|
1461 if(use_static) |
26560d4fdb1f
Memory leak fix patch by (Burkhard Plaum <plaum >at< ipf.uni-stuttgart )dot( de>)
michael
parents:
2364
diff
changeset
|
1462 rl->max_run[last] = av_mallocz_static(MAX_LEVEL + 1); |
26560d4fdb1f
Memory leak fix patch by (Burkhard Plaum <plaum >at< ipf.uni-stuttgart )dot( de>)
michael
parents:
2364
diff
changeset
|
1463 else |
26560d4fdb1f
Memory leak fix patch by (Burkhard Plaum <plaum >at< ipf.uni-stuttgart )dot( de>)
michael
parents:
2364
diff
changeset
|
1464 rl->max_run[last] = av_malloc(MAX_LEVEL + 1); |
1042 | 1465 memcpy(rl->max_run[last], max_run, MAX_LEVEL + 1); |
2370
26560d4fdb1f
Memory leak fix patch by (Burkhard Plaum <plaum >at< ipf.uni-stuttgart )dot( de>)
michael
parents:
2364
diff
changeset
|
1466 if(use_static) |
26560d4fdb1f
Memory leak fix patch by (Burkhard Plaum <plaum >at< ipf.uni-stuttgart )dot( de>)
michael
parents:
2364
diff
changeset
|
1467 rl->index_run[last] = av_mallocz_static(MAX_RUN + 1); |
26560d4fdb1f
Memory leak fix patch by (Burkhard Plaum <plaum >at< ipf.uni-stuttgart )dot( de>)
michael
parents:
2364
diff
changeset
|
1468 else |
26560d4fdb1f
Memory leak fix patch by (Burkhard Plaum <plaum >at< ipf.uni-stuttgart )dot( de>)
michael
parents:
2364
diff
changeset
|
1469 rl->index_run[last] = av_malloc(MAX_RUN + 1); |
1042 | 1470 memcpy(rl->index_run[last], index_run, MAX_RUN + 1); |
1471 } | |
1472 } | |
1473 | |
0 | 1474 /* 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
|
1475 //FIXME check that this is ok for mpeg4 interlaced |
1064 | 1476 static void draw_edges_c(uint8_t *buf, int wrap, int width, int height, int w) |
0 | 1477 { |
1064 | 1478 uint8_t *ptr, *last_line; |
0 | 1479 int i; |
1480 | |
1481 last_line = buf + (height - 1) * wrap; | |
1482 for(i=0;i<w;i++) { | |
1483 /* top and bottom */ | |
1484 memcpy(buf - (i + 1) * wrap, buf, width); | |
1485 memcpy(last_line + (i + 1) * wrap, last_line, width); | |
1486 } | |
1487 /* left and right */ | |
1488 ptr = buf; | |
1489 for(i=0;i<height;i++) { | |
1490 memset(ptr - w, ptr[0], w); | |
1491 memset(ptr + width, ptr[width-1], w); | |
1492 ptr += wrap; | |
1493 } | |
1494 /* corners */ | |
1495 for(i=0;i<w;i++) { | |
1496 memset(buf - (i + 1) * wrap - w, buf[0], w); /* top left */ | |
1497 memset(buf - (i + 1) * wrap + width, buf[width-1], w); /* top right */ | |
1498 memset(last_line + (i + 1) * wrap - w, last_line[0], w); /* top left */ | |
1499 memset(last_line + (i + 1) * wrap + width, last_line[width-1], w); /* top right */ | |
1500 } | |
1501 } | |
1502 | |
1586 | 1503 int ff_find_unused_picture(MpegEncContext *s, int shared){ |
924 | 1504 int i; |
2967 | 1505 |
924 | 1506 if(shared){ |
1507 for(i=0; i<MAX_PICTURE_COUNT; i++){ | |
1586 | 1508 if(s->picture[i].data[0]==NULL && s->picture[i].type==0) return i; |
924 | 1509 } |
1510 }else{ | |
1511 for(i=0; i<MAX_PICTURE_COUNT; i++){ | |
1586 | 1512 if(s->picture[i].data[0]==NULL && s->picture[i].type!=0) return i; //FIXME |
924 | 1513 } |
1514 for(i=0; i<MAX_PICTURE_COUNT; i++){ | |
1586 | 1515 if(s->picture[i].data[0]==NULL) return i; |
924 | 1516 } |
1517 } | |
1518 | |
1586 | 1519 assert(0); |
1520 return -1; | |
924 | 1521 } |
1522 | |
1597 | 1523 static void update_noise_reduction(MpegEncContext *s){ |
1524 int intra, i; | |
1525 | |
1526 for(intra=0; intra<2; intra++){ | |
1527 if(s->dct_count[intra] > (1<<16)){ | |
1528 for(i=0; i<64; i++){ | |
1529 s->dct_error_sum[intra][i] >>=1; | |
1530 } | |
1531 s->dct_count[intra] >>= 1; | |
1532 } | |
2967 | 1533 |
1597 | 1534 for(i=0; i<64; i++){ |
1535 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); | |
1536 } | |
1537 } | |
1538 } | |
1539 | |
1586 | 1540 /** |
1541 * generic function for encode/decode called after coding/decoding the header and before a frame is coded/decoded | |
1542 */ | |
771
d4cc92144266
handle direct rendering buffer allocation failure
michaelni
parents:
768
diff
changeset
|
1543 int MPV_frame_start(MpegEncContext *s, AVCodecContext *avctx) |
0 | 1544 { |
924 | 1545 int i; |
925 | 1546 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
|
1547 s->mb_skipped = 0; |
1168 | 1548 |
1234 | 1549 assert(s->last_picture_ptr==NULL || s->out_format != FMT_H264 || s->codec_id == CODEC_ID_SVQ3); |
1228 | 1550 |
903 | 1551 /* mark&release old frames */ |
1944 | 1552 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
|
1553 if(s->out_format != FMT_H264 || s->codec_id == CODEC_ID_SVQ3){ |
1138 | 1554 avctx->release_buffer(avctx, (AVFrame*)s->last_picture_ptr); |
903 | 1555 |
1556 /* release forgotten pictures */ | |
1557 /* if(mpeg124/h263) */ | |
1558 if(!s->encoding){ | |
1559 for(i=0; i<MAX_PICTURE_COUNT; i++){ | |
1138 | 1560 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
|
1561 av_log(avctx, AV_LOG_ERROR, "releasing zombie picture\n"); |
2967 | 1562 avctx->release_buffer(avctx, (AVFrame*)&s->picture[i]); |
903 | 1563 } |
1564 } | |
1565 } | |
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
|
1566 } |
903 | 1567 } |
910
eb448df811be
fixing files where the first frame isn a keyframe
michaelni
parents:
909
diff
changeset
|
1568 alloc: |
eb448df811be
fixing files where the first frame isn a keyframe
michaelni
parents:
909
diff
changeset
|
1569 if(!s->encoding){ |
2764 | 1570 /* release non reference frames */ |
1228 | 1571 for(i=0; i<MAX_PICTURE_COUNT; i++){ |
1572 if(s->picture[i].data[0] && !s->picture[i].reference /*&& s->picture[i].type!=FF_BUFFER_TYPE_SHARED*/){ | |
1573 s->avctx->release_buffer(s->avctx, (AVFrame*)&s->picture[i]); | |
1574 } | |
1575 } | |
1576 | |
1586 | 1577 if(s->current_picture_ptr && s->current_picture_ptr->data[0]==NULL) |
1578 pic= (AVFrame*)s->current_picture_ptr; //we allready have a unused image (maybe it was set before reading the header) | |
1579 else{ | |
1580 i= ff_find_unused_picture(s, 0); | |
1581 pic= (AVFrame*)&s->picture[i]; | |
1582 } | |
1583 | |
2537
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2534
diff
changeset
|
1584 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
|
1585 && !s->dropable ? 3 : 0; |
1138 | 1586 |
1705 | 1587 pic->coded_picture_number= s->coded_picture_number++; |
2967 | 1588 |
1384 | 1589 if( alloc_picture(s, (Picture*)pic, 0) < 0) |
1590 return -1; | |
903 | 1591 |
1586 | 1592 s->current_picture_ptr= (Picture*)pic; |
1658 | 1593 s->current_picture_ptr->top_field_first= s->top_field_first; //FIXME use only the vars from current_pic |
1659 | 1594 s->current_picture_ptr->interlaced_frame= !s->progressive_frame && !s->progressive_sequence; |
903 | 1595 } |
456 | 1596 |
1173 | 1597 s->current_picture_ptr->pict_type= s->pict_type; |
2967 | 1598 // 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
|
1599 // 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
|
1600 s->current_picture_ptr->key_frame= s->pict_type == I_TYPE; |
1173 | 1601 |
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
|
1602 copy_picture(&s->current_picture, s->current_picture_ptr); |
2967 | 1603 |
903 | 1604 if (s->pict_type != B_TYPE) { |
1138 | 1605 s->last_picture_ptr= s->next_picture_ptr; |
1944 | 1606 if(!s->dropable) |
1607 s->next_picture_ptr= s->current_picture_ptr; | |
1608 } | |
1609 /* 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 | 1610 s->last_picture_ptr ? s->last_picture_ptr->data[0] : NULL, |
1611 s->next_picture_ptr ? s->next_picture_ptr->data[0] : NULL, | |
1944 | 1612 s->current_picture_ptr ? s->current_picture_ptr->data[0] : NULL, |
1613 s->pict_type, s->dropable);*/ | |
2967 | 1614 |
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
|
1615 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
|
1616 if(s->next_picture_ptr) copy_picture(&s->next_picture, s->next_picture_ptr); |
2967 | 1617 |
4413
371bb9f644da
fix inifnite loop with http://sam.zoy.org/zzuf/lol-mplayer.mpg
michael
parents:
4399
diff
changeset
|
1618 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
|
1619 av_log(avctx, AV_LOG_ERROR, "warning: first frame is no keyframe\n"); |
2764 | 1620 assert(s->pict_type != B_TYPE); //these should have been dropped if we don't have a reference |
1393 | 1621 goto alloc; |
1622 } | |
1623 | |
1624 assert(s->pict_type == I_TYPE || (s->last_picture_ptr && s->last_picture_ptr->data[0])); | |
1625 | |
1138 | 1626 if(s->picture_structure!=PICT_FRAME){ |
1627 int i; | |
1628 for(i=0; i<4; i++){ | |
1629 if(s->picture_structure == PICT_BOTTOM_FIELD){ | |
1630 s->current_picture.data[i] += s->current_picture.linesize[i]; | |
2967 | 1631 } |
1138 | 1632 s->current_picture.linesize[i] *= 2; |
1633 s->last_picture.linesize[i] *=2; | |
1634 s->next_picture.linesize[i] *=2; | |
1635 } | |
553 | 1636 } |
2967 | 1637 |
910
eb448df811be
fixing files where the first frame isn a keyframe
michaelni
parents:
909
diff
changeset
|
1638 s->hurry_up= s->avctx->hurry_up; |
eb448df811be
fixing files where the first frame isn a keyframe
michaelni
parents:
909
diff
changeset
|
1639 s->error_resilience= avctx->error_resilience; |
eb448df811be
fixing files where the first frame isn a keyframe
michaelni
parents:
909
diff
changeset
|
1640 |
2764 | 1641 /* set dequantizer, we can't do it during init as it might change for mpeg4 |
1642 and we can't do it in the header decode as init isnt called for mpeg4 there yet */ | |
1689 | 1643 if(s->mpeg_quant || s->codec_id == CODEC_ID_MPEG2VIDEO){ |
1644 s->dct_unquantize_intra = s->dct_unquantize_mpeg2_intra; | |
1645 s->dct_unquantize_inter = s->dct_unquantize_mpeg2_inter; | |
2345 | 1646 }else if(s->out_format == FMT_H263 || s->out_format == FMT_H261){ |
1689 | 1647 s->dct_unquantize_intra = s->dct_unquantize_h263_intra; |
1648 s->dct_unquantize_inter = s->dct_unquantize_h263_inter; | |
1649 }else{ | |
1650 s->dct_unquantize_intra = s->dct_unquantize_mpeg1_intra; | |
1651 s->dct_unquantize_inter = s->dct_unquantize_mpeg1_inter; | |
1652 } | |
771
d4cc92144266
handle direct rendering buffer allocation failure
michaelni
parents:
768
diff
changeset
|
1653 |
1597 | 1654 if(s->dct_error_sum){ |
1655 assert(s->avctx->noise_reduction && s->encoding); | |
1656 | |
1657 update_noise_reduction(s); | |
1658 } | |
2967 | 1659 |
1381 | 1660 #ifdef HAVE_XVMC |
1661 if(s->avctx->xvmc_acceleration) | |
1662 return XVMC_field_start(s, avctx); | |
1663 #endif | |
771
d4cc92144266
handle direct rendering buffer allocation failure
michaelni
parents:
768
diff
changeset
|
1664 return 0; |
0 | 1665 } |
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
|
1666 |
0 | 1667 /* generic function for encode/decode called after a frame has been coded/decoded */ |
1668 void MPV_frame_end(MpegEncContext *s) | |
1669 { | |
903 | 1670 int i; |
0 | 1671 /* draw edge for correct motion prediction if outside */ |
1381 | 1672 #ifdef HAVE_XVMC |
1673 //just to make sure that all data is rendered. | |
1674 if(s->avctx->xvmc_acceleration){ | |
1675 XVMC_field_end(s); | |
1676 }else | |
1677 #endif | |
2537
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2534
diff
changeset
|
1678 if(s->unrestricted_mv && s->current_picture.reference && !s->intra_only && !(s->flags&CODEC_FLAG_EMU_EDGE)) { |
903 | 1679 draw_edges(s->current_picture.data[0], s->linesize , s->h_edge_pos , s->v_edge_pos , EDGE_WIDTH ); |
1680 draw_edges(s->current_picture.data[1], s->uvlinesize, s->h_edge_pos>>1, s->v_edge_pos>>1, EDGE_WIDTH/2); | |
1681 draw_edges(s->current_picture.data[2], s->uvlinesize, s->h_edge_pos>>1, s->v_edge_pos>>1, EDGE_WIDTH/2); | |
0 | 1682 } |
207 | 1683 emms_c(); |
2967 | 1684 |
612 | 1685 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
|
1686 s->last_lambda_for[s->pict_type]= s->current_picture_ptr->quality; |
329 | 1687 if(s->pict_type!=B_TYPE){ |
1688 s->last_non_b_pict_type= s->pict_type; | |
1689 } | |
1138 | 1690 #if 0 |
1691 /* copy back current_picture variables */ | |
903 | 1692 for(i=0; i<MAX_PICTURE_COUNT; i++){ |
1693 if(s->picture[i].data[0] == s->current_picture.data[0]){ | |
1694 s->picture[i]= s->current_picture; | |
1695 break; | |
2967 | 1696 } |
903 | 1697 } |
1698 assert(i<MAX_PICTURE_COUNT); | |
2967 | 1699 #endif |
903 | 1700 |
1228 | 1701 if(s->encoding){ |
2764 | 1702 /* release non-reference frames */ |
1228 | 1703 for(i=0; i<MAX_PICTURE_COUNT; i++){ |
1704 if(s->picture[i].data[0] && !s->picture[i].reference /*&& s->picture[i].type!=FF_BUFFER_TYPE_SHARED*/){ | |
1705 s->avctx->release_buffer(s->avctx, (AVFrame*)&s->picture[i]); | |
1706 } | |
1707 } | |
324 | 1708 } |
1138 | 1709 // clear copies, to avoid confusion |
1710 #if 0 | |
1711 memset(&s->last_picture, 0, sizeof(Picture)); | |
1712 memset(&s->next_picture, 0, sizeof(Picture)); | |
1713 memset(&s->current_picture, 0, sizeof(Picture)); | |
1714 #endif | |
2213 | 1715 s->avctx->coded_frame= (AVFrame*)s->current_picture_ptr; |
903 | 1716 } |
1717 | |
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
|
1718 /** |
1285 | 1719 * draws an line from (ex, ey) -> (sx, sy). |
1720 * @param w width of the image | |
1721 * @param h height of the image | |
1722 * @param stride stride/linesize of the image | |
1723 * @param color color of the arrow | |
1724 */ | |
1725 static void draw_line(uint8_t *buf, int sx, int sy, int ex, int ey, int w, int h, int stride, int color){ | |
3595 | 1726 int x, y, fr, f; |
2967 | 1727 |
4594 | 1728 sx= av_clip(sx, 0, w-1); |
1729 sy= av_clip(sy, 0, h-1); | |
1730 ex= av_clip(ex, 0, w-1); | |
1731 ey= av_clip(ey, 0, h-1); | |
2967 | 1732 |
1285 | 1733 buf[sy*stride + sx]+= color; |
2967 | 1734 |
4001 | 1735 if(FFABS(ex - sx) > FFABS(ey - sy)){ |
1285 | 1736 if(sx > ex){ |
4120 | 1737 FFSWAP(int, sx, ex); |
1738 FFSWAP(int, sy, ey); | |
1285 | 1739 } |
1740 buf+= sx + sy*stride; | |
1741 ex-= sx; | |
1742 f= ((ey-sy)<<16)/ex; | |
1743 for(x= 0; x <= ex; x++){ | |
1918
ea20f38b8d57
nicer looking arrows for the motion vector vissualization
michael
parents:
1916
diff
changeset
|
1744 y = (x*f)>>16; |
ea20f38b8d57
nicer looking arrows for the motion vector vissualization
michael
parents:
1916
diff
changeset
|
1745 fr= (x*f)&0xFFFF; |
ea20f38b8d57
nicer looking arrows for the motion vector vissualization
michael
parents:
1916
diff
changeset
|
1746 buf[ y *stride + x]+= (color*(0x10000-fr))>>16; |
ea20f38b8d57
nicer looking arrows for the motion vector vissualization
michael
parents:
1916
diff
changeset
|
1747 buf[(y+1)*stride + x]+= (color* fr )>>16; |
1285 | 1748 } |
1749 }else{ | |
1750 if(sy > ey){ | |
4120 | 1751 FFSWAP(int, sx, ex); |
1752 FFSWAP(int, sy, ey); | |
1285 | 1753 } |
1754 buf+= sx + sy*stride; | |
1755 ey-= sy; | |
1756 if(ey) f= ((ex-sx)<<16)/ey; | |
1757 else f= 0; | |
1758 for(y= 0; y <= ey; y++){ | |
1918
ea20f38b8d57
nicer looking arrows for the motion vector vissualization
michael
parents:
1916
diff
changeset
|
1759 x = (y*f)>>16; |
ea20f38b8d57
nicer looking arrows for the motion vector vissualization
michael
parents:
1916
diff
changeset
|
1760 fr= (y*f)&0xFFFF; |
ea20f38b8d57
nicer looking arrows for the motion vector vissualization
michael
parents:
1916
diff
changeset
|
1761 buf[y*stride + x ]+= (color*(0x10000-fr))>>16;; |
ea20f38b8d57
nicer looking arrows for the motion vector vissualization
michael
parents:
1916
diff
changeset
|
1762 buf[y*stride + x+1]+= (color* fr )>>16;; |
1285 | 1763 } |
1764 } | |
1765 } | |
1766 | |
1767 /** | |
1768 * draws an arrow from (ex, ey) -> (sx, sy). | |
1769 * @param w width of the image | |
1770 * @param h height of the image | |
1771 * @param stride stride/linesize of the image | |
1772 * @param color color of the arrow | |
1773 */ | |
2967 | 1774 static void draw_arrow(uint8_t *buf, int sx, int sy, int ex, int ey, int w, int h, int stride, int color){ |
1285 | 1775 int dx,dy; |
1776 | |
4594 | 1777 sx= av_clip(sx, -100, w+100); |
1778 sy= av_clip(sy, -100, h+100); | |
1779 ex= av_clip(ex, -100, w+100); | |
1780 ey= av_clip(ey, -100, h+100); | |
2967 | 1781 |
1285 | 1782 dx= ex - sx; |
1783 dy= ey - sy; | |
2967 | 1784 |
1285 | 1785 if(dx*dx + dy*dy > 3*3){ |
1786 int rx= dx + dy; | |
1787 int ry= -dx + dy; | |
1788 int length= ff_sqrt((rx*rx + ry*ry)<<8); | |
2967 | 1789 |
1285 | 1790 //FIXME subpixel accuracy |
1791 rx= ROUNDED_DIV(rx*3<<4, length); | |
1792 ry= ROUNDED_DIV(ry*3<<4, length); | |
2967 | 1793 |
1285 | 1794 draw_line(buf, sx, sy, sx + rx, sy + ry, w, h, stride, color); |
1795 draw_line(buf, sx, sy, sx - ry, sy + rx, w, h, stride, color); | |
1796 } | |
1797 draw_line(buf, sx, sy, ex, ey, w, h, stride, color); | |
1798 } | |
1799 | |
1800 /** | |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1173
diff
changeset
|
1801 * 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
|
1802 */ |
1706
3ba5c493db6f
motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1705
diff
changeset
|
1803 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
|
1804 |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1173
diff
changeset
|
1805 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
|
1806 |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1173
diff
changeset
|
1807 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
|
1808 int x,y; |
2967 | 1809 |
1706
3ba5c493db6f
motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1705
diff
changeset
|
1810 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
|
1811 switch (pict->pict_type) { |
3ba5c493db6f
motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1705
diff
changeset
|
1812 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
|
1813 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
|
1814 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
|
1815 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
|
1816 case FF_SI_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"SI\n"); break; |
2967 | 1817 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
|
1818 } |
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 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
|
1820 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
|
1821 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
|
1822 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
|
1823 if(count>9) count=9; |
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, "%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
|
1825 } |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1173
diff
changeset
|
1826 if(s->avctx->debug&FF_DEBUG_QP){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1597
diff
changeset
|
1827 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
|
1828 } |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1173
diff
changeset
|
1829 if(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
|
1830 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
|
1831 //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
|
1832 if(IS_PCM(mb_type)) |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1597
diff
changeset
|
1833 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
|
1834 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
|
1835 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
|
1836 else if(IS_INTRA4x4(mb_type)) |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1597
diff
changeset
|
1837 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
|
1838 else if(IS_INTRA16x16(mb_type)) |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1597
diff
changeset
|
1839 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
|
1840 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
|
1841 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
|
1842 else if(IS_DIRECT(mb_type)) |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1597
diff
changeset
|
1843 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
|
1844 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
|
1845 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
|
1846 else if(IS_GMC(mb_type)) |
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, "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
|
1848 else if(IS_SKIP(mb_type)) |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1597
diff
changeset
|
1849 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
|
1850 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
|
1851 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
|
1852 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
|
1853 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
|
1854 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
|
1855 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
|
1856 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
|
1857 } |
2967 | 1858 |
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 //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
|
1860 if(IS_8X8(mb_type)) |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1597
diff
changeset
|
1861 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
|
1862 else if(IS_16X8(mb_type)) |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1597
diff
changeset
|
1863 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
|
1864 else if(IS_8X16(mb_type)) |
2677 | 1865 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
|
1866 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
|
1867 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
|
1868 else |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1597
diff
changeset
|
1869 av_log(s->avctx, AV_LOG_DEBUG, "?"); |
2967 | 1870 |
1871 | |
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
|
1872 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
|
1873 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
|
1874 else |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1597
diff
changeset
|
1875 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
|
1876 } |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1597
diff
changeset
|
1877 // 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
|
1878 } |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1597
diff
changeset
|
1879 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
|
1880 } |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1173
diff
changeset
|
1881 } |
1668
30746f429df6
move motion_val & mb_type to AVFrame patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1662
diff
changeset
|
1882 |
1706
3ba5c493db6f
motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1705
diff
changeset
|
1883 if((s->avctx->debug&(FF_DEBUG_VIS_QP|FF_DEBUG_VIS_MB_TYPE)) || (s->avctx->debug_mv)){ |
1285 | 1884 const int shift= 1 + s->quarter_sample; |
1885 int mb_y; | |
1706
3ba5c493db6f
motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1705
diff
changeset
|
1886 uint8_t *ptr; |
1707 | 1887 int i; |
1723
033d889d7c2c
non YV12 vissualization fix by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1722
diff
changeset
|
1888 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
|
1889 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
|
1890 const int height= s->avctx->height; |
2395 | 1891 const int mv_sample_log2= 4 - pict->motion_subsample_log2; |
3268 | 1892 const int mv_stride= (s->mb_width << mv_sample_log2) + (s->codec_id == CODEC_ID_H264 ? 0 : 1); |
1285 | 1893 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
|
1894 |
1723
033d889d7c2c
non YV12 vissualization fix by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1722
diff
changeset
|
1895 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
|
1896 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
|
1897 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
|
1898 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
|
1899 } |
3ba5c493db6f
motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1705
diff
changeset
|
1900 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
|
1901 ptr= pict->data[0]; |
1285 | 1902 |
1903 for(mb_y=0; mb_y<s->mb_height; mb_y++){ | |
1904 int mb_x; | |
1905 for(mb_x=0; mb_x<s->mb_width; mb_x++){ | |
1906 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
|
1907 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
|
1908 int type; |
3ba5c493db6f
motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1705
diff
changeset
|
1909 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
|
1910 int direction = 0; |
1706
3ba5c493db6f
motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1705
diff
changeset
|
1911 switch (type) { |
3ba5c493db6f
motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1705
diff
changeset
|
1912 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
|
1913 continue; |
3ba5c493db6f
motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1705
diff
changeset
|
1914 direction = 0; |
3ba5c493db6f
motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1705
diff
changeset
|
1915 break; |
3ba5c493db6f
motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1705
diff
changeset
|
1916 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
|
1917 continue; |
3ba5c493db6f
motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1705
diff
changeset
|
1918 direction = 0; |
3ba5c493db6f
motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1705
diff
changeset
|
1919 break; |
3ba5c493db6f
motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1705
diff
changeset
|
1920 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
|
1921 continue; |
3ba5c493db6f
motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1705
diff
changeset
|
1922 direction = 1; |
3ba5c493db6f
motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1705
diff
changeset
|
1923 break; |
3ba5c493db6f
motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1705
diff
changeset
|
1924 } |
1712 | 1925 if(!USES_LIST(pict->mb_type[mb_index], direction)) |
1926 continue; | |
1927 | |
1706
3ba5c493db6f
motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1705
diff
changeset
|
1928 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
|
1929 int i; |
3ba5c493db6f
motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1705
diff
changeset
|
1930 for(i=0; i<4; i++){ |
1285 | 1931 int sx= mb_x*16 + 4 + 8*(i&1); |
1932 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
|
1933 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
|
1934 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
|
1935 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
|
1936 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
|
1937 } |
3ba5c493db6f
motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1705
diff
changeset
|
1938 }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
|
1939 int i; |
3ba5c493db6f
motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1705
diff
changeset
|
1940 for(i=0; i<2; i++){ |
1629
74685a0ec851
16x8 MV vissualization by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1628
diff
changeset
|
1941 int sx=mb_x*16 + 8; |
74685a0ec851
16x8 MV vissualization by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1628
diff
changeset
|
1942 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
|
1943 int xy= (mb_x*2 + (mb_y*2 + i)*mv_stride) << (mv_sample_log2-1); |
2395 | 1944 int mx=(pict->motion_val[direction][xy][0]>>shift); |
1945 int my=(pict->motion_val[direction][xy][1]>>shift); | |
2967 | 1946 |
2395 | 1947 if(IS_INTERLACED(pict->mb_type[mb_index])) |
1948 my*=2; | |
2967 | 1949 |
2395 | 1950 draw_arrow(ptr, sx, sy, mx+sx, my+sy, width, height, s->linesize, 100); |
1951 } | |
1952 }else if(IS_8X16(pict->mb_type[mb_index])){ | |
1953 int i; | |
1954 for(i=0; i<2; i++){ | |
1955 int sx=mb_x*16 + 4 + 8*i; | |
1956 int sy=mb_y*16 + 8; | |
2522
e25782262d7d
kill warnings patch by (M«©ns Rullg«©rd <mru inprovide com>)
michael
parents:
2514
diff
changeset
|
1957 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
|
1958 int mx=(pict->motion_val[direction][xy][0]>>shift); |
b306574523ad
fix y scale of mv vissualization of interlaced MVs
michael
parents:
1945
diff
changeset
|
1959 int my=(pict->motion_val[direction][xy][1]>>shift); |
2967 | 1960 |
1947
b306574523ad
fix y scale of mv vissualization of interlaced MVs
michael
parents:
1945
diff
changeset
|
1961 if(IS_INTERLACED(pict->mb_type[mb_index])) |
b306574523ad
fix y scale of mv vissualization of interlaced MVs
michael
parents:
1945
diff
changeset
|
1962 my*=2; |
2967 | 1963 |
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
|
1964 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
|
1965 } |
3ba5c493db6f
motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1705
diff
changeset
|
1966 }else{ |
3ba5c493db6f
motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1705
diff
changeset
|
1967 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
|
1968 int sy= mb_y*16 + 8; |
2395 | 1969 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
|
1970 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
|
1971 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
|
1972 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
|
1973 } |
2967 | 1974 } |
1685 | 1975 } |
1976 if((s->avctx->debug&FF_DEBUG_VIS_QP) && pict->motion_val){ | |
1977 uint64_t c= (pict->qscale_table[mb_index]*128/31) * 0x0101010101010101ULL; | |
1978 int y; | |
1979 for(y=0; y<8; y++){ | |
1980 *(uint64_t*)(pict->data[1] + 8*mb_x + (8*mb_y + y)*pict->linesize[1])= c; | |
1981 *(uint64_t*)(pict->data[2] + 8*mb_x + (8*mb_y + y)*pict->linesize[2])= c; | |
1982 } | |
1983 } | |
1984 if((s->avctx->debug&FF_DEBUG_VIS_MB_TYPE) && pict->motion_val){ | |
1985 int mb_type= pict->mb_type[mb_index]; | |
1986 uint64_t u,v; | |
1987 int y; | |
1988 #define COLOR(theta, r)\ | |
1989 u= (int)(128 + r*cos(theta*3.141592/180));\ | |
1990 v= (int)(128 + r*sin(theta*3.141592/180)); | |
1991 | |
2967 | 1992 |
1685 | 1993 u=v=128; |
1994 if(IS_PCM(mb_type)){ | |
1995 COLOR(120,48) | |
1996 }else if((IS_INTRA(mb_type) && IS_ACPRED(mb_type)) || IS_INTRA16x16(mb_type)){ | |
1997 COLOR(30,48) | |
1998 }else if(IS_INTRA4x4(mb_type)){ | |
1999 COLOR(90,48) | |
2000 }else if(IS_DIRECT(mb_type) && IS_SKIP(mb_type)){ | |
2001 // COLOR(120,48) | |
2002 }else if(IS_DIRECT(mb_type)){ | |
2003 COLOR(150,48) | |
2004 }else if(IS_GMC(mb_type) && IS_SKIP(mb_type)){ | |
2005 COLOR(170,48) | |
2006 }else if(IS_GMC(mb_type)){ | |
2007 COLOR(190,48) | |
2008 }else if(IS_SKIP(mb_type)){ | |
2009 // COLOR(180,48) | |
2010 }else if(!USES_LIST(mb_type, 1)){ | |
2011 COLOR(240,48) | |
2012 }else if(!USES_LIST(mb_type, 0)){ | |
2013 COLOR(0,48) | |
2014 }else{ | |
2015 assert(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1)); | |
2016 COLOR(300,48) | |
2017 } | |
2018 | |
2019 u*= 0x0101010101010101ULL; | |
2020 v*= 0x0101010101010101ULL; | |
2021 for(y=0; y<8; y++){ | |
2022 *(uint64_t*)(pict->data[1] + 8*mb_x + (8*mb_y + y)*pict->linesize[1])= u; | |
2023 *(uint64_t*)(pict->data[2] + 8*mb_x + (8*mb_y + y)*pict->linesize[2])= v; | |
2024 } | |
2025 | |
2026 //segmentation | |
2027 if(IS_8X8(mb_type) || IS_16X8(mb_type)){ | |
2028 *(uint64_t*)(pict->data[0] + 16*mb_x + 0 + (16*mb_y + 8)*pict->linesize[0])^= 0x8080808080808080ULL; | |
2029 *(uint64_t*)(pict->data[0] + 16*mb_x + 8 + (16*mb_y + 8)*pict->linesize[0])^= 0x8080808080808080ULL; | |
2030 } | |
2031 if(IS_8X8(mb_type) || IS_8X16(mb_type)){ | |
2032 for(y=0; y<16; y++) | |
2033 pict->data[0][16*mb_x + 8 + (16*mb_y + y)*pict->linesize[0]]^= 0x80; | |
2034 } | |
2534 | 2035 if(IS_8X8(mb_type) && mv_sample_log2 >= 2){ |
2036 int dm= 1 << (mv_sample_log2-2); | |
2037 for(i=0; i<4; i++){ | |
2038 int sx= mb_x*16 + 8*(i&1); | |
2039 int sy= mb_y*16 + 8*(i>>1); | |
2040 int xy= (mb_x*2 + (i&1) + (mb_y*2 + (i>>1))*mv_stride) << (mv_sample_log2-1); | |
2041 //FIXME bidir | |
2042 int32_t *mv = (int32_t*)&pict->motion_val[0][xy]; | |
2043 if(mv[0] != mv[dm] || mv[dm*mv_stride] != mv[dm*(mv_stride+1)]) | |
2044 for(y=0; y<8; y++) | |
2045 pict->data[0][sx + 4 + (sy + y)*pict->linesize[0]]^= 0x80; | |
2046 if(mv[0] != mv[dm*mv_stride] || mv[dm] != mv[dm*(mv_stride+1)]) | |
2047 *(uint64_t*)(pict->data[0] + sx + (sy + 4)*pict->linesize[0])^= 0x8080808080808080ULL; | |
2048 } | |
2049 } | |
2967 | 2050 |
1685 | 2051 if(IS_INTERLACED(mb_type) && s->codec_id == CODEC_ID_H264){ |
2052 // hmm | |
2053 } | |
1285 | 2054 } |
2055 s->mbskip_table[mb_index]=0; | |
2056 } | |
2057 } | |
2058 } | |
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
|
2059 } |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1173
diff
changeset
|
2060 |
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
|
2061 #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
|
2062 |
915 | 2063 static int get_sae(uint8_t *src, int ref, int stride){ |
2064 int x,y; | |
2065 int acc=0; | |
2967 | 2066 |
915 | 2067 for(y=0; y<16; y++){ |
2068 for(x=0; x<16; x++){ | |
4001 | 2069 acc+= FFABS(src[x+y*stride] - ref); |
915 | 2070 } |
2071 } | |
2967 | 2072 |
915 | 2073 return acc; |
2074 } | |
2075 | |
2076 static int get_intra_count(MpegEncContext *s, uint8_t *src, uint8_t *ref, int stride){ | |
2077 int x, y, w, h; | |
2078 int acc=0; | |
2967 | 2079 |
915 | 2080 w= s->width &~15; |
2081 h= s->height&~15; | |
2967 | 2082 |
915 | 2083 for(y=0; y<h; y+=16){ |
2084 for(x=0; x<w; x+=16){ | |
2085 int offset= x + y*stride; | |
1708 | 2086 int sad = s->dsp.sad[0](NULL, src + offset, ref + offset, stride, 16); |
915 | 2087 int mean= (s->dsp.pix_sum(src + offset, stride) + 128)>>8; |
2088 int sae = get_sae(src + offset, mean, stride); | |
2967 | 2089 |
915 | 2090 acc+= sae + 500 < sad; |
2091 } | |
2092 } | |
2093 return acc; | |
2094 } | |
2095 | |
924 | 2096 |
925 | 2097 static int load_input_picture(MpegEncContext *s, AVFrame *pic_arg){ |
1373 | 2098 AVFrame *pic=NULL; |
2427 | 2099 int64_t pts; |
924 | 2100 int i; |
903 | 2101 const int encoding_delay= s->max_b_frames; |
924 | 2102 int direct=1; |
2967 | 2103 |
2419 | 2104 if(pic_arg){ |
2427 | 2105 pts= pic_arg->pts; |
2106 pic_arg->display_picture_number= s->input_picture_number++; | |
2107 | |
2967 | 2108 if(pts != AV_NOPTS_VALUE){ |
2419 | 2109 if(s->user_specified_pts != AV_NOPTS_VALUE){ |
2637 | 2110 int64_t time= pts; |
2111 int64_t last= s->user_specified_pts; | |
2967 | 2112 |
2113 if(time <= last){ | |
2962 | 2114 av_log(s->avctx, AV_LOG_ERROR, "Error, Invalid timestamp=%"PRId64", last=%"PRId64"\n", pts, s->user_specified_pts); |
2419 | 2115 return -1; |
2116 } | |
2117 } | |
2427 | 2118 s->user_specified_pts= pts; |
2419 | 2119 }else{ |
2120 if(s->user_specified_pts != AV_NOPTS_VALUE){ | |
2967 | 2121 s->user_specified_pts= |
2637 | 2122 pts= s->user_specified_pts + 1; |
2962 | 2123 av_log(s->avctx, AV_LOG_INFO, "Warning: AVFrame.pts=? trying to guess (%"PRId64")\n", pts); |
2419 | 2124 }else{ |
2637 | 2125 pts= pic_arg->display_picture_number; |
2419 | 2126 } |
2127 } | |
2128 } | |
2129 | |
1373 | 2130 if(pic_arg){ |
924 | 2131 if(encoding_delay && !(s->flags&CODEC_FLAG_INPUT_PRESERVED)) direct=0; |
2132 if(pic_arg->linesize[0] != s->linesize) direct=0; | |
2133 if(pic_arg->linesize[1] != s->uvlinesize) direct=0; | |
2134 if(pic_arg->linesize[2] != s->uvlinesize) direct=0; | |
2967 | 2135 |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1597
diff
changeset
|
2136 // av_log(AV_LOG_DEBUG, "%d %d %d %d\n",pic_arg->linesize[0], pic_arg->linesize[1], s->linesize, s->uvlinesize); |
2967 | 2137 |
924 | 2138 if(direct){ |
1586 | 2139 i= ff_find_unused_picture(s, 1); |
924 | 2140 |
925 | 2141 pic= (AVFrame*)&s->picture[i]; |
1168 | 2142 pic->reference= 3; |
2967 | 2143 |
924 | 2144 for(i=0; i<4; i++){ |
2145 pic->data[i]= pic_arg->data[i]; | |
2146 pic->linesize[i]= pic_arg->linesize[i]; | |
2147 } | |
2148 alloc_picture(s, (Picture*)pic, 1); | |
2149 }else{ | |
1586 | 2150 i= ff_find_unused_picture(s, 0); |
924 | 2151 |
925 | 2152 pic= (AVFrame*)&s->picture[i]; |
1168 | 2153 pic->reference= 3; |
924 | 2154 |
2155 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
|
2156 |
3068 | 2157 if( pic->data[0] + INPLACE_OFFSET == pic_arg->data[0] |
2158 && pic->data[1] + INPLACE_OFFSET == pic_arg->data[1] | |
2159 && pic->data[2] + INPLACE_OFFSET == pic_arg->data[2]){ | |
924 | 2160 // empty |
2161 }else{ | |
2162 int h_chroma_shift, v_chroma_shift; | |
2163 avcodec_get_chroma_sub_sample(s->avctx->pix_fmt, &h_chroma_shift, &v_chroma_shift); | |
2967 | 2164 |
924 | 2165 for(i=0; i<3; i++){ |
2166 int src_stride= pic_arg->linesize[i]; | |
2167 int dst_stride= i ? s->uvlinesize : s->linesize; | |
2168 int h_shift= i ? h_chroma_shift : 0; | |
2169 int v_shift= i ? v_chroma_shift : 0; | |
2170 int w= s->width >>h_shift; | |
2171 int h= s->height>>v_shift; | |
2172 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
|
2173 uint8_t *dst= pic->data[i]; |
16ace038f452
fix buffer underflows by reencoding the current frame with a higher QP
michael
parents:
3929
diff
changeset
|
2174 |
16ace038f452
fix buffer underflows by reencoding the current frame with a higher QP
michael
parents:
3929
diff
changeset
|
2175 if(!s->avctx->rc_buffer_size) |
16ace038f452
fix buffer underflows by reencoding the current frame with a higher QP
michael
parents:
3929
diff
changeset
|
2176 dst +=INPLACE_OFFSET; |
2967 | 2177 |
924 | 2178 if(src_stride==dst_stride) |
2179 memcpy(dst, src, src_stride*h); | |
2180 else{ | |
2181 while(h--){ | |
2182 memcpy(dst, src, w); | |
2183 dst += dst_stride; | |
2184 src += src_stride; | |
2185 } | |
2186 } | |
2187 } | |
2188 } | |
324 | 2189 } |
1938
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1918
diff
changeset
|
2190 copy_picture_attributes(s, pic, pic_arg); |
2427 | 2191 pic->pts= pts; //we set this here to avoid modifiying pic_arg |
1373 | 2192 } |
2967 | 2193 |
903 | 2194 /* shift buffer entries */ |
2195 for(i=1; i<MAX_PICTURE_COUNT /*s->encoding_delay+1*/; i++) | |
2196 s->input_picture[i-1]= s->input_picture[i]; | |
2967 | 2197 |
903 | 2198 s->input_picture[encoding_delay]= (Picture*)pic; |
2199 | |
2200 return 0; | |
2201 } | |
2202 | |
2381 | 2203 static int skip_check(MpegEncContext *s, Picture *p, Picture *ref){ |
2204 int x, y, plane; | |
2205 int score=0; | |
2382 | 2206 int64_t score64=0; |
2381 | 2207 |
2208 for(plane=0; plane<3; plane++){ | |
2209 const int stride= p->linesize[plane]; | |
2210 const int bw= plane ? 1 : 2; | |
2211 for(y=0; y<s->mb_height*bw; y++){ | |
2212 for(x=0; x<s->mb_width*bw; x++){ | |
2931 | 2213 int off= p->type == FF_BUFFER_TYPE_SHARED ? 0: 16; |
2214 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 | 2215 |
2382 | 2216 switch(s->avctx->frame_skip_exp){ |
2217 case 0: score= FFMAX(score, v); break; | |
4001 | 2218 case 1: score+= FFABS(v);break; |
2382 | 2219 case 2: score+= v*v;break; |
4001 | 2220 case 3: score64+= FFABS(v*v*(int64_t)v);break; |
2382 | 2221 case 4: score64+= v*v*(int64_t)(v*v);break; |
2222 } | |
2381 | 2223 } |
2224 } | |
2225 } | |
2967 | 2226 |
2382 | 2227 if(score) score64= score; |
2228 | |
2229 if(score64 < s->avctx->frame_skip_threshold) | |
2381 | 2230 return 1; |
2382 | 2231 if(score64 < ((s->avctx->frame_skip_factor * (int64_t)s->lambda)>>8)) |
2381 | 2232 return 1; |
2233 return 0; | |
2234 } | |
2235 | |
2988 | 2236 static int estimate_best_b_count(MpegEncContext *s){ |
2237 AVCodec *codec= avcodec_find_encoder(s->avctx->codec_id); | |
2238 AVCodecContext *c= avcodec_alloc_context(); | |
2239 AVFrame input[FF_MAX_B_FRAMES+2]; | |
2990
0300c2647bc3
support downscaling frames for dynamic b frame decission
michael
parents:
2988
diff
changeset
|
2240 const int scale= s->avctx->brd_scale; |
3068 | 2241 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
|
2242 int outbuf_size= s->width * s->height; //FIXME |
2988 | 2243 uint8_t *outbuf= av_malloc(outbuf_size); |
2244 int64_t best_rd= INT64_MAX; | |
2245 int best_b_count= -1; | |
3068 | 2246 |
3245 | 2247 assert(scale>=0 && scale <=3); |
2248 | |
3068 | 2249 // emms_c(); |
2250 p_lambda= s->last_lambda_for[P_TYPE]; //s->next_picture_ptr->quality; | |
4001 | 2251 b_lambda= s->last_lambda_for[B_TYPE]; //p_lambda *FFABS(s->avctx->b_quant_factor) + s->avctx->b_quant_offset; |
3068 | 2252 if(!b_lambda) b_lambda= p_lambda; //FIXME we should do this somewhere else |
2253 lambda2= (b_lambda*b_lambda + (1<<FF_LAMBDA_SHIFT)/2 ) >> FF_LAMBDA_SHIFT; | |
2988 | 2254 |
2255 c->width = s->width >> scale; | |
2256 c->height= s->height>> scale; | |
2257 c->flags= CODEC_FLAG_QSCALE | CODEC_FLAG_PSNR | CODEC_FLAG_INPUT_PRESERVED /*| CODEC_FLAG_EMU_EDGE*/; | |
2258 c->flags|= s->avctx->flags & CODEC_FLAG_QPEL; | |
2259 c->mb_decision= s->avctx->mb_decision; | |
2260 c->me_cmp= s->avctx->me_cmp; | |
2261 c->mb_cmp= s->avctx->mb_cmp; | |
2262 c->me_sub_cmp= s->avctx->me_sub_cmp; | |
2263 c->pix_fmt = PIX_FMT_YUV420P; | |
2264 c->time_base= s->avctx->time_base; | |
2265 c->max_b_frames= s->max_b_frames; | |
2266 | |
2267 if (avcodec_open(c, codec) < 0) | |
2268 return -1; | |
2269 | |
2270 for(i=0; i<s->max_b_frames+2; i++){ | |
2271 int ysize= c->width*c->height; | |
2272 int csize= (c->width/2)*(c->height/2); | |
3068 | 2273 Picture pre_input, *pre_input_ptr= i ? s->input_picture[i-1] : s->next_picture_ptr; |
2274 | |
2988 | 2275 avcodec_get_frame_defaults(&input[i]); |
2276 input[i].data[0]= av_malloc(ysize + 2*csize); | |
2277 input[i].data[1]= input[i].data[0] + ysize; | |
2278 input[i].data[2]= input[i].data[1] + csize; | |
2279 input[i].linesize[0]= c->width; | |
2280 input[i].linesize[1]= | |
2281 input[i].linesize[2]= c->width/2; | |
2282 | |
4416 | 2283 if(pre_input_ptr && (!i || s->input_picture[i-1])) { |
2284 pre_input= *pre_input_ptr; | |
2285 | |
2286 if(pre_input.type != FF_BUFFER_TYPE_SHARED && i) { | |
2287 pre_input.data[0]+=INPLACE_OFFSET; | |
2288 pre_input.data[1]+=INPLACE_OFFSET; | |
2289 pre_input.data[2]+=INPLACE_OFFSET; | |
2290 } | |
2291 | |
3245 | 2292 s->dsp.shrink[scale](input[i].data[0], input[i].linesize[0], pre_input.data[0], pre_input.linesize[0], c->width, c->height); |
2293 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); | |
2294 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); | |
2295 } | |
2988 | 2296 } |
2297 | |
2298 for(j=0; j<s->max_b_frames+1; j++){ | |
2299 int64_t rd=0; | |
2300 | |
2301 if(!s->input_picture[j]) | |
2302 break; | |
2303 | |
2304 c->error[0]= c->error[1]= c->error[2]= 0; | |
2305 | |
2306 input[0].pict_type= I_TYPE; | |
3068 | 2307 input[0].quality= 1 * FF_QP2LAMBDA; |
2988 | 2308 out_size = avcodec_encode_video(c, outbuf, outbuf_size, &input[0]); |
3068 | 2309 // rd += (out_size * lambda2) >> FF_LAMBDA_SHIFT; |
2988 | 2310 |
2311 for(i=0; i<s->max_b_frames+1; i++){ | |
2312 int is_p= i % (j+1) == j || i==s->max_b_frames; | |
2313 | |
2314 input[i+1].pict_type= is_p ? P_TYPE : B_TYPE; | |
3068 | 2315 input[i+1].quality= is_p ? p_lambda : b_lambda; |
2988 | 2316 out_size = avcodec_encode_video(c, outbuf, outbuf_size, &input[i+1]); |
3068 | 2317 rd += (out_size * lambda2) >> (FF_LAMBDA_SHIFT - 3); |
2988 | 2318 } |
2319 | |
2320 /* get the delayed frames */ | |
2321 while(out_size){ | |
2322 out_size = avcodec_encode_video(c, outbuf, outbuf_size, NULL); | |
3068 | 2323 rd += (out_size * lambda2) >> (FF_LAMBDA_SHIFT - 3); |
2988 | 2324 } |
2325 | |
2326 rd += c->error[0] + c->error[1] + c->error[2]; | |
2327 | |
2328 if(rd < best_rd){ | |
2329 best_rd= rd; | |
2330 best_b_count= j; | |
2331 } | |
2332 } | |
2333 | |
2334 av_freep(&outbuf); | |
2335 avcodec_close(c); | |
2336 av_freep(&c); | |
2337 | |
2338 for(i=0; i<s->max_b_frames+2; i++){ | |
2339 av_freep(&input[i].data[0]); | |
2340 } | |
2341 | |
2342 return best_b_count; | |
2343 } | |
2344 | |
903 | 2345 static void select_input_picture(MpegEncContext *s){ |
2346 int i; | |
924 | 2347 |
903 | 2348 for(i=1; i<MAX_PICTURE_COUNT; i++) |
2349 s->reordered_input_picture[i-1]= s->reordered_input_picture[i]; | |
2350 s->reordered_input_picture[MAX_PICTURE_COUNT-1]= NULL; | |
2351 | |
2764 | 2352 /* set next picture type & ordering */ |
903 | 2353 if(s->reordered_input_picture[0]==NULL && s->input_picture[0]){ |
1138 | 2354 if(/*s->picture_in_gop_number >= s->gop_size ||*/ s->next_picture_ptr==NULL || s->intra_only){ |
915 | 2355 s->reordered_input_picture[0]= s->input_picture[0]; |
2356 s->reordered_input_picture[0]->pict_type= I_TYPE; | |
1705 | 2357 s->reordered_input_picture[0]->coded_picture_number= s->coded_picture_number++; |
915 | 2358 }else{ |
2359 int b_frames; | |
2381 | 2360 |
2361 if(s->avctx->frame_skip_threshold || s->avctx->frame_skip_factor){ | |
2931 | 2362 if(s->picture_in_gop_number < s->gop_size && skip_check(s, s->input_picture[0], s->next_picture_ptr)){ |
2363 //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
|
2364 //av_log(NULL, AV_LOG_DEBUG, "skip %p %"PRId64"\n", s->input_picture[0]->data[0], s->input_picture[0]->pts); |
2967 | 2365 |
2381 | 2366 if(s->input_picture[0]->type == FF_BUFFER_TYPE_SHARED){ |
2367 for(i=0; i<4; i++) | |
2368 s->input_picture[0]->data[i]= NULL; | |
2967 | 2369 s->input_picture[0]->type= 0; |
2381 | 2370 }else{ |
2967 | 2371 assert( s->input_picture[0]->type==FF_BUFFER_TYPE_USER |
2381 | 2372 || s->input_picture[0]->type==FF_BUFFER_TYPE_INTERNAL); |
2967 | 2373 |
2381 | 2374 s->avctx->release_buffer(s->avctx, (AVFrame*)s->input_picture[0]); |
2375 } | |
2967 | 2376 |
2931 | 2377 emms_c(); |
2378 ff_vbv_update(s, 0); | |
2381 | 2379 |
2380 goto no_output_pic; | |
2381 } | |
2382 } | |
2383 | |
915 | 2384 if(s->flags&CODEC_FLAG_PASS2){ |
2385 for(i=0; i<s->max_b_frames+1; i++){ | |
2386 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
|
2387 |
2967 | 2388 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
|
2389 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
|
2390 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
|
2391 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
|
2392 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
|
2393 } |
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
|
2394 |
2967 | 2395 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
|
2396 s->rc_context.entry[pict_num].new_pict_type; |
915 | 2397 } |
2398 } | |
924 | 2399 |
2297 | 2400 if(s->avctx->b_frame_strategy==0){ |
915 | 2401 b_frames= s->max_b_frames; |
1373 | 2402 while(b_frames && !s->input_picture[b_frames]) b_frames--; |
1687 | 2403 }else if(s->avctx->b_frame_strategy==1){ |
915 | 2404 for(i=1; i<s->max_b_frames+1; i++){ |
1373 | 2405 if(s->input_picture[i] && s->input_picture[i]->b_frame_score==0){ |
2967 | 2406 s->input_picture[i]->b_frame_score= |
2407 get_intra_count(s, s->input_picture[i ]->data[0], | |
924 | 2408 s->input_picture[i-1]->data[0], s->linesize) + 1; |
915 | 2409 } |
2410 } | |
2728 | 2411 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
|
2412 if(s->input_picture[i]==NULL || s->input_picture[i]->b_frame_score - 1 > s->mb_num/s->avctx->b_sensitivity) break; |
915 | 2413 } |
2967 | 2414 |
915 | 2415 b_frames= FFMAX(0, i-1); |
2967 | 2416 |
915 | 2417 /* reset scores */ |
2418 for(i=0; i<b_frames+1; i++){ | |
2419 s->input_picture[i]->b_frame_score=0; | |
2420 } | |
2988 | 2421 }else if(s->avctx->b_frame_strategy==2){ |
2422 b_frames= estimate_best_b_count(s); | |
915 | 2423 }else{ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1597
diff
changeset
|
2424 av_log(s->avctx, AV_LOG_ERROR, "illegal b frame strategy\n"); |
915 | 2425 b_frames=0; |
909
8ae1e4c24e91
new PSNR code (now works with chroma, b frames, ...)
michaelni
parents:
903
diff
changeset
|
2426 } |
915 | 2427 |
2428 emms_c(); | |
2429 //static int b_count=0; | |
2430 //b_count+= b_frames; | |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1597
diff
changeset
|
2431 //av_log(s->avctx, AV_LOG_DEBUG, "b_frames: %d\n", b_count); |
2297 | 2432 |
2433 for(i= b_frames - 1; i>=0; i--){ | |
2434 int type= s->input_picture[i]->pict_type; | |
2435 if(type && type != B_TYPE) | |
2436 b_frames= i; | |
2437 } | |
2438 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
|
2439 av_log(s->avctx, AV_LOG_ERROR, "warning, too many b frames in a row\n"); |
2297 | 2440 } |
2441 | |
1754
bdf3927bf8c5
closed gop support & flags2 as all bits in flags are used
michael
parents:
1751
diff
changeset
|
2442 if(s->picture_in_gop_number + b_frames >= s->gop_size){ |
2298 | 2443 if((s->flags2 & CODEC_FLAG2_STRICT_GOP) && s->gop_size > s->picture_in_gop_number){ |
2444 b_frames= s->gop_size - s->picture_in_gop_number - 1; | |
2445 }else{ | |
1754
bdf3927bf8c5
closed gop support & flags2 as all bits in flags are used
michael
parents:
1751
diff
changeset
|
2446 if(s->flags & CODEC_FLAG_CLOSED_GOP) |
bdf3927bf8c5
closed gop support & flags2 as all bits in flags are used
michael
parents:
1751
diff
changeset
|
2447 b_frames=0; |
bdf3927bf8c5
closed gop support & flags2 as all bits in flags are used
michael
parents:
1751
diff
changeset
|
2448 s->input_picture[b_frames]->pict_type= I_TYPE; |
2298 | 2449 } |
1754
bdf3927bf8c5
closed gop support & flags2 as all bits in flags are used
michael
parents:
1751
diff
changeset
|
2450 } |
2967 | 2451 |
1754
bdf3927bf8c5
closed gop support & flags2 as all bits in flags are used
michael
parents:
1751
diff
changeset
|
2452 if( (s->flags & CODEC_FLAG_CLOSED_GOP) |
bdf3927bf8c5
closed gop support & flags2 as all bits in flags are used
michael
parents:
1751
diff
changeset
|
2453 && b_frames |
bdf3927bf8c5
closed gop support & flags2 as all bits in flags are used
michael
parents:
1751
diff
changeset
|
2454 && 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
|
2455 b_frames--; |
bdf3927bf8c5
closed gop support & flags2 as all bits in flags are used
michael
parents:
1751
diff
changeset
|
2456 |
915 | 2457 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
|
2458 if(s->reordered_input_picture[0]->pict_type != I_TYPE) |
915 | 2459 s->reordered_input_picture[0]->pict_type= P_TYPE; |
1705 | 2460 s->reordered_input_picture[0]->coded_picture_number= s->coded_picture_number++; |
915 | 2461 for(i=0; i<b_frames; i++){ |
2462 s->reordered_input_picture[i+1]= s->input_picture[i]; | |
2463 s->reordered_input_picture[i+1]->pict_type= B_TYPE; | |
1705 | 2464 s->reordered_input_picture[i+1]->coded_picture_number= s->coded_picture_number++; |
903 | 2465 } |
324 | 2466 } |
2467 } | |
2381 | 2468 no_output_pic: |
903 | 2469 if(s->reordered_input_picture[0]){ |
1168 | 2470 s->reordered_input_picture[0]->reference= s->reordered_input_picture[0]->pict_type!=B_TYPE ? 3 : 0; |
1138 | 2471 |
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
|
2472 copy_picture(&s->new_picture, s->reordered_input_picture[0]); |
924 | 2473 |
3939
16ace038f452
fix buffer underflows by reencoding the current frame with a higher QP
michael
parents:
3929
diff
changeset
|
2474 if(s->reordered_input_picture[0]->type == FF_BUFFER_TYPE_SHARED || s->avctx->rc_buffer_size){ |
2764 | 2475 // input is a shared pix, so we can't modifiy it -> alloc a new one & ensure that the shared one is reuseable |
2967 | 2476 |
1586 | 2477 int i= ff_find_unused_picture(s, 0); |
924 | 2478 Picture *pic= &s->picture[i]; |
2479 | |
3939
16ace038f452
fix buffer underflows by reencoding the current frame with a higher QP
michael
parents:
3929
diff
changeset
|
2480 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
|
2481 alloc_picture(s, pic, 0); |
16ace038f452
fix buffer underflows by reencoding the current frame with a higher QP
michael
parents:
3929
diff
changeset
|
2482 |
924 | 2483 /* 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
|
2484 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
|
2485 s->avctx->release_buffer(s->avctx, (AVFrame*)s->reordered_input_picture[0]); |
924 | 2486 for(i=0; i<4; i++) |
2487 s->reordered_input_picture[0]->data[i]= NULL; | |
2488 s->reordered_input_picture[0]->type= 0; | |
2967 | 2489 |
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
|
2490 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
|
2491 |
1138 | 2492 s->current_picture_ptr= pic; |
924 | 2493 }else{ |
1138 | 2494 // input is not a shared pix -> reuse buffer for current_pix |
2495 | |
2967 | 2496 assert( s->reordered_input_picture[0]->type==FF_BUFFER_TYPE_USER |
924 | 2497 || s->reordered_input_picture[0]->type==FF_BUFFER_TYPE_INTERNAL); |
2967 | 2498 |
1138 | 2499 s->current_picture_ptr= s->reordered_input_picture[0]; |
924 | 2500 for(i=0; i<4; i++){ |
3068 | 2501 s->new_picture.data[i]+= INPLACE_OFFSET; |
924 | 2502 } |
903 | 2503 } |
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
|
2504 copy_picture(&s->current_picture, s->current_picture_ptr); |
2967 | 2505 |
903 | 2506 s->picture_number= s->new_picture.display_picture_number; |
2507 //printf("dpn:%d\n", s->picture_number); | |
2508 }else{ | |
2509 memset(&s->new_picture, 0, sizeof(Picture)); | |
324 | 2510 } |
2511 } | |
2512 | |
0 | 2513 int MPV_encode_picture(AVCodecContext *avctx, |
2514 unsigned char *buf, int buf_size, void *data) | |
2515 { | |
2516 MpegEncContext *s = avctx->priv_data; | |
925 | 2517 AVFrame *pic_arg = data; |
1684 | 2518 int i, stuffing_count; |
0 | 2519 |
1799 | 2520 for(i=0; i<avctx->thread_count; i++){ |
1838 | 2521 int start_y= s->thread_context[i]->start_mb_y; |
2522 int end_y= s->thread_context[i]-> end_mb_y; | |
1799 | 2523 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
|
2524 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
|
2525 uint8_t *end = buf + (size_t)(((int64_t) buf_size)* end_y/h); |
1799 | 2526 |
2527 init_put_bits(&s->thread_context[i]->pb, start, end - start); | |
2528 } | |
0 | 2529 |
903 | 2530 s->picture_in_gop_number++; |
2531 | |
2243
b8bad8bbbc64
check if the user specified timestamps are strictly monotone
michael
parents:
2235
diff
changeset
|
2532 if(load_input_picture(s, pic_arg) < 0) |
b8bad8bbbc64
check if the user specified timestamps are strictly monotone
michael
parents:
2235
diff
changeset
|
2533 return -1; |
2967 | 2534 |
903 | 2535 select_input_picture(s); |
2967 | 2536 |
324 | 2537 /* output? */ |
903 | 2538 if(s->new_picture.data[0]){ |
2539 s->pict_type= s->new_picture.pict_type; | |
2540 //emms_c(); | |
2541 //printf("qs:%f %f %d\n", s->new_picture.quality, s->current_picture.quality, s->qscale); | |
553 | 2542 MPV_frame_start(s, avctx); |
3939
16ace038f452
fix buffer underflows by reencoding the current frame with a higher QP
michael
parents:
3929
diff
changeset
|
2543 vbv_retry: |
3766 | 2544 if (encode_picture(s, s->picture_number) < 0) |
2545 return -1; | |
2967 | 2546 |
376 | 2547 avctx->real_pict_num = s->picture_number; |
324 | 2548 avctx->header_bits = s->header_bits; |
2549 avctx->mv_bits = s->mv_bits; | |
2550 avctx->misc_bits = s->misc_bits; | |
2551 avctx->i_tex_bits = s->i_tex_bits; | |
2552 avctx->p_tex_bits = s->p_tex_bits; | |
2553 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
|
2554 avctx->p_count = s->mb_num - s->i_count - s->skip_count; //FIXME f/b_count in avctx |
324 | 2555 avctx->skip_count = s->skip_count; |
0 | 2556 |
324 | 2557 MPV_frame_end(s); |
2558 | |
2559 if (s->out_format == FMT_MJPEG) | |
2560 mjpeg_picture_trailer(s); | |
2967 | 2561 |
3939
16ace038f452
fix buffer underflows by reencoding the current frame with a higher QP
michael
parents:
3929
diff
changeset
|
2562 if(avctx->rc_buffer_size){ |
16ace038f452
fix buffer underflows by reencoding the current frame with a higher QP
michael
parents:
3929
diff
changeset
|
2563 RateControlContext *rcc= &s->rc_context; |
16ace038f452
fix buffer underflows by reencoding the current frame with a higher QP
michael
parents:
3929
diff
changeset
|
2564 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
|
2565 |
4096
99616a74260a
use lambda/lmax instead of qscale/qmax as end check for vbv retry
michael
parents:
4052
diff
changeset
|
2566 if(put_bits_count(&s->pb) > max_size && s->lambda < s->avctx->lmax){ |
4052 | 2567 s->next_lambda= FFMAX(s->lambda+1, s->lambda*(s->qscale+1) / s->qscale); |
4218 | 2568 if(s->adaptive_quant){ |
2569 int i; | |
4223 | 2570 for(i=0; i<s->mb_height*s->mb_stride; i++) |
4218 | 2571 s->lambda_table[i]= FFMAX(s->lambda_table[i]+1, s->lambda_table[i]*(s->qscale+1) / s->qscale); |
2572 } | |
3939
16ace038f452
fix buffer underflows by reencoding the current frame with a higher QP
michael
parents:
3929
diff
changeset
|
2573 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
|
2574 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
|
2575 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
|
2576 s->no_rounding ^= 1; |
16ace038f452
fix buffer underflows by reencoding the current frame with a higher QP
michael
parents:
3929
diff
changeset
|
2577 } |
4111 | 2578 if(s->pict_type!=B_TYPE){ |
2579 s->time_base= s->last_time_base; | |
2580 s->last_non_b_time= s->time - s->pp_time; | |
2581 } | |
3939
16ace038f452
fix buffer underflows by reencoding the current frame with a higher QP
michael
parents:
3929
diff
changeset
|
2582 // 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
|
2583 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
|
2584 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
|
2585 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
|
2586 } |
16ace038f452
fix buffer underflows by reencoding the current frame with a higher QP
michael
parents:
3929
diff
changeset
|
2587 goto vbv_retry; |
16ace038f452
fix buffer underflows by reencoding the current frame with a higher QP
michael
parents:
3929
diff
changeset
|
2588 } |
16ace038f452
fix buffer underflows by reencoding the current frame with a higher QP
michael
parents:
3929
diff
changeset
|
2589 |
16ace038f452
fix buffer underflows by reencoding the current frame with a higher QP
michael
parents:
3929
diff
changeset
|
2590 assert(s->avctx->rc_max_rate); |
16ace038f452
fix buffer underflows by reencoding the current frame with a higher QP
michael
parents:
3929
diff
changeset
|
2591 } |
16ace038f452
fix buffer underflows by reencoding the current frame with a higher QP
michael
parents:
3929
diff
changeset
|
2592 |
329 | 2593 if(s->flags&CODEC_FLAG_PASS1) |
2594 ff_write_pass1_stats(s); | |
1138 | 2595 |
2596 for(i=0; i<4; i++){ | |
2955 | 2597 s->current_picture_ptr->error[i]= s->current_picture.error[i]; |
1138 | 2598 avctx->error[i] += s->current_picture_ptr->error[i]; |
2599 } | |
1766 | 2600 |
2428
548c87c06dbb
assertion about bits statistic and minor bits stat fix
michael
parents:
2427
diff
changeset
|
2601 if(s->flags&CODEC_FLAG_PASS1) |
548c87c06dbb
assertion about bits statistic and minor bits stat fix
michael
parents:
2427
diff
changeset
|
2602 assert(avctx->header_bits + avctx->mv_bits + avctx->misc_bits + avctx->i_tex_bits + avctx->p_tex_bits == put_bits_count(&s->pb)); |
1684 | 2603 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
|
2604 s->frame_bits = put_bits_count(&s->pb); |
1766 | 2605 |
2606 stuffing_count= ff_vbv_update(s, s->frame_bits); | |
2607 if(stuffing_count){ | |
2422 | 2608 if(s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb)>>3) < stuffing_count + 50){ |
2609 av_log(s->avctx, AV_LOG_ERROR, "stuffing too large\n"); | |
2610 return -1; | |
2611 } | |
2612 | |
1766 | 2613 switch(s->codec_id){ |
2614 case CODEC_ID_MPEG1VIDEO: | |
2615 case CODEC_ID_MPEG2VIDEO: | |
2616 while(stuffing_count--){ | |
2617 put_bits(&s->pb, 8, 0); | |
2618 } | |
2619 break; | |
2620 case CODEC_ID_MPEG4: | |
2621 put_bits(&s->pb, 16, 0); | |
2622 put_bits(&s->pb, 16, 0x1C3); | |
2623 stuffing_count -= 4; | |
2624 while(stuffing_count--){ | |
2625 put_bits(&s->pb, 8, 0xFF); | |
2626 } | |
2627 break; | |
2628 default: | |
2629 av_log(s->avctx, AV_LOG_ERROR, "vbv buffer overflow\n"); | |
2630 } | |
2631 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
|
2632 s->frame_bits = put_bits_count(&s->pb); |
1766 | 2633 } |
2634 | |
2967 | 2635 /* update mpeg1/2 vbv_delay for CBR */ |
1907 | 2636 if(s->avctx->rc_max_rate && s->avctx->rc_min_rate == s->avctx->rc_max_rate && s->out_format == FMT_MPEG1 |
2637 && 90000LL * (avctx->rc_buffer_size-1) <= s->avctx->rc_max_rate*0xFFFFLL){ | |
1766 | 2638 int vbv_delay; |
2639 | |
2640 assert(s->repeat_first_field==0); | |
2967 | 2641 |
1766 | 2642 vbv_delay= lrintf(90000 * s->rc_context.buffer_index / s->avctx->rc_max_rate); |
2643 assert(vbv_delay < 0xFFFF); | |
2644 | |
2645 s->vbv_delay_ptr[0] &= 0xF8; | |
2646 s->vbv_delay_ptr[0] |= vbv_delay>>13; | |
2647 s->vbv_delay_ptr[1] = vbv_delay>>5; | |
2648 s->vbv_delay_ptr[2] &= 0x07; | |
2649 s->vbv_delay_ptr[2] |= vbv_delay<<3; | |
2650 } | |
2651 s->total_bits += s->frame_bits; | |
2652 avctx->frame_bits = s->frame_bits; | |
2653 }else{ | |
2654 assert((pbBufPtr(&s->pb) == s->pb.buf)); | |
2655 s->frame_bits=0; | |
1684 | 2656 } |
1766 | 2657 assert((s->frame_bits&7)==0); |
2967 | 2658 |
1684 | 2659 return s->frame_bits/8; |
0 | 2660 } |
2661 | |
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
|
2662 #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
|
2663 |
255 | 2664 static inline void gmc1_motion(MpegEncContext *s, |
1064 | 2665 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
|
2666 uint8_t **ref_picture) |
255 | 2667 { |
1064 | 2668 uint8_t *ptr; |
556 | 2669 int offset, src_x, src_y, linesize, uvlinesize; |
255 | 2670 int motion_x, motion_y; |
566 | 2671 int emu=0; |
255 | 2672 |
2673 motion_x= s->sprite_offset[0][0]; | |
2674 motion_y= s->sprite_offset[0][1]; | |
2675 src_x = s->mb_x * 16 + (motion_x >> (s->sprite_warping_accuracy+1)); | |
2676 src_y = s->mb_y * 16 + (motion_y >> (s->sprite_warping_accuracy+1)); | |
2677 motion_x<<=(3-s->sprite_warping_accuracy); | |
2678 motion_y<<=(3-s->sprite_warping_accuracy); | |
4594 | 2679 src_x = av_clip(src_x, -16, s->width); |
255 | 2680 if (src_x == s->width) |
2681 motion_x =0; | |
4594 | 2682 src_y = av_clip(src_y, -16, s->height); |
255 | 2683 if (src_y == s->height) |
2684 motion_y =0; | |
753 | 2685 |
255 | 2686 linesize = s->linesize; |
556 | 2687 uvlinesize = s->uvlinesize; |
2967 | 2688 |
1842
0d82db458a3c
interlaced mpeg4 + edge emu fix (fixes decoding of mermaid.avi)
michael
parents:
1838
diff
changeset
|
2689 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
|
2690 |
566 | 2691 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
|
2692 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
|
2693 || (unsigned)src_y >= s->v_edge_pos - 17){ |
1317
26c44d2433c1
make ff_emulated_edge_mc() independant of MpegEncContext
michaelni
parents:
1315
diff
changeset
|
2694 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 | 2695 ptr= s->edge_emu_buffer; |
2696 } | |
2697 } | |
2967 | 2698 |
753 | 2699 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
|
2700 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
|
2701 s->dsp.gmc1(dest_y+8, ptr+8, linesize, 16, motion_x&15, motion_y&15, 128 - s->no_rounding); |
753 | 2702 }else{ |
2703 int dxy; | |
2967 | 2704 |
753 | 2705 dxy= ((motion_x>>3)&1) | ((motion_y>>2)&2); |
2706 if (s->no_rounding){ | |
2979 | 2707 s->dsp.put_no_rnd_pixels_tab[0][dxy](dest_y, ptr, linesize, 16); |
753 | 2708 }else{ |
853
eacc2dd8fd9d
* using DSPContext - so each codec could use its local (sub)set of CPU extension
kabi
parents:
847
diff
changeset
|
2709 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
|
2710 } |
753 | 2711 } |
2967 | 2712 |
753 | 2713 if(s->flags&CODEC_FLAG_GRAY) return; |
255 | 2714 |
2715 motion_x= s->sprite_offset[1][0]; | |
2716 motion_y= s->sprite_offset[1][1]; | |
2717 src_x = s->mb_x * 8 + (motion_x >> (s->sprite_warping_accuracy+1)); | |
2718 src_y = s->mb_y * 8 + (motion_y >> (s->sprite_warping_accuracy+1)); | |
2719 motion_x<<=(3-s->sprite_warping_accuracy); | |
2720 motion_y<<=(3-s->sprite_warping_accuracy); | |
4594 | 2721 src_x = av_clip(src_x, -8, s->width>>1); |
255 | 2722 if (src_x == s->width>>1) |
2723 motion_x =0; | |
4594 | 2724 src_y = av_clip(src_y, -8, s->height>>1); |
255 | 2725 if (src_y == s->height>>1) |
2726 motion_y =0; | |
2727 | |
1842
0d82db458a3c
interlaced mpeg4 + edge emu fix (fixes decoding of mermaid.avi)
michael
parents:
1838
diff
changeset
|
2728 offset = (src_y * uvlinesize) + src_x; |
255 | 2729 ptr = ref_picture[1] + offset; |
1002 | 2730 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
|
2731 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
|
2732 || (unsigned)src_y >= (s->v_edge_pos>>1) - 9){ |
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); |
1002 | 2734 ptr= s->edge_emu_buffer; |
2735 emu=1; | |
2736 } | |
566 | 2737 } |
1842
0d82db458a3c
interlaced mpeg4 + edge emu fix (fixes decoding of mermaid.avi)
michael
parents:
1838
diff
changeset
|
2738 s->dsp.gmc1(dest_cb, ptr, uvlinesize, 8, motion_x&15, motion_y&15, 128 - s->no_rounding); |
2967 | 2739 |
255 | 2740 ptr = ref_picture[2] + offset; |
566 | 2741 if(emu){ |
1317
26c44d2433c1
make ff_emulated_edge_mc() independant of MpegEncContext
michaelni
parents:
1315
diff
changeset
|
2742 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 | 2743 ptr= s->edge_emu_buffer; |
2744 } | |
1842
0d82db458a3c
interlaced mpeg4 + edge emu fix (fixes decoding of mermaid.avi)
michael
parents:
1838
diff
changeset
|
2745 s->dsp.gmc1(dest_cr, ptr, uvlinesize, 8, motion_x&15, motion_y&15, 128 - s->no_rounding); |
2967 | 2746 |
255 | 2747 return; |
2748 } | |
2749 | |
753 | 2750 static inline void gmc_motion(MpegEncContext *s, |
1064 | 2751 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
|
2752 uint8_t **ref_picture) |
753 | 2753 { |
1064 | 2754 uint8_t *ptr; |
753 | 2755 int linesize, uvlinesize; |
2756 const int a= s->sprite_warping_accuracy; | |
2757 int ox, oy; | |
2758 | |
2759 linesize = s->linesize; | |
2760 uvlinesize = s->uvlinesize; | |
2761 | |
1842
0d82db458a3c
interlaced mpeg4 + edge emu fix (fixes decoding of mermaid.avi)
michael
parents:
1838
diff
changeset
|
2762 ptr = ref_picture[0]; |
0d82db458a3c
interlaced mpeg4 + edge emu fix (fixes decoding of mermaid.avi)
michael
parents:
1838
diff
changeset
|
2763 |
753 | 2764 ox= s->sprite_offset[0][0] + s->sprite_delta[0][0]*s->mb_x*16 + s->sprite_delta[0][1]*s->mb_y*16; |
2765 oy= s->sprite_offset[0][1] + s->sprite_delta[1][0]*s->mb_x*16 + s->sprite_delta[1][1]*s->mb_y*16; | |
2766 | |
853
eacc2dd8fd9d
* using DSPContext - so each codec could use its local (sub)set of CPU extension
kabi
parents:
847
diff
changeset
|
2767 s->dsp.gmc(dest_y, ptr, linesize, 16, |
2967 | 2768 ox, |
2769 oy, | |
753 | 2770 s->sprite_delta[0][0], s->sprite_delta[0][1], |
2967 | 2771 s->sprite_delta[1][0], s->sprite_delta[1][1], |
753 | 2772 a+1, (1<<(2*a+1)) - s->no_rounding, |
2773 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
|
2774 s->dsp.gmc(dest_y+8, ptr, linesize, 16, |
2967 | 2775 ox + s->sprite_delta[0][0]*8, |
2776 oy + s->sprite_delta[1][0]*8, | |
753 | 2777 s->sprite_delta[0][0], s->sprite_delta[0][1], |
2967 | 2778 s->sprite_delta[1][0], s->sprite_delta[1][1], |
753 | 2779 a+1, (1<<(2*a+1)) - s->no_rounding, |
2780 s->h_edge_pos, s->v_edge_pos); | |
2781 | |
2782 if(s->flags&CODEC_FLAG_GRAY) return; | |
2783 | |
2784 ox= s->sprite_offset[1][0] + s->sprite_delta[0][0]*s->mb_x*8 + s->sprite_delta[0][1]*s->mb_y*8; | |
2785 oy= s->sprite_offset[1][1] + s->sprite_delta[1][0]*s->mb_x*8 + s->sprite_delta[1][1]*s->mb_y*8; | |
2786 | |
1842
0d82db458a3c
interlaced mpeg4 + edge emu fix (fixes decoding of mermaid.avi)
michael
parents:
1838
diff
changeset
|
2787 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
|
2788 s->dsp.gmc(dest_cb, 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); | |
2967 | 2795 |
1842
0d82db458a3c
interlaced mpeg4 + edge emu fix (fixes decoding of mermaid.avi)
michael
parents:
1838
diff
changeset
|
2796 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
|
2797 s->dsp.gmc(dest_cr, ptr, uvlinesize, 8, |
2967 | 2798 ox, |
2799 oy, | |
753 | 2800 s->sprite_delta[0][0], s->sprite_delta[0][1], |
2967 | 2801 s->sprite_delta[1][0], s->sprite_delta[1][1], |
753 | 2802 a+1, (1<<(2*a+1)) - s->no_rounding, |
2803 s->h_edge_pos>>1, s->v_edge_pos>>1); | |
2804 } | |
2805 | |
1317
26c44d2433c1
make ff_emulated_edge_mc() independant of MpegEncContext
michaelni
parents:
1315
diff
changeset
|
2806 /** |
26c44d2433c1
make ff_emulated_edge_mc() independant of MpegEncContext
michaelni
parents:
1315
diff
changeset
|
2807 * 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
|
2808 * @param buf destination buffer |
26c44d2433c1
make ff_emulated_edge_mc() independant of MpegEncContext
michaelni
parents:
1315
diff
changeset
|
2809 * @param src source buffer |
26c44d2433c1
make ff_emulated_edge_mc() independant of MpegEncContext
michaelni
parents:
1315
diff
changeset
|
2810 * @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
|
2811 * @param block_w width of block |
26c44d2433c1
make ff_emulated_edge_mc() independant of MpegEncContext
michaelni
parents:
1315
diff
changeset
|
2812 * @param block_h height of block |
26c44d2433c1
make ff_emulated_edge_mc() independant of MpegEncContext
michaelni
parents:
1315
diff
changeset
|
2813 * @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
|
2814 * @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
|
2815 * @param w width of the source buffer |
26c44d2433c1
make ff_emulated_edge_mc() independant of MpegEncContext
michaelni
parents:
1315
diff
changeset
|
2816 * @param h height of the source buffer |
26c44d2433c1
make ff_emulated_edge_mc() independant of MpegEncContext
michaelni
parents:
1315
diff
changeset
|
2817 */ |
2967 | 2818 void ff_emulated_edge_mc(uint8_t *buf, uint8_t *src, int linesize, int block_w, int block_h, |
553 | 2819 int src_x, int src_y, int w, int h){ |
2820 int x, y; | |
2821 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
|
2822 |
553 | 2823 if(src_y>= h){ |
2824 src+= (h-1-src_y)*linesize; | |
2825 src_y=h-1; | |
554 | 2826 }else if(src_y<=-block_h){ |
2827 src+= (1-block_h-src_y)*linesize; | |
2828 src_y=1-block_h; | |
553 | 2829 } |
2830 if(src_x>= w){ | |
2831 src+= (w-1-src_x); | |
2832 src_x=w-1; | |
554 | 2833 }else if(src_x<=-block_w){ |
2834 src+= (1-block_w-src_x); | |
2835 src_x=1-block_w; | |
553 | 2836 } |
2837 | |
847 | 2838 start_y= FFMAX(0, -src_y); |
2839 start_x= FFMAX(0, -src_x); | |
2840 end_y= FFMIN(block_h, h-src_y); | |
2841 end_x= FFMIN(block_w, w-src_x); | |
566 | 2842 |
553 | 2843 // copy existing part |
2844 for(y=start_y; y<end_y; y++){ | |
2845 for(x=start_x; x<end_x; x++){ | |
2846 buf[x + y*linesize]= src[x + y*linesize]; | |
2847 } | |
2848 } | |
2849 | |
2850 //top | |
2851 for(y=0; y<start_y; y++){ | |
2852 for(x=start_x; x<end_x; x++){ | |
2853 buf[x + y*linesize]= buf[x + start_y*linesize]; | |
2854 } | |
2855 } | |
2856 | |
2857 //bottom | |
2858 for(y=end_y; y<block_h; y++){ | |
2859 for(x=start_x; x<end_x; x++){ | |
2860 buf[x + y*linesize]= buf[x + (end_y-1)*linesize]; | |
2861 } | |
2862 } | |
2967 | 2863 |
553 | 2864 for(y=0; y<block_h; y++){ |
2865 //left | |
2866 for(x=0; x<start_x; x++){ | |
2867 buf[x + y*linesize]= buf[start_x + y*linesize]; | |
2868 } | |
2967 | 2869 |
553 | 2870 //right |
2871 for(x=end_x; x<block_w; x++){ | |
2872 buf[x + y*linesize]= buf[end_x - 1 + y*linesize]; | |
2873 } | |
2874 } | |
2875 } | |
2876 | |
2967 | 2877 static inline int hpel_motion(MpegEncContext *s, |
1842
0d82db458a3c
interlaced mpeg4 + edge emu fix (fixes decoding of mermaid.avi)
michael
parents:
1838
diff
changeset
|
2878 uint8_t *dest, uint8_t *src, |
0d82db458a3c
interlaced mpeg4 + edge emu fix (fixes decoding of mermaid.avi)
michael
parents:
1838
diff
changeset
|
2879 int field_based, int field_select, |
1633 | 2880 int src_x, int src_y, |
2881 int width, int height, int stride, | |
2882 int h_edge_pos, int v_edge_pos, | |
2883 int w, int h, op_pixels_func *pix_op, | |
2884 int motion_x, int motion_y) | |
2885 { | |
2886 int dxy; | |
2887 int emu=0; | |
2888 | |
2889 dxy = ((motion_y & 1) << 1) | (motion_x & 1); | |
2890 src_x += motion_x >> 1; | |
2891 src_y += motion_y >> 1; | |
2967 | 2892 |
1633 | 2893 /* WARNING: do no forget half pels */ |
4594 | 2894 src_x = av_clip(src_x, -16, width); //FIXME unneeded for emu? |
1633 | 2895 if (src_x == width) |
2896 dxy &= ~1; | |
4594 | 2897 src_y = av_clip(src_y, -16, height); |
1633 | 2898 if (src_y == height) |
2899 dxy &= ~2; | |
2900 src += src_y * stride + src_x; | |
2901 | |
2902 if(s->unrestricted_mv && (s->flags&CODEC_FLAG_EMU_EDGE)){ | |
2903 if( (unsigned)src_x > h_edge_pos - (motion_x&1) - w | |
2904 || (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
|
2905 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
|
2906 src_x, src_y<<field_based, h_edge_pos, s->v_edge_pos); |
1633 | 2907 src= s->edge_emu_buffer; |
2908 emu=1; | |
2909 } | |
2910 } | |
1842
0d82db458a3c
interlaced mpeg4 + edge emu fix (fixes decoding of mermaid.avi)
michael
parents:
1838
diff
changeset
|
2911 if(field_select) |
0d82db458a3c
interlaced mpeg4 + edge emu fix (fixes decoding of mermaid.avi)
michael
parents:
1838
diff
changeset
|
2912 src += s->linesize; |
1633 | 2913 pix_op[dxy](dest, src, stride, h); |
2914 return emu; | |
2915 } | |
553 | 2916 |
2967 | 2917 static inline int hpel_motion_lowres(MpegEncContext *s, |
2292 | 2918 uint8_t *dest, uint8_t *src, |
2919 int field_based, int field_select, | |
2920 int src_x, int src_y, | |
2921 int width, int height, int stride, | |
2922 int h_edge_pos, int v_edge_pos, | |
2923 int w, int h, h264_chroma_mc_func *pix_op, | |
2924 int motion_x, int motion_y) | |
2925 { | |
2926 const int lowres= s->avctx->lowres; | |
2927 const int s_mask= (2<<lowres)-1; | |
2928 int emu=0; | |
2929 int sx, sy; | |
2930 | |
2931 if(s->quarter_sample){ | |
2932 motion_x/=2; | |
2933 motion_y/=2; | |
2934 } | |
2935 | |
2936 sx= motion_x & s_mask; | |
2937 sy= motion_y & s_mask; | |
2938 src_x += motion_x >> (lowres+1); | |
2939 src_y += motion_y >> (lowres+1); | |
2967 | 2940 |
2292 | 2941 src += src_y * stride + src_x; |
2942 | |
2943 if( (unsigned)src_x > h_edge_pos - (!!sx) - w | |
2944 || (unsigned)src_y >(v_edge_pos >> field_based) - (!!sy) - h){ | |
2945 ff_emulated_edge_mc(s->edge_emu_buffer, src, s->linesize, w+1, (h+1)<<field_based, | |
2946 src_x, src_y<<field_based, h_edge_pos, v_edge_pos); | |
2947 src= s->edge_emu_buffer; | |
2948 emu=1; | |
2949 } | |
2950 | |
2951 sx <<= 2 - lowres; | |
2952 sy <<= 2 - lowres; | |
2953 if(field_select) | |
2954 src += s->linesize; | |
2955 pix_op[lowres](dest, src, stride, h, sx, sy); | |
2956 return emu; | |
2957 } | |
2958 | |
0 | 2959 /* 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
|
2960 static av_always_inline void mpeg_motion(MpegEncContext *s, |
1064 | 2961 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
|
2962 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
|
2963 uint8_t **ref_picture, op_pixels_func (*pix_op)[4], |
0 | 2964 int motion_x, int motion_y, int h) |
2965 { | |
1846 | 2966 uint8_t *ptr_y, *ptr_cb, *ptr_cr; |
2967 int dxy, uvdxy, mx, my, src_x, src_y, uvsrc_x, uvsrc_y, v_edge_pos, uvlinesize, linesize; | |
2967 | 2968 |
2969 #if 0 | |
255 | 2970 if(s->quarter_sample) |
2971 { | |
2972 motion_x>>=1; | |
2973 motion_y>>=1; | |
2974 } | |
651 | 2975 #endif |
1633 | 2976 |
582
5132a4ee50cd
different edge positions fixed with edge emu / dr1
michaelni
parents:
575
diff
changeset
|
2977 v_edge_pos = s->v_edge_pos >> field_based; |
1846 | 2978 linesize = s->current_picture.linesize[0] << field_based; |
1138 | 2979 uvlinesize = s->current_picture.linesize[1] << field_based; |
1633 | 2980 |
1846 | 2981 dxy = ((motion_y & 1) << 1) | (motion_x & 1); |
2982 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
|
2983 src_y =(s->mb_y<<(4-field_based)) + (motion_y >> 1); |
485 | 2984 |
0 | 2985 if (s->out_format == FMT_H263) { |
1916 | 2986 if((s->workaround_bugs & FF_BUG_HPEL_CHROMA) && field_based){ |
2987 mx = (motion_x>>1)|(motion_x&1); | |
2988 my = motion_y >>1; | |
2989 uvdxy = ((my & 1) << 1) | (mx & 1); | |
2990 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
|
2991 uvsrc_y = (s->mb_y<<(3-field_based)) + (my >> 1); |
1916 | 2992 }else{ |
2993 uvdxy = dxy | (motion_y & 2) | ((motion_x & 2) >> 1); | |
2994 uvsrc_x = src_x>>1; | |
2995 uvsrc_y = src_y>>1; | |
2996 } | |
2044
b6f2add2511e
h261 decoder by (Maarten Daniels <maarten.daniels at student dot luc dot ac dot be>)
michael
parents:
2042
diff
changeset
|
2997 }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
|
2998 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
|
2999 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
|
3000 uvdxy = 0; |
b6f2add2511e
h261 decoder by (Maarten Daniels <maarten.daniels at student dot luc dot ac dot be>)
michael
parents:
2042
diff
changeset
|
3001 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
|
3002 uvsrc_y = s->mb_y*8 + my; |
0 | 3003 } else { |
2074
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
3004 if(s->chroma_y_shift){ |
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
3005 mx = motion_x / 2; |
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
3006 my = motion_y / 2; |
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
3007 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
|
3008 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
|
3009 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
|
3010 } else { |
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
3011 if(s->chroma_x_shift){ |
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
3012 //Chroma422 |
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
3013 mx = motion_x / 2; |
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
3014 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
|
3015 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
|
3016 uvsrc_y = src_y; |
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
3017 } else { |
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
3018 //Chroma444 |
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
3019 uvdxy = dxy; |
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
3020 uvsrc_x = src_x; |
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
3021 uvsrc_y = src_y; |
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
3022 } |
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
3023 } |
1846 | 3024 } |
3025 | |
3026 ptr_y = ref_picture[0] + src_y * linesize + src_x; | |
3027 ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x; | |
3028 ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x; | |
3029 | |
3030 if( (unsigned)src_x > s->h_edge_pos - (motion_x&1) - 16 | |
3031 || (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
|
3032 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
|
3033 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
|
3034 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
|
3035 return ; |
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
3036 } |
1846 | 3037 ff_emulated_edge_mc(s->edge_emu_buffer, ptr_y, s->linesize, 17, 17+field_based, |
3038 src_x, src_y<<field_based, s->h_edge_pos, s->v_edge_pos); | |
3039 ptr_y = s->edge_emu_buffer; | |
3040 if(!(s->flags&CODEC_FLAG_GRAY)){ | |
1874 | 3041 uint8_t *uvbuf= s->edge_emu_buffer+18*s->linesize; |
2967 | 3042 ff_emulated_edge_mc(uvbuf , ptr_cb, s->uvlinesize, 9, 9+field_based, |
1846 | 3043 uvsrc_x, uvsrc_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1); |
2967 | 3044 ff_emulated_edge_mc(uvbuf+16, ptr_cr, s->uvlinesize, 9, 9+field_based, |
1846 | 3045 uvsrc_x, uvsrc_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1); |
3046 ptr_cb= uvbuf; | |
3047 ptr_cr= uvbuf+16; | |
3048 } | |
3049 } | |
3050 | |
3051 if(bottom_field){ //FIXME use this for field pix too instead of the obnoxious hack which changes picture.data | |
3052 dest_y += s->linesize; | |
3053 dest_cb+= s->uvlinesize; | |
3054 dest_cr+= s->uvlinesize; | |
3055 } | |
3056 | |
3057 if(field_select){ | |
3058 ptr_y += s->linesize; | |
3059 ptr_cb+= s->uvlinesize; | |
3060 ptr_cr+= s->uvlinesize; | |
3061 } | |
3062 | |
3063 pix_op[0][dxy](dest_y, ptr_y, linesize, h); | |
2967 | 3064 |
1846 | 3065 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
|
3066 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
|
3067 pix_op[s->chroma_x_shift][uvdxy](dest_cr, ptr_cr, uvlinesize, h >> s->chroma_y_shift); |
1846 | 3068 } |
2639 | 3069 #if defined(CONFIG_H261_ENCODER) || defined(CONFIG_H261_DECODER) |
2291 | 3070 if(s->out_format == FMT_H261){ |
3071 ff_h261_loop_filter(s); | |
3072 } | |
2639 | 3073 #endif |
0 | 3074 } |
2256 | 3075 |
3076 /* 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
|
3077 static av_always_inline void mpeg_motion_lowres(MpegEncContext *s, |
2256 | 3078 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr, |
3079 int field_based, int bottom_field, int field_select, | |
3080 uint8_t **ref_picture, h264_chroma_mc_func *pix_op, | |
3081 int motion_x, int motion_y, int h) | |
3082 { | |
3083 uint8_t *ptr_y, *ptr_cb, *ptr_cr; | |
3084 int mx, my, src_x, src_y, uvsrc_x, uvsrc_y, uvlinesize, linesize, sx, sy, uvsx, uvsy; | |
3085 const int lowres= s->avctx->lowres; | |
3086 const int block_s= 8>>lowres; | |
3087 const int s_mask= (2<<lowres)-1; | |
3088 const int h_edge_pos = s->h_edge_pos >> lowres; | |
3089 const int v_edge_pos = s->v_edge_pos >> lowres; | |
3090 linesize = s->current_picture.linesize[0] << field_based; | |
3091 uvlinesize = s->current_picture.linesize[1] << field_based; | |
3092 | |
2260 | 3093 if(s->quarter_sample){ //FIXME obviously not perfect but qpel wont work in lowres anyway |
3094 motion_x/=2; | |
3095 motion_y/=2; | |
3096 } | |
2967 | 3097 |
2260 | 3098 if(field_based){ |
3099 motion_y += (bottom_field - field_select)*((1<<lowres)-1); | |
3100 } | |
3101 | |
2256 | 3102 sx= motion_x & s_mask; |
3103 sy= motion_y & s_mask; | |
3104 src_x = s->mb_x*2*block_s + (motion_x >> (lowres+1)); | |
2260 | 3105 src_y =(s->mb_y*2*block_s>>field_based) + (motion_y >> (lowres+1)); |
2967 | 3106 |
2256 | 3107 if (s->out_format == FMT_H263) { |
2265 | 3108 uvsx = ((motion_x>>1) & s_mask) | (sx&1); |
3109 uvsy = ((motion_y>>1) & s_mask) | (sy&1); | |
2256 | 3110 uvsrc_x = src_x>>1; |
3111 uvsrc_y = src_y>>1; | |
3112 }else if(s->out_format == FMT_H261){//even chroma mv's are full pel in H261 | |
3113 mx = motion_x / 4; | |
3114 my = motion_y / 4; | |
3115 uvsx = (2*mx) & s_mask; | |
3116 uvsy = (2*my) & s_mask; | |
3117 uvsrc_x = s->mb_x*block_s + (mx >> lowres); | |
3118 uvsrc_y = s->mb_y*block_s + (my >> lowres); | |
3119 } else { | |
3120 mx = motion_x / 2; | |
3121 my = motion_y / 2; | |
3122 uvsx = mx & s_mask; | |
3123 uvsy = my & s_mask; | |
3124 uvsrc_x = s->mb_x*block_s + (mx >> (lowres+1)); | |
2260 | 3125 uvsrc_y =(s->mb_y*block_s>>field_based) + (my >> (lowres+1)); |
2256 | 3126 } |
3127 | |
3128 ptr_y = ref_picture[0] + src_y * linesize + src_x; | |
3129 ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x; | |
3130 ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x; | |
3131 | |
3132 if( (unsigned)src_x > h_edge_pos - (!!sx) - 2*block_s | |
3133 || (unsigned)src_y >(v_edge_pos >> field_based) - (!!sy) - h){ | |
3134 ff_emulated_edge_mc(s->edge_emu_buffer, ptr_y, s->linesize, 17, 17+field_based, | |
3135 src_x, src_y<<field_based, h_edge_pos, v_edge_pos); | |
3136 ptr_y = s->edge_emu_buffer; | |
3137 if(!(s->flags&CODEC_FLAG_GRAY)){ | |
3138 uint8_t *uvbuf= s->edge_emu_buffer+18*s->linesize; | |
2967 | 3139 ff_emulated_edge_mc(uvbuf , ptr_cb, s->uvlinesize, 9, 9+field_based, |
2256 | 3140 uvsrc_x, uvsrc_y<<field_based, h_edge_pos>>1, v_edge_pos>>1); |
2967 | 3141 ff_emulated_edge_mc(uvbuf+16, ptr_cr, s->uvlinesize, 9, 9+field_based, |
2256 | 3142 uvsrc_x, uvsrc_y<<field_based, h_edge_pos>>1, v_edge_pos>>1); |
3143 ptr_cb= uvbuf; | |
3144 ptr_cr= uvbuf+16; | |
3145 } | |
3146 } | |
3147 | |
2260 | 3148 if(bottom_field){ //FIXME use this for field pix too instead of the obnoxious hack which changes picture.data |
3149 dest_y += s->linesize; | |
3150 dest_cb+= s->uvlinesize; | |
3151 dest_cr+= s->uvlinesize; | |
3152 } | |
3153 | |
3154 if(field_select){ | |
3155 ptr_y += s->linesize; | |
3156 ptr_cb+= s->uvlinesize; | |
3157 ptr_cr+= s->uvlinesize; | |
3158 } | |
3159 | |
2256 | 3160 sx <<= 2 - lowres; |
3161 sy <<= 2 - lowres; | |
3162 pix_op[lowres-1](dest_y, ptr_y, linesize, h, sx, sy); | |
2967 | 3163 |
2256 | 3164 if(!(s->flags&CODEC_FLAG_GRAY)){ |
3165 uvsx <<= 2 - lowres; | |
3166 uvsy <<= 2 - lowres; | |
3167 pix_op[lowres](dest_cb, ptr_cb, uvlinesize, h >> s->chroma_y_shift, uvsx, uvsy); | |
3168 pix_op[lowres](dest_cr, ptr_cr, uvlinesize, h >> s->chroma_y_shift, uvsx, uvsy); | |
3169 } | |
2291 | 3170 //FIXME h261 lowres loop filter |
2256 | 3171 } |
3172 | |
1633 | 3173 //FIXME move to dsputil, avg variant, 16x16 version |
3174 static inline void put_obmc(uint8_t *dst, uint8_t *src[5], int stride){ | |
3175 int x; | |
3176 uint8_t * const top = src[1]; | |
3177 uint8_t * const left = src[2]; | |
3178 uint8_t * const mid = src[0]; | |
3179 uint8_t * const right = src[3]; | |
3180 uint8_t * const bottom= src[4]; | |
3181 #define OBMC_FILTER(x, t, l, m, r, b)\ | |
3182 dst[x]= (t*top[x] + l*left[x] + m*mid[x] + r*right[x] + b*bottom[x] + 4)>>3 | |
3183 #define OBMC_FILTER4(x, t, l, m, r, b)\ | |
3184 OBMC_FILTER(x , t, l, m, r, b);\ | |
3185 OBMC_FILTER(x+1 , t, l, m, r, b);\ | |
3186 OBMC_FILTER(x +stride, t, l, m, r, b);\ | |
3187 OBMC_FILTER(x+1+stride, t, l, m, r, b); | |
2967 | 3188 |
1633 | 3189 x=0; |
3190 OBMC_FILTER (x , 2, 2, 4, 0, 0); | |
3191 OBMC_FILTER (x+1, 2, 1, 5, 0, 0); | |
3192 OBMC_FILTER4(x+2, 2, 1, 5, 0, 0); | |
3193 OBMC_FILTER4(x+4, 2, 0, 5, 1, 0); | |
3194 OBMC_FILTER (x+6, 2, 0, 5, 1, 0); | |
3195 OBMC_FILTER (x+7, 2, 0, 4, 2, 0); | |
3196 x+= stride; | |
3197 OBMC_FILTER (x , 1, 2, 5, 0, 0); | |
3198 OBMC_FILTER (x+1, 1, 2, 5, 0, 0); | |
3199 OBMC_FILTER (x+6, 1, 0, 5, 2, 0); | |
3200 OBMC_FILTER (x+7, 1, 0, 5, 2, 0); | |
3201 x+= stride; | |
3202 OBMC_FILTER4(x , 1, 2, 5, 0, 0); | |
3203 OBMC_FILTER4(x+2, 1, 1, 6, 0, 0); | |
3204 OBMC_FILTER4(x+4, 1, 0, 6, 1, 0); | |
3205 OBMC_FILTER4(x+6, 1, 0, 5, 2, 0); | |
3206 x+= 2*stride; | |
3207 OBMC_FILTER4(x , 0, 2, 5, 0, 1); | |
3208 OBMC_FILTER4(x+2, 0, 1, 6, 0, 1); | |
3209 OBMC_FILTER4(x+4, 0, 0, 6, 1, 1); | |
3210 OBMC_FILTER4(x+6, 0, 0, 5, 2, 1); | |
3211 x+= 2*stride; | |
3212 OBMC_FILTER (x , 0, 2, 5, 0, 1); | |
3213 OBMC_FILTER (x+1, 0, 2, 5, 0, 1); | |
3214 OBMC_FILTER4(x+2, 0, 1, 5, 0, 2); | |
3215 OBMC_FILTER4(x+4, 0, 0, 5, 1, 2); | |
3216 OBMC_FILTER (x+6, 0, 0, 5, 2, 1); | |
3217 OBMC_FILTER (x+7, 0, 0, 5, 2, 1); | |
3218 x+= stride; | |
3219 OBMC_FILTER (x , 0, 2, 4, 0, 2); | |
3220 OBMC_FILTER (x+1, 0, 1, 5, 0, 2); | |
3221 OBMC_FILTER (x+6, 0, 0, 5, 1, 2); | |
3222 OBMC_FILTER (x+7, 0, 0, 4, 2, 2); | |
3223 } | |
3224 | |
3225 /* obmc for 1 8x8 luma block */ | |
3226 static inline void obmc_motion(MpegEncContext *s, | |
3227 uint8_t *dest, uint8_t *src, | |
3228 int src_x, int src_y, | |
3229 op_pixels_func *pix_op, | |
3230 int16_t mv[5][2]/* mid top left right bottom*/) | |
3231 #define MID 0 | |
3232 { | |
3233 int i; | |
3234 uint8_t *ptr[5]; | |
2967 | 3235 |
1633 | 3236 assert(s->quarter_sample==0); |
2967 | 3237 |
1633 | 3238 for(i=0; i<5; i++){ |
3239 if(i && mv[i][0]==mv[MID][0] && mv[i][1]==mv[MID][1]){ | |
3240 ptr[i]= ptr[MID]; | |
3241 }else{ | |
1799 | 3242 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
|
3243 hpel_motion(s, ptr[i], src, 0, 0, |
1633 | 3244 src_x, src_y, |
3245 s->width, s->height, s->linesize, | |
3246 s->h_edge_pos, s->v_edge_pos, | |
3247 8, 8, pix_op, | |
3248 mv[i][0], mv[i][1]); | |
3249 } | |
3250 } | |
3251 | |
2967 | 3252 put_obmc(dest, ptr, s->linesize); |
1633 | 3253 } |
0 | 3254 |
255 | 3255 static inline void qpel_motion(MpegEncContext *s, |
1064 | 3256 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
|
3257 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
|
3258 uint8_t **ref_picture, op_pixels_func (*pix_op)[4], |
651 | 3259 qpel_mc_func (*qpix_op)[16], |
255 | 3260 int motion_x, int motion_y, int h) |
3261 { | |
1846 | 3262 uint8_t *ptr_y, *ptr_cb, *ptr_cr; |
3263 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
|
3264 |
255 | 3265 dxy = ((motion_y & 3) << 2) | (motion_x & 3); |
1846 | 3266 src_x = s->mb_x * 16 + (motion_x >> 2); |
255 | 3267 src_y = s->mb_y * (16 >> field_based) + (motion_y >> 2); |
3268 | |
582
5132a4ee50cd
different edge positions fixed with edge emu / dr1
michaelni
parents:
575
diff
changeset
|
3269 v_edge_pos = s->v_edge_pos >> field_based; |
255 | 3270 linesize = s->linesize << field_based; |
671 | 3271 uvlinesize = s->uvlinesize << field_based; |
2967 | 3272 |
671 | 3273 if(field_based){ |
3274 mx= motion_x/2; | |
3275 my= motion_y>>1; | |
1048 | 3276 }else if(s->workaround_bugs&FF_BUG_QPEL_CHROMA2){ |
3277 static const int rtab[8]= {0,0,1,1,0,0,0,1}; | |
3278 mx= (motion_x>>1) + rtab[motion_x&7]; | |
3279 my= (motion_y>>1) + rtab[motion_y&7]; | |
760 | 3280 }else if(s->workaround_bugs&FF_BUG_QPEL_CHROMA){ |
671 | 3281 mx= (motion_x>>1)|(motion_x&1); |
3282 my= (motion_y>>1)|(motion_y&1); | |
3283 }else{ | |
3284 mx= motion_x/2; | |
3285 my= motion_y/2; | |
3286 } | |
3287 mx= (mx>>1)|(mx&1); | |
3288 my= (my>>1)|(my&1); | |
1048 | 3289 |
1846 | 3290 uvdxy= (mx&1) | ((my&1)<<1); |
671 | 3291 mx>>=1; |
3292 my>>=1; | |
255 | 3293 |
1846 | 3294 uvsrc_x = s->mb_x * 8 + mx; |
3295 uvsrc_y = s->mb_y * (8 >> field_based) + my; | |
3296 | |
3297 ptr_y = ref_picture[0] + src_y * linesize + src_x; | |
3298 ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x; | |
3299 ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x; | |
3300 | |
2967 | 3301 if( (unsigned)src_x > s->h_edge_pos - (motion_x&3) - 16 |
1846 | 3302 || (unsigned)src_y > v_edge_pos - (motion_y&3) - h ){ |
2967 | 3303 ff_emulated_edge_mc(s->edge_emu_buffer, ptr_y, s->linesize, 17, 17+field_based, |
1846 | 3304 src_x, src_y<<field_based, s->h_edge_pos, s->v_edge_pos); |
3305 ptr_y= s->edge_emu_buffer; | |
3306 if(!(s->flags&CODEC_FLAG_GRAY)){ | |
1874 | 3307 uint8_t *uvbuf= s->edge_emu_buffer + 18*s->linesize; |
2967 | 3308 ff_emulated_edge_mc(uvbuf, ptr_cb, s->uvlinesize, 9, 9 + field_based, |
1846 | 3309 uvsrc_x, uvsrc_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1); |
2967 | 3310 ff_emulated_edge_mc(uvbuf + 16, ptr_cr, s->uvlinesize, 9, 9 + field_based, |
1846 | 3311 uvsrc_x, uvsrc_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1); |
3312 ptr_cb= uvbuf; | |
3313 ptr_cr= uvbuf + 16; | |
3314 } | |
3315 } | |
3316 | |
3317 if(!field_based) | |
3318 qpix_op[0][dxy](dest_y, ptr_y, linesize); | |
3319 else{ | |
3320 if(bottom_field){ | |
3321 dest_y += s->linesize; | |
3322 dest_cb+= s->uvlinesize; | |
3323 dest_cr+= s->uvlinesize; | |
3324 } | |
3325 | |
3326 if(field_select){ | |
3327 ptr_y += s->linesize; | |
3328 ptr_cb += s->uvlinesize; | |
3329 ptr_cr += s->uvlinesize; | |
3330 } | |
3331 //damn interlaced mode | |
3332 //FIXME boundary mirroring is not exactly correct here | |
3333 qpix_op[1][dxy](dest_y , ptr_y , linesize); | |
3334 qpix_op[1][dxy](dest_y+8, ptr_y+8, linesize); | |
3335 } | |
3336 if(!(s->flags&CODEC_FLAG_GRAY)){ | |
3337 pix_op[1][uvdxy](dest_cr, ptr_cr, uvlinesize, h >> 1); | |
3338 pix_op[1][uvdxy](dest_cb, ptr_cb, uvlinesize, h >> 1); | |
3339 } | |
255 | 3340 } |
3341 | |
1013 | 3342 inline int ff_h263_round_chroma(int x){ |
3343 if (x >= 0) | |
3344 return (h263_chroma_roundtab[x & 0xf] + ((x >> 3) & ~1)); | |
3345 else { | |
3346 x = -x; | |
3347 return -(h263_chroma_roundtab[x & 0xf] + ((x >> 3) & ~1)); | |
3348 } | |
3349 } | |
255 | 3350 |
1225 | 3351 /** |
1633 | 3352 * h263 chorma 4mv motion compensation. |
3353 */ | |
3354 static inline void chroma_4mv_motion(MpegEncContext *s, | |
3355 uint8_t *dest_cb, uint8_t *dest_cr, | |
3356 uint8_t **ref_picture, | |
3357 op_pixels_func *pix_op, | |
3358 int mx, int my){ | |
3359 int dxy, emu=0, src_x, src_y, offset; | |
3360 uint8_t *ptr; | |
2967 | 3361 |
1633 | 3362 /* In case of 8X8, we construct a single chroma motion vector |
3363 with a special rounding */ | |
3364 mx= ff_h263_round_chroma(mx); | |
3365 my= ff_h263_round_chroma(my); | |
2967 | 3366 |
1633 | 3367 dxy = ((my & 1) << 1) | (mx & 1); |
3368 mx >>= 1; | |
3369 my >>= 1; | |
3370 | |
3371 src_x = s->mb_x * 8 + mx; | |
3372 src_y = s->mb_y * 8 + my; | |
4594 | 3373 src_x = av_clip(src_x, -8, s->width/2); |
1633 | 3374 if (src_x == s->width/2) |
3375 dxy &= ~1; | |
4594 | 3376 src_y = av_clip(src_y, -8, s->height/2); |
1633 | 3377 if (src_y == s->height/2) |
3378 dxy &= ~2; | |
2967 | 3379 |
1633 | 3380 offset = (src_y * (s->uvlinesize)) + src_x; |
3381 ptr = ref_picture[1] + offset; | |
3382 if(s->flags&CODEC_FLAG_EMU_EDGE){ | |
3383 if( (unsigned)src_x > (s->h_edge_pos>>1) - (dxy &1) - 8 | |
3384 || (unsigned)src_y > (s->v_edge_pos>>1) - (dxy>>1) - 8){ | |
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 emu=1; | |
3388 } | |
3389 } | |
3390 pix_op[dxy](dest_cb, ptr, s->uvlinesize, 8); | |
3391 | |
3392 ptr = ref_picture[2] + offset; | |
3393 if(emu){ | |
3394 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); | |
3395 ptr= s->edge_emu_buffer; | |
3396 } | |
3397 pix_op[dxy](dest_cr, ptr, s->uvlinesize, 8); | |
3398 } | |
3399 | |
2292 | 3400 static inline void chroma_4mv_motion_lowres(MpegEncContext *s, |
3401 uint8_t *dest_cb, uint8_t *dest_cr, | |
3402 uint8_t **ref_picture, | |
3403 h264_chroma_mc_func *pix_op, | |
3404 int mx, int my){ | |
3405 const int lowres= s->avctx->lowres; | |
3406 const int block_s= 8>>lowres; | |
3407 const int s_mask= (2<<lowres)-1; | |
3408 const int h_edge_pos = s->h_edge_pos >> (lowres+1); | |
3409 const int v_edge_pos = s->v_edge_pos >> (lowres+1); | |
3410 int emu=0, src_x, src_y, offset, sx, sy; | |
3411 uint8_t *ptr; | |
2967 | 3412 |
2292 | 3413 if(s->quarter_sample){ |
3414 mx/=2; | |
3415 my/=2; | |
3416 } | |
3417 | |
3418 /* In case of 8X8, we construct a single chroma motion vector | |
3419 with a special rounding */ | |
3420 mx= ff_h263_round_chroma(mx); | |
3421 my= ff_h263_round_chroma(my); | |
2967 | 3422 |
2292 | 3423 sx= mx & s_mask; |
3424 sy= my & s_mask; | |
3425 src_x = s->mb_x*block_s + (mx >> (lowres+1)); | |
3426 src_y = s->mb_y*block_s + (my >> (lowres+1)); | |
2967 | 3427 |
2292 | 3428 offset = src_y * s->uvlinesize + src_x; |
3429 ptr = ref_picture[1] + offset; | |
3430 if(s->flags&CODEC_FLAG_EMU_EDGE){ | |
3431 if( (unsigned)src_x > h_edge_pos - (!!sx) - block_s | |
3432 || (unsigned)src_y > v_edge_pos - (!!sy) - block_s){ | |
3433 ff_emulated_edge_mc(s->edge_emu_buffer, ptr, s->uvlinesize, 9, 9, src_x, src_y, h_edge_pos, v_edge_pos); | |
3434 ptr= s->edge_emu_buffer; | |
3435 emu=1; | |
3436 } | |
2967 | 3437 } |
2292 | 3438 sx <<= 2 - lowres; |
3439 sy <<= 2 - lowres; | |
3440 pix_op[lowres](dest_cb, ptr, s->uvlinesize, block_s, sx, sy); | |
2967 | 3441 |
2292 | 3442 ptr = ref_picture[2] + offset; |
3443 if(emu){ | |
3444 ff_emulated_edge_mc(s->edge_emu_buffer, ptr, s->uvlinesize, 9, 9, src_x, src_y, h_edge_pos, v_edge_pos); | |
3445 ptr= s->edge_emu_buffer; | |
3446 } | |
3447 pix_op[lowres](dest_cr, ptr, s->uvlinesize, block_s, sx, sy); | |
3448 } | |
3449 | |
3216
4186eb8d29a1
prefetch pixels for future motion compensation. 4-10% faster mpeg1/2/4 decoding (on an athlon-xp).
lorenm
parents:
3145
diff
changeset
|
3450 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
|
3451 /* 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
|
3452 * 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
|
3453 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
|
3454 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
|
3455 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
|
3456 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
|
3457 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
|
3458 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
|
3459 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
|
3460 } |
4186eb8d29a1
prefetch pixels for future motion compensation. 4-10% faster mpeg1/2/4 decoding (on an athlon-xp).
lorenm
parents:
3145
diff
changeset
|
3461 |
1633 | 3462 /** |
2764 | 3463 * motion compensation of a single macroblock |
1225 | 3464 * @param s context |
3465 * @param dest_y luma destination pointer | |
3466 * @param dest_cb chroma cb/u destination pointer | |
3467 * @param dest_cr chroma cr/v destination pointer | |
3468 * @param dir direction (0->forward, 1->backward) | |
3469 * @param ref_picture array[3] of pointers to the 3 planes of the reference picture | |
3470 * @param pic_op halfpel motion compensation function (average or put normally) | |
3471 * @param pic_op qpel motion compensation function (average or put normally) | |
3472 * the motion vectors are taken from s->mv and the MV type from s->mv_type | |
3473 */ | |
2967 | 3474 static inline void MPV_motion(MpegEncContext *s, |
1064 | 3475 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr, |
2967 | 3476 int dir, uint8_t **ref_picture, |
651 | 3477 op_pixels_func (*pix_op)[4], qpel_mc_func (*qpix_op)[16]) |
0 | 3478 { |
1633 | 3479 int dxy, mx, my, src_x, src_y, motion_x, motion_y; |
0 | 3480 int mb_x, mb_y, i; |
1064 | 3481 uint8_t *ptr, *dest; |
0 | 3482 |
3483 mb_x = s->mb_x; | |
3484 mb_y = s->mb_y; | |
3485 | |
3216
4186eb8d29a1
prefetch pixels for future motion compensation. 4-10% faster mpeg1/2/4 decoding (on an athlon-xp).
lorenm
parents:
3145
diff
changeset
|
3486 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
|
3487 |
1655 | 3488 if(s->obmc && s->pict_type != B_TYPE){ |
1633 | 3489 int16_t mv_cache[4][4][2]; |
3490 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
|
3491 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
|
3492 const int mot_xy= mb_x*2 + mb_y*2*mot_stride; |
1633 | 3493 |
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
|
3494 assert(!s->mb_skipped); |
2967 | 3495 |
1668
30746f429df6
move motion_val & mb_type to AVFrame patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1662
diff
changeset
|
3496 memcpy(mv_cache[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
|
3497 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
|
3498 memcpy(mv_cache[3][1], s->current_picture.motion_val[0][mot_xy+mot_stride], sizeof(int16_t)*4); |
1633 | 3499 |
3500 if(mb_y==0 || IS_INTRA(s->current_picture.mb_type[xy-s->mb_stride])){ | |
3501 memcpy(mv_cache[0][1], mv_cache[1][1], sizeof(int16_t)*4); | |
3502 }else{ | |
1668
30746f429df6
move motion_val & mb_type to AVFrame patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1662
diff
changeset
|
3503 memcpy(mv_cache[0][1], s->current_picture.motion_val[0][mot_xy-mot_stride], sizeof(int16_t)*4); |
1633 | 3504 } |
3505 | |
3506 if(mb_x==0 || IS_INTRA(s->current_picture.mb_type[xy-1])){ | |
3507 *(int32_t*)mv_cache[1][0]= *(int32_t*)mv_cache[1][1]; | |
3508 *(int32_t*)mv_cache[2][0]= *(int32_t*)mv_cache[2][1]; | |
3509 }else{ | |
1668
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[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
|
3511 *(int32_t*)mv_cache[2][0]= *(int32_t*)s->current_picture.motion_val[0][mot_xy-1+mot_stride]; |
1633 | 3512 } |
3513 | |
3514 if(mb_x+1>=s->mb_width || IS_INTRA(s->current_picture.mb_type[xy+1])){ | |
3515 *(int32_t*)mv_cache[1][3]= *(int32_t*)mv_cache[1][2]; | |
3516 *(int32_t*)mv_cache[2][3]= *(int32_t*)mv_cache[2][2]; | |
3517 }else{ | |
1668
30746f429df6
move motion_val & mb_type to AVFrame patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1662
diff
changeset
|
3518 *(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
|
3519 *(int32_t*)mv_cache[2][3]= *(int32_t*)s->current_picture.motion_val[0][mot_xy+2+mot_stride]; |
1633 | 3520 } |
2967 | 3521 |
1633 | 3522 mx = 0; |
3523 my = 0; | |
3524 for(i=0;i<4;i++) { | |
3525 const int x= (i&1)+1; | |
3526 const int y= (i>>1)+1; | |
3527 int16_t mv[5][2]= { | |
3528 {mv_cache[y][x ][0], mv_cache[y][x ][1]}, | |
3529 {mv_cache[y-1][x][0], mv_cache[y-1][x][1]}, | |
3530 {mv_cache[y][x-1][0], mv_cache[y][x-1][1]}, | |
3531 {mv_cache[y][x+1][0], mv_cache[y][x+1][1]}, | |
3532 {mv_cache[y+1][x][0], mv_cache[y+1][x][1]}}; | |
3533 //FIXME cleanup | |
3534 obmc_motion(s, dest_y + ((i & 1) * 8) + (i >> 1) * 8 * s->linesize, | |
3535 ref_picture[0], | |
3536 mb_x * 16 + (i & 1) * 8, mb_y * 16 + (i >>1) * 8, | |
3537 pix_op[1], | |
3538 mv); | |
3539 | |
3540 mx += mv[0][0]; | |
3541 my += mv[0][1]; | |
3542 } | |
3543 if(!(s->flags&CODEC_FLAG_GRAY)) | |
3544 chroma_4mv_motion(s, dest_cb, dest_cr, ref_picture, pix_op[1], mx, my); | |
3545 | |
3546 return; | |
3547 } | |
2967 | 3548 |
0 | 3549 switch(s->mv_type) { |
3550 case MV_TYPE_16X16: | |
255 | 3551 if(s->mcsel){ |
753 | 3552 if(s->real_sprite_warping_points==1){ |
1842
0d82db458a3c
interlaced mpeg4 + edge emu fix (fixes decoding of mermaid.avi)
michael
parents:
1838
diff
changeset
|
3553 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
|
3554 ref_picture); |
753 | 3555 }else{ |
1842
0d82db458a3c
interlaced mpeg4 + edge emu fix (fixes decoding of mermaid.avi)
michael
parents:
1838
diff
changeset
|
3556 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
|
3557 ref_picture); |
753 | 3558 } |
651 | 3559 }else if(s->quarter_sample){ |
2967 | 3560 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
|
3561 0, 0, 0, |
0d82db458a3c
interlaced mpeg4 + edge emu fix (fixes decoding of mermaid.avi)
michael
parents:
1838
diff
changeset
|
3562 ref_picture, pix_op, qpix_op, |
255 | 3563 s->mv[dir][0][0], s->mv[dir][0][1], 16); |
936 | 3564 }else if(s->mspel){ |
3565 ff_mspel_motion(s, dest_y, dest_cb, dest_cr, | |
3566 ref_picture, pix_op, | |
3567 s->mv[dir][0][0], s->mv[dir][0][1], 16); | |
1042 | 3568 }else |
3569 { | |
2967 | 3570 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
|
3571 0, 0, 0, |
0d82db458a3c
interlaced mpeg4 + edge emu fix (fixes decoding of mermaid.avi)
michael
parents:
1838
diff
changeset
|
3572 ref_picture, pix_op, |
255 | 3573 s->mv[dir][0][0], s->mv[dir][0][1], 16); |
2967 | 3574 } |
0 | 3575 break; |
3576 case MV_TYPE_8X8: | |
673 | 3577 mx = 0; |
3578 my = 0; | |
3579 if(s->quarter_sample){ | |
3580 for(i=0;i<4;i++) { | |
3581 motion_x = s->mv[dir][i][0]; | |
3582 motion_y = s->mv[dir][i][1]; | |
0 | 3583 |
673 | 3584 dxy = ((motion_y & 3) << 2) | (motion_x & 3); |
3585 src_x = mb_x * 16 + (motion_x >> 2) + (i & 1) * 8; | |
3586 src_y = mb_y * 16 + (motion_y >> 2) + (i >>1) * 8; | |
2967 | 3587 |
673 | 3588 /* WARNING: do no forget half pels */ |
4594 | 3589 src_x = av_clip(src_x, -16, s->width); |
673 | 3590 if (src_x == s->width) |
3591 dxy &= ~3; | |
4594 | 3592 src_y = av_clip(src_y, -16, s->height); |
673 | 3593 if (src_y == s->height) |
3594 dxy &= ~12; | |
2967 | 3595 |
673 | 3596 ptr = ref_picture[0] + (src_y * s->linesize) + (src_x); |
3597 if(s->flags&CODEC_FLAG_EMU_EDGE){ | |
2967 | 3598 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
|
3599 || (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
|
3600 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 | 3601 ptr= s->edge_emu_buffer; |
3602 } | |
3603 } | |
3604 dest = dest_y + ((i & 1) * 8) + (i >> 1) * 8 * s->linesize; | |
3605 qpix_op[1][dxy](dest, ptr, s->linesize); | |
3606 | |
3607 mx += s->mv[dir][i][0]/2; | |
3608 my += s->mv[dir][i][1]/2; | |
3609 } | |
3610 }else{ | |
3611 for(i=0;i<4;i++) { | |
1633 | 3612 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
|
3613 ref_picture[0], 0, 0, |
1633 | 3614 mb_x * 16 + (i & 1) * 8, mb_y * 16 + (i >>1) * 8, |
3615 s->width, s->height, s->linesize, | |
3616 s->h_edge_pos, s->v_edge_pos, | |
3617 8, 8, pix_op[1], | |
3618 s->mv[dir][i][0], s->mv[dir][i][1]); | |
673 | 3619 |
3620 mx += s->mv[dir][i][0]; | |
3621 my += s->mv[dir][i][1]; | |
554 | 3622 } |
0 | 3623 } |
673 | 3624 |
1633 | 3625 if(!(s->flags&CODEC_FLAG_GRAY)) |
3626 chroma_4mv_motion(s, dest_cb, dest_cr, ref_picture, pix_op[1], mx, my); | |
0 | 3627 break; |
3628 case MV_TYPE_FIELD: | |
3629 if (s->picture_structure == PICT_FRAME) { | |
671 | 3630 if(s->quarter_sample){ |
1843 | 3631 for(i=0; i<2; i++){ |
3632 qpel_motion(s, dest_y, dest_cb, dest_cr, | |
3633 1, i, s->field_select[dir][i], | |
3634 ref_picture, pix_op, qpix_op, | |
3635 s->mv[dir][i][0], s->mv[dir][i][1], 8); | |
3636 } | |
671 | 3637 }else{ |
2967 | 3638 /* top field */ |
1842
0d82db458a3c
interlaced mpeg4 + edge emu fix (fixes decoding of mermaid.avi)
michael
parents:
1838
diff
changeset
|
3639 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
|
3640 1, 0, s->field_select[dir][0], |
0d82db458a3c
interlaced mpeg4 + edge emu fix (fixes decoding of mermaid.avi)
michael
parents:
1838
diff
changeset
|
3641 ref_picture, pix_op, |
671 | 3642 s->mv[dir][0][0], s->mv[dir][0][1], 8); |
3643 /* bottom field */ | |
1842
0d82db458a3c
interlaced mpeg4 + edge emu fix (fixes decoding of mermaid.avi)
michael
parents:
1838
diff
changeset
|
3644 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
|
3645 1, 1, s->field_select[dir][1], |
0d82db458a3c
interlaced mpeg4 + edge emu fix (fixes decoding of mermaid.avi)
michael
parents:
1838
diff
changeset
|
3646 ref_picture, pix_op, |
671 | 3647 s->mv[dir][1][0], s->mv[dir][1][1], 8); |
3648 } | |
0 | 3649 } else { |
1842
0d82db458a3c
interlaced mpeg4 + edge emu fix (fixes decoding of mermaid.avi)
michael
parents:
1838
diff
changeset
|
3650 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
|
3651 ref_picture= s->current_picture_ptr->data; |
2967 | 3652 } |
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
|
3653 |
1842
0d82db458a3c
interlaced mpeg4 + edge emu fix (fixes decoding of mermaid.avi)
michael
parents:
1838
diff
changeset
|
3654 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
|
3655 0, 0, s->field_select[dir][0], |
0d82db458a3c
interlaced mpeg4 + edge emu fix (fixes decoding of mermaid.avi)
michael
parents:
1838
diff
changeset
|
3656 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
|
3657 s->mv[dir][0][0], s->mv[dir][0][1], 16); |
0 | 3658 } |
3659 break; | |
1843 | 3660 case MV_TYPE_16X8: |
3661 for(i=0; i<2; i++){ | |
3662 uint8_t ** ref2picture; | |
3663 | |
3664 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
|
3665 ref2picture= ref_picture; |
338a2f6e6402
Mpeg2 16x8 Patch by ("Ivan Kalvachev" <ivan at cacad dot com>)
michaelni
parents:
1328
diff
changeset
|
3666 }else{ |
1842
0d82db458a3c
interlaced mpeg4 + edge emu fix (fixes decoding of mermaid.avi)
michael
parents:
1838
diff
changeset
|
3667 ref2picture= s->current_picture_ptr->data; |
2967 | 3668 } |
3669 | |
3670 mpeg_motion(s, dest_y, dest_cb, dest_cr, | |
1843 | 3671 0, 0, s->field_select[dir][i], |
1842
0d82db458a3c
interlaced mpeg4 + edge emu fix (fixes decoding of mermaid.avi)
michael
parents:
1838
diff
changeset
|
3672 ref2picture, pix_op, |
1843 | 3673 s->mv[dir][i][0], s->mv[dir][i][1] + 16*i, 8); |
2967 | 3674 |
1843 | 3675 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
|
3676 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
|
3677 dest_cr+= (16>>s->chroma_y_shift)*s->uvlinesize; |
2967 | 3678 } |
1339
338a2f6e6402
Mpeg2 16x8 Patch by ("Ivan Kalvachev" <ivan at cacad dot com>)
michaelni
parents:
1328
diff
changeset
|
3679 break; |
1326
6cdd3b8f4fd3
DMV support patch by ("Ivan Kalvachev" <ivan at cacad dot com>)
michaelni
parents:
1317
diff
changeset
|
3680 case MV_TYPE_DMV: |
6cdd3b8f4fd3
DMV support patch by ("Ivan Kalvachev" <ivan at cacad dot com>)
michaelni
parents:
1317
diff
changeset
|
3681 if(s->picture_structure == PICT_FRAME){ |
1843 | 3682 for(i=0; i<2; i++){ |
3683 int j; | |
3684 for(j=0; j<2; j++){ | |
3685 mpeg_motion(s, dest_y, dest_cb, dest_cr, | |
3686 1, j, j^i, | |
3687 ref_picture, pix_op, | |
3688 s->mv[dir][2*i + j][0], s->mv[dir][2*i + j][1], 8); | |
3689 } | |
2967 | 3690 pix_op = s->dsp.avg_pixels_tab; |
1843 | 3691 } |
1326
6cdd3b8f4fd3
DMV support patch by ("Ivan Kalvachev" <ivan at cacad dot com>)
michaelni
parents:
1317
diff
changeset
|
3692 }else{ |
1843 | 3693 for(i=0; i<2; i++){ |
2967 | 3694 mpeg_motion(s, dest_y, dest_cb, dest_cr, |
1843 | 3695 0, 0, s->picture_structure != i+1, |
3696 ref_picture, pix_op, | |
3697 s->mv[dir][2*i][0],s->mv[dir][2*i][1],16); | |
3698 | |
3699 // after put we make avg of the same block | |
2967 | 3700 pix_op=s->dsp.avg_pixels_tab; |
1843 | 3701 |
3702 //opposite parity is always in the same frame if this is second field | |
3703 if(!s->first_field){ | |
2967 | 3704 ref_picture = s->current_picture_ptr->data; |
1843 | 3705 } |
1842
0d82db458a3c
interlaced mpeg4 + edge emu fix (fixes decoding of mermaid.avi)
michael
parents:
1838
diff
changeset
|
3706 } |
1326
6cdd3b8f4fd3
DMV support patch by ("Ivan Kalvachev" <ivan at cacad dot com>)
michaelni
parents:
1317
diff
changeset
|
3707 } |
6cdd3b8f4fd3
DMV support patch by ("Ivan Kalvachev" <ivan at cacad dot com>)
michaelni
parents:
1317
diff
changeset
|
3708 break; |
1633 | 3709 default: assert(0); |
0 | 3710 } |
3711 } | |
3712 | |
2256 | 3713 /** |
2764 | 3714 * motion compensation of a single macroblock |
2256 | 3715 * @param s context |
3716 * @param dest_y luma destination pointer | |
3717 * @param dest_cb chroma cb/u destination pointer | |
3718 * @param dest_cr chroma cr/v destination pointer | |
3719 * @param dir direction (0->forward, 1->backward) | |
3720 * @param ref_picture array[3] of pointers to the 3 planes of the reference picture | |
3721 * @param pic_op halfpel motion compensation function (average or put normally) | |
3722 * the motion vectors are taken from s->mv and the MV type from s->mv_type | |
3723 */ | |
2967 | 3724 static inline void MPV_motion_lowres(MpegEncContext *s, |
2256 | 3725 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr, |
2967 | 3726 int dir, uint8_t **ref_picture, |
2256 | 3727 h264_chroma_mc_func *pix_op) |
3728 { | |
2292 | 3729 int mx, my; |
2260 | 3730 int mb_x, mb_y, i; |
3731 const int lowres= s->avctx->lowres; | |
2967 | 3732 const int block_s= 8>>lowres; |
2260 | 3733 |
3734 mb_x = s->mb_x; | |
3735 mb_y = s->mb_y; | |
3736 | |
3737 switch(s->mv_type) { | |
3738 case MV_TYPE_16X16: | |
2967 | 3739 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr, |
2260 | 3740 0, 0, 0, |
3741 ref_picture, pix_op, | |
3742 s->mv[dir][0][0], s->mv[dir][0][1], 2*block_s); | |
3743 break; | |
2292 | 3744 case MV_TYPE_8X8: |
2260 | 3745 mx = 0; |
3746 my = 0; | |
3747 for(i=0;i<4;i++) { | |
2292 | 3748 hpel_motion_lowres(s, dest_y + ((i & 1) + (i >> 1) * s->linesize)*block_s, |
2260 | 3749 ref_picture[0], 0, 0, |
2292 | 3750 (2*mb_x + (i & 1))*block_s, (2*mb_y + (i >>1))*block_s, |
2260 | 3751 s->width, s->height, s->linesize, |
2292 | 3752 s->h_edge_pos >> lowres, s->v_edge_pos >> lowres, |
3753 block_s, block_s, pix_op, | |
2260 | 3754 s->mv[dir][i][0], s->mv[dir][i][1]); |
3755 | |
3756 mx += s->mv[dir][i][0]; | |
3757 my += s->mv[dir][i][1]; | |
3758 } | |
3759 | |
3760 if(!(s->flags&CODEC_FLAG_GRAY)) | |
2292 | 3761 chroma_4mv_motion_lowres(s, dest_cb, dest_cr, ref_picture, pix_op, mx, my); |
3762 break; | |
2260 | 3763 case MV_TYPE_FIELD: |
3764 if (s->picture_structure == PICT_FRAME) { | |
2967 | 3765 /* top field */ |
2260 | 3766 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr, |
3767 1, 0, s->field_select[dir][0], | |
3768 ref_picture, pix_op, | |
3769 s->mv[dir][0][0], s->mv[dir][0][1], block_s); | |
3770 /* bottom field */ | |
3771 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr, | |
3772 1, 1, s->field_select[dir][1], | |
3773 ref_picture, pix_op, | |
3774 s->mv[dir][1][0], s->mv[dir][1][1], block_s); | |
3775 } else { | |
3776 if(s->picture_structure != s->field_select[dir][0] + 1 && s->pict_type != B_TYPE && !s->first_field){ | |
3777 ref_picture= s->current_picture_ptr->data; | |
2967 | 3778 } |
2260 | 3779 |
3780 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr, | |
3781 0, 0, s->field_select[dir][0], | |
3782 ref_picture, pix_op, | |
3783 s->mv[dir][0][0], s->mv[dir][0][1], 2*block_s); | |
3784 } | |
3785 break; | |
3786 case MV_TYPE_16X8: | |
3787 for(i=0; i<2; i++){ | |
3788 uint8_t ** ref2picture; | |
3789 | |
3790 if(s->picture_structure == s->field_select[dir][i] + 1 || s->pict_type == B_TYPE || s->first_field){ | |
3791 ref2picture= ref_picture; | |
3792 }else{ | |
3793 ref2picture= s->current_picture_ptr->data; | |
2967 | 3794 } |
3795 | |
3796 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr, | |
2260 | 3797 0, 0, s->field_select[dir][i], |
3798 ref2picture, pix_op, | |
3799 s->mv[dir][i][0], s->mv[dir][i][1] + 2*block_s*i, block_s); | |
2967 | 3800 |
2260 | 3801 dest_y += 2*block_s*s->linesize; |
3802 dest_cb+= (2*block_s>>s->chroma_y_shift)*s->uvlinesize; | |
3803 dest_cr+= (2*block_s>>s->chroma_y_shift)*s->uvlinesize; | |
2967 | 3804 } |
2260 | 3805 break; |
3806 case MV_TYPE_DMV: | |
3807 if(s->picture_structure == PICT_FRAME){ | |
3808 for(i=0; i<2; i++){ | |
3809 int j; | |
3810 for(j=0; j<2; j++){ | |
3811 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr, | |
3812 1, j, j^i, | |
3813 ref_picture, pix_op, | |
3814 s->mv[dir][2*i + j][0], s->mv[dir][2*i + j][1], block_s); | |
3815 } | |
3816 pix_op = s->dsp.avg_h264_chroma_pixels_tab; | |
3817 } | |
3818 }else{ | |
3819 for(i=0; i<2; i++){ | |
2967 | 3820 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr, |
2260 | 3821 0, 0, s->picture_structure != i+1, |
3822 ref_picture, pix_op, | |
3823 s->mv[dir][2*i][0],s->mv[dir][2*i][1],2*block_s); | |
3824 | |
3825 // after put we make avg of the same block | |
3826 pix_op = s->dsp.avg_h264_chroma_pixels_tab; | |
3827 | |
3828 //opposite parity is always in the same frame if this is second field | |
3829 if(!s->first_field){ | |
2967 | 3830 ref_picture = s->current_picture_ptr->data; |
2260 | 3831 } |
3832 } | |
3833 } | |
3834 break; | |
3835 default: assert(0); | |
3836 } | |
2256 | 3837 } |
0 | 3838 |
3839 /* put block[] to dest[] */ | |
2967 | 3840 static inline void put_dct(MpegEncContext *s, |
1651 | 3841 DCTELEM *block, int i, uint8_t *dest, int line_size, int qscale) |
0 | 3842 { |
1689 | 3843 s->dct_unquantize_intra(s, block, i, qscale); |
1092 | 3844 s->dsp.idct_put (dest, line_size, block); |
0 | 3845 } |
3846 | |
3847 /* add block[] to dest[] */ | |
2967 | 3848 static inline void add_dct(MpegEncContext *s, |
1064 | 3849 DCTELEM *block, int i, uint8_t *dest, int line_size) |
0 | 3850 { |
3851 if (s->block_last_index[i] >= 0) { | |
1092 | 3852 s->dsp.idct_add (dest, line_size, block); |
481 | 3853 } |
3854 } | |
3855 | |
2967 | 3856 static inline void add_dequant_dct(MpegEncContext *s, |
1644 | 3857 DCTELEM *block, int i, uint8_t *dest, int line_size, int qscale) |
481 | 3858 { |
3859 if (s->block_last_index[i] >= 0) { | |
1689 | 3860 s->dct_unquantize_inter(s, block, i, qscale); |
324 | 3861 |
1092 | 3862 s->dsp.idct_add (dest, line_size, block); |
0 | 3863 } |
3864 } | |
3865 | |
456 | 3866 /** |
3867 * cleans dc, ac, coded_block for the current non intra MB | |
3868 */ | |
3869 void ff_clean_intra_table_entries(MpegEncContext *s) | |
3870 { | |
1938
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1918
diff
changeset
|
3871 int wrap = s->b8_stride; |
456 | 3872 int xy = s->block_index[0]; |
2967 | 3873 |
3874 s->dc_val[0][xy ] = | |
3875 s->dc_val[0][xy + 1 ] = | |
456 | 3876 s->dc_val[0][xy + wrap] = |
3877 s->dc_val[0][xy + 1 + wrap] = 1024; | |
3878 /* ac pred */ | |
1064 | 3879 memset(s->ac_val[0][xy ], 0, 32 * sizeof(int16_t)); |
3880 memset(s->ac_val[0][xy + wrap], 0, 32 * sizeof(int16_t)); | |
456 | 3881 if (s->msmpeg4_version>=3) { |
3882 s->coded_block[xy ] = | |
3883 s->coded_block[xy + 1 ] = | |
3884 s->coded_block[xy + wrap] = | |
3885 s->coded_block[xy + 1 + wrap] = 0; | |
3886 } | |
3887 /* chroma */ | |
1938
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1918
diff
changeset
|
3888 wrap = s->mb_stride; |
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1918
diff
changeset
|
3889 xy = s->mb_x + s->mb_y * wrap; |
456 | 3890 s->dc_val[1][xy] = |
3891 s->dc_val[2][xy] = 1024; | |
3892 /* ac pred */ | |
1064 | 3893 memset(s->ac_val[1][xy], 0, 16 * sizeof(int16_t)); |
3894 memset(s->ac_val[2][xy], 0, 16 * sizeof(int16_t)); | |
2967 | 3895 |
1938
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1918
diff
changeset
|
3896 s->mbintra_table[xy]= 0; |
456 | 3897 } |
3898 | |
0 | 3899 /* generic function called after a macroblock has been parsed by the |
3900 decoder or after it has been encoded by the encoder. | |
3901 | |
3902 Important variables used: | |
3903 s->mb_intra : true if intra macroblock | |
3904 s->mv_dir : motion vector direction | |
3905 s->mv_type : motion vector type | |
3906 s->mv : motion vector | |
3907 s->interlaced_dct : true if interlaced dct used (mpeg2) | |
3908 */ | |
4283
d6f83e2f8804
rename always_inline to av_always_inline and move to common.h
mru
parents:
4281
diff
changeset
|
3909 static av_always_inline void MPV_decode_mb_internal(MpegEncContext *s, DCTELEM block[12][64], int lowres_flag) |
0 | 3910 { |
244 | 3911 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
|
3912 const int mb_xy = s->mb_y * s->mb_stride + s->mb_x; |
1381 | 3913 #ifdef HAVE_XVMC |
3914 if(s->avctx->xvmc_acceleration){ | |
1580
628bf341e099
XvMC speedup by removing one memcpy and doing MB packing
iive
parents:
1579
diff
changeset
|
3915 XVMC_decode_mb(s);//xvmc uses pblocks |
1381 | 3916 return; |
3917 } | |
3918 #endif | |
0 | 3919 |
3920 mb_x = s->mb_x; | |
3921 mb_y = s->mb_y; | |
3922 | |
1833
ba27ce284d07
export DCT coefficients patch by (Wolfgang Hesseler <wolfgang.hesseler at imk dot fraunhofer dot de>)
michael
parents:
1831
diff
changeset
|
3923 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
|
3924 /* save DCT coefficients */ |
ba27ce284d07
export DCT coefficients patch by (Wolfgang Hesseler <wolfgang.hesseler at imk dot fraunhofer dot de>)
michael
parents:
1831
diff
changeset
|
3925 int i,j; |
ba27ce284d07
export DCT coefficients patch by (Wolfgang Hesseler <wolfgang.hesseler at imk dot fraunhofer dot de>)
michael
parents:
1831
diff
changeset
|
3926 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
|
3927 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
|
3928 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
|
3929 *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
|
3930 } |
ba27ce284d07
export DCT coefficients patch by (Wolfgang Hesseler <wolfgang.hesseler at imk dot fraunhofer dot de>)
michael
parents:
1831
diff
changeset
|
3931 |
903 | 3932 s->current_picture.qscale_table[mb_xy]= s->qscale; |
108
1e4a4af694d1
exporting qscale data for postprocessing (for MPlayer)
arpi_esp
parents:
79
diff
changeset
|
3933 |
0 | 3934 /* update DC predictors for P macroblocks */ |
3935 if (!s->mb_intra) { | |
249
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
3936 if (s->h263_pred || s->h263_aic) { |
481 | 3937 if(s->mbintra_table[mb_xy]) |
456 | 3938 ff_clean_intra_table_entries(s); |
0 | 3939 } else { |
456 | 3940 s->last_dc[0] = |
3941 s->last_dc[1] = | |
0 | 3942 s->last_dc[2] = 128 << s->intra_dc_precision; |
3943 } | |
3944 } | |
249
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
3945 else if (s->h263_pred || s->h263_aic) |
481 | 3946 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
|
3947 |
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
|
3948 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 | 3949 uint8_t *dest_y, *dest_cb, *dest_cr; |
481 | 3950 int dct_linesize, dct_offset; |
651 | 3951 op_pixels_func (*op_pix)[4]; |
3952 qpel_mc_func (*op_qpix)[16]; | |
2627
bf158d23bbcc
Spelling errors patch by (Kevin Baragona | kevinmb500 gawab com)
michael
parents:
2620
diff
changeset
|
3953 const int linesize= s->current_picture.linesize[0]; //not s->linesize as this would be wrong for field pics |
1138 | 3954 const int uvlinesize= s->current_picture.linesize[1]; |
2256 | 3955 const int readable= s->pict_type != B_TYPE || s->encoding || s->avctx->draw_horiz_band || lowres_flag; |
3956 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
|
3957 |
903 | 3958 /* avoid copy if macroblock skipped in last frame too */ |
3959 /* skip only during decoding as we might trash the buffers during encoding a bit */ | |
3960 if(!s->encoding){ | |
1064 | 3961 uint8_t *mbskip_ptr = &s->mbskip_table[mb_xy]; |
903 | 3962 const int age= s->current_picture.age; |
3963 | |
3964 assert(age); | |
3965 | |
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
|
3966 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
|
3967 s->mb_skipped= 0; |
903 | 3968 assert(s->pict_type!=I_TYPE); |
2967 | 3969 |
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
|
3970 (*mbskip_ptr) ++; /* indicate that this time we skipped it */ |
556 | 3971 if(*mbskip_ptr >99) *mbskip_ptr= 99; |
3972 | |
903 | 3973 /* 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
|
3974 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
|
3975 return; |
903 | 3976 } |
1021
2d7c9f5738de
trying to fix mb skip bug in mpeg1/2 if slices are not used
michaelni
parents:
1014
diff
changeset
|
3977 } 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
|
3978 (*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
|
3979 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
|
3980 } else{ |
7
1d3ac9654178
added skip macroblock optimization (big perf win on black regions for example)
glantau
parents:
0
diff
changeset
|
3981 *mbskip_ptr = 0; /* not skipped */ |
1d3ac9654178
added skip macroblock optimization (big perf win on black regions for example)
glantau
parents:
0
diff
changeset
|
3982 } |
717 | 3983 } |
2967 | 3984 |
2074
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
3985 dct_linesize = linesize << s->interlaced_dct; |
2256 | 3986 dct_offset =(s->interlaced_dct)? linesize : linesize*block_size; |
2967 | 3987 |
1632 | 3988 if(readable){ |
3989 dest_y= s->dest[0]; | |
3990 dest_cb= s->dest[1]; | |
3991 dest_cr= s->dest[2]; | |
3992 }else{ | |
1799 | 3993 dest_y = s->b_scratchpad; |
1834 | 3994 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
|
3995 dest_cr= s->b_scratchpad+32*linesize; |
1632 | 3996 } |
2256 | 3997 |
0 | 3998 if (!s->mb_intra) { |
3999 /* motion handling */ | |
2627
bf158d23bbcc
Spelling errors patch by (Kevin Baragona | kevinmb500 gawab com)
michael
parents:
2620
diff
changeset
|
4000 /* decoding or more than one mb_type (MC was already done otherwise) */ |
1389 | 4001 if(!s->encoding){ |
2256 | 4002 if(lowres_flag){ |
4003 h264_chroma_mc_func *op_pix = s->dsp.put_h264_chroma_pixels_tab; | |
4004 | |
4005 if (s->mv_dir & MV_DIR_FORWARD) { | |
4006 MPV_motion_lowres(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.data, op_pix); | |
4007 op_pix = s->dsp.avg_h264_chroma_pixels_tab; | |
4008 } | |
4009 if (s->mv_dir & MV_DIR_BACKWARD) { | |
4010 MPV_motion_lowres(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.data, op_pix); | |
4011 } | |
324 | 4012 }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
|
4013 op_qpix= s->me.qpel_put; |
2967 | 4014 if ((!s->no_rounding) || s->pict_type==B_TYPE){ |
2256 | 4015 op_pix = s->dsp.put_pixels_tab; |
4016 }else{ | |
4017 op_pix = s->dsp.put_no_rnd_pixels_tab; | |
4018 } | |
4019 if (s->mv_dir & MV_DIR_FORWARD) { | |
4020 MPV_motion(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.data, op_pix, op_qpix); | |
4021 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
|
4022 op_qpix= s->me.qpel_avg; |
2256 | 4023 } |
4024 if (s->mv_dir & MV_DIR_BACKWARD) { | |
4025 MPV_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.data, op_pix, op_qpix); | |
4026 } | |
324 | 4027 } |
0 | 4028 } |
4029 | |
481 | 4030 /* skip dequant / idct if we are really late ;) */ |
2792 | 4031 if(s->hurry_up>1) goto skip_idct; |
4032 if(s->avctx->skip_idct){ | |
4033 if( (s->avctx->skip_idct >= AVDISCARD_NONREF && s->pict_type == B_TYPE) | |
4034 ||(s->avctx->skip_idct >= AVDISCARD_NONKEY && s->pict_type != I_TYPE) | |
4035 || s->avctx->skip_idct >= AVDISCARD_ALL) | |
4036 goto skip_idct; | |
4037 } | |
481 | 4038 |
0 | 4039 /* add dct residue */ |
1421 | 4040 if(s->encoding || !( s->h263_msmpeg4 || s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO |
711 | 4041 || (s->codec_id==CODEC_ID_MPEG4 && !s->mpeg_quant))){ |
2256 | 4042 add_dequant_dct(s, block[0], 0, dest_y , dct_linesize, s->qscale); |
4043 add_dequant_dct(s, block[1], 1, dest_y + block_size, dct_linesize, s->qscale); | |
4044 add_dequant_dct(s, block[2], 2, dest_y + dct_offset , dct_linesize, s->qscale); | |
4045 add_dequant_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize, s->qscale); | |
0 | 4046 |
485 | 4047 if(!(s->flags&CODEC_FLAG_GRAY)){ |
3309 | 4048 if (s->chroma_y_shift){ |
4049 add_dequant_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale); | |
4050 add_dequant_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale); | |
4051 }else{ | |
4052 dct_linesize >>= 1; | |
4053 dct_offset >>=1; | |
4054 add_dequant_dct(s, block[4], 4, dest_cb, dct_linesize, s->chroma_qscale); | |
4055 add_dequant_dct(s, block[5], 5, dest_cr, dct_linesize, s->chroma_qscale); | |
4056 add_dequant_dct(s, block[6], 6, dest_cb + dct_offset, dct_linesize, s->chroma_qscale); | |
4057 add_dequant_dct(s, block[7], 7, dest_cr + dct_offset, dct_linesize, s->chroma_qscale); | |
4058 } | |
485 | 4059 } |
936 | 4060 } else if(s->codec_id != CODEC_ID_WMV2){ |
2256 | 4061 add_dct(s, block[0], 0, dest_y , dct_linesize); |
4062 add_dct(s, block[1], 1, dest_y + block_size, dct_linesize); | |
4063 add_dct(s, block[2], 2, dest_y + dct_offset , dct_linesize); | |
4064 add_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize); | |
481 | 4065 |
485 | 4066 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
|
4067 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
|
4068 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
|
4069 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
|
4070 }else{ |
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
4071 //chroma422 |
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
4072 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
|
4073 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
|
4074 |
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
4075 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
|
4076 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
|
4077 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
|
4078 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
|
4079 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
|
4080 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
|
4081 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
|
4082 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
|
4083 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
|
4084 } |
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
4085 } |
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
4086 }//fi gray |
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
4087 } |
1042 | 4088 else{ |
936 | 4089 ff_wmv2_add_mb(s, block, dest_y, dest_cb, dest_cr); |
481 | 4090 } |
0 | 4091 } else { |
4092 /* dct only in intra block */ | |
1421 | 4093 if(s->encoding || !(s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO)){ |
2256 | 4094 put_dct(s, block[0], 0, dest_y , dct_linesize, s->qscale); |
4095 put_dct(s, block[1], 1, dest_y + block_size, dct_linesize, s->qscale); | |
4096 put_dct(s, block[2], 2, dest_y + dct_offset , dct_linesize, s->qscale); | |
4097 put_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize, s->qscale); | |
0 | 4098 |
711 | 4099 if(!(s->flags&CODEC_FLAG_GRAY)){ |
3309 | 4100 if(s->chroma_y_shift){ |
4101 put_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale); | |
4102 put_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale); | |
4103 }else{ | |
4104 dct_offset >>=1; | |
4105 dct_linesize >>=1; | |
4106 put_dct(s, block[4], 4, dest_cb, dct_linesize, s->chroma_qscale); | |
4107 put_dct(s, block[5], 5, dest_cr, dct_linesize, s->chroma_qscale); | |
4108 put_dct(s, block[6], 6, dest_cb + dct_offset, dct_linesize, s->chroma_qscale); | |
4109 put_dct(s, block[7], 7, dest_cr + dct_offset, dct_linesize, s->chroma_qscale); | |
4110 } | |
711 | 4111 } |
4112 }else{ | |
2256 | 4113 s->dsp.idct_put(dest_y , dct_linesize, block[0]); |
4114 s->dsp.idct_put(dest_y + block_size, dct_linesize, block[1]); | |
4115 s->dsp.idct_put(dest_y + dct_offset , dct_linesize, block[2]); | |
4116 s->dsp.idct_put(dest_y + dct_offset + block_size, dct_linesize, block[3]); | |
711 | 4117 |
4118 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
|
4119 if(s->chroma_y_shift){ |
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, uvlinesize, block[4]); |
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
4121 s->dsp.idct_put(dest_cr, uvlinesize, block[5]); |
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
4122 }else{ |
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
4123 |
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
4124 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
|
4125 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
|
4126 |
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
4127 s->dsp.idct_put(dest_cb, dct_linesize, block[4]); |
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
4128 s->dsp.idct_put(dest_cr, dct_linesize, block[5]); |
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
4129 s->dsp.idct_put(dest_cb + 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
|
4130 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
|
4131 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
|
4132 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
|
4133 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
|
4134 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
|
4135 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
|
4136 } |
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
4137 } |
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
4138 }//gray |
485 | 4139 } |
0 | 4140 } |
2792 | 4141 skip_idct: |
1632 | 4142 if(!readable){ |
4143 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
|
4144 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
|
4145 s->dsp.put_pixels_tab[s->chroma_x_shift][0](s->dest[2], dest_cr, uvlinesize,16 >> s->chroma_y_shift); |
1632 | 4146 } |
0 | 4147 } |
294 | 4148 } |
4149 | |
2256 | 4150 void MPV_decode_mb(MpegEncContext *s, DCTELEM block[12][64]){ |
4151 if(s->avctx->lowres) MPV_decode_mb_internal(s, block, 1); | |
4152 else MPV_decode_mb_internal(s, block, 0); | |
4153 } | |
4154 | |
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
|
4155 #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
|
4156 |
605
40874804a5af
same dc skip behavior for chroma & luma elimination, its confusing otherwise imho
michaelni
parents:
604
diff
changeset
|
4157 static inline void dct_single_coeff_elimination(MpegEncContext *s, int n, int threshold) |
456 | 4158 { |
4159 static const char tab[64]= | |
4160 {3,2,2,1,1,1,1,1, | |
4161 1,1,1,1,1,1,1,1, | |
4162 1,1,1,1,1,1,1,1, | |
4163 0,0,0,0,0,0,0,0, | |
4164 0,0,0,0,0,0,0,0, | |
4165 0,0,0,0,0,0,0,0, | |
4166 0,0,0,0,0,0,0,0, | |
4167 0,0,0,0,0,0,0,0}; | |
4168 int score=0; | |
4169 int run=0; | |
4170 int i; | |
4171 DCTELEM *block= s->block[n]; | |
4172 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
|
4173 int skip_dc; |
456 | 4174 |
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
|
4175 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
|
4176 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
|
4177 threshold= -threshold; |
605
40874804a5af
same dc skip behavior for chroma & luma elimination, its confusing otherwise imho
michaelni
parents:
604
diff
changeset
|
4178 }else |
40874804a5af
same dc skip behavior for chroma & luma elimination, its confusing otherwise imho
michaelni
parents:
604
diff
changeset
|
4179 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
|
4180 |
456 | 4181 /* are all which we could set to zero are allready zero? */ |
4182 if(last_index<=skip_dc - 1) return; | |
4183 | |
4184 for(i=0; i<=last_index; i++){ | |
706
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
4185 const int j = s->intra_scantable.permutated[i]; |
4001 | 4186 const int level = FFABS(block[j]); |
456 | 4187 if(level==1){ |
4188 if(skip_dc && i==0) continue; | |
4189 score+= tab[run]; | |
4190 run=0; | |
4191 }else if(level>1){ | |
4192 return; | |
4193 }else{ | |
4194 run++; | |
4195 } | |
4196 } | |
4197 if(score >= threshold) return; | |
4198 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
|
4199 const int j = s->intra_scantable.permutated[i]; |
456 | 4200 block[j]=0; |
4201 } | |
4202 if(block[0]) s->block_last_index[n]= 0; | |
4203 else s->block_last_index[n]= -1; | |
4204 } | |
4205 | |
344 | 4206 static inline void clip_coeffs(MpegEncContext *s, DCTELEM *block, int last_index) |
4207 { | |
4208 int i; | |
4209 const int maxlevel= s->max_qcoeff; | |
4210 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
|
4211 int overflow=0; |
2967 | 4212 |
706
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
4213 if(s->mb_intra){ |
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
4214 i=1; //skip clipping of intra dc |
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
4215 }else |
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
4216 i=0; |
2967 | 4217 |
706
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
4218 for(;i<=last_index; i++){ |
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
4219 const int j= s->intra_scantable.permutated[i]; |
344 | 4220 int level = block[j]; |
2967 | 4221 |
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
|
4222 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
|
4223 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
|
4224 overflow++; |
7e040c2a86e4
warn the user if we had to clip some dct coefficient due to a crappy format which doenst support the whole needed range (msmpeg4/wmv mostly but mpeg1 too to a lesser extend)
michael
parents:
1719
diff
changeset
|
4225 }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
|
4226 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
|
4227 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
|
4228 } |
2967 | 4229 |
344 | 4230 block[j]= level; |
4231 } | |
2967 | 4232 |
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
|
4233 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
|
4234 av_log(s->avctx, AV_LOG_INFO, "warning, clipping %d dct coefficients to %d..%d\n", overflow, minlevel, maxlevel); |
344 | 4235 } |
324 | 4236 |
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
|
4237 #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
|
4238 |
1098
b7f267d168b7
mpeg2 field pictures + sliced mode (doesnt work with mplayer though, dunno why)
michaelni
parents:
1096
diff
changeset
|
4239 /** |
b7f267d168b7
mpeg2 field pictures + sliced mode (doesnt work with mplayer though, dunno why)
michaelni
parents:
1096
diff
changeset
|
4240 * |
b7f267d168b7
mpeg2 field pictures + sliced mode (doesnt work with mplayer though, dunno why)
michaelni
parents:
1096
diff
changeset
|
4241 * @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
|
4242 */ |
b7f267d168b7
mpeg2 field pictures + sliced mode (doesnt work with mplayer though, dunno why)
michaelni
parents:
1096
diff
changeset
|
4243 void ff_draw_horiz_band(MpegEncContext *s, int y, int h){ |
1368 | 4244 if (s->avctx->draw_horiz_band) { |
1370 | 4245 AVFrame *src; |
1368 | 4246 int offset[4]; |
2967 | 4247 |
1370 | 4248 if(s->picture_structure != PICT_FRAME){ |
4249 h <<= 1; | |
4250 y <<= 1; | |
4251 if(s->first_field && !(s->avctx->slice_flags&SLICE_FLAG_ALLOW_FIELD)) return; | |
4252 } | |
4253 | |
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
|
4254 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
|
4255 |
2967 | 4256 if(s->pict_type==B_TYPE || s->low_delay || (s->avctx->slice_flags&SLICE_FLAG_CODED_ORDER)) |
1370 | 4257 src= (AVFrame*)s->current_picture_ptr; |
4258 else if(s->last_picture_ptr) | |
4259 src= (AVFrame*)s->last_picture_ptr; | |
4260 else | |
4261 return; | |
2967 | 4262 |
1369 | 4263 if(s->pict_type==B_TYPE && s->picture_structure == PICT_FRAME && s->out_format != FMT_H264){ |
1368 | 4264 offset[0]= |
4265 offset[1]= | |
4266 offset[2]= | |
4267 offset[3]= 0; | |
4268 }else{ | |
4269 offset[0]= y * s->linesize;; | |
2967 | 4270 offset[1]= |
2074
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
4271 offset[2]= (y >> s->chroma_y_shift) * s->uvlinesize; |
1368 | 4272 offset[3]= 0; |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
731
diff
changeset
|
4273 } |
1368 | 4274 |
813 | 4275 emms_c(); |
4276 | |
1370 | 4277 s->avctx->draw_horiz_band(s->avctx, src, offset, |
4278 y, s->picture_structure, h); | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
731
diff
changeset
|
4279 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
731
diff
changeset
|
4280 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
731
diff
changeset
|
4281 |
1389 | 4282 void ff_init_block_index(MpegEncContext *s){ //FIXME maybe rename |
2764 | 4283 const int linesize= s->current_picture.linesize[0]; //not s->linesize as this would be wrong for field pics |
1389 | 4284 const int uvlinesize= s->current_picture.linesize[1]; |
2256 | 4285 const int mb_size= 4 - s->avctx->lowres; |
2967 | 4286 |
1938
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1918
diff
changeset
|
4287 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
|
4288 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
|
4289 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
|
4290 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
|
4291 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
|
4292 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
|
4293 //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
|
4294 |
2256 | 4295 s->dest[0] = s->current_picture.data[0] + ((s->mb_x - 1) << mb_size); |
4296 s->dest[1] = s->current_picture.data[1] + ((s->mb_x - 1) << (mb_size - s->chroma_x_shift)); | |
4297 s->dest[2] = s->current_picture.data[2] + ((s->mb_x - 1) << (mb_size - s->chroma_x_shift)); | |
2168 | 4298 |
2074
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
4299 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
|
4300 { |
2256 | 4301 s->dest[0] += s->mb_y * linesize << mb_size; |
4302 s->dest[1] += s->mb_y * uvlinesize << (mb_size - s->chroma_y_shift); | |
4303 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
|
4304 } |
1389 | 4305 } |
4306 | |
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
|
4307 #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
|
4308 |
1777 | 4309 static void get_vissual_weight(int16_t *weight, uint8_t *ptr, int stride){ |
4310 int x, y; | |
4311 //FIXME optimize | |
4312 for(y=0; y<8; y++){ | |
4313 for(x=0; x<8; x++){ | |
4314 int x2, y2; | |
4315 int sum=0; | |
4316 int sqr=0; | |
4317 int count=0; | |
4318 | |
4319 for(y2= FFMAX(y-1, 0); y2 < FFMIN(8, y+2); y2++){ | |
4320 for(x2= FFMAX(x-1, 0); x2 < FFMIN(8, x+2); x2++){ | |
4321 int v= ptr[x2 + y2*stride]; | |
4322 sum += v; | |
4323 sqr += v*v; | |
4324 count++; | |
4325 } | |
4326 } | |
4327 weight[x + 8*y]= (36*ff_sqrt(count*sqr - sum*sum)) / count; | |
4328 } | |
4329 } | |
4330 } | |
4331 | |
4283
d6f83e2f8804
rename always_inline to av_always_inline and move to common.h
mru
parents:
4281
diff
changeset
|
4332 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 | 4333 { |
3309 | 4334 int16_t weight[8][64]; |
4335 DCTELEM orig[8][64]; | |
294 | 4336 const int mb_x= s->mb_x; |
4337 const int mb_y= s->mb_y; | |
4338 int i; | |
3309 | 4339 int skip_dct[8]; |
697 | 4340 int dct_offset = s->linesize*8; //default for progressive frames |
1778 | 4341 uint8_t *ptr_y, *ptr_cb, *ptr_cr; |
4342 int wrap_y, wrap_c; | |
2967 | 4343 |
4327 | 4344 for(i=0; i<mb_block_count; i++) skip_dct[i]=s->skipdct; |
2967 | 4345 |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
673
diff
changeset
|
4346 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
|
4347 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
|
4348 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
|
4349 |
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
|
4350 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
|
4351 update_qscale(s); |
2967 | 4352 |
1616 | 4353 if(!(s->flags&CODEC_FLAG_QP_RD)){ |
4320 | 4354 s->qscale= s->current_picture_ptr->qscale_table[mb_xy]; |
1616 | 4355 s->dquant= s->qscale - last_qp; |
4356 | |
1805
5dd5b2052f5b
mpeg4 b frame + adaptive quantization assertion failure fix
michael
parents:
1804
diff
changeset
|
4357 if(s->out_format==FMT_H263){ |
4594 | 4358 s->dquant= av_clip(s->dquant, -2, 2); |
2967 | 4359 |
4360 if(s->codec_id==CODEC_ID_MPEG4){ | |
1805
5dd5b2052f5b
mpeg4 b frame + adaptive quantization assertion failure fix
michael
parents:
1804
diff
changeset
|
4361 if(!s->mb_intra){ |
5dd5b2052f5b
mpeg4 b frame + adaptive quantization assertion failure fix
michael
parents:
1804
diff
changeset
|
4362 if(s->pict_type == B_TYPE){ |
4324 | 4363 if(s->dquant&1 || s->mv_dir&MV_DIRECT) |
1805
5dd5b2052f5b
mpeg4 b frame + adaptive quantization assertion failure fix
michael
parents:
1804
diff
changeset
|
4364 s->dquant= 0; |
5dd5b2052f5b
mpeg4 b frame + adaptive quantization assertion failure fix
michael
parents:
1804
diff
changeset
|
4365 } |
5dd5b2052f5b
mpeg4 b frame + adaptive quantization assertion failure fix
michael
parents:
1804
diff
changeset
|
4366 if(s->mv_type==MV_TYPE_8X8) |
5dd5b2052f5b
mpeg4 b frame + adaptive quantization assertion failure fix
michael
parents:
1804
diff
changeset
|
4367 s->dquant=0; |
5dd5b2052f5b
mpeg4 b frame + adaptive quantization assertion failure fix
michael
parents:
1804
diff
changeset
|
4368 } |
1616 | 4369 } |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
673
diff
changeset
|
4370 } |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
673
diff
changeset
|
4371 } |
1652 | 4372 ff_set_qscale(s, last_qp + s->dquant); |
2054 | 4373 }else if(s->flags&CODEC_FLAG_QP_RD) |
4374 ff_set_qscale(s, s->qscale + s->dquant); | |
294 | 4375 |
1778 | 4376 wrap_y = s->linesize; |
4377 wrap_c = s->uvlinesize; | |
4378 ptr_y = s->new_picture.data[0] + (mb_y * 16 * wrap_y) + mb_x * 16; | |
3309 | 4379 ptr_cb = s->new_picture.data[1] + (mb_y * mb_block_height * wrap_c) + mb_x * 8; |
4380 ptr_cr = s->new_picture.data[2] + (mb_y * mb_block_height * wrap_c) + mb_x * 8; | |
1778 | 4381 |
4382 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
|
4383 uint8_t *ebuf= s->edge_emu_buffer + 32; |
5ca07515a309
10l (dont store 2 different things at the same place ...)
michael
parents:
2132
diff
changeset
|
4384 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
|
4385 ptr_y= ebuf; |
3309 | 4386 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
|
4387 ptr_cb= ebuf+18*wrap_y; |
3309 | 4388 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
|
4389 ptr_cr= ebuf+18*wrap_y+8; |
1778 | 4390 } |
4391 | |
324 | 4392 if (s->mb_intra) { |
697 | 4393 if(s->flags&CODEC_FLAG_INTERLACED_DCT){ |
4394 int progressive_score, interlaced_score; | |
1708 | 4395 |
1729 | 4396 s->interlaced_dct=0; |
2967 | 4397 progressive_score= s->dsp.ildct_cmp[4](s, ptr_y , NULL, wrap_y, 8) |
1777 | 4398 +s->dsp.ildct_cmp[4](s, ptr_y + wrap_y*8, NULL, wrap_y, 8) - 400; |
1729 | 4399 |
4400 if(progressive_score > 0){ | |
2967 | 4401 interlaced_score = s->dsp.ildct_cmp[4](s, ptr_y , NULL, wrap_y*2, 8) |
1777 | 4402 +s->dsp.ildct_cmp[4](s, ptr_y + wrap_y , NULL, wrap_y*2, 8); |
1729 | 4403 if(progressive_score > interlaced_score){ |
4404 s->interlaced_dct=1; | |
2967 | 4405 |
1729 | 4406 dct_offset= wrap_y; |
4407 wrap_y<<=1; | |
3309 | 4408 if (s->chroma_format == CHROMA_422) |
4409 wrap_c<<=1; | |
1729 | 4410 } |
4411 } | |
697 | 4412 } |
2967 | 4413 |
2979 | 4414 s->dsp.get_pixels(s->block[0], ptr_y , wrap_y); |
1777 | 4415 s->dsp.get_pixels(s->block[1], ptr_y + 8, wrap_y); |
4416 s->dsp.get_pixels(s->block[2], ptr_y + dct_offset , wrap_y); | |
4417 s->dsp.get_pixels(s->block[3], ptr_y + dct_offset + 8, wrap_y); | |
294 | 4418 |
487 | 4419 if(s->flags&CODEC_FLAG_GRAY){ |
4420 skip_dct[4]= 1; | |
4421 skip_dct[5]= 1; | |
4422 }else{ | |
2979 | 4423 s->dsp.get_pixels(s->block[4], ptr_cb, wrap_c); |
1777 | 4424 s->dsp.get_pixels(s->block[5], ptr_cr, wrap_c); |
3309 | 4425 if(!s->chroma_y_shift){ /* 422 */ |
4426 s->dsp.get_pixels(s->block[6], ptr_cb + (dct_offset>>1), wrap_c); | |
4427 s->dsp.get_pixels(s->block[7], ptr_cr + (dct_offset>>1), wrap_c); | |
4428 } | |
1777 | 4429 } |
324 | 4430 }else{ |
651 | 4431 op_pixels_func (*op_pix)[4]; |
4432 qpel_mc_func (*op_qpix)[16]; | |
1064 | 4433 uint8_t *dest_y, *dest_cb, *dest_cr; |
294 | 4434 |
1389 | 4435 dest_y = s->dest[0]; |
4436 dest_cb = s->dest[1]; | |
4437 dest_cr = s->dest[2]; | |
324 | 4438 |
327 | 4439 if ((!s->no_rounding) || s->pict_type==B_TYPE){ |
2979 | 4440 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
|
4441 op_qpix= s->dsp.put_qpel_pixels_tab; |
295 | 4442 }else{ |
853
eacc2dd8fd9d
* using DSPContext - so each codec could use its local (sub)set of CPU extension
kabi
parents:
847
diff
changeset
|
4443 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
|
4444 op_qpix= s->dsp.put_no_rnd_qpel_pixels_tab; |
324 | 4445 } |
295 | 4446 |
324 | 4447 if (s->mv_dir & MV_DIR_FORWARD) { |
903 | 4448 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
|
4449 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
|
4450 op_qpix= s->dsp.avg_qpel_pixels_tab; |
324 | 4451 } |
4452 if (s->mv_dir & MV_DIR_BACKWARD) { | |
903 | 4453 MPV_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.data, op_pix, op_qpix); |
324 | 4454 } |
295 | 4455 |
697 | 4456 if(s->flags&CODEC_FLAG_INTERLACED_DCT){ |
4457 int progressive_score, interlaced_score; | |
1729 | 4458 |
4459 s->interlaced_dct=0; | |
2967 | 4460 progressive_score= s->dsp.ildct_cmp[0](s, dest_y , ptr_y , wrap_y, 8) |
1729 | 4461 +s->dsp.ildct_cmp[0](s, dest_y + wrap_y*8, ptr_y + wrap_y*8, wrap_y, 8) - 400; |
2967 | 4462 |
1729 | 4463 if(s->avctx->ildct_cmp == FF_CMP_VSSE) progressive_score -= 400; |
4464 | |
4465 if(progressive_score>0){ | |
2967 | 4466 interlaced_score = s->dsp.ildct_cmp[0](s, dest_y , ptr_y , wrap_y*2, 8) |
1729 | 4467 +s->dsp.ildct_cmp[0](s, dest_y + wrap_y , ptr_y + wrap_y , wrap_y*2, 8); |
2967 | 4468 |
1729 | 4469 if(progressive_score > interlaced_score){ |
4470 s->interlaced_dct=1; | |
2967 | 4471 |
1729 | 4472 dct_offset= wrap_y; |
4473 wrap_y<<=1; | |
3309 | 4474 if (s->chroma_format == CHROMA_422) |
4475 wrap_c<<=1; | |
1729 | 4476 } |
4477 } | |
697 | 4478 } |
2967 | 4479 |
2979 | 4480 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
|
4481 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
|
4482 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
|
4483 s->dsp.diff_pixels(s->block[3], ptr_y + dct_offset + 8, dest_y + dct_offset + 8, wrap_y); |
2967 | 4484 |
487 | 4485 if(s->flags&CODEC_FLAG_GRAY){ |
4486 skip_dct[4]= 1; | |
4487 skip_dct[5]= 1; | |
4488 }else{ | |
853
eacc2dd8fd9d
* using DSPContext - so each codec could use its local (sub)set of CPU extension
kabi
parents:
847
diff
changeset
|
4489 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
|
4490 s->dsp.diff_pixels(s->block[5], ptr_cr, dest_cr, wrap_c); |
3309 | 4491 if(!s->chroma_y_shift){ /* 422 */ |
4492 s->dsp.diff_pixels(s->block[6], ptr_cb + (dct_offset>>1), dest_cb + (dct_offset>>1), wrap_c); | |
4493 s->dsp.diff_pixels(s->block[7], ptr_cr + (dct_offset>>1), dest_cr + (dct_offset>>1), wrap_c); | |
4494 } | |
487 | 4495 } |
2967 | 4496 /* 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
|
4497 if(s->current_picture.mc_mb_var[s->mb_stride*mb_y+ mb_x]<2*s->qscale*s->qscale){ |
697 | 4498 //FIXME optimize |
2979 | 4499 if(s->dsp.sad[1](NULL, ptr_y , dest_y , wrap_y, 8) < 20*s->qscale) skip_dct[0]= 1; |
1708 | 4500 if(s->dsp.sad[1](NULL, ptr_y + 8, dest_y + 8, wrap_y, 8) < 20*s->qscale) skip_dct[1]= 1; |
4501 if(s->dsp.sad[1](NULL, ptr_y +dct_offset , dest_y +dct_offset , wrap_y, 8) < 20*s->qscale) skip_dct[2]= 1; | |
4502 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; | |
4503 if(s->dsp.sad[1](NULL, ptr_cb , dest_cb , wrap_c, 8) < 20*s->qscale) skip_dct[4]= 1; | |
4504 if(s->dsp.sad[1](NULL, ptr_cr , dest_cr , wrap_c, 8) < 20*s->qscale) skip_dct[5]= 1; | |
3309 | 4505 if(!s->chroma_y_shift){ /* 422 */ |
4506 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; | |
4507 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; | |
4508 } | |
456 | 4509 } |
1778 | 4510 } |
4511 | |
4512 if(s->avctx->quantizer_noise_shaping){ | |
4513 if(!skip_dct[0]) get_vissual_weight(weight[0], ptr_y , wrap_y); | |
4514 if(!skip_dct[1]) get_vissual_weight(weight[1], ptr_y + 8, wrap_y); | |
4515 if(!skip_dct[2]) get_vissual_weight(weight[2], ptr_y + dct_offset , wrap_y); | |
4516 if(!skip_dct[3]) get_vissual_weight(weight[3], ptr_y + dct_offset + 8, wrap_y); | |
4517 if(!skip_dct[4]) get_vissual_weight(weight[4], ptr_cb , wrap_c); | |
4518 if(!skip_dct[5]) get_vissual_weight(weight[5], ptr_cr , wrap_c); | |
3309 | 4519 if(!s->chroma_y_shift){ /* 422 */ |
4520 if(!skip_dct[6]) get_vissual_weight(weight[6], ptr_cb + (dct_offset>>1), wrap_c); | |
4521 if(!skip_dct[7]) get_vissual_weight(weight[7], ptr_cr + (dct_offset>>1), wrap_c); | |
4522 } | |
4523 memcpy(orig[0], s->block[0], sizeof(DCTELEM)*64*mb_block_count); | |
294 | 4524 } |
2967 | 4525 |
294 | 4526 /* DCT & quantize */ |
1778 | 4527 assert(s->out_format!=FMT_MJPEG || s->qscale==8); |
4528 { | |
3309 | 4529 for(i=0;i<mb_block_count;i++) { |
456 | 4530 if(!skip_dct[i]){ |
4531 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
|
4532 s->block_last_index[i] = s->dct_quantize(s, s->block[i], i, s->qscale, &overflow); |
344 | 4533 // 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
|
4534 // 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
|
4535 // of improve it. Just INTRADC clipping deserves changes in quantizer |
456 | 4536 if (overflow) clip_coeffs(s, s->block[i], s->block_last_index[i]); |
4537 }else | |
4538 s->block_last_index[i]= -1; | |
344 | 4539 } |
1777 | 4540 if(s->avctx->quantizer_noise_shaping){ |
3309 | 4541 for(i=0;i<mb_block_count;i++) { |
1777 | 4542 if(!skip_dct[i]){ |
4543 s->block_last_index[i] = dct_quantize_refine(s, s->block[i], weight[i], orig[i], i, s->qscale); | |
4544 } | |
4545 } | |
4546 } | |
2967 | 4547 |
456 | 4548 if(s->luma_elim_threshold && !s->mb_intra) |
4549 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
|
4550 dct_single_coeff_elimination(s, i, s->luma_elim_threshold); |
456 | 4551 if(s->chroma_elim_threshold && !s->mb_intra) |
3309 | 4552 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
|
4553 dct_single_coeff_elimination(s, i, s->chroma_elim_threshold); |
1497 | 4554 |
4555 if(s->flags & CODEC_FLAG_CBP_RD){ | |
3309 | 4556 for(i=0;i<mb_block_count;i++) { |
1497 | 4557 if(s->block_last_index[i] == -1) |
4558 s->coded_score[i]= INT_MAX/256; | |
4559 } | |
4560 } | |
294 | 4561 } |
4562 | |
487 | 4563 if((s->flags&CODEC_FLAG_GRAY) && s->mb_intra){ |
4564 s->block_last_index[4]= | |
4565 s->block_last_index[5]= 0; | |
4566 s->block[4][0]= | |
1011 | 4567 s->block[5][0]= (1024 + s->c_dc_scale/2)/ s->c_dc_scale; |
487 | 4568 } |
4569 | |
1708 | 4570 //non c quantize code returns incorrect block_last_index FIXME |
4571 if(s->alternate_scan && s->dct_quantize != dct_quantize_c){ | |
3309 | 4572 for(i=0; i<mb_block_count; i++){ |
1708 | 4573 int j; |
4574 if(s->block_last_index[i]>0){ | |
4575 for(j=63; j>0; j--){ | |
4576 if(s->block[i][ s->intra_scantable.permutated[j] ]) break; | |
4577 } | |
4578 s->block_last_index[i]= j; | |
4579 } | |
4580 } | |
4581 } | |
4582 | |
294 | 4583 /* huffman encode */ |
936 | 4584 switch(s->codec_id){ //FIXME funct ptr could be slightly faster |
4585 case CODEC_ID_MPEG1VIDEO: | |
1421 | 4586 case CODEC_ID_MPEG2VIDEO: |
936 | 4587 mpeg1_encode_mb(s, s->block, motion_x, motion_y); break; |
4588 case CODEC_ID_MPEG4: | |
4589 mpeg4_encode_mb(s, s->block, motion_x, motion_y); break; | |
4590 case CODEC_ID_MSMPEG4V2: | |
4591 case CODEC_ID_MSMPEG4V3: | |
4592 case CODEC_ID_WMV1: | |
4593 msmpeg4_encode_mb(s, s->block, motion_x, motion_y); break; | |
4594 case CODEC_ID_WMV2: | |
4595 ff_wmv2_encode_mb(s, s->block, motion_x, motion_y); break; | |
2639 | 4596 #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
|
4597 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
|
4598 ff_h261_encode_mb(s, s->block, motion_x, motion_y); break; |
2639 | 4599 #endif |
936 | 4600 case CODEC_ID_H263: |
4601 case CODEC_ID_H263P: | |
1353
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1344
diff
changeset
|
4602 case CODEC_ID_FLV1: |
936 | 4603 case CODEC_ID_RV10: |
2380 | 4604 case CODEC_ID_RV20: |
936 | 4605 h263_encode_mb(s, s->block, motion_x, motion_y); break; |
1042 | 4606 case CODEC_ID_MJPEG: |
4607 mjpeg_encode_mb(s, s->block); break; | |
936 | 4608 default: |
4609 assert(0); | |
294 | 4610 } |
4611 } | |
4612 | |
4283
d6f83e2f8804
rename always_inline to av_always_inline and move to common.h
mru
parents:
4281
diff
changeset
|
4613 static av_always_inline void encode_mb(MpegEncContext *s, int motion_x, int motion_y) |
3309 | 4614 { |
4615 if (s->chroma_format == CHROMA_420) encode_mb_internal(s, motion_x, motion_y, 8, 6); | |
4616 else encode_mb_internal(s, motion_x, motion_y, 16, 8); | |
4617 } | |
4618 | |
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
|
4619 #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
|
4620 |
1368 | 4621 void ff_mpeg_flush(AVCodecContext *avctx){ |
4622 int i; | |
4623 MpegEncContext *s = avctx->priv_data; | |
2967 | 4624 |
4625 if(s==NULL || s->picture==NULL) | |
1751 | 4626 return; |
2967 | 4627 |
1368 | 4628 for(i=0; i<MAX_PICTURE_COUNT; i++){ |
4629 if(s->picture[i].data[0] && ( s->picture[i].type == FF_BUFFER_TYPE_INTERNAL | |
4630 || s->picture[i].type == FF_BUFFER_TYPE_USER)) | |
4631 avctx->release_buffer(avctx, (AVFrame*)&s->picture[i]); | |
4632 } | |
1601 | 4633 s->current_picture_ptr = s->last_picture_ptr = s->next_picture_ptr = NULL; |
2967 | 4634 |
2380 | 4635 s->mb_x= s->mb_y= 0; |
2967 | 4636 |
1395 | 4637 s->parse_context.state= -1; |
4638 s->parse_context.frame_start_found= 0; | |
4639 s->parse_context.overread= 0; | |
4640 s->parse_context.overread_index= 0; | |
4641 s->parse_context.index= 0; | |
4642 s->parse_context.last_index= 0; | |
1851 | 4643 s->bitstream_buffer_size=0; |
4346 | 4644 s->pp_time=0; |
1368 | 4645 } |
4646 | |
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
|
4647 #ifdef CONFIG_ENCODERS |
1064 | 4648 void ff_copy_bits(PutBitContext *pb, uint8_t *src, int length) |
294 | 4649 { |
1810 | 4650 const uint16_t *srcw= (uint16_t*)src; |
1799 | 4651 int words= length>>4; |
326 | 4652 int bits= length&15; |
4653 int i; | |
4654 | |
456 | 4655 if(length==0) return; |
2967 | 4656 |
1803 | 4657 if(words < 16){ |
4658 for(i=0; i<words; i++) put_bits(pb, 16, be2me_16(srcw[i])); | |
4659 }else if(put_bits_count(pb)&7){ | |
4660 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
|
4661 }else{ |
1803 | 4662 for(i=0; put_bits_count(pb)&31; i++) |
4663 put_bits(pb, 8, src[i]); | |
1799 | 4664 flush_put_bits(pb); |
1803 | 4665 memcpy(pbBufPtr(pb), src+i, 2*words-i); |
4666 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
|
4667 } |
2967 | 4668 |
1803 | 4669 put_bits(pb, bits, be2me_16(srcw[words])>>(16-bits)); |
0 | 4670 } |
4671 | |
456 | 4672 static inline void copy_context_before_encode(MpegEncContext *d, MpegEncContext *s, int type){ |
326 | 4673 int i; |
4674 | |
4675 memcpy(d->last_mv, s->last_mv, 2*2*2*sizeof(int)); //FIXME is memcpy faster then a loop? | |
4676 | |
4677 /* mpeg1 */ | |
1160 | 4678 d->mb_skip_run= s->mb_skip_run; |
326 | 4679 for(i=0; i<3; i++) |
4680 d->last_dc[i]= s->last_dc[i]; | |
2967 | 4681 |
326 | 4682 /* statistics */ |
4683 d->mv_bits= s->mv_bits; | |
4684 d->i_tex_bits= s->i_tex_bits; | |
4685 d->p_tex_bits= s->p_tex_bits; | |
4686 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
|
4687 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
|
4688 d->b_count= s->b_count; |
326 | 4689 d->skip_count= s->skip_count; |
4690 d->misc_bits= s->misc_bits; | |
329 | 4691 d->last_bits= 0; |
327 | 4692 |
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
|
4693 d->mb_skipped= 0; |
912 | 4694 d->qscale= s->qscale; |
1616 | 4695 d->dquant= s->dquant; |
326 | 4696 } |
4697 | |
456 | 4698 static inline void copy_context_after_encode(MpegEncContext *d, MpegEncContext *s, int type){ |
326 | 4699 int i; |
4700 | |
2967 | 4701 memcpy(d->mv, s->mv, 2*4*2*sizeof(int)); |
326 | 4702 memcpy(d->last_mv, s->last_mv, 2*2*2*sizeof(int)); //FIXME is memcpy faster then a loop? |
2967 | 4703 |
326 | 4704 /* mpeg1 */ |
1160 | 4705 d->mb_skip_run= s->mb_skip_run; |
326 | 4706 for(i=0; i<3; i++) |
4707 d->last_dc[i]= s->last_dc[i]; | |
2967 | 4708 |
326 | 4709 /* statistics */ |
4710 d->mv_bits= s->mv_bits; | |
4711 d->i_tex_bits= s->i_tex_bits; | |
4712 d->p_tex_bits= s->p_tex_bits; | |
4713 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
|
4714 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
|
4715 d->b_count= s->b_count; |
326 | 4716 d->skip_count= s->skip_count; |
4717 d->misc_bits= s->misc_bits; | |
4718 | |
4719 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
|
4720 d->mb_skipped= s->mb_skipped; |
326 | 4721 d->mv_type= s->mv_type; |
4722 d->mv_dir= s->mv_dir; | |
4723 d->pb= s->pb; | |
456 | 4724 if(s->data_partitioning){ |
4725 d->pb2= s->pb2; | |
4726 d->tex_pb= s->tex_pb; | |
4727 } | |
326 | 4728 d->block= s->block; |
3309 | 4729 for(i=0; i<8; i++) |
326 | 4730 d->block_last_index[i]= s->block_last_index[i]; |
755 | 4731 d->interlaced_dct= s->interlaced_dct; |
912 | 4732 d->qscale= s->qscale; |
326 | 4733 } |
4734 | |
2967 | 4735 static inline void encode_mb_hq(MpegEncContext *s, MpegEncContext *backup, MpegEncContext *best, int type, |
456 | 4736 PutBitContext pb[2], PutBitContext pb2[2], PutBitContext tex_pb[2], |
4737 int *dmin, int *next_block, int motion_x, int motion_y) | |
4738 { | |
1389 | 4739 int score; |
4740 uint8_t *dest_backup[3]; | |
2967 | 4741 |
456 | 4742 copy_context_before_encode(s, backup, type); |
4743 | |
4744 s->block= s->blocks[*next_block]; | |
4745 s->pb= pb[*next_block]; | |
4746 if(s->data_partitioning){ | |
4747 s->pb2 = pb2 [*next_block]; | |
4748 s->tex_pb= tex_pb[*next_block]; | |
4749 } | |
2967 | 4750 |
1389 | 4751 if(*next_block){ |
4752 memcpy(dest_backup, s->dest, sizeof(s->dest)); | |
1799 | 4753 s->dest[0] = s->rd_scratchpad; |
4754 s->dest[1] = s->rd_scratchpad + 16*s->linesize; | |
4755 s->dest[2] = s->rd_scratchpad + 16*s->linesize + 8; | |
4756 assert(s->linesize >= 32); //FIXME | |
1389 | 4757 } |
456 | 4758 |
4759 encode_mb(s, motion_x, motion_y); | |
2967 | 4760 |
1786 | 4761 score= put_bits_count(&s->pb); |
456 | 4762 if(s->data_partitioning){ |
1786 | 4763 score+= put_bits_count(&s->pb2); |
4764 score+= put_bits_count(&s->tex_pb); | |
456 | 4765 } |
2967 | 4766 |
1389 | 4767 if(s->avctx->mb_decision == FF_MB_DECISION_RD){ |
4768 MPV_decode_mb(s, s->block); | |
4769 | |
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
|
4770 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
|
4771 score += sse_mb(s) << FF_LAMBDA_SHIFT; |
1389 | 4772 } |
2967 | 4773 |
1389 | 4774 if(*next_block){ |
4775 memcpy(s->dest, dest_backup, sizeof(s->dest)); | |
4776 } | |
4777 | |
4778 if(score<*dmin){ | |
4779 *dmin= score; | |
456 | 4780 *next_block^=1; |
4781 | |
4782 copy_context_after_encode(best, s, type); | |
4783 } | |
4784 } | |
2967 | 4785 |
1389 | 4786 static int sse(MpegEncContext *s, uint8_t *src1, uint8_t *src2, int w, int h, int stride){ |
4179 | 4787 uint32_t *sq = ff_squareTbl + 256; |
909
8ae1e4c24e91
new PSNR code (now works with chroma, b frames, ...)
michaelni
parents:
903
diff
changeset
|
4788 int acc=0; |
8ae1e4c24e91
new PSNR code (now works with chroma, b frames, ...)
michaelni
parents:
903
diff
changeset
|
4789 int x,y; |
2967 | 4790 |
4791 if(w==16 && h==16) | |
1708 | 4792 return s->dsp.sse[0](NULL, src1, src2, stride, 16); |
936 | 4793 else if(w==8 && h==8) |
1708 | 4794 return s->dsp.sse[1](NULL, src1, src2, stride, 8); |
2967 | 4795 |
909
8ae1e4c24e91
new PSNR code (now works with chroma, b frames, ...)
michaelni
parents:
903
diff
changeset
|
4796 for(y=0; y<h; y++){ |
8ae1e4c24e91
new PSNR code (now works with chroma, b frames, ...)
michaelni
parents:
903
diff
changeset
|
4797 for(x=0; x<w; x++){ |
8ae1e4c24e91
new PSNR code (now works with chroma, b frames, ...)
michaelni
parents:
903
diff
changeset
|
4798 acc+= sq[src1[x + y*stride] - src2[x + y*stride]]; |
2967 | 4799 } |
4800 } | |
4801 | |
936 | 4802 assert(acc>=0); |
2967 | 4803 |
909
8ae1e4c24e91
new PSNR code (now works with chroma, b frames, ...)
michaelni
parents:
903
diff
changeset
|
4804 return acc; |
8ae1e4c24e91
new PSNR code (now works with chroma, b frames, ...)
michaelni
parents:
903
diff
changeset
|
4805 } |
326 | 4806 |
1389 | 4807 static int sse_mb(MpegEncContext *s){ |
4808 int w= 16; | |
4809 int h= 16; | |
4810 | |
4811 if(s->mb_x*16 + 16 > s->width ) w= s->width - s->mb_x*16; | |
4812 if(s->mb_y*16 + 16 > s->height) h= s->height- s->mb_y*16; | |
4813 | |
4814 if(w==16 && h==16) | |
2065
9e4bebc39ade
noise preserving sum of squares comparission function
michael
parents:
2063
diff
changeset
|
4815 if(s->avctx->mb_cmp == FF_CMP_NSSE){ |
2066 | 4816 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) |
4817 +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) | |
4818 +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
|
4819 }else{ |
1708 | 4820 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) |
4821 +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) | |
4822 +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
|
4823 } |
1389 | 4824 else |
4825 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) | |
4826 +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) | |
4827 +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); | |
4828 } | |
4829 | |
1799 | 4830 static int pre_estimate_motion_thread(AVCodecContext *c, void *arg){ |
4831 MpegEncContext *s= arg; | |
4832 | |
2967 | 4833 |
1799 | 4834 s->me.pre_pass=1; |
4835 s->me.dia_size= s->avctx->pre_dia_size; | |
4836 s->first_slice_line=1; | |
4837 for(s->mb_y= s->end_mb_y-1; s->mb_y >= s->start_mb_y; s->mb_y--) { | |
4838 for(s->mb_x=s->mb_width-1; s->mb_x >=0 ;s->mb_x--) { | |
4839 ff_pre_estimate_p_frame_motion(s, s->mb_x, s->mb_y); | |
4840 } | |
4841 s->first_slice_line=0; | |
4842 } | |
2967 | 4843 |
1799 | 4844 s->me.pre_pass=0; |
2967 | 4845 |
1799 | 4846 return 0; |
4847 } | |
4848 | |
4849 static int estimate_motion_thread(AVCodecContext *c, void *arg){ | |
4850 MpegEncContext *s= arg; | |
4851 | |
4281
de525a2b41db
ff_check_alignment to warn the user about a missaligned stack
michael
parents:
4274
diff
changeset
|
4852 ff_check_alignment(); |
de525a2b41db
ff_check_alignment to warn the user about a missaligned stack
michael
parents:
4274
diff
changeset
|
4853 |
1799 | 4854 s->me.dia_size= s->avctx->dia_size; |
4855 s->first_slice_line=1; | |
4856 for(s->mb_y= s->start_mb_y; s->mb_y < s->end_mb_y; s->mb_y++) { | |
4857 s->mb_x=0; //for block init below | |
4858 ff_init_block_index(s); | |
4859 for(s->mb_x=0; s->mb_x < s->mb_width; s->mb_x++) { | |
4860 s->block_index[0]+=2; | |
4861 s->block_index[1]+=2; | |
4862 s->block_index[2]+=2; | |
4863 s->block_index[3]+=2; | |
2967 | 4864 |
1799 | 4865 /* compute motion vector & mb_type and store in context */ |
4866 if(s->pict_type==B_TYPE) | |
4867 ff_estimate_b_frame_motion(s, s->mb_x, s->mb_y); | |
4868 else | |
4869 ff_estimate_p_frame_motion(s, s->mb_x, s->mb_y); | |
4870 } | |
4871 s->first_slice_line=0; | |
4872 } | |
4873 return 0; | |
4874 } | |
4875 | |
1804
cc0a15943a87
multithreaded spatial complexity calculation for i frames
michael
parents:
1803
diff
changeset
|
4876 static int mb_var_thread(AVCodecContext *c, void *arg){ |
cc0a15943a87
multithreaded spatial complexity calculation for i frames
michael
parents:
1803
diff
changeset
|
4877 MpegEncContext *s= arg; |
cc0a15943a87
multithreaded spatial complexity calculation for i frames
michael
parents:
1803
diff
changeset
|
4878 int mb_x, mb_y; |
cc0a15943a87
multithreaded spatial complexity calculation for i frames
michael
parents:
1803
diff
changeset
|
4879 |
4281
de525a2b41db
ff_check_alignment to warn the user about a missaligned stack
michael
parents:
4274
diff
changeset
|
4880 ff_check_alignment(); |
de525a2b41db
ff_check_alignment to warn the user about a missaligned stack
michael
parents:
4274
diff
changeset
|
4881 |
1804
cc0a15943a87
multithreaded spatial complexity calculation for i frames
michael
parents:
1803
diff
changeset
|
4882 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
|
4883 for(mb_x=0; mb_x < s->mb_width; mb_x++) { |
cc0a15943a87
multithreaded spatial complexity calculation for i frames
michael
parents:
1803
diff
changeset
|
4884 int xx = mb_x * 16; |
cc0a15943a87
multithreaded spatial complexity calculation for i frames
michael
parents:
1803
diff
changeset
|
4885 int yy = mb_y * 16; |
cc0a15943a87
multithreaded spatial complexity calculation for i frames
michael
parents:
1803
diff
changeset
|
4886 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
|
4887 int varc; |
cc0a15943a87
multithreaded spatial complexity calculation for i frames
michael
parents:
1803
diff
changeset
|
4888 int sum = s->dsp.pix_sum(pix, s->linesize); |
2967 | 4889 |
1804
cc0a15943a87
multithreaded spatial complexity calculation for i frames
michael
parents:
1803
diff
changeset
|
4890 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
|
4891 |
cc0a15943a87
multithreaded spatial complexity calculation for i frames
michael
parents:
1803
diff
changeset
|
4892 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
|
4893 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
|
4894 s->me.mb_var_sum_temp += varc; |
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 } |
1805
5dd5b2052f5b
mpeg4 b frame + adaptive quantization assertion failure fix
michael
parents:
1804
diff
changeset
|
4897 return 0; |
1804
cc0a15943a87
multithreaded spatial complexity calculation for i frames
michael
parents:
1803
diff
changeset
|
4898 } |
cc0a15943a87
multithreaded spatial complexity calculation for i frames
michael
parents:
1803
diff
changeset
|
4899 |
1799 | 4900 static void write_slice_end(MpegEncContext *s){ |
4901 if(s->codec_id==CODEC_ID_MPEG4){ | |
4902 if(s->partitioned_frame){ | |
4903 ff_mpeg4_merge_partitions(s); | |
4904 } | |
2967 | 4905 |
1799 | 4906 ff_mpeg4_stuffing(&s->pb); |
4907 }else if(s->out_format == FMT_MJPEG){ | |
4908 ff_mjpeg_stuffing(&s->pb); | |
4909 } | |
4910 | |
4911 align_put_bits(&s->pb); | |
4912 flush_put_bits(&s->pb); | |
2967 | 4913 |
2428
548c87c06dbb
assertion about bits statistic and minor bits stat fix
michael
parents:
2427
diff
changeset
|
4914 if((s->flags&CODEC_FLAG_PASS1) && !s->partitioned_frame) |
548c87c06dbb
assertion about bits statistic and minor bits stat fix
michael
parents:
2427
diff
changeset
|
4915 s->misc_bits+= get_bits_diff(s); |
1799 | 4916 } |
4917 | |
4918 static int encode_thread(AVCodecContext *c, void *arg){ | |
4919 MpegEncContext *s= arg; | |
766 | 4920 int mb_x, mb_y, pdif = 0; |
1708 | 4921 int i, j; |
326 | 4922 MpegEncContext best_s, backup_s; |
2422 | 4923 uint8_t bit_buf[2][MAX_MB_BYTES]; |
4924 uint8_t bit_buf2[2][MAX_MB_BYTES]; | |
4925 uint8_t bit_buf_tex[2][MAX_MB_BYTES]; | |
456 | 4926 PutBitContext pb[2], pb2[2], tex_pb[2]; |
1799 | 4927 //printf("%d->%d\n", s->resync_mb_y, s->end_mb_y); |
456 | 4928 |
4281
de525a2b41db
ff_check_alignment to warn the user about a missaligned stack
michael
parents:
4274
diff
changeset
|
4929 ff_check_alignment(); |
de525a2b41db
ff_check_alignment to warn the user about a missaligned stack
michael
parents:
4274
diff
changeset
|
4930 |
456 | 4931 for(i=0; i<2; i++){ |
2422 | 4932 init_put_bits(&pb [i], bit_buf [i], MAX_MB_BYTES); |
4933 init_put_bits(&pb2 [i], bit_buf2 [i], MAX_MB_BYTES); | |
4934 init_put_bits(&tex_pb[i], bit_buf_tex[i], MAX_MB_BYTES); | |
456 | 4935 } |
0 | 4936 |
1786 | 4937 s->last_bits= put_bits_count(&s->pb); |
286 | 4938 s->mv_bits=0; |
4939 s->misc_bits=0; | |
4940 s->i_tex_bits=0; | |
4941 s->p_tex_bits=0; | |
4942 s->i_count=0; | |
656
e47fa3e3f2d5
statistics for forw & back p-MBs instead of just one counter for both
michaelni
parents:
652
diff
changeset
|
4943 s->f_count=0; |
e47fa3e3f2d5
statistics for forw & back p-MBs instead of just one counter for both
michaelni
parents:
652
diff
changeset
|
4944 s->b_count=0; |
286 | 4945 s->skip_count=0; |
4946 | |
909
8ae1e4c24e91
new PSNR code (now works with chroma, b frames, ...)
michaelni
parents:
903
diff
changeset
|
4947 for(i=0; i<3; i++){ |
8ae1e4c24e91
new PSNR code (now works with chroma, b frames, ...)
michaelni
parents:
903
diff
changeset
|
4948 /* init last dc values */ |
8ae1e4c24e91
new PSNR code (now works with chroma, b frames, ...)
michaelni
parents:
903
diff
changeset
|
4949 /* note: quant matrix value (8) is implied here */ |
1992 | 4950 s->last_dc[i] = 128 << s->intra_dc_precision; |
2967 | 4951 |
2955 | 4952 s->current_picture.error[i] = 0; |
909
8ae1e4c24e91
new PSNR code (now works with chroma, b frames, ...)
michaelni
parents:
903
diff
changeset
|
4953 } |
1160 | 4954 s->mb_skip_run = 0; |
1708 | 4955 memset(s->last_mv, 0, sizeof(s->last_mv)); |
2967 | 4956 |
1051
e5a9dbf597d4
mpeg1 bframe encoding patch by (Rapha«³l LEGRAND) with some modifications by me
michaelni
parents:
1048
diff
changeset
|
4957 s->last_mv_dir = 0; |
0 | 4958 |
1353
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1344
diff
changeset
|
4959 switch(s->codec_id){ |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1344
diff
changeset
|
4960 case CODEC_ID_H263: |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1344
diff
changeset
|
4961 case CODEC_ID_H263P: |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1344
diff
changeset
|
4962 case CODEC_ID_FLV1: |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
731
diff
changeset
|
4963 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
|
4964 break; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1344
diff
changeset
|
4965 case CODEC_ID_MPEG4: |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1344
diff
changeset
|
4966 if(s->partitioned_frame) |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1344
diff
changeset
|
4967 ff_mpeg4_init_partitions(s); |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1344
diff
changeset
|
4968 break; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1344
diff
changeset
|
4969 } |
456 | 4970 |
4971 s->resync_mb_x=0; | |
2967 | 4972 s->resync_mb_y=0; |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
731
diff
changeset
|
4973 s->first_slice_line = 1; |
766 | 4974 s->ptr_lastgob = s->pb.buf; |
1799 | 4975 for(mb_y= s->start_mb_y; mb_y < s->end_mb_y; mb_y++) { |
4976 // printf("row %d at %X\n", s->mb_y, (int)s); | |
1389 | 4977 s->mb_x=0; |
4978 s->mb_y= mb_y; | |
4979 | |
1652 | 4980 ff_set_qscale(s, s->qscale); |
1389 | 4981 ff_init_block_index(s); |
2967 | 4982 |
232
b640ec5948b0
- Now the ME is done for the entire picture when enconding, the
pulento
parents:
231
diff
changeset
|
4983 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
|
4984 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
|
4985 int mb_type= s->mb_type[xy]; |
456 | 4986 // int d; |
1389 | 4987 int dmin= INT_MAX; |
1708 | 4988 int dir; |
0 | 4989 |
2422 | 4990 if(s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb)>>3) < MAX_MB_BYTES){ |
4991 av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n"); | |
4992 return -1; | |
4993 } | |
4994 if(s->data_partitioning){ | |
4995 if( s->pb2 .buf_end - s->pb2 .buf - (put_bits_count(&s-> pb2)>>3) < MAX_MB_BYTES | |
4996 || s->tex_pb.buf_end - s->tex_pb.buf - (put_bits_count(&s->tex_pb )>>3) < MAX_MB_BYTES){ | |
4997 av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n"); | |
4998 return -1; | |
4999 } | |
5000 } | |
5001 | |
232
b640ec5948b0
- Now the ME is done for the entire picture when enconding, the
pulento
parents:
231
diff
changeset
|
5002 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
|
5003 s->mb_y = mb_y; // moved into loop, can get changed by H.261 |
1389 | 5004 ff_update_block_index(s); |
456 | 5005 |
2639 | 5006 #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
|
5007 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
|
5008 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
|
5009 xy= s->mb_y*s->mb_stride + s->mb_x; |
2345 | 5010 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
|
5011 } |
2639 | 5012 #endif |
2327
5e5cf598a48b
H.261 encoder by (Maarten Daniels <maarten dot daniels at luc dot ac dot be>)
michael
parents:
2298
diff
changeset
|
5013 |
766 | 5014 /* write gob / video packet header */ |
1661 | 5015 if(s->rtp_mode){ |
766 | 5016 int current_packet_size, is_gob_start; |
2967 | 5017 |
1801
3f26dfb3eba4
replace a few pbBufPtr() by put_bits_count(), one of them was actually wrong
michael
parents:
1799
diff
changeset
|
5018 current_packet_size= ((put_bits_count(&s->pb)+7)>>3) - (s->ptr_lastgob - s->pb.buf); |
2967 | 5019 |
5020 is_gob_start= s->avctx->rtp_payload_size && current_packet_size >= s->avctx->rtp_payload_size && mb_y + mb_x>0; | |
5021 | |
1799 | 5022 if(s->start_mb_y == mb_y && mb_y > 0 && mb_x==0) is_gob_start=1; |
2967 | 5023 |
1661 | 5024 switch(s->codec_id){ |
5025 case CODEC_ID_H263: | |
5026 case CODEC_ID_H263P: | |
5027 if(!s->h263_slice_structured) | |
5028 if(s->mb_x || s->mb_y%s->gob_index) is_gob_start=0; | |
5029 break; | |
5030 case CODEC_ID_MPEG2VIDEO: | |
5031 if(s->mb_x==0 && s->mb_y!=0) is_gob_start=1; | |
5032 case CODEC_ID_MPEG1VIDEO: | |
5033 if(s->mb_skip_run) is_gob_start=0; | |
5034 break; | |
5035 } | |
1799 | 5036 |
1661 | 5037 if(is_gob_start){ |
1799 | 5038 if(s->start_mb_y != mb_y || mb_x!=0){ |
5039 write_slice_end(s); | |
5040 | |
5041 if(s->codec_id==CODEC_ID_MPEG4 && s->partitioned_frame){ | |
5042 ff_mpeg4_init_partitions(s); | |
5043 } | |
1661 | 5044 } |
2967 | 5045 |
1786 | 5046 assert((put_bits_count(&s->pb)&7) == 0); |
1661 | 5047 current_packet_size= pbBufPtr(&s->pb) - s->ptr_lastgob; |
2967 | 5048 |
1688 | 5049 if(s->avctx->error_rate && s->resync_mb_x + s->resync_mb_y > 0){ |
2371 | 5050 int r= put_bits_count(&s->pb)/8 + s->picture_number + 16 + s->mb_x + s->mb_y; |
1688 | 5051 int d= 100 / s->avctx->error_rate; |
5052 if(r % d == 0){ | |
5053 current_packet_size=0; | |
5054 #ifndef ALT_BITSTREAM_WRITER | |
5055 s->pb.buf_ptr= s->ptr_lastgob; | |
5056 #endif | |
5057 assert(pbBufPtr(&s->pb) == s->ptr_lastgob); | |
5058 } | |
5059 } | |
2492
57ba17bd3924
rtp_callback: send number of mb patch by (Johan Bilien {jobi via.ecp fr)
michael
parents:
2450
diff
changeset
|
5060 |
57ba17bd3924
rtp_callback: send number of mb patch by (Johan Bilien {jobi via.ecp fr)
michael
parents:
2450
diff
changeset
|
5061 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
|
5062 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
|
5063 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
|
5064 } |
2967 | 5065 |
1661 | 5066 switch(s->codec_id){ |
5067 case CODEC_ID_MPEG4: | |
456 | 5068 ff_mpeg4_encode_video_packet_header(s); |
5069 ff_mpeg4_clean_buffers(s); | |
1661 | 5070 break; |
5071 case CODEC_ID_MPEG1VIDEO: | |
5072 case CODEC_ID_MPEG2VIDEO: | |
1421 | 5073 ff_mpeg1_encode_slice_header(s); |
5074 ff_mpeg1_clean_buffers(s); | |
1661 | 5075 break; |
5076 case CODEC_ID_H263: | |
5077 case CODEC_ID_H263P: | |
2967 | 5078 h263_encode_gob_header(s, mb_y); |
1661 | 5079 break; |
1160 | 5080 } |
1661 | 5081 |
5082 if(s->flags&CODEC_FLAG_PASS1){ | |
1786 | 5083 int bits= put_bits_count(&s->pb); |
1661 | 5084 s->misc_bits+= bits - s->last_bits; |
5085 s->last_bits= bits; | |
766 | 5086 } |
2967 | 5087 |
1662 | 5088 s->ptr_lastgob += current_packet_size; |
456 | 5089 s->first_slice_line=1; |
5090 s->resync_mb_x=mb_x; | |
5091 s->resync_mb_y=mb_y; | |
5092 } | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
731
diff
changeset
|
5093 } |
456 | 5094 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
731
diff
changeset
|
5095 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
|
5096 && s->resync_mb_y+1 == s->mb_y){ |
2967 | 5097 s->first_slice_line=0; |
456 | 5098 } |
5099 | |
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
|
5100 s->mb_skipped=0; |
1616 | 5101 s->dquant=0; //only for QP_RD |
5102 | |
2230 | 5103 if(mb_type & (mb_type-1) || (s->flags & CODEC_FLAG_QP_RD)){ // more than 1 MB type possible or CODEC_FLAG_QP_RD |
327 | 5104 int next_block=0; |
456 | 5105 int pb_bits_count, pb2_bits_count, tex_pb_bits_count; |
326 | 5106 |
5107 copy_context_before_encode(&backup_s, s, -1); | |
456 | 5108 backup_s.pb= s->pb; |
5109 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
|
5110 best_s.partitioned_frame= s->partitioned_frame; |
456 | 5111 if(s->data_partitioning){ |
5112 backup_s.pb2= s->pb2; | |
5113 backup_s.tex_pb= s->tex_pb; | |
5114 } | |
326 | 5115 |
1708 | 5116 if(mb_type&CANDIDATE_MB_TYPE_INTER){ |
327 | 5117 s->mv_dir = MV_DIR_FORWARD; |
295 | 5118 s->mv_type = MV_TYPE_16X16; |
294 | 5119 s->mb_intra= 0; |
324 | 5120 s->mv[0][0][0] = s->p_mv_table[xy][0]; |
5121 s->mv[0][0][1] = s->p_mv_table[xy][1]; | |
2967 | 5122 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER, pb, pb2, tex_pb, |
456 | 5123 &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]); |
0 | 5124 } |
2967 | 5125 if(mb_type&CANDIDATE_MB_TYPE_INTER_I){ |
1708 | 5126 s->mv_dir = MV_DIR_FORWARD; |
5127 s->mv_type = MV_TYPE_FIELD; | |
5128 s->mb_intra= 0; | |
5129 for(i=0; i<2; i++){ | |
5130 j= s->field_select[0][i] = s->p_field_select_table[i][xy]; | |
5131 s->mv[0][i][0] = s->p_field_mv_table[i][j][xy][0]; | |
5132 s->mv[0][i][1] = s->p_field_mv_table[i][j][xy][1]; | |
5133 } | |
2967 | 5134 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER_I, pb, pb2, tex_pb, |
1708 | 5135 &dmin, &next_block, 0, 0); |
5136 } | |
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
|
5137 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
|
5138 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
|
5139 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
|
5140 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
|
5141 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
|
5142 s->mv[0][0][1] = 0; |
2967 | 5143 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
|
5144 &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
|
5145 } |
2967 | 5146 if(mb_type&CANDIDATE_MB_TYPE_INTER4V){ |
327 | 5147 s->mv_dir = MV_DIR_FORWARD; |
295 | 5148 s->mv_type = MV_TYPE_8X8; |
5149 s->mb_intra= 0; | |
5150 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
|
5151 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
|
5152 s->mv[0][i][1] = s->current_picture.motion_val[0][s->block_index[i]][1]; |
295 | 5153 } |
2967 | 5154 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER4V, pb, pb2, tex_pb, |
456 | 5155 &dmin, &next_block, 0, 0); |
327 | 5156 } |
1708 | 5157 if(mb_type&CANDIDATE_MB_TYPE_FORWARD){ |
327 | 5158 s->mv_dir = MV_DIR_FORWARD; |
5159 s->mv_type = MV_TYPE_16X16; | |
5160 s->mb_intra= 0; | |
5161 s->mv[0][0][0] = s->b_forw_mv_table[xy][0]; | |
5162 s->mv[0][0][1] = s->b_forw_mv_table[xy][1]; | |
2967 | 5163 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_FORWARD, pb, pb2, tex_pb, |
456 | 5164 &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]); |
327 | 5165 } |
1708 | 5166 if(mb_type&CANDIDATE_MB_TYPE_BACKWARD){ |
327 | 5167 s->mv_dir = MV_DIR_BACKWARD; |
5168 s->mv_type = MV_TYPE_16X16; | |
5169 s->mb_intra= 0; | |
5170 s->mv[1][0][0] = s->b_back_mv_table[xy][0]; | |
5171 s->mv[1][0][1] = s->b_back_mv_table[xy][1]; | |
2967 | 5172 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BACKWARD, pb, pb2, tex_pb, |
456 | 5173 &dmin, &next_block, s->mv[1][0][0], s->mv[1][0][1]); |
327 | 5174 } |
1708 | 5175 if(mb_type&CANDIDATE_MB_TYPE_BIDIR){ |
327 | 5176 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD; |
5177 s->mv_type = MV_TYPE_16X16; | |
5178 s->mb_intra= 0; | |
5179 s->mv[0][0][0] = s->b_bidir_forw_mv_table[xy][0]; | |
5180 s->mv[0][0][1] = s->b_bidir_forw_mv_table[xy][1]; | |
5181 s->mv[1][0][0] = s->b_bidir_back_mv_table[xy][0]; | |
5182 s->mv[1][0][1] = s->b_bidir_back_mv_table[xy][1]; | |
2967 | 5183 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BIDIR, pb, pb2, tex_pb, |
456 | 5184 &dmin, &next_block, 0, 0); |
327 | 5185 } |
2967 | 5186 if(mb_type&CANDIDATE_MB_TYPE_FORWARD_I){ |
1708 | 5187 s->mv_dir = MV_DIR_FORWARD; |
5188 s->mv_type = MV_TYPE_FIELD; | |
5189 s->mb_intra= 0; | |
5190 for(i=0; i<2; i++){ | |
5191 j= s->field_select[0][i] = s->b_field_select_table[0][i][xy]; | |
5192 s->mv[0][i][0] = s->b_field_mv_table[0][i][j][xy][0]; | |
5193 s->mv[0][i][1] = s->b_field_mv_table[0][i][j][xy][1]; | |
5194 } | |
2967 | 5195 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_FORWARD_I, pb, pb2, tex_pb, |
1708 | 5196 &dmin, &next_block, 0, 0); |
5197 } | |
2967 | 5198 if(mb_type&CANDIDATE_MB_TYPE_BACKWARD_I){ |
1708 | 5199 s->mv_dir = MV_DIR_BACKWARD; |
5200 s->mv_type = MV_TYPE_FIELD; | |
5201 s->mb_intra= 0; | |
5202 for(i=0; i<2; i++){ | |
5203 j= s->field_select[1][i] = s->b_field_select_table[1][i][xy]; | |
5204 s->mv[1][i][0] = s->b_field_mv_table[1][i][j][xy][0]; | |
5205 s->mv[1][i][1] = s->b_field_mv_table[1][i][j][xy][1]; | |
5206 } | |
2967 | 5207 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BACKWARD_I, pb, pb2, tex_pb, |
1708 | 5208 &dmin, &next_block, 0, 0); |
5209 } | |
2967 | 5210 if(mb_type&CANDIDATE_MB_TYPE_BIDIR_I){ |
1708 | 5211 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD; |
5212 s->mv_type = MV_TYPE_FIELD; | |
5213 s->mb_intra= 0; | |
5214 for(dir=0; dir<2; dir++){ | |
5215 for(i=0; i<2; i++){ | |
5216 j= s->field_select[dir][i] = s->b_field_select_table[dir][i][xy]; | |
5217 s->mv[dir][i][0] = s->b_field_mv_table[dir][i][j][xy][0]; | |
5218 s->mv[dir][i][1] = s->b_field_mv_table[dir][i][j][xy][1]; | |
5219 } | |
5220 } | |
2967 | 5221 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BIDIR_I, pb, pb2, tex_pb, |
1708 | 5222 &dmin, &next_block, 0, 0); |
5223 } | |
5224 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
|
5225 s->mv_dir = 0; |
295 | 5226 s->mv_type = MV_TYPE_16X16; |
294 | 5227 s->mb_intra= 1; |
5228 s->mv[0][0][0] = 0; | |
5229 s->mv[0][0][1] = 0; | |
2967 | 5230 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTRA, pb, pb2, tex_pb, |
456 | 5231 &dmin, &next_block, 0, 0); |
1389 | 5232 if(s->h263_pred || s->h263_aic){ |
5233 if(best_s.mb_intra) | |
5234 s->mbintra_table[mb_x + mb_y*s->mb_stride]=1; | |
5235 else | |
5236 ff_clean_intra_table_entries(s); //old mode? | |
5237 } | |
295 | 5238 } |
1616 | 5239 |
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
|
5240 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
|
5241 if(best_s.mv_type==MV_TYPE_16X16){ //FIXME move 4mv after QPRD |
1616 | 5242 const int last_qp= backup_s.qscale; |
4217 | 5243 int qpi, qp, dc[6]; |
1617 | 5244 DCTELEM ac[6][16]; |
1623 | 5245 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
|
5246 static const int dquant_tab[4]={-1,1,-2,2}; |
2967 | 5247 |
1616 | 5248 assert(backup_s.dquant == 0); |
5249 | |
5250 //FIXME intra | |
5251 s->mv_dir= best_s.mv_dir; | |
5252 s->mv_type = MV_TYPE_16X16; | |
5253 s->mb_intra= best_s.mb_intra; | |
5254 s->mv[0][0][0] = best_s.mv[0][0][0]; | |
5255 s->mv[0][0][1] = best_s.mv[0][0][1]; | |
5256 s->mv[1][0][0] = best_s.mv[1][0][0]; | |
5257 s->mv[1][0][1] = best_s.mv[1][0][1]; | |
2967 | 5258 |
4215
7583920b3217
testing all dquant for qp_rd fixes the qp runaway to 31 bug
michael
parents:
4206
diff
changeset
|
5259 qpi = s->pict_type == B_TYPE ? 2 : 0; |
4217 | 5260 for(; qpi<4; qpi++){ |
5261 int dquant= dquant_tab[qpi]; | |
1616 | 5262 qp= last_qp + dquant; |
5263 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
|
5264 continue; |
1616 | 5265 backup_s.dquant= dquant; |
2229 | 5266 if(s->mb_intra && s->dc_val[0]){ |
1617 | 5267 for(i=0; i<6; i++){ |
5268 dc[i]= s->dc_val[0][ s->block_index[i] ]; | |
5269 memcpy(ac[i], s->ac_val[0][s->block_index[i]], sizeof(DCTELEM)*16); | |
5270 } | |
1616 | 5271 } |
1617 | 5272 |
2967 | 5273 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER /* wrong but unused */, pb, pb2, tex_pb, |
1623 | 5274 &dmin, &next_block, s->mv[mvdir][0][0], s->mv[mvdir][0][1]); |
1616 | 5275 if(best_s.qscale != qp){ |
2229 | 5276 if(s->mb_intra && s->dc_val[0]){ |
1617 | 5277 for(i=0; i<6; i++){ |
5278 s->dc_val[0][ s->block_index[i] ]= dc[i]; | |
5279 memcpy(s->ac_val[0][s->block_index[i]], ac[i], sizeof(DCTELEM)*16); | |
5280 } | |
1616 | 5281 } |
5282 } | |
5283 } | |
5284 } | |
5285 } | |
4314
5ed8f8fd71e9
try direct mode MB after QPRD, slight PSNR/bitrate gain if b frames + QPRD
michael
parents:
4283
diff
changeset
|
5286 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
|
5287 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
|
5288 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
|
5289 |
5ed8f8fd71e9
try direct mode MB after QPRD, slight PSNR/bitrate gain if b frames + QPRD
michael
parents:
4283
diff
changeset
|
5290 backup_s.dquant = 0; |
5ed8f8fd71e9
try direct mode MB after QPRD, slight PSNR/bitrate gain if b frames + QPRD
michael
parents:
4283
diff
changeset
|
5291 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
|
5292 s->mb_intra= 0; |
5ed8f8fd71e9
try direct mode MB after QPRD, slight PSNR/bitrate gain if b frames + QPRD
michael
parents:
4283
diff
changeset
|
5293 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
|
5294 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
|
5295 &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
|
5296 } |
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
|
5297 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
|
5298 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
|
5299 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
|
5300 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
|
5301 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
|
5302 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
|
5303 &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
|
5304 } |
4327 | 5305 if(!best_s.mb_intra && s->flags2&CODEC_FLAG2_SKIP_RD){ |
5306 int coded=0; | |
5307 for(i=0; i<6; i++) | |
5308 coded |= s->block_last_index[i]; | |
5309 if(coded){ | |
5310 int mx,my; | |
5311 memcpy(s->mv, best_s.mv, sizeof(s->mv)); | |
5312 if(best_s.mv_dir & MV_DIRECT){ | |
5313 mx=my=0; //FIXME find the one we actually used | |
5314 ff_mpeg4_set_direct_mv(s, mx, my); | |
5315 }else if(best_s.mv_dir&MV_DIR_BACKWARD){ | |
5316 mx= s->mv[1][0][0]; | |
5317 my= s->mv[1][0][1]; | |
5318 }else{ | |
5319 mx= s->mv[0][0][0]; | |
5320 my= s->mv[0][0][1]; | |
5321 } | |
5322 | |
5323 s->mv_dir= best_s.mv_dir; | |
5324 s->mv_type = best_s.mv_type; | |
5325 s->mb_intra= 0; | |
5326 /* s->mv[0][0][0] = best_s.mv[0][0][0]; | |
5327 s->mv[0][0][1] = best_s.mv[0][0][1]; | |
5328 s->mv[1][0][0] = best_s.mv[1][0][0]; | |
5329 s->mv[1][0][1] = best_s.mv[1][0][1];*/ | |
5330 backup_s.dquant= 0; | |
5331 s->skipdct=1; | |
5332 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER /* wrong but unused */, pb, pb2, tex_pb, | |
5333 &dmin, &next_block, mx, my); | |
5334 s->skipdct=0; | |
5335 } | |
5336 } | |
5337 | |
4314
5ed8f8fd71e9
try direct mode MB after QPRD, slight PSNR/bitrate gain if b frames + QPRD
michael
parents:
4283
diff
changeset
|
5338 s->current_picture.qscale_table[xy]= best_s.qscale; |
1616 | 5339 |
326 | 5340 copy_context_after_encode(s, &best_s, -1); |
2967 | 5341 |
1786 | 5342 pb_bits_count= put_bits_count(&s->pb); |
456 | 5343 flush_put_bits(&s->pb); |
5344 ff_copy_bits(&backup_s.pb, bit_buf[next_block^1], pb_bits_count); | |
5345 s->pb= backup_s.pb; | |
2967 | 5346 |
456 | 5347 if(s->data_partitioning){ |
1786 | 5348 pb2_bits_count= put_bits_count(&s->pb2); |
456 | 5349 flush_put_bits(&s->pb2); |
5350 ff_copy_bits(&backup_s.pb2, bit_buf2[next_block^1], pb2_bits_count); | |
5351 s->pb2= backup_s.pb2; | |
2967 | 5352 |
1786 | 5353 tex_pb_bits_count= put_bits_count(&s->tex_pb); |
456 | 5354 flush_put_bits(&s->tex_pb); |
5355 ff_copy_bits(&backup_s.tex_pb, bit_buf_tex[next_block^1], tex_pb_bits_count); | |
5356 s->tex_pb= backup_s.tex_pb; | |
5357 } | |
1786 | 5358 s->last_bits= put_bits_count(&s->pb); |
2967 | 5359 |
1389 | 5360 if (s->out_format == FMT_H263 && s->pict_type!=B_TYPE) |
5361 ff_h263_update_motion_val(s); | |
2967 | 5362 |
1799 | 5363 if(next_block==0){ //FIXME 16 vs linesize16 |
5364 s->dsp.put_pixels_tab[0][0](s->dest[0], s->rd_scratchpad , s->linesize ,16); | |
5365 s->dsp.put_pixels_tab[1][0](s->dest[1], s->rd_scratchpad + 16*s->linesize , s->uvlinesize, 8); | |
5366 s->dsp.put_pixels_tab[1][0](s->dest[2], s->rd_scratchpad + 16*s->linesize + 8, s->uvlinesize, 8); | |
1389 | 5367 } |
5368 | |
5369 if(s->avctx->mb_decision == FF_MB_DECISION_BITS) | |
5370 MPV_decode_mb(s, s->block); | |
294 | 5371 } else { |
4416 | 5372 int motion_x = 0, motion_y = 0; |
324 | 5373 s->mv_type=MV_TYPE_16X16; |
294 | 5374 // only one MB-Type possible |
2967 | 5375 |
327 | 5376 switch(mb_type){ |
1708 | 5377 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
|
5378 s->mv_dir = 0; |
294 | 5379 s->mb_intra= 1; |
324 | 5380 motion_x= s->mv[0][0][0] = 0; |
5381 motion_y= s->mv[0][0][1] = 0; | |
327 | 5382 break; |
1708 | 5383 case CANDIDATE_MB_TYPE_INTER: |
324 | 5384 s->mv_dir = MV_DIR_FORWARD; |
5385 s->mb_intra= 0; | |
5386 motion_x= s->mv[0][0][0] = s->p_mv_table[xy][0]; | |
5387 motion_y= s->mv[0][0][1] = s->p_mv_table[xy][1]; | |
327 | 5388 break; |
1708 | 5389 case CANDIDATE_MB_TYPE_INTER_I: |
5390 s->mv_dir = MV_DIR_FORWARD; | |
5391 s->mv_type = MV_TYPE_FIELD; | |
5392 s->mb_intra= 0; | |
5393 for(i=0; i<2; i++){ | |
5394 j= s->field_select[0][i] = s->p_field_select_table[i][xy]; | |
5395 s->mv[0][i][0] = s->p_field_mv_table[i][j][xy][0]; | |
5396 s->mv[0][i][1] = s->p_field_mv_table[i][j][xy][1]; | |
5397 } | |
5398 break; | |
5399 case CANDIDATE_MB_TYPE_INTER4V: | |
456 | 5400 s->mv_dir = MV_DIR_FORWARD; |
5401 s->mv_type = MV_TYPE_8X8; | |
5402 s->mb_intra= 0; | |
5403 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
|
5404 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
|
5405 s->mv[0][i][1] = s->current_picture.motion_val[0][s->block_index[i]][1]; |
456 | 5406 } |
5407 break; | |
1708 | 5408 case CANDIDATE_MB_TYPE_DIRECT: |
324 | 5409 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT; |
5410 s->mb_intra= 0; | |
327 | 5411 motion_x=s->b_direct_mv_table[xy][0]; |
5412 motion_y=s->b_direct_mv_table[xy][1]; | |
936 | 5413 ff_mpeg4_set_direct_mv(s, motion_x, motion_y); |
327 | 5414 break; |
4323 | 5415 case CANDIDATE_MB_TYPE_DIRECT0: |
5416 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT; | |
5417 s->mb_intra= 0; | |
5418 ff_mpeg4_set_direct_mv(s, 0, 0); | |
5419 break; | |
1708 | 5420 case CANDIDATE_MB_TYPE_BIDIR: |
324 | 5421 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD; |
294 | 5422 s->mb_intra= 0; |
324 | 5423 s->mv[0][0][0] = s->b_bidir_forw_mv_table[xy][0]; |
5424 s->mv[0][0][1] = s->b_bidir_forw_mv_table[xy][1]; | |
5425 s->mv[1][0][0] = s->b_bidir_back_mv_table[xy][0]; | |
5426 s->mv[1][0][1] = s->b_bidir_back_mv_table[xy][1]; | |
327 | 5427 break; |
1708 | 5428 case CANDIDATE_MB_TYPE_BACKWARD: |
324 | 5429 s->mv_dir = MV_DIR_BACKWARD; |
5430 s->mb_intra= 0; | |
5431 motion_x= s->mv[1][0][0] = s->b_back_mv_table[xy][0]; | |
5432 motion_y= s->mv[1][0][1] = s->b_back_mv_table[xy][1]; | |
327 | 5433 break; |
1708 | 5434 case CANDIDATE_MB_TYPE_FORWARD: |
324 | 5435 s->mv_dir = MV_DIR_FORWARD; |
5436 s->mb_intra= 0; | |
5437 motion_x= s->mv[0][0][0] = s->b_forw_mv_table[xy][0]; | |
5438 motion_y= s->mv[0][0][1] = s->b_forw_mv_table[xy][1]; | |
5439 // printf(" %d %d ", motion_x, motion_y); | |
327 | 5440 break; |
1708 | 5441 case CANDIDATE_MB_TYPE_FORWARD_I: |
5442 s->mv_dir = MV_DIR_FORWARD; | |
5443 s->mv_type = MV_TYPE_FIELD; | |
5444 s->mb_intra= 0; | |
5445 for(i=0; i<2; i++){ | |
5446 j= s->field_select[0][i] = s->b_field_select_table[0][i][xy]; | |
5447 s->mv[0][i][0] = s->b_field_mv_table[0][i][j][xy][0]; | |
5448 s->mv[0][i][1] = s->b_field_mv_table[0][i][j][xy][1]; | |
5449 } | |
5450 break; | |
5451 case CANDIDATE_MB_TYPE_BACKWARD_I: | |
5452 s->mv_dir = MV_DIR_BACKWARD; | |
5453 s->mv_type = MV_TYPE_FIELD; | |
5454 s->mb_intra= 0; | |
5455 for(i=0; i<2; i++){ | |
5456 j= s->field_select[1][i] = s->b_field_select_table[1][i][xy]; | |
5457 s->mv[1][i][0] = s->b_field_mv_table[1][i][j][xy][0]; | |
5458 s->mv[1][i][1] = s->b_field_mv_table[1][i][j][xy][1]; | |
5459 } | |
5460 break; | |
5461 case CANDIDATE_MB_TYPE_BIDIR_I: | |
5462 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD; | |
5463 s->mv_type = MV_TYPE_FIELD; | |
5464 s->mb_intra= 0; | |
5465 for(dir=0; dir<2; dir++){ | |
5466 for(i=0; i<2; i++){ | |
5467 j= s->field_select[dir][i] = s->b_field_select_table[dir][i][xy]; | |
5468 s->mv[dir][i][0] = s->b_field_mv_table[dir][i][j][xy][0]; | |
5469 s->mv[dir][i][1] = s->b_field_mv_table[dir][i][j][xy][1]; | |
5470 } | |
5471 } | |
5472 break; | |
327 | 5473 default: |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1597
diff
changeset
|
5474 av_log(s->avctx, AV_LOG_ERROR, "illegal MB type\n"); |
294 | 5475 } |
1051
e5a9dbf597d4
mpeg1 bframe encoding patch by (Rapha«³l LEGRAND) with some modifications by me
michaelni
parents:
1048
diff
changeset
|
5476 |
324 | 5477 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
|
5478 |
2627
bf158d23bbcc
Spelling errors patch by (Kevin Baragona | kevinmb500 gawab com)
michael
parents:
2620
diff
changeset
|
5479 // 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
|
5480 s->last_mv_dir = s->mv_dir; |
2967 | 5481 |
1389 | 5482 if (s->out_format == FMT_H263 && s->pict_type!=B_TYPE) |
5483 ff_h263_update_motion_val(s); | |
2967 | 5484 |
1389 | 5485 MPV_decode_mb(s, s->block); |
248
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
244
diff
changeset
|
5486 } |
1051
e5a9dbf597d4
mpeg1 bframe encoding patch by (Rapha«³l LEGRAND) with some modifications by me
michaelni
parents:
1048
diff
changeset
|
5487 |
327 | 5488 /* clean the MV table in IPS frames for direct mode in B frames */ |
5489 if(s->mb_intra /* && I,P,S_TYPE */){ | |
5490 s->p_mv_table[xy][0]=0; | |
5491 s->p_mv_table[xy][1]=0; | |
5492 } | |
2967 | 5493 |
909
8ae1e4c24e91
new PSNR code (now works with chroma, b frames, ...)
michaelni
parents:
903
diff
changeset
|
5494 if(s->flags&CODEC_FLAG_PSNR){ |
8ae1e4c24e91
new PSNR code (now works with chroma, b frames, ...)
michaelni
parents:
903
diff
changeset
|
5495 int w= 16; |
8ae1e4c24e91
new PSNR code (now works with chroma, b frames, ...)
michaelni
parents:
903
diff
changeset
|
5496 int h= 16; |
8ae1e4c24e91
new PSNR code (now works with chroma, b frames, ...)
michaelni
parents:
903
diff
changeset
|
5497 |
8ae1e4c24e91
new PSNR code (now works with chroma, b frames, ...)
michaelni
parents:
903
diff
changeset
|
5498 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
|
5499 if(s->mb_y*16 + 16 > s->height) h= s->height- s->mb_y*16; |
936 | 5500 |
2955 | 5501 s->current_picture.error[0] += sse( |
1389 | 5502 s, s->new_picture.data[0] + s->mb_x*16 + s->mb_y*s->linesize*16, |
5503 s->dest[0], w, h, s->linesize); | |
2955 | 5504 s->current_picture.error[1] += sse( |
1389 | 5505 s, s->new_picture.data[1] + s->mb_x*8 + s->mb_y*s->uvlinesize*8, |
5506 s->dest[1], w>>1, h>>1, s->uvlinesize); | |
2955 | 5507 s->current_picture.error[2] += sse( |
1389 | 5508 s, s->new_picture .data[2] + s->mb_x*8 + s->mb_y*s->uvlinesize*8, |
5509 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
|
5510 } |
2345 | 5511 if(s->loop_filter){ |
5512 if(s->out_format == FMT_H263) | |
5513 ff_h263_loop_filter(s); | |
5514 } | |
1786 | 5515 //printf("MB %d %d bits\n", s->mb_x+s->mb_y*s->mb_stride, put_bits_count(&s->pb)); |
0 | 5516 } |
5517 } | |
286 | 5518 |
2627
bf158d23bbcc
Spelling errors patch by (Kevin Baragona | kevinmb500 gawab com)
michael
parents:
2620
diff
changeset
|
5519 //not beautiful here but we must write it before flushing so it has to be here |
456 | 5520 if (s->msmpeg4_version && s->msmpeg4_version<4 && s->pict_type == I_TYPE) |
208 | 5521 msmpeg4_encode_ext_header(s); |
456 | 5522 |
1799 | 5523 write_slice_end(s); |
5524 | |
2967 | 5525 /* Send the last GOB if RTP */ |
1661 | 5526 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
|
5527 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
|
5528 pdif = pbBufPtr(&s->pb) - s->ptr_lastgob; |
231 | 5529 /* Call the RTP callback to send the last GOB */ |
1799 | 5530 emms_c(); |
2492
57ba17bd3924
rtp_callback: send number of mb patch by (Johan Bilien {jobi via.ecp fr)
michael
parents:
2450
diff
changeset
|
5531 s->avctx->rtp_callback(s->avctx, s->ptr_lastgob, pdif, number_mb); |
231 | 5532 } |
1799 | 5533 |
5534 return 0; | |
5535 } | |
5536 | |
5537 #define MERGE(field) dst->field += src->field; src->field=0 | |
5538 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
|
5539 MERGE(me.scene_change_score); |
3ab8f3e2ae6a
moving motion estimation specific variables from MpegEncContext -> MotionEstContext
michael
parents:
1994
diff
changeset
|
5540 MERGE(me.mc_mb_var_sum_temp); |
3ab8f3e2ae6a
moving motion estimation specific variables from MpegEncContext -> MotionEstContext
michael
parents:
1994
diff
changeset
|
5541 MERGE(me.mb_var_sum_temp); |
1799 | 5542 } |
5543 | |
5544 static void merge_context_after_encode(MpegEncContext *dst, MpegEncContext *src){ | |
5545 int i; | |
5546 | |
5547 MERGE(dct_count[0]); //note, the other dct vars are not part of the context | |
5548 MERGE(dct_count[1]); | |
5549 MERGE(mv_bits); | |
5550 MERGE(i_tex_bits); | |
5551 MERGE(p_tex_bits); | |
5552 MERGE(i_count); | |
5553 MERGE(f_count); | |
5554 MERGE(b_count); | |
5555 MERGE(skip_count); | |
5556 MERGE(misc_bits); | |
5557 MERGE(error_count); | |
5558 MERGE(padding_bug_score); | |
2955 | 5559 MERGE(current_picture.error[0]); |
5560 MERGE(current_picture.error[1]); | |
5561 MERGE(current_picture.error[2]); | |
1799 | 5562 |
5563 if(dst->avctx->noise_reduction){ | |
5564 for(i=0; i<64; i++){ | |
5565 MERGE(dct_error_sum[0][i]); | |
5566 MERGE(dct_error_sum[1][i]); | |
5567 } | |
5568 } | |
2967 | 5569 |
1799 | 5570 assert(put_bits_count(&src->pb) % 8 ==0); |
5571 assert(put_bits_count(&dst->pb) % 8 ==0); | |
5572 ff_copy_bits(&dst->pb, src->pb.buf, put_bits_count(&src->pb)); | |
5573 flush_put_bits(&dst->pb); | |
5574 } | |
5575 | |
3766 | 5576 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
|
5577 if (s->next_lambda){ |
16ace038f452
fix buffer underflows by reencoding the current frame with a higher QP
michael
parents:
3929
diff
changeset
|
5578 s->current_picture_ptr->quality= |
16ace038f452
fix buffer underflows by reencoding the current frame with a higher QP
michael
parents:
3929
diff
changeset
|
5579 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
|
5580 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
|
5581 } else if (!s->fixed_qscale) { |
2974 | 5582 s->current_picture_ptr->quality= |
5583 s->current_picture.quality = ff_rate_estimate_qscale(s, dry_run); | |
3766 | 5584 if (s->current_picture.quality < 0) |
5585 return -1; | |
5586 } | |
2974 | 5587 |
5588 if(s->adaptive_quant){ | |
5589 switch(s->codec_id){ | |
5590 case CODEC_ID_MPEG4: | |
5591 ff_clean_mpeg4_qscales(s); | |
5592 break; | |
5593 case CODEC_ID_H263: | |
5594 case CODEC_ID_H263P: | |
5595 case CODEC_ID_FLV1: | |
5596 ff_clean_h263_qscales(s); | |
5597 break; | |
5598 } | |
5599 | |
5600 s->lambda= s->lambda_table[0]; | |
5601 //FIXME broken | |
5602 }else | |
5603 s->lambda= s->current_picture.quality; | |
5604 //printf("%d %d\n", s->avctx->global_quality, s->current_picture.quality); | |
5605 update_qscale(s); | |
3780
6741c0e88310
return 0 from encode_picture() and estimate_qp() on success
mru
parents:
3777
diff
changeset
|
5606 return 0; |
2974 | 5607 } |
5608 | |
3766 | 5609 static int encode_picture(MpegEncContext *s, int picture_number) |
1799 | 5610 { |
2024
f65d87bfdd5a
some of the warning fixes by (Michael Roitzsch <mroi at users dot sourceforge dot net>)
michael
parents:
2015
diff
changeset
|
5611 int i; |
1799 | 5612 int bits; |
5613 | |
5614 s->picture_number = picture_number; | |
2967 | 5615 |
1799 | 5616 /* Reset the average MB variance */ |
2015
3ab8f3e2ae6a
moving motion estimation specific variables from MpegEncContext -> MotionEstContext
michael
parents:
1994
diff
changeset
|
5617 s->me.mb_var_sum_temp = |
3ab8f3e2ae6a
moving motion estimation specific variables from MpegEncContext -> MotionEstContext
michael
parents:
1994
diff
changeset
|
5618 s->me.mc_mb_var_sum_temp = 0; |
1799 | 5619 |
5620 /* we need to initialize some time vars before we can encode b-frames */ | |
5621 // RAL: Condition added for MPEG1VIDEO | |
5622 if (s->codec_id == CODEC_ID_MPEG1VIDEO || s->codec_id == CODEC_ID_MPEG2VIDEO || (s->h263_pred && !s->h263_msmpeg4)) | |
1834 | 5623 ff_set_mpeg4_time(s, s->picture_number); //FIXME rename and use has_b_frames or similar |
2967 | 5624 |
2015
3ab8f3e2ae6a
moving motion estimation specific variables from MpegEncContext -> MotionEstContext
michael
parents:
1994
diff
changeset
|
5625 s->me.scene_change_score=0; |
2967 | 5626 |
2053 | 5627 // s->lambda= s->current_picture_ptr->quality; //FIXME qscale / ... stuff for ME ratedistoration |
2967 | 5628 |
1799 | 5629 if(s->pict_type==I_TYPE){ |
5630 if(s->msmpeg4_version >= 3) s->no_rounding=1; | |
5631 else s->no_rounding=0; | |
5632 }else if(s->pict_type!=B_TYPE){ | |
5633 if(s->flipflop_rounding || s->codec_id == CODEC_ID_H263P || s->codec_id == CODEC_ID_MPEG4) | |
2967 | 5634 s->no_rounding ^= 1; |
5635 } | |
5636 | |
2981 | 5637 if(s->flags & CODEC_FLAG_PASS2){ |
3766 | 5638 if (estimate_qp(s,1) < 0) |
5639 return -1; | |
2981 | 5640 ff_get_2pass_fcode(s); |
5641 }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
|
5642 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
|
5643 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
|
5644 else |
2997
188f4ef688f2
second try of improved lambda/qp guessing for motion estimation RD in first pass
michael
parents:
2990
diff
changeset
|
5645 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
|
5646 update_qscale(s); |
529163f99474
improved lambda/qp guessing for motion estimation RD in first pass
michael
parents:
2979
diff
changeset
|
5647 } |
2974 | 5648 |
2627
bf158d23bbcc
Spelling errors patch by (Kevin Baragona | kevinmb500 gawab com)
michael
parents:
2620
diff
changeset
|
5649 s->mb_intra=0; //for the rate distortion & bit compare functions |
1799 | 5650 for(i=1; i<s->avctx->thread_count; i++){ |
1827 | 5651 ff_update_duplicate_context(s->thread_context[i], s); |
1799 | 5652 } |
1962 | 5653 |
5654 ff_init_me(s); | |
5655 | |
1799 | 5656 /* Estimate motion for every MB */ |
5657 if(s->pict_type != I_TYPE){ | |
2584 | 5658 s->lambda = (s->lambda * s->avctx->me_penalty_compensation + 128)>>8; |
4097 | 5659 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
|
5660 if(s->pict_type != B_TYPE && s->avctx->me_threshold==0){ |
1799 | 5661 if((s->avctx->pre_me && s->last_non_b_pict_type==I_TYPE) || s->avctx->pre_me==2){ |
5662 s->avctx->execute(s->avctx, pre_estimate_motion_thread, (void**)&(s->thread_context[0]), NULL, s->avctx->thread_count); | |
5663 } | |
5664 } | |
5665 | |
5666 s->avctx->execute(s->avctx, estimate_motion_thread, (void**)&(s->thread_context[0]), NULL, s->avctx->thread_count); | |
5667 }else /* if(s->pict_type == I_TYPE) */{ | |
5668 /* I-Frame */ | |
5669 for(i=0; i<s->mb_stride*s->mb_height; i++) | |
5670 s->mb_type[i]= CANDIDATE_MB_TYPE_INTRA; | |
2967 | 5671 |
1799 | 5672 if(!s->fixed_qscale){ |
5673 /* finding spatial complexity for I-frame rate control */ | |
1804
cc0a15943a87
multithreaded spatial complexity calculation for i frames
michael
parents:
1803
diff
changeset
|
5674 s->avctx->execute(s->avctx, mb_var_thread, (void**)&(s->thread_context[0]), NULL, s->avctx->thread_count); |
1799 | 5675 } |
5676 } | |
1804
cc0a15943a87
multithreaded spatial complexity calculation for i frames
michael
parents:
1803
diff
changeset
|
5677 for(i=1; i<s->avctx->thread_count; i++){ |
cc0a15943a87
multithreaded spatial complexity calculation for i frames
michael
parents:
1803
diff
changeset
|
5678 merge_context_after_me(s, s->thread_context[i]); |
cc0a15943a87
multithreaded spatial complexity calculation for i frames
michael
parents:
1803
diff
changeset
|
5679 } |
2015
3ab8f3e2ae6a
moving motion estimation specific variables from MpegEncContext -> MotionEstContext
michael
parents:
1994
diff
changeset
|
5680 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
|
5681 s->current_picture. mb_var_sum= s->current_picture_ptr-> mb_var_sum= s->me. mb_var_sum_temp; |
1799 | 5682 emms_c(); |
5683 | |
2015
3ab8f3e2ae6a
moving motion estimation specific variables from MpegEncContext -> MotionEstContext
michael
parents:
1994
diff
changeset
|
5684 if(s->me.scene_change_score > s->avctx->scenechange_threshold && s->pict_type == P_TYPE){ |
1799 | 5685 s->pict_type= I_TYPE; |
5686 for(i=0; i<s->mb_stride*s->mb_height; i++) | |
5687 s->mb_type[i]= CANDIDATE_MB_TYPE_INTRA; | |
5688 //printf("Scene change detected, encoding as I Frame %d %d\n", s->current_picture.mb_var_sum, s->current_picture.mc_mb_var_sum); | |
5689 } | |
5690 | |
5691 if(!s->umvplus){ | |
5692 if(s->pict_type==P_TYPE || s->pict_type==S_TYPE) { | |
5693 s->f_code= ff_get_best_fcode(s, s->p_mv_table, CANDIDATE_MB_TYPE_INTER); | |
5694 | |
5695 if(s->flags & CODEC_FLAG_INTERLACED_ME){ | |
5696 int a,b; | |
5697 a= ff_get_best_fcode(s, s->p_field_mv_table[0][0], CANDIDATE_MB_TYPE_INTER_I); //FIXME field_select | |
5698 b= ff_get_best_fcode(s, s->p_field_mv_table[1][1], CANDIDATE_MB_TYPE_INTER_I); | |
5699 s->f_code= FFMAX(s->f_code, FFMAX(a,b)); | |
5700 } | |
2967 | 5701 |
1799 | 5702 ff_fix_long_p_mvs(s); |
5703 ff_fix_long_mvs(s, NULL, 0, s->p_mv_table, s->f_code, CANDIDATE_MB_TYPE_INTER, 0); | |
5704 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
|
5705 int j; |
1799 | 5706 for(i=0; i<2; i++){ |
5707 for(j=0; j<2; j++) | |
2967 | 5708 ff_fix_long_mvs(s, s->p_field_select_table[i], j, |
1799 | 5709 s->p_field_mv_table[i][j], s->f_code, CANDIDATE_MB_TYPE_INTER_I, 0); |
5710 } | |
5711 } | |
5712 } | |
5713 | |
5714 if(s->pict_type==B_TYPE){ | |
5715 int a, b; | |
5716 | |
5717 a = ff_get_best_fcode(s, s->b_forw_mv_table, CANDIDATE_MB_TYPE_FORWARD); | |
5718 b = ff_get_best_fcode(s, s->b_bidir_forw_mv_table, CANDIDATE_MB_TYPE_BIDIR); | |
5719 s->f_code = FFMAX(a, b); | |
5720 | |
5721 a = ff_get_best_fcode(s, s->b_back_mv_table, CANDIDATE_MB_TYPE_BACKWARD); | |
5722 b = ff_get_best_fcode(s, s->b_bidir_back_mv_table, CANDIDATE_MB_TYPE_BIDIR); | |
5723 s->b_code = FFMAX(a, b); | |
5724 | |
5725 ff_fix_long_mvs(s, NULL, 0, s->b_forw_mv_table, s->f_code, CANDIDATE_MB_TYPE_FORWARD, 1); | |
5726 ff_fix_long_mvs(s, NULL, 0, s->b_back_mv_table, s->b_code, CANDIDATE_MB_TYPE_BACKWARD, 1); | |
5727 ff_fix_long_mvs(s, NULL, 0, s->b_bidir_forw_mv_table, s->f_code, CANDIDATE_MB_TYPE_BIDIR, 1); | |
5728 ff_fix_long_mvs(s, NULL, 0, s->b_bidir_back_mv_table, s->b_code, CANDIDATE_MB_TYPE_BIDIR, 1); | |
5729 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
|
5730 int dir, j; |
1799 | 5731 for(dir=0; dir<2; dir++){ |
5732 for(i=0; i<2; i++){ | |
5733 for(j=0; j<2; j++){ | |
2967 | 5734 int type= dir ? (CANDIDATE_MB_TYPE_BACKWARD_I|CANDIDATE_MB_TYPE_BIDIR_I) |
1799 | 5735 : (CANDIDATE_MB_TYPE_FORWARD_I |CANDIDATE_MB_TYPE_BIDIR_I); |
2967 | 5736 ff_fix_long_mvs(s, s->b_field_select_table[dir][i], j, |
1799 | 5737 s->b_field_mv_table[dir][i][j], dir ? s->b_code : s->f_code, type, 1); |
5738 } | |
5739 } | |
5740 } | |
5741 } | |
5742 } | |
5743 } | |
5744 | |
3766 | 5745 if (estimate_qp(s, 0) < 0) |
5746 return -1; | |
2967 | 5747 |
5748 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
|
5749 s->qscale= 3; //reduce clipping problems |
2967 | 5750 |
1799 | 5751 if (s->out_format == FMT_MJPEG) { |
5752 /* for mjpeg, we do include qscale in the matrix */ | |
5753 s->intra_matrix[0] = ff_mpeg1_default_intra_matrix[0]; | |
5754 for(i=1;i<64;i++){ | |
5755 int j= s->dsp.idct_permutation[i]; | |
5756 | |
4594 | 5757 s->intra_matrix[j] = av_clip_uint8((ff_mpeg1_default_intra_matrix[i] * s->qscale) >> 3); |
1799 | 5758 } |
2967 | 5759 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
|
5760 s->intra_matrix, s->intra_quant_bias, 8, 8, 1); |
1799 | 5761 s->qscale= 8; |
5762 } | |
2967 | 5763 |
1799 | 5764 //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
|
5765 s->current_picture_ptr->key_frame= |
1799 | 5766 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
|
5767 s->current_picture_ptr->pict_type= |
1799 | 5768 s->current_picture.pict_type= s->pict_type; |
5769 | |
5770 if(s->current_picture.key_frame) | |
5771 s->picture_in_gop_number=0; | |
5772 | |
5773 s->last_bits= put_bits_count(&s->pb); | |
5774 switch(s->out_format) { | |
5775 case FMT_MJPEG: | |
5776 mjpeg_picture_header(s); | |
5777 break; | |
2639 | 5778 #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
|
5779 case FMT_H261: |
5e5cf598a48b
H.261 encoder by (Maarten Daniels <maarten dot daniels at luc dot ac dot be>)
michael
parents:
2298
diff
changeset
|
5780 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
|
5781 break; |
2639 | 5782 #endif |
1799 | 5783 case FMT_H263: |
2967 | 5784 if (s->codec_id == CODEC_ID_WMV2) |
1799 | 5785 ff_wmv2_encode_picture_header(s, picture_number); |
2967 | 5786 else if (s->h263_msmpeg4) |
1799 | 5787 msmpeg4_encode_picture_header(s, picture_number); |
5788 else if (s->h263_pred) | |
5789 mpeg4_encode_picture_header(s, picture_number); | |
2639 | 5790 #ifdef CONFIG_RV10_ENCODER |
2967 | 5791 else if (s->codec_id == CODEC_ID_RV10) |
1799 | 5792 rv10_encode_picture_header(s, picture_number); |
2639 | 5793 #endif |
5794 #ifdef CONFIG_RV20_ENCODER | |
2967 | 5795 else if (s->codec_id == CODEC_ID_RV20) |
2380 | 5796 rv20_encode_picture_header(s, picture_number); |
2639 | 5797 #endif |
1799 | 5798 else if (s->codec_id == CODEC_ID_FLV1) |
5799 ff_flv_encode_picture_header(s, picture_number); | |
5800 else | |
5801 h263_encode_picture_header(s, picture_number); | |
5802 break; | |
5803 case FMT_MPEG1: | |
5804 mpeg1_encode_picture_header(s, picture_number); | |
5805 break; | |
5806 case FMT_H264: | |
5807 break; | |
5808 default: | |
5809 assert(0); | |
5810 } | |
5811 bits= put_bits_count(&s->pb); | |
5812 s->header_bits= bits - s->last_bits; | |
2967 | 5813 |
1799 | 5814 for(i=1; i<s->avctx->thread_count; i++){ |
5815 update_duplicate_context_after_me(s->thread_context[i], s); | |
5816 } | |
5817 s->avctx->execute(s->avctx, encode_thread, (void**)&(s->thread_context[0]), NULL, s->avctx->thread_count); | |
5818 for(i=1; i<s->avctx->thread_count; i++){ | |
5819 merge_context_after_encode(s, s->thread_context[i]); | |
5820 } | |
5821 emms_c(); | |
3780
6741c0e88310
return 0 from encode_picture() and estimate_qp() on success
mru
parents:
3777
diff
changeset
|
5822 return 0; |
0 | 5823 } |
5824 | |
1719 | 5825 static void denoise_dct_c(MpegEncContext *s, DCTELEM *block){ |
1597 | 5826 const int intra= s->mb_intra; |
5827 int i; | |
5828 | |
1599 | 5829 s->dct_count[intra]++; |
5830 | |
1597 | 5831 for(i=0; i<64; i++){ |
5832 int level= block[i]; | |
5833 | |
5834 if(level){ | |
5835 if(level>0){ | |
5836 s->dct_error_sum[intra][i] += level; | |
5837 level -= s->dct_offset[intra][i]; | |
5838 if(level<0) level=0; | |
5839 }else{ | |
5840 s->dct_error_sum[intra][i] -= level; | |
5841 level += s->dct_offset[intra][i]; | |
5842 if(level>0) level=0; | |
5843 } | |
5844 block[i]= level; | |
5845 } | |
5846 } | |
5847 } | |
5848 | |
2967 | 5849 static int dct_quantize_trellis_c(MpegEncContext *s, |
945 | 5850 DCTELEM *block, int n, |
5851 int qscale, int *overflow){ | |
5852 const int *qmat; | |
1064 | 5853 const uint8_t *scantable= s->intra_scantable.scantable; |
1718 | 5854 const uint8_t *perm_scantable= s->intra_scantable.permutated; |
945 | 5855 int max=0; |
5856 unsigned int threshold1, threshold2; | |
5857 int bias=0; | |
5858 int run_tab[65]; | |
5859 int level_tab[65]; | |
5860 int score_tab[65]; | |
1718 | 5861 int survivor[65]; |
5862 int survivor_count; | |
946 | 5863 int last_run=0; |
5864 int last_level=0; | |
5865 int last_score= 0; | |
1718 | 5866 int last_i; |
1715 | 5867 int coeff[2][64]; |
945 | 5868 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
|
5869 int qmul, qadd, start_i, last_non_zero, i, dc; |
945 | 5870 const int esc_length= s->ac_esc_length; |
5871 uint8_t * length; | |
5872 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
|
5873 const int lambda= s->lambda2 >> (FF_LAMBDA_SHIFT - 6); |
2967 | 5874 |
1092 | 5875 s->dsp.fdct (block); |
2967 | 5876 |
1597 | 5877 if(s->dct_error_sum) |
1719 | 5878 s->denoise_dct(s, block); |
945 | 5879 qmul= qscale*16; |
5880 qadd= ((qscale-1)|1)*8; | |
946 | 5881 |
945 | 5882 if (s->mb_intra) { |
5883 int q; | |
5884 if (!s->h263_aic) { | |
5885 if (n < 4) | |
5886 q = s->y_dc_scale; | |
5887 else | |
5888 q = s->c_dc_scale; | |
5889 q = q << 3; | |
5890 } else{ | |
5891 /* For AIC we skip quant/dequant of INTRADC */ | |
5892 q = 1 << 3; | |
5893 qadd=0; | |
5894 } | |
2967 | 5895 |
945 | 5896 /* note: block[0] is assumed to be positive */ |
5897 block[0] = (block[0] + (q >> 1)) / q; | |
5898 start_i = 1; | |
5899 last_non_zero = 0; | |
5900 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
|
5901 if(s->mpeg_quant || s->out_format == FMT_MPEG1) |
945 | 5902 bias= 1<<(QMAT_SHIFT-1); |
5903 length = s->intra_ac_vlc_length; | |
5904 last_length= s->intra_ac_vlc_last_length; | |
5905 } else { | |
5906 start_i = 0; | |
5907 last_non_zero = -1; | |
5908 qmat = s->q_inter_matrix[qscale]; | |
5909 length = s->inter_ac_vlc_length; | |
5910 last_length= s->inter_ac_vlc_last_length; | |
5911 } | |
1718 | 5912 last_i= start_i; |
945 | 5913 |
5914 threshold1= (1<<QMAT_SHIFT) - bias - 1; | |
5915 threshold2= (threshold1<<1); | |
946 | 5916 |
1715 | 5917 for(i=63; i>=start_i; i--) { |
5918 const int j = scantable[i]; | |
5919 int level = block[j] * qmat[j]; | |
5920 | |
5921 if(((unsigned)(level+threshold1))>threshold2){ | |
5922 last_non_zero = i; | |
5923 break; | |
5924 } | |
5925 } | |
5926 | |
5927 for(i=start_i; i<=last_non_zero; i++) { | |
945 | 5928 const int j = scantable[i]; |
1715 | 5929 int level = block[j] * qmat[j]; |
945 | 5930 |
5931 // if( bias+level >= (1<<(QMAT_SHIFT - 3)) | |
5932 // || bias-level >= (1<<(QMAT_SHIFT - 3))){ | |
5933 if(((unsigned)(level+threshold1))>threshold2){ | |
5934 if(level>0){ | |
5935 level= (bias + level)>>QMAT_SHIFT; | |
1718 | 5936 coeff[0][i]= level; |
5937 coeff[1][i]= level-1; | |
946 | 5938 // coeff[2][k]= level-2; |
945 | 5939 }else{ |
5940 level= (bias - level)>>QMAT_SHIFT; | |
1718 | 5941 coeff[0][i]= -level; |
5942 coeff[1][i]= -level+1; | |
946 | 5943 // coeff[2][k]= -level+2; |
945 | 5944 } |
1718 | 5945 coeff_count[i]= FFMIN(level, 2); |
5946 assert(coeff_count[i]); | |
945 | 5947 max |=level; |
5948 }else{ | |
1718 | 5949 coeff[0][i]= (level>>31)|1; |
5950 coeff_count[i]= 1; | |
945 | 5951 } |
5952 } | |
2967 | 5953 |
2627
bf158d23bbcc
Spelling errors patch by (Kevin Baragona | kevinmb500 gawab com)
michael
parents:
2620
diff
changeset
|
5954 *overflow= s->max_qcoeff < max; //overflow might have happened |
2967 | 5955 |
945 | 5956 if(last_non_zero < start_i){ |
5957 memset(block + start_i, 0, (64-start_i)*sizeof(DCTELEM)); | |
5958 return last_non_zero; | |
5959 } | |
5960 | |
1718 | 5961 score_tab[start_i]= 0; |
5962 survivor[0]= start_i; | |
5963 survivor_count= 1; | |
2967 | 5964 |
1718 | 5965 for(i=start_i; i<=last_non_zero; i++){ |
5966 int level_index, j; | |
4001 | 5967 const int dct_coeff= FFABS(block[ scantable[i] ]); |
945 | 5968 const int zero_distoration= dct_coeff*dct_coeff; |
946 | 5969 int best_score=256*256*256*120; |
945 | 5970 for(level_index=0; level_index < coeff_count[i]; level_index++){ |
5971 int distoration; | |
5972 int level= coeff[level_index][i]; | |
4001 | 5973 const int alevel= FFABS(level); |
945 | 5974 int unquant_coeff; |
2967 | 5975 |
945 | 5976 assert(level); |
5977 | |
5978 if(s->out_format == FMT_H263){ | |
1716 | 5979 unquant_coeff= alevel*qmul + qadd; |
947 | 5980 }else{ //MPEG1 |
1718 | 5981 j= s->dsp.idct_permutation[ scantable[i] ]; //FIXME optimize |
947 | 5982 if(s->mb_intra){ |
1716 | 5983 unquant_coeff = (int)( alevel * qscale * s->intra_matrix[j]) >> 3; |
947 | 5984 unquant_coeff = (unquant_coeff - 1) | 1; |
5985 }else{ | |
1716 | 5986 unquant_coeff = ((( alevel << 1) + 1) * qscale * ((int) s->inter_matrix[j])) >> 4; |
947 | 5987 unquant_coeff = (unquant_coeff - 1) | 1; |
5988 } | |
5989 unquant_coeff<<= 3; | |
5990 } | |
946 | 5991 |
1715 | 5992 distoration= (unquant_coeff - dct_coeff) * (unquant_coeff - dct_coeff) - zero_distoration; |
945 | 5993 level+=64; |
5994 if((level&(~127)) == 0){ | |
1718 | 5995 for(j=survivor_count-1; j>=0; j--){ |
5996 int run= i - survivor[j]; | |
947 | 5997 int score= distoration + length[UNI_AC_ENC_INDEX(run, level)]*lambda; |
945 | 5998 score += score_tab[i-run]; |
2967 | 5999 |
945 | 6000 if(score < best_score){ |
1718 | 6001 best_score= score; |
945 | 6002 run_tab[i+1]= run; |
6003 level_tab[i+1]= level-64; | |
6004 } | |
6005 } | |
6006 | |
6007 if(s->out_format == FMT_H263){ | |
1718 | 6008 for(j=survivor_count-1; j>=0; j--){ |
6009 int run= i - survivor[j]; | |
947 | 6010 int score= distoration + last_length[UNI_AC_ENC_INDEX(run, level)]*lambda; |
945 | 6011 score += score_tab[i-run]; |
946 | 6012 if(score < last_score){ |
6013 last_score= score; | |
6014 last_run= run; | |
6015 last_level= level-64; | |
6016 last_i= i+1; | |
945 | 6017 } |
6018 } | |
6019 } | |
6020 }else{ | |
6021 distoration += esc_length*lambda; | |
1718 | 6022 for(j=survivor_count-1; j>=0; j--){ |
6023 int run= i - survivor[j]; | |
945 | 6024 int score= distoration + score_tab[i-run]; |
2967 | 6025 |
945 | 6026 if(score < best_score){ |
1718 | 6027 best_score= score; |
945 | 6028 run_tab[i+1]= run; |
6029 level_tab[i+1]= level-64; | |
6030 } | |
6031 } | |
6032 | |
6033 if(s->out_format == FMT_H263){ | |
1718 | 6034 for(j=survivor_count-1; j>=0; j--){ |
6035 int run= i - survivor[j]; | |
945 | 6036 int score= distoration + score_tab[i-run]; |
946 | 6037 if(score < last_score){ |
6038 last_score= score; | |
6039 last_run= run; | |
6040 last_level= level-64; | |
6041 last_i= i+1; | |
945 | 6042 } |
6043 } | |
6044 } | |
6045 } | |
6046 } | |
2967 | 6047 |
1718 | 6048 score_tab[i+1]= best_score; |
6049 | |
946 | 6050 //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 | 6051 if(last_non_zero <= 27){ |
6052 for(; survivor_count; survivor_count--){ | |
6053 if(score_tab[ survivor[survivor_count-1] ] <= best_score) | |
6054 break; | |
6055 } | |
6056 }else{ | |
6057 for(; survivor_count; survivor_count--){ | |
6058 if(score_tab[ survivor[survivor_count-1] ] <= best_score + lambda) | |
6059 break; | |
6060 } | |
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
|
6061 } |
1718 | 6062 |
6063 survivor[ survivor_count++ ]= i+1; | |
945 | 6064 } |
946 | 6065 |
945 | 6066 if(s->out_format != FMT_H263){ |
946 | 6067 last_score= 256*256*256*120; |
1718 | 6068 for(i= survivor[0]; i<=last_non_zero + 1; i++){ |
946 | 6069 int score= score_tab[i]; |
947 | 6070 if(i) score += lambda*2; //FIXME exacter? |
6071 | |
946 | 6072 if(score < last_score){ |
6073 last_score= score; | |
6074 last_i= i; | |
6075 last_level= level_tab[i]; | |
6076 last_run= run_tab[i]; | |
6077 } | |
945 | 6078 } |
6079 } | |
1490
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1480
diff
changeset
|
6080 |
1715 | 6081 s->coded_score[n] = last_score; |
2967 | 6082 |
4001 | 6083 dc= FFABS(block[0]); |
1718 | 6084 last_non_zero= last_i - 1; |
945 | 6085 memset(block + start_i, 0, (64-start_i)*sizeof(DCTELEM)); |
2967 | 6086 |
945 | 6087 if(last_non_zero < start_i) |
6088 return last_non_zero; | |
1490
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1480
diff
changeset
|
6089 |
1480
8657d6800d15
slight quality improvement ( < +0.04 PSNR) for high bitrate videos with trellis quantization
michaelni
parents:
1471
diff
changeset
|
6090 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
|
6091 int best_level= 0; |
8657d6800d15
slight quality improvement ( < +0.04 PSNR) for high bitrate videos with trellis quantization
michaelni
parents:
1471
diff
changeset
|
6092 int best_score= dc * dc; |
2967 | 6093 |
1480
8657d6800d15
slight quality improvement ( < +0.04 PSNR) for high bitrate videos with trellis quantization
michaelni
parents:
1471
diff
changeset
|
6094 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
|
6095 int level= coeff[i][0]; |
4001 | 6096 int alevel= FFABS(level); |
1716 | 6097 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
|
6098 |
8657d6800d15
slight quality improvement ( < +0.04 PSNR) for high bitrate videos with trellis quantization
michaelni
parents:
1471
diff
changeset
|
6099 if(s->out_format == FMT_H263){ |
1716 | 6100 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
|
6101 }else{ //MPEG1 |
1716 | 6102 unquant_coeff = ((( alevel << 1) + 1) * qscale * ((int) s->inter_matrix[0])) >> 4; |
6103 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
|
6104 } |
8657d6800d15
slight quality improvement ( < +0.04 PSNR) for high bitrate videos with trellis quantization
michaelni
parents:
1471
diff
changeset
|
6105 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
|
6106 unquant_coeff<<= 3 + 3; |
8657d6800d15
slight quality improvement ( < +0.04 PSNR) for high bitrate videos with trellis quantization
michaelni
parents:
1471
diff
changeset
|
6107 |
1716 | 6108 distortion= (unquant_coeff - dc) * (unquant_coeff - dc); |
1490
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1480
diff
changeset
|
6109 level+=64; |
1716 | 6110 if((level&(~127)) == 0) score= distortion + last_length[UNI_AC_ENC_INDEX(0, level)]*lambda; |
6111 else score= distortion + esc_length*lambda; | |
1490
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1480
diff
changeset
|
6112 |
1480
8657d6800d15
slight quality improvement ( < +0.04 PSNR) for high bitrate videos with trellis quantization
michaelni
parents:
1471
diff
changeset
|
6113 if(score < best_score){ |
8657d6800d15
slight quality improvement ( < +0.04 PSNR) for high bitrate videos with trellis quantization
michaelni
parents:
1471
diff
changeset
|
6114 best_score= score; |
1490
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1480
diff
changeset
|
6115 best_level= level - 64; |
1480
8657d6800d15
slight quality improvement ( < +0.04 PSNR) for high bitrate videos with trellis quantization
michaelni
parents:
1471
diff
changeset
|
6116 } |
8657d6800d15
slight quality improvement ( < +0.04 PSNR) for high bitrate videos with trellis quantization
michaelni
parents:
1471
diff
changeset
|
6117 } |
8657d6800d15
slight quality improvement ( < +0.04 PSNR) for high bitrate videos with trellis quantization
michaelni
parents:
1471
diff
changeset
|
6118 block[0]= best_level; |
1490
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1480
diff
changeset
|
6119 s->coded_score[n] = best_score - dc*dc; |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1480
diff
changeset
|
6120 if(best_level == 0) return -1; |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1480
diff
changeset
|
6121 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
|
6122 } |
1490
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1480
diff
changeset
|
6123 |
946 | 6124 i= last_i; |
6125 assert(last_level); | |
1718 | 6126 |
6127 block[ perm_scantable[last_non_zero] ]= last_level; | |
946 | 6128 i -= last_run + 1; |
2967 | 6129 |
1718 | 6130 for(; i>start_i; i -= run_tab[i] + 1){ |
6131 block[ perm_scantable[i-1] ]= level_tab[i]; | |
945 | 6132 } |
6133 | |
6134 return last_non_zero; | |
6135 } | |
6136 | |
1777 | 6137 //#define REFINE_STATS 1 |
6138 static int16_t basis[64][64]; | |
6139 | |
6140 static void build_basis(uint8_t *perm){ | |
6141 int i, j, x, y; | |
6142 emms_c(); | |
6143 for(i=0; i<8; i++){ | |
6144 for(j=0; j<8; j++){ | |
6145 for(y=0; y<8; y++){ | |
6146 for(x=0; x<8; x++){ | |
6147 double s= 0.25*(1<<BASIS_SHIFT); | |
6148 int index= 8*i + j; | |
6149 int perm_index= perm[index]; | |
6150 if(i==0) s*= sqrt(0.5); | |
6151 if(j==0) s*= sqrt(0.5); | |
6152 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))); | |
6153 } | |
6154 } | |
6155 } | |
6156 } | |
6157 } | |
6158 | |
6159 static int dct_quantize_refine(MpegEncContext *s, //FIXME breaks denoise? | |
6160 DCTELEM *block, int16_t *weight, DCTELEM *orig, | |
6161 int n, int qscale){ | |
6162 int16_t rem[64]; | |
3089 | 6163 DECLARE_ALIGNED_16(DCTELEM, d1[64]); |
1777 | 6164 const int *qmat; |
6165 const uint8_t *scantable= s->intra_scantable.scantable; | |
6166 const uint8_t *perm_scantable= s->intra_scantable.permutated; | |
6167 // unsigned int threshold1, threshold2; | |
6168 // int bias=0; | |
6169 int run_tab[65]; | |
6170 int prev_run=0; | |
6171 int prev_level=0; | |
6172 int qmul, qadd, start_i, last_non_zero, i, dc; | |
6173 uint8_t * length; | |
6174 uint8_t * last_length; | |
6175 int lambda; | |
4416 | 6176 int rle_index, run, q = 1, sum; //q is only used when s->mb_intra is true |
1777 | 6177 #ifdef REFINE_STATS |
6178 static int count=0; | |
6179 static int after_last=0; | |
6180 static int to_zero=0; | |
6181 static int from_zero=0; | |
6182 static int raise=0; | |
6183 static int lower=0; | |
6184 static int messed_sign=0; | |
6185 #endif | |
6186 | |
6187 if(basis[0][0] == 0) | |
6188 build_basis(s->dsp.idct_permutation); | |
2967 | 6189 |
1777 | 6190 qmul= qscale*2; |
6191 qadd= (qscale-1)|1; | |
6192 if (s->mb_intra) { | |
6193 if (!s->h263_aic) { | |
6194 if (n < 4) | |
6195 q = s->y_dc_scale; | |
6196 else | |
6197 q = s->c_dc_scale; | |
6198 } else{ | |
6199 /* For AIC we skip quant/dequant of INTRADC */ | |
6200 q = 1; | |
6201 qadd=0; | |
6202 } | |
6203 q <<= RECON_SHIFT-3; | |
6204 /* note: block[0] is assumed to be positive */ | |
6205 dc= block[0]*q; | |
6206 // block[0] = (block[0] + (q >> 1)) / q; | |
6207 start_i = 1; | |
6208 qmat = s->q_intra_matrix[qscale]; | |
6209 // if(s->mpeg_quant || s->out_format == FMT_MPEG1) | |
6210 // bias= 1<<(QMAT_SHIFT-1); | |
6211 length = s->intra_ac_vlc_length; | |
6212 last_length= s->intra_ac_vlc_last_length; | |
6213 } else { | |
6214 dc= 0; | |
6215 start_i = 0; | |
6216 qmat = s->q_inter_matrix[qscale]; | |
6217 length = s->inter_ac_vlc_length; | |
6218 last_length= s->inter_ac_vlc_last_length; | |
6219 } | |
6220 last_non_zero = s->block_last_index[n]; | |
6221 | |
6222 #ifdef REFINE_STATS | |
6223 {START_TIMER | |
6224 #endif | |
1784 | 6225 dc += (1<<(RECON_SHIFT-1)); |
6226 for(i=0; i<64; i++){ | |
2627
bf158d23bbcc
Spelling errors patch by (Kevin Baragona | kevinmb500 gawab com)
michael
parents:
2620
diff
changeset
|
6227 rem[i]= dc - (orig[i]<<RECON_SHIFT); //FIXME use orig dirrectly instead of copying to rem[] |
1777 | 6228 } |
6229 #ifdef REFINE_STATS | |
6230 STOP_TIMER("memset rem[]")} | |
6231 #endif | |
6232 sum=0; | |
6233 for(i=0; i<64; i++){ | |
6234 int one= 36; | |
6235 int qns=4; | |
6236 int w; | |
6237 | |
4001 | 6238 w= FFABS(weight[i]) + qns*one; |
1777 | 6239 w= 15 + (48*qns*one + w/2)/w; // 16 .. 63 |
6240 | |
6241 weight[i] = w; | |
6242 // w=weight[i] = (63*qns + (w/2)) / w; | |
2967 | 6243 |
1777 | 6244 assert(w>0); |
6245 assert(w<(1<<6)); | |
6246 sum += w*w; | |
6247 } | |
6248 lambda= sum*(uint64_t)s->lambda2 >> (FF_LAMBDA_SHIFT - 6 + 6 + 6 + 6); | |
6249 #ifdef REFINE_STATS | |
6250 {START_TIMER | |
6251 #endif | |
6252 run=0; | |
6253 rle_index=0; | |
6254 for(i=start_i; i<=last_non_zero; i++){ | |
6255 int j= perm_scantable[i]; | |
6256 const int level= block[j]; | |
6257 int coeff; | |
2967 | 6258 |
1777 | 6259 if(level){ |
6260 if(level<0) coeff= qmul*level - qadd; | |
6261 else coeff= qmul*level + qadd; | |
6262 run_tab[rle_index++]=run; | |
6263 run=0; | |
6264 | |
1784 | 6265 s->dsp.add_8x8basis(rem, basis[j], coeff); |
1777 | 6266 }else{ |
6267 run++; | |
6268 } | |
6269 } | |
6270 #ifdef REFINE_STATS | |
6271 if(last_non_zero>0){ | |
6272 STOP_TIMER("init rem[]") | |
6273 } | |
6274 } | |
6275 | |
6276 {START_TIMER | |
6277 #endif | |
6278 for(;;){ | |
1784 | 6279 int best_score=s->dsp.try_8x8basis(rem, weight, basis[0], 0); |
1777 | 6280 int best_coeff=0; |
6281 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
|
6282 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
|
6283 #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
|
6284 {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
|
6285 #endif |
14d918d0ef42
analyze the gradient of the error surface to avoid a few checks in the quantizing noise shaper
michael
parents:
1784
diff
changeset
|
6286 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
|
6287 |
14d918d0ef42
analyze the gradient of the error surface to avoid a few checks in the quantizing noise shaper
michael
parents:
1784
diff
changeset
|
6288 if(analyze_gradient){ |
1777 | 6289 #ifdef REFINE_STATS |
6290 {START_TIMER | |
6291 #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
|
6292 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
|
6293 int w= weight[i]; |
2967 | 6294 |
1785
14d918d0ef42
analyze the gradient of the error surface to avoid a few checks in the quantizing noise shaper
michael
parents:
1784
diff
changeset
|
6295 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
|
6296 } |
14d918d0ef42
analyze the gradient of the error surface to avoid a few checks in the quantizing noise shaper
michael
parents:
1784
diff
changeset
|
6297 #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
|
6298 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
|
6299 {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
|
6300 #endif |
14d918d0ef42
analyze the gradient of the error surface to avoid a few checks in the quantizing noise shaper
michael
parents:
1784
diff
changeset
|
6301 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
|
6302 #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
|
6303 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
|
6304 #endif |
14d918d0ef42
analyze the gradient of the error surface to avoid a few checks in the quantizing noise shaper
michael
parents:
1784
diff
changeset
|
6305 } |
14d918d0ef42
analyze the gradient of the error surface to avoid a few checks in the quantizing noise shaper
michael
parents:
1784
diff
changeset
|
6306 |
1777 | 6307 if(start_i){ |
6308 const int level= block[0]; | |
6309 int change, old_coeff; | |
6310 | |
6311 assert(s->mb_intra); | |
2967 | 6312 |
1777 | 6313 old_coeff= q*level; |
2967 | 6314 |
1777 | 6315 for(change=-1; change<=1; change+=2){ |
6316 int new_level= level + change; | |
6317 int score, new_coeff; | |
2967 | 6318 |
1777 | 6319 new_coeff= q*new_level; |
6320 if(new_coeff >= 2048 || new_coeff < 0) | |
6321 continue; | |
6322 | |
1784 | 6323 score= s->dsp.try_8x8basis(rem, weight, basis[0], new_coeff - old_coeff); |
1777 | 6324 if(score<best_score){ |
6325 best_score= score; | |
6326 best_coeff= 0; | |
6327 best_change= change; | |
6328 best_unquant_change= new_coeff - old_coeff; | |
6329 } | |
6330 } | |
6331 } | |
2967 | 6332 |
1777 | 6333 run=0; |
6334 rle_index=0; | |
6335 run2= run_tab[rle_index++]; | |
6336 prev_level=0; | |
6337 prev_run=0; | |
6338 | |
6339 for(i=start_i; i<64; i++){ | |
6340 int j= perm_scantable[i]; | |
6341 const int level= block[j]; | |
6342 int change, old_coeff; | |
6343 | |
6344 if(s->avctx->quantizer_noise_shaping < 3 && i > last_non_zero + 1) | |
6345 break; | |
6346 | |
6347 if(level){ | |
6348 if(level<0) old_coeff= qmul*level - qadd; | |
6349 else old_coeff= qmul*level + qadd; | |
6350 run2= run_tab[rle_index++]; //FIXME ! maybe after last | |
6351 }else{ | |
6352 old_coeff=0; | |
6353 run2--; | |
6354 assert(run2>=0 || i >= last_non_zero ); | |
6355 } | |
2967 | 6356 |
1777 | 6357 for(change=-1; change<=1; change+=2){ |
6358 int new_level= level + change; | |
6359 int score, new_coeff, unquant_change; | |
2967 | 6360 |
1777 | 6361 score=0; |
4001 | 6362 if(s->avctx->quantizer_noise_shaping < 2 && FFABS(new_level) > FFABS(level)) |
1777 | 6363 continue; |
6364 | |
6365 if(new_level){ | |
6366 if(new_level<0) new_coeff= qmul*new_level - qadd; | |
6367 else new_coeff= qmul*new_level + qadd; | |
6368 if(new_coeff >= 2048 || new_coeff <= -2048) | |
6369 continue; | |
6370 //FIXME check for overflow | |
2967 | 6371 |
1777 | 6372 if(level){ |
6373 if(level < 63 && level > -63){ | |
6374 if(i < last_non_zero) | |
6375 score += length[UNI_AC_ENC_INDEX(run, new_level+64)] | |
6376 - length[UNI_AC_ENC_INDEX(run, level+64)]; | |
6377 else | |
6378 score += last_length[UNI_AC_ENC_INDEX(run, new_level+64)] | |
6379 - last_length[UNI_AC_ENC_INDEX(run, level+64)]; | |
6380 } | |
6381 }else{ | |
4001 | 6382 assert(FFABS(new_level)==1); |
2967 | 6383 |
1785
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(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
|
6385 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
|
6386 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
|
6387 continue; |
14d918d0ef42
analyze the gradient of the error surface to avoid a few checks in the quantizing noise shaper
michael
parents:
1784
diff
changeset
|
6388 } |
14d918d0ef42
analyze the gradient of the error surface to avoid a few checks in the quantizing noise shaper
michael
parents:
1784
diff
changeset
|
6389 |
1777 | 6390 if(i < last_non_zero){ |
6391 int next_i= i + run2 + 1; | |
6392 int next_level= block[ perm_scantable[next_i] ] + 64; | |
2967 | 6393 |
1777 | 6394 if(next_level&(~127)) |
6395 next_level= 0; | |
6396 | |
6397 if(next_i < last_non_zero) | |
6398 score += length[UNI_AC_ENC_INDEX(run, 65)] | |
6399 + length[UNI_AC_ENC_INDEX(run2, next_level)] | |
6400 - length[UNI_AC_ENC_INDEX(run + run2 + 1, next_level)]; | |
6401 else | |
6402 score += length[UNI_AC_ENC_INDEX(run, 65)] | |
6403 + last_length[UNI_AC_ENC_INDEX(run2, next_level)] | |
6404 - last_length[UNI_AC_ENC_INDEX(run + run2 + 1, next_level)]; | |
6405 }else{ | |
6406 score += last_length[UNI_AC_ENC_INDEX(run, 65)]; | |
6407 if(prev_level){ | |
6408 score += length[UNI_AC_ENC_INDEX(prev_run, prev_level)] | |
6409 - last_length[UNI_AC_ENC_INDEX(prev_run, prev_level)]; | |
6410 } | |
6411 } | |
6412 } | |
6413 }else{ | |
6414 new_coeff=0; | |
4001 | 6415 assert(FFABS(level)==1); |
1777 | 6416 |
6417 if(i < last_non_zero){ | |
6418 int next_i= i + run2 + 1; | |
6419 int next_level= block[ perm_scantable[next_i] ] + 64; | |
2967 | 6420 |
1777 | 6421 if(next_level&(~127)) |
6422 next_level= 0; | |
6423 | |
6424 if(next_i < last_non_zero) | |
6425 score += length[UNI_AC_ENC_INDEX(run + run2 + 1, next_level)] | |
6426 - length[UNI_AC_ENC_INDEX(run2, next_level)] | |
6427 - length[UNI_AC_ENC_INDEX(run, 65)]; | |
6428 else | |
6429 score += last_length[UNI_AC_ENC_INDEX(run + run2 + 1, next_level)] | |
6430 - last_length[UNI_AC_ENC_INDEX(run2, next_level)] | |
6431 - length[UNI_AC_ENC_INDEX(run, 65)]; | |
6432 }else{ | |
6433 score += -last_length[UNI_AC_ENC_INDEX(run, 65)]; | |
6434 if(prev_level){ | |
6435 score += last_length[UNI_AC_ENC_INDEX(prev_run, prev_level)] | |
6436 - length[UNI_AC_ENC_INDEX(prev_run, prev_level)]; | |
6437 } | |
6438 } | |
6439 } | |
2967 | 6440 |
1777 | 6441 score *= lambda; |
6442 | |
6443 unquant_change= new_coeff - old_coeff; | |
6444 assert((score < 100*lambda && score > -100*lambda) || lambda==0); | |
2967 | 6445 |
1784 | 6446 score+= s->dsp.try_8x8basis(rem, weight, basis[j], unquant_change); |
1777 | 6447 if(score<best_score){ |
6448 best_score= score; | |
6449 best_coeff= i; | |
6450 best_change= change; | |
6451 best_unquant_change= unquant_change; | |
6452 } | |
6453 } | |
6454 if(level){ | |
6455 prev_level= level + 64; | |
6456 if(prev_level&(~127)) | |
6457 prev_level= 0; | |
6458 prev_run= run; | |
6459 run=0; | |
6460 }else{ | |
6461 run++; | |
6462 } | |
6463 } | |
6464 #ifdef REFINE_STATS | |
6465 STOP_TIMER("iterative step")} | |
6466 #endif | |
6467 | |
6468 if(best_change){ | |
6469 int j= perm_scantable[ best_coeff ]; | |
2967 | 6470 |
1777 | 6471 block[j] += best_change; |
2967 | 6472 |
1777 | 6473 if(best_coeff > last_non_zero){ |
6474 last_non_zero= best_coeff; | |
6475 assert(block[j]); | |
6476 #ifdef REFINE_STATS | |
6477 after_last++; | |
6478 #endif | |
6479 }else{ | |
6480 #ifdef REFINE_STATS | |
6481 if(block[j]){ | |
6482 if(block[j] - best_change){ | |
4001 | 6483 if(FFABS(block[j]) > FFABS(block[j] - best_change)){ |
1777 | 6484 raise++; |
6485 }else{ | |
6486 lower++; | |
6487 } | |
6488 }else{ | |
6489 from_zero++; | |
6490 } | |
6491 }else{ | |
6492 to_zero++; | |
6493 } | |
6494 #endif | |
6495 for(; last_non_zero>=start_i; last_non_zero--){ | |
6496 if(block[perm_scantable[last_non_zero]]) | |
6497 break; | |
6498 } | |
6499 } | |
6500 #ifdef REFINE_STATS | |
6501 count++; | |
6502 if(256*256*256*64 % count == 0){ | |
6503 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); | |
6504 } | |
6505 #endif | |
6506 run=0; | |
6507 rle_index=0; | |
6508 for(i=start_i; i<=last_non_zero; i++){ | |
6509 int j= perm_scantable[i]; | |
6510 const int level= block[j]; | |
2967 | 6511 |
1777 | 6512 if(level){ |
6513 run_tab[rle_index++]=run; | |
6514 run=0; | |
6515 }else{ | |
6516 run++; | |
6517 } | |
6518 } | |
2967 | 6519 |
1784 | 6520 s->dsp.add_8x8basis(rem, basis[j], best_unquant_change); |
1777 | 6521 }else{ |
6522 break; | |
6523 } | |
6524 } | |
6525 #ifdef REFINE_STATS | |
6526 if(last_non_zero>0){ | |
6527 STOP_TIMER("iterative search") | |
6528 } | |
6529 } | |
6530 #endif | |
6531 | |
6532 return last_non_zero; | |
6533 } | |
6534 | |
2967 | 6535 static int dct_quantize_c(MpegEncContext *s, |
0 | 6536 DCTELEM *block, int n, |
344 | 6537 int qscale, int *overflow) |
0 | 6538 { |
1715 | 6539 int i, j, level, last_non_zero, q, start_i; |
0 | 6540 const int *qmat; |
1064 | 6541 const uint8_t *scantable= s->intra_scantable.scantable; |
344 | 6542 int bias; |
6543 int max=0; | |
6544 unsigned int threshold1, threshold2; | |
828
ace3ccd18dd2
Altivec Patch (Mark III) by (Dieter Shirley <dieters at schemasoft dot com>)
michaelni
parents:
815
diff
changeset
|
6545 |
1092 | 6546 s->dsp.fdct (block); |
0 | 6547 |
1597 | 6548 if(s->dct_error_sum) |
1719 | 6549 s->denoise_dct(s, block); |
1597 | 6550 |
0 | 6551 if (s->mb_intra) { |
350
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
347
diff
changeset
|
6552 if (!s->h263_aic) { |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
347
diff
changeset
|
6553 if (n < 4) |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
347
diff
changeset
|
6554 q = s->y_dc_scale; |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
347
diff
changeset
|
6555 else |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
347
diff
changeset
|
6556 q = s->c_dc_scale; |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
347
diff
changeset
|
6557 q = q << 3; |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
347
diff
changeset
|
6558 } else |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
347
diff
changeset
|
6559 /* 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
|
6560 q = 1 << 3; |
2967 | 6561 |
0 | 6562 /* note: block[0] is assumed to be positive */ |
6563 block[0] = (block[0] + (q >> 1)) / q; | |
1715 | 6564 start_i = 1; |
0 | 6565 last_non_zero = 0; |
344 | 6566 qmat = s->q_intra_matrix[qscale]; |
635 | 6567 bias= s->intra_quant_bias<<(QMAT_SHIFT - QUANT_BIAS_SHIFT); |
0 | 6568 } else { |
1715 | 6569 start_i = 0; |
0 | 6570 last_non_zero = -1; |
344 | 6571 qmat = s->q_inter_matrix[qscale]; |
635 | 6572 bias= s->inter_quant_bias<<(QMAT_SHIFT - QUANT_BIAS_SHIFT); |
0 | 6573 } |
635 | 6574 threshold1= (1<<QMAT_SHIFT) - bias - 1; |
6575 threshold2= (threshold1<<1); | |
1715 | 6576 for(i=63;i>=start_i;i--) { |
764 | 6577 j = scantable[i]; |
1715 | 6578 level = block[j] * qmat[j]; |
6579 | |
6580 if(((unsigned)(level+threshold1))>threshold2){ | |
6581 last_non_zero = i; | |
6582 break; | |
6583 }else{ | |
6584 block[j]=0; | |
6585 } | |
6586 } | |
6587 for(i=start_i; i<=last_non_zero; i++) { | |
6588 j = scantable[i]; | |
6589 level = block[j] * qmat[j]; | |
344 | 6590 |
1215 | 6591 // if( bias+level >= (1<<QMAT_SHIFT) |
6592 // || bias-level >= (1<<QMAT_SHIFT)){ | |
344 | 6593 if(((unsigned)(level+threshold1))>threshold2){ |
6594 if(level>0){ | |
635 | 6595 level= (bias + level)>>QMAT_SHIFT; |
344 | 6596 block[j]= level; |
6597 }else{ | |
635 | 6598 level= (bias - level)>>QMAT_SHIFT; |
344 | 6599 block[j]= -level; |
0 | 6600 } |
344 | 6601 max |=level; |
6602 }else{ | |
6603 block[j]=0; | |
0 | 6604 } |
6605 } | |
2627
bf158d23bbcc
Spelling errors patch by (Kevin Baragona | kevinmb500 gawab com)
michael
parents:
2620
diff
changeset
|
6606 *overflow= s->max_qcoeff < max; //overflow might have happened |
2967 | 6607 |
764 | 6608 /* we need this permutation so that we correct the IDCT, we only permute the !=0 elements */ |
1092 | 6609 if (s->dsp.idct_permutation_type != FF_NO_IDCT_PERM) |
2979 | 6610 ff_block_permute(block, s->dsp.idct_permutation, scantable, last_non_zero); |
764 | 6611 |
0 | 6612 return last_non_zero; |
6613 } | |
6614 | |
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
|
6615 #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
|
6616 |
2967 | 6617 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
|
6618 DCTELEM *block, int n, int qscale) |
0 | 6619 { |
200 | 6620 int i, level, nCoeffs; |
1064 | 6621 const uint16_t *quant_matrix; |
0 | 6622 |
706
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
6623 nCoeffs= s->block_last_index[n]; |
2967 | 6624 |
6625 if (n < 4) | |
1689 | 6626 block[0] = block[0] * s->y_dc_scale; |
6627 else | |
6628 block[0] = block[0] * s->c_dc_scale; | |
6629 /* XXX: only mpeg1 */ | |
6630 quant_matrix = s->intra_matrix; | |
6631 for(i=1;i<=nCoeffs;i++) { | |
6632 int j= s->intra_scantable.permutated[i]; | |
6633 level = block[j]; | |
6634 if (level) { | |
6635 if (level < 0) { | |
6636 level = -level; | |
6637 level = (int)(level * qscale * quant_matrix[j]) >> 3; | |
6638 level = (level - 1) | 1; | |
6639 level = -level; | |
6640 } else { | |
6641 level = (int)(level * qscale * quant_matrix[j]) >> 3; | |
6642 level = (level - 1) | 1; | |
0 | 6643 } |
1689 | 6644 block[j] = level; |
0 | 6645 } |
6646 } | |
6647 } | |
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
|
6648 |
2967 | 6649 static void dct_unquantize_mpeg1_inter_c(MpegEncContext *s, |
1689 | 6650 DCTELEM *block, int n, int qscale) |
6651 { | |
6652 int i, level, nCoeffs; | |
6653 const uint16_t *quant_matrix; | |
6654 | |
6655 nCoeffs= s->block_last_index[n]; | |
2967 | 6656 |
1689 | 6657 quant_matrix = s->inter_matrix; |
6658 for(i=0; i<=nCoeffs; i++) { | |
6659 int j= s->intra_scantable.permutated[i]; | |
6660 level = block[j]; | |
6661 if (level) { | |
6662 if (level < 0) { | |
6663 level = -level; | |
6664 level = (((level << 1) + 1) * qscale * | |
6665 ((int) (quant_matrix[j]))) >> 4; | |
6666 level = (level - 1) | 1; | |
6667 level = -level; | |
6668 } else { | |
6669 level = (((level << 1) + 1) * qscale * | |
6670 ((int) (quant_matrix[j]))) >> 4; | |
6671 level = (level - 1) | 1; | |
6672 } | |
6673 block[j] = level; | |
6674 } | |
6675 } | |
6676 } | |
6677 | |
2967 | 6678 static void dct_unquantize_mpeg2_intra_c(MpegEncContext *s, |
325 | 6679 DCTELEM *block, int n, int qscale) |
6680 { | |
6681 int i, level, nCoeffs; | |
1064 | 6682 const uint16_t *quant_matrix; |
325 | 6683 |
706
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
6684 if(s->alternate_scan) nCoeffs= 63; |
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
6685 else nCoeffs= s->block_last_index[n]; |
2967 | 6686 |
6687 if (n < 4) | |
1689 | 6688 block[0] = block[0] * s->y_dc_scale; |
6689 else | |
6690 block[0] = block[0] * s->c_dc_scale; | |
6691 quant_matrix = s->intra_matrix; | |
6692 for(i=1;i<=nCoeffs;i++) { | |
6693 int j= s->intra_scantable.permutated[i]; | |
6694 level = block[j]; | |
6695 if (level) { | |
6696 if (level < 0) { | |
6697 level = -level; | |
6698 level = (int)(level * qscale * quant_matrix[j]) >> 3; | |
6699 level = -level; | |
6700 } else { | |
6701 level = (int)(level * qscale * quant_matrix[j]) >> 3; | |
6702 } | |
6703 block[j] = level; | |
6704 } | |
6705 } | |
6706 } | |
6707 | |
3281
7fac25904a8b
missmatch control for mpeg2 intra dequantization if bitexact=1
michael
parents:
3268
diff
changeset
|
6708 static void dct_unquantize_mpeg2_intra_bitexact(MpegEncContext *s, |
7fac25904a8b
missmatch control for mpeg2 intra dequantization if bitexact=1
michael
parents:
3268
diff
changeset
|
6709 DCTELEM *block, int n, int qscale) |
7fac25904a8b
missmatch control for mpeg2 intra dequantization if bitexact=1
michael
parents:
3268
diff
changeset
|
6710 { |
7fac25904a8b
missmatch control for mpeg2 intra dequantization if bitexact=1
michael
parents:
3268
diff
changeset
|
6711 int i, level, nCoeffs; |
7fac25904a8b
missmatch control for mpeg2 intra dequantization if bitexact=1
michael
parents:
3268
diff
changeset
|
6712 const uint16_t *quant_matrix; |
7fac25904a8b
missmatch control for mpeg2 intra dequantization if bitexact=1
michael
parents:
3268
diff
changeset
|
6713 int sum=-1; |
7fac25904a8b
missmatch control for mpeg2 intra dequantization if bitexact=1
michael
parents:
3268
diff
changeset
|
6714 |
7fac25904a8b
missmatch control for mpeg2 intra dequantization if bitexact=1
michael
parents:
3268
diff
changeset
|
6715 if(s->alternate_scan) nCoeffs= 63; |
7fac25904a8b
missmatch control for mpeg2 intra dequantization if bitexact=1
michael
parents:
3268
diff
changeset
|
6716 else nCoeffs= s->block_last_index[n]; |
7fac25904a8b
missmatch control for mpeg2 intra dequantization if bitexact=1
michael
parents:
3268
diff
changeset
|
6717 |
7fac25904a8b
missmatch control for mpeg2 intra dequantization if bitexact=1
michael
parents:
3268
diff
changeset
|
6718 if (n < 4) |
7fac25904a8b
missmatch control for mpeg2 intra dequantization if bitexact=1
michael
parents:
3268
diff
changeset
|
6719 block[0] = block[0] * s->y_dc_scale; |
7fac25904a8b
missmatch control for mpeg2 intra dequantization if bitexact=1
michael
parents:
3268
diff
changeset
|
6720 else |
7fac25904a8b
missmatch control for mpeg2 intra dequantization if bitexact=1
michael
parents:
3268
diff
changeset
|
6721 block[0] = block[0] * s->c_dc_scale; |
7fac25904a8b
missmatch control for mpeg2 intra dequantization if bitexact=1
michael
parents:
3268
diff
changeset
|
6722 quant_matrix = s->intra_matrix; |
7fac25904a8b
missmatch control for mpeg2 intra dequantization if bitexact=1
michael
parents:
3268
diff
changeset
|
6723 for(i=1;i<=nCoeffs;i++) { |
7fac25904a8b
missmatch control for mpeg2 intra dequantization if bitexact=1
michael
parents:
3268
diff
changeset
|
6724 int j= s->intra_scantable.permutated[i]; |
7fac25904a8b
missmatch control for mpeg2 intra dequantization if bitexact=1
michael
parents:
3268
diff
changeset
|
6725 level = block[j]; |
7fac25904a8b
missmatch control for mpeg2 intra dequantization if bitexact=1
michael
parents:
3268
diff
changeset
|
6726 if (level) { |
7fac25904a8b
missmatch control for mpeg2 intra dequantization if bitexact=1
michael
parents:
3268
diff
changeset
|
6727 if (level < 0) { |
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 level = (int)(level * qscale * quant_matrix[j]) >> 3; |
7fac25904a8b
missmatch control for mpeg2 intra dequantization if bitexact=1
michael
parents:
3268
diff
changeset
|
6730 level = -level; |
7fac25904a8b
missmatch control for mpeg2 intra dequantization if bitexact=1
michael
parents:
3268
diff
changeset
|
6731 } else { |
7fac25904a8b
missmatch control for mpeg2 intra dequantization if bitexact=1
michael
parents:
3268
diff
changeset
|
6732 level = (int)(level * qscale * quant_matrix[j]) >> 3; |
7fac25904a8b
missmatch control for mpeg2 intra dequantization if bitexact=1
michael
parents:
3268
diff
changeset
|
6733 } |
7fac25904a8b
missmatch control for mpeg2 intra dequantization if bitexact=1
michael
parents:
3268
diff
changeset
|
6734 block[j] = level; |
7fac25904a8b
missmatch control for mpeg2 intra dequantization if bitexact=1
michael
parents:
3268
diff
changeset
|
6735 sum+=level; |
7fac25904a8b
missmatch control for mpeg2 intra dequantization if bitexact=1
michael
parents:
3268
diff
changeset
|
6736 } |
7fac25904a8b
missmatch control for mpeg2 intra dequantization if bitexact=1
michael
parents:
3268
diff
changeset
|
6737 } |
7fac25904a8b
missmatch control for mpeg2 intra dequantization if bitexact=1
michael
parents:
3268
diff
changeset
|
6738 block[63]^=sum&1; |
7fac25904a8b
missmatch control for mpeg2 intra dequantization if bitexact=1
michael
parents:
3268
diff
changeset
|
6739 } |
7fac25904a8b
missmatch control for mpeg2 intra dequantization if bitexact=1
michael
parents:
3268
diff
changeset
|
6740 |
2967 | 6741 static void dct_unquantize_mpeg2_inter_c(MpegEncContext *s, |
1689 | 6742 DCTELEM *block, int n, int qscale) |
6743 { | |
6744 int i, level, nCoeffs; | |
6745 const uint16_t *quant_matrix; | |
6746 int sum=-1; | |
6747 | |
6748 if(s->alternate_scan) nCoeffs= 63; | |
6749 else nCoeffs= s->block_last_index[n]; | |
2967 | 6750 |
1689 | 6751 quant_matrix = s->inter_matrix; |
6752 for(i=0; i<=nCoeffs; i++) { | |
6753 int j= s->intra_scantable.permutated[i]; | |
6754 level = block[j]; | |
6755 if (level) { | |
6756 if (level < 0) { | |
6757 level = -level; | |
6758 level = (((level << 1) + 1) * qscale * | |
6759 ((int) (quant_matrix[j]))) >> 4; | |
6760 level = -level; | |
6761 } else { | |
6762 level = (((level << 1) + 1) * qscale * | |
6763 ((int) (quant_matrix[j]))) >> 4; | |
6764 } | |
6765 block[j] = level; | |
6766 sum+=level; | |
6767 } | |
6768 } | |
6769 block[63]^=sum&1; | |
6770 } | |
6771 | |
2967 | 6772 static void dct_unquantize_h263_intra_c(MpegEncContext *s, |
1689 | 6773 DCTELEM *block, int n, int qscale) |
6774 { | |
6775 int i, level, qmul, qadd; | |
6776 int nCoeffs; | |
2967 | 6777 |
1689 | 6778 assert(s->block_last_index[n]>=0); |
2967 | 6779 |
1689 | 6780 qmul = qscale << 1; |
2967 | 6781 |
1689 | 6782 if (!s->h263_aic) { |
2967 | 6783 if (n < 4) |
325 | 6784 block[0] = block[0] * s->y_dc_scale; |
6785 else | |
6786 block[0] = block[0] * s->c_dc_scale; | |
1689 | 6787 qadd = (qscale - 1) | 1; |
6788 }else{ | |
6789 qadd = 0; | |
6790 } | |
6791 if(s->ac_pred) | |
6792 nCoeffs=63; | |
6793 else | |
6794 nCoeffs= s->inter_scantable.raster_end[ s->block_last_index[n] ]; | |
6795 | |
6796 for(i=1; i<=nCoeffs; i++) { | |
6797 level = block[i]; | |
6798 if (level) { | |
6799 if (level < 0) { | |
6800 level = level * qmul - qadd; | |
6801 } else { | |
6802 level = level * qmul + qadd; | |
325 | 6803 } |
1689 | 6804 block[i] = level; |
325 | 6805 } |
6806 } | |
6807 } | |
6808 | |
2967 | 6809 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
|
6810 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
|
6811 { |
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
|
6812 int i, level, qmul, qadd; |
200 | 6813 int nCoeffs; |
2967 | 6814 |
706
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
6815 assert(s->block_last_index[n]>=0); |
2967 | 6816 |
706
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
6817 qadd = (qscale - 1) | 1; |
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
6818 qmul = qscale << 1; |
2967 | 6819 |
1689 | 6820 nCoeffs= s->inter_scantable.raster_end[ s->block_last_index[n] ]; |
6821 | |
6822 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
|
6823 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
|
6824 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
|
6825 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
|
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 } 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
|
6828 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
|
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 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
|
6831 } |
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
|
6832 } |
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
|
6833 } |
0 | 6834 |
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
|
6835 #ifdef CONFIG_ENCODERS |
0 | 6836 AVCodec h263_encoder = { |
6837 "h263", | |
6838 CODEC_TYPE_VIDEO, | |
6839 CODEC_ID_H263, | |
6840 sizeof(MpegEncContext), | |
6841 MPV_encode_init, | |
6842 MPV_encode_picture, | |
6843 MPV_encode_end, | |
2524 | 6844 .pix_fmts= (enum PixelFormat[]){PIX_FMT_YUV420P, -1}, |
0 | 6845 }; |
6846 | |
6847 AVCodec h263p_encoder = { | |
6848 "h263p", | |
6849 CODEC_TYPE_VIDEO, | |
6850 CODEC_ID_H263P, | |
6851 sizeof(MpegEncContext), | |
6852 MPV_encode_init, | |
6853 MPV_encode_picture, | |
6854 MPV_encode_end, | |
2524 | 6855 .pix_fmts= (enum PixelFormat[]){PIX_FMT_YUV420P, -1}, |
0 | 6856 }; |
6857 | |
1353
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1344
diff
changeset
|
6858 AVCodec flv_encoder = { |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1344
diff
changeset
|
6859 "flv", |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1344
diff
changeset
|
6860 CODEC_TYPE_VIDEO, |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1344
diff
changeset
|
6861 CODEC_ID_FLV1, |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1344
diff
changeset
|
6862 sizeof(MpegEncContext), |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1344
diff
changeset
|
6863 MPV_encode_init, |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1344
diff
changeset
|
6864 MPV_encode_picture, |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1344
diff
changeset
|
6865 MPV_encode_end, |
2524 | 6866 .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
|
6867 }; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1344
diff
changeset
|
6868 |
0 | 6869 AVCodec rv10_encoder = { |
6870 "rv10", | |
6871 CODEC_TYPE_VIDEO, | |
6872 CODEC_ID_RV10, | |
6873 sizeof(MpegEncContext), | |
6874 MPV_encode_init, | |
6875 MPV_encode_picture, | |
6876 MPV_encode_end, | |
2524 | 6877 .pix_fmts= (enum PixelFormat[]){PIX_FMT_YUV420P, -1}, |
0 | 6878 }; |
6879 | |
2380 | 6880 AVCodec rv20_encoder = { |
6881 "rv20", | |
6882 CODEC_TYPE_VIDEO, | |
6883 CODEC_ID_RV20, | |
6884 sizeof(MpegEncContext), | |
6885 MPV_encode_init, | |
6886 MPV_encode_picture, | |
6887 MPV_encode_end, | |
2524 | 6888 .pix_fmts= (enum PixelFormat[]){PIX_FMT_YUV420P, -1}, |
2380 | 6889 }; |
6890 | |
71 | 6891 AVCodec mpeg4_encoder = { |
6892 "mpeg4", | |
0 | 6893 CODEC_TYPE_VIDEO, |
71 | 6894 CODEC_ID_MPEG4, |
0 | 6895 sizeof(MpegEncContext), |
6896 MPV_encode_init, | |
6897 MPV_encode_picture, | |
6898 MPV_encode_end, | |
2524 | 6899 .pix_fmts= (enum PixelFormat[]){PIX_FMT_YUV420P, -1}, |
2111 | 6900 .capabilities= CODEC_CAP_DELAY, |
0 | 6901 }; |
6902 | |
307 | 6903 AVCodec msmpeg4v1_encoder = { |
6904 "msmpeg4v1", | |
0 | 6905 CODEC_TYPE_VIDEO, |
307 | 6906 CODEC_ID_MSMPEG4V1, |
0 | 6907 sizeof(MpegEncContext), |
6908 MPV_encode_init, | |
6909 MPV_encode_picture, | |
6910 MPV_encode_end, | |
2524 | 6911 .pix_fmts= (enum PixelFormat[]){PIX_FMT_YUV420P, -1}, |
0 | 6912 }; |
307 | 6913 |
6914 AVCodec msmpeg4v2_encoder = { | |
6915 "msmpeg4v2", | |
6916 CODEC_TYPE_VIDEO, | |
6917 CODEC_ID_MSMPEG4V2, | |
6918 sizeof(MpegEncContext), | |
6919 MPV_encode_init, | |
6920 MPV_encode_picture, | |
6921 MPV_encode_end, | |
2524 | 6922 .pix_fmts= (enum PixelFormat[]){PIX_FMT_YUV420P, -1}, |
307 | 6923 }; |
6924 | |
6925 AVCodec msmpeg4v3_encoder = { | |
6926 "msmpeg4", | |
6927 CODEC_TYPE_VIDEO, | |
6928 CODEC_ID_MSMPEG4V3, | |
6929 sizeof(MpegEncContext), | |
6930 MPV_encode_init, | |
6931 MPV_encode_picture, | |
6932 MPV_encode_end, | |
2524 | 6933 .pix_fmts= (enum PixelFormat[]){PIX_FMT_YUV420P, -1}, |
307 | 6934 }; |
499 | 6935 |
6936 AVCodec wmv1_encoder = { | |
6937 "wmv1", | |
6938 CODEC_TYPE_VIDEO, | |
6939 CODEC_ID_WMV1, | |
6940 sizeof(MpegEncContext), | |
6941 MPV_encode_init, | |
6942 MPV_encode_picture, | |
6943 MPV_encode_end, | |
2524 | 6944 .pix_fmts= (enum PixelFormat[]){PIX_FMT_YUV420P, -1}, |
499 | 6945 }; |
6946 | |
1042 | 6947 AVCodec mjpeg_encoder = { |
6948 "mjpeg", | |
6949 CODEC_TYPE_VIDEO, | |
6950 CODEC_ID_MJPEG, | |
6951 sizeof(MpegEncContext), | |
6952 MPV_encode_init, | |
6953 MPV_encode_picture, | |
6954 MPV_encode_end, | |
3929 | 6955 .pix_fmts= (enum PixelFormat[]){PIX_FMT_YUVJ420P, PIX_FMT_YUVJ422P, -1}, |
1042 | 6956 }; |
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 |