Mercurial > libavcodec.hg
annotate mpegvideo.c @ 5169:3fd46e281bd8 libavcodec
add a comment to indicate which #endif belong to which #define
author | gpoirier |
---|---|
date | Sun, 17 Jun 2007 18:59:28 +0000 |
parents | 9d4ca30481e0 |
children | b3fd384aaa28 |
rev | line source |
---|---|
0 | 1 /* |
2 * The simplest mpeg encoder (well, it was the simplest!) | |
429 | 3 * Copyright (c) 2000,2001 Fabrice Bellard. |
1739
07a484280a82
copyright year update of the files i touched and remembered, things look annoyingly unmaintained otherwise
michael
parents:
1729
diff
changeset
|
4 * Copyright (c) 2002-2004 Michael Niedermayer <michaelni@gmx.at> |
0 | 5 * |
3947
c8c591fe26f8
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
3939
diff
changeset
|
6 * This file is part of FFmpeg. |
c8c591fe26f8
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
3939
diff
changeset
|
7 * |
c8c591fe26f8
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
3939
diff
changeset
|
8 * FFmpeg is free software; you can redistribute it and/or |
429 | 9 * modify it under the terms of the GNU Lesser General Public |
10 * License as published by the Free Software Foundation; either | |
3947
c8c591fe26f8
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
3939
diff
changeset
|
11 * version 2.1 of the License, or (at your option) any later version. |
0 | 12 * |
3947
c8c591fe26f8
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
3939
diff
changeset
|
13 * FFmpeg is distributed in the hope that it will be useful, |
0 | 14 * but WITHOUT ANY WARRANTY; without even the implied warranty of |
429 | 15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
16 * Lesser General Public License for more details. | |
0 | 17 * |
429 | 18 * You should have received a copy of the GNU Lesser General Public |
3947
c8c591fe26f8
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
3939
diff
changeset
|
19 * License along with FFmpeg; if not, write to the Free Software |
3036
0b546eab515d
Update licensing information: The FSF changed postal address.
diego
parents:
3011
diff
changeset
|
20 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA |
295 | 21 * |
325 | 22 * 4MV & hq & b-frame encoding stuff by Michael Niedermayer <michaelni@gmx.at> |
0 | 23 */ |
2967 | 24 |
1106 | 25 /** |
26 * @file mpegvideo.c | |
27 * The simplest mpeg encoder (well, it was the simplest!). | |
2967 | 28 */ |
29 | |
0 | 30 #include "avcodec.h" |
31 #include "dsputil.h" | |
32 #include "mpegvideo.h" | |
5028 | 33 #include "mjpegenc.h" |
4967
6d45158e0249
disable reference to msmpeg4 and wmv2 code when those codecs are not compiled in
aurel
parents:
4668
diff
changeset
|
34 #include "msmpeg4.h" |
1557 | 35 #include "faandct.h" |
2024
f65d87bfdd5a
some of the warning fixes by (Michael Roitzsch <mroi at users dot sourceforge dot net>)
michael
parents:
2015
diff
changeset
|
36 #include <limits.h> |
0 | 37 |
1422
efeed6e29f9b
oooooops, having 2 Eterms open and doing cvs diff in one and cvs commit in the other sucks, especially if they are in different directories (MPlayer/main/libavcodec vs. ffmpeg/libavcodec)
michaelni
parents:
1421
diff
changeset
|
38 //#undef NDEBUG |
efeed6e29f9b
oooooops, having 2 Eterms open and doing cvs diff in one and cvs commit in the other sucks, especially if they are in different directories (MPlayer/main/libavcodec vs. ffmpeg/libavcodec)
michaelni
parents:
1421
diff
changeset
|
39 //#include <assert.h> |
706
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
40 |
1070
6da5ae9ee199
more #ifdef CONFIG_ENCODERS patch by (Wolfgang Hesseler <qv at multimediaware dot com>) with modifications by me (s/WOLFGANG/CONFIG_ENCODERS/ and some other fixes)
michaelni
parents:
1064
diff
changeset
|
41 #ifdef CONFIG_ENCODERS |
3766 | 42 static int encode_picture(MpegEncContext *s, int picture_number); |
1070
6da5ae9ee199
more #ifdef CONFIG_ENCODERS patch by (Wolfgang Hesseler <qv at multimediaware dot com>) with modifications by me (s/WOLFGANG/CONFIG_ENCODERS/ and some other fixes)
michaelni
parents:
1064
diff
changeset
|
43 #endif //CONFIG_ENCODERS |
2967 | 44 static void dct_unquantize_mpeg1_intra_c(MpegEncContext *s, |
1689 | 45 DCTELEM *block, int n, int qscale); |
2967 | 46 static void dct_unquantize_mpeg1_inter_c(MpegEncContext *s, |
1689 | 47 DCTELEM *block, int n, int qscale); |
48 static void dct_unquantize_mpeg2_intra_c(MpegEncContext *s, | |
13
174ef88f619a
use block[] in structure to have it aligned on 8 bytes for mmx optimizations - dct_unquantize is always a function pointer - added specialized dct_unquantize_h263
glantau
parents:
8
diff
changeset
|
49 DCTELEM *block, int n, int qscale); |
3281
7fac25904a8b
missmatch control for mpeg2 intra dequantization if bitexact=1
michael
parents:
3268
diff
changeset
|
50 static void dct_unquantize_mpeg2_intra_bitexact(MpegEncContext *s, |
7fac25904a8b
missmatch control for mpeg2 intra dequantization if bitexact=1
michael
parents:
3268
diff
changeset
|
51 DCTELEM *block, int n, int qscale); |
1689 | 52 static void dct_unquantize_mpeg2_inter_c(MpegEncContext *s, |
325 | 53 DCTELEM *block, int n, int qscale); |
2967 | 54 static void dct_unquantize_h263_intra_c(MpegEncContext *s, |
1689 | 55 DCTELEM *block, int n, int qscale); |
2967 | 56 static void dct_unquantize_h263_inter_c(MpegEncContext *s, |
13
174ef88f619a
use block[] in structure to have it aligned on 8 bytes for mmx optimizations - dct_unquantize is always a function pointer - added specialized dct_unquantize_h263
glantau
parents:
8
diff
changeset
|
57 DCTELEM *block, int n, int qscale); |
1064 | 58 static void draw_edges_c(uint8_t *buf, int wrap, int width, int height, int w); |
1070
6da5ae9ee199
more #ifdef CONFIG_ENCODERS patch by (Wolfgang Hesseler <qv at multimediaware dot com>) with modifications by me (s/WOLFGANG/CONFIG_ENCODERS/ and some other fixes)
michaelni
parents:
1064
diff
changeset
|
59 #ifdef CONFIG_ENCODERS |
344 | 60 static int dct_quantize_c(MpegEncContext *s, DCTELEM *block, int n, int qscale, int *overflow); |
945 | 61 static int dct_quantize_trellis_c(MpegEncContext *s, DCTELEM *block, int n, int qscale, int *overflow); |
1777 | 62 static int dct_quantize_refine(MpegEncContext *s, DCTELEM *block, int16_t *weight, DCTELEM *orig, int n, int qscale); |
1389 | 63 static int sse_mb(MpegEncContext *s); |
1719 | 64 static void denoise_dct_c(MpegEncContext *s, DCTELEM *block); |
1070
6da5ae9ee199
more #ifdef CONFIG_ENCODERS patch by (Wolfgang Hesseler <qv at multimediaware dot com>) with modifications by me (s/WOLFGANG/CONFIG_ENCODERS/ and some other fixes)
michaelni
parents:
1064
diff
changeset
|
65 #endif //CONFIG_ENCODERS |
206 | 66 |
1381 | 67 #ifdef HAVE_XVMC |
68 extern int XVMC_field_start(MpegEncContext*s, AVCodecContext *avctx); | |
69 extern void XVMC_field_end(MpegEncContext *s); | |
1580
628bf341e099
XvMC speedup by removing one memcpy and doing MB packing
iive
parents:
1579
diff
changeset
|
70 extern void XVMC_decode_mb(MpegEncContext *s); |
1381 | 71 #endif |
72 | |
1064 | 73 void (*draw_edges)(uint8_t *buf, int wrap, int width, int height, int w)= draw_edges_c; |
206 | 74 |
0 | 75 |
76 /* enable all paranoid tests for rounding, overflows, etc... */ | |
77 //#define PARANOID | |
78 | |
79 //#define DEBUG | |
80 | |
321 | 81 |
0 | 82 /* for jpeg fast DCT */ |
83 #define CONST_BITS 14 | |
84 | |
853
eacc2dd8fd9d
* using DSPContext - so each codec could use its local (sub)set of CPU extension
kabi
parents:
847
diff
changeset
|
85 static const uint16_t aanscales[64] = { |
0 | 86 /* precomputed values scaled up by 14 bits */ |
87 16384, 22725, 21407, 19266, 16384, 12873, 8867, 4520, | |
88 22725, 31521, 29692, 26722, 22725, 17855, 12299, 6270, | |
89 21407, 29692, 27969, 25172, 21407, 16819, 11585, 5906, | |
90 19266, 26722, 25172, 22654, 19266, 15137, 10426, 5315, | |
91 16384, 22725, 21407, 19266, 16384, 12873, 8867, 4520, | |
92 12873, 17855, 16819, 15137, 12873, 10114, 6967, 3552, | |
936 | 93 8867 , 12299, 11585, 10426, 8867, 6967, 4799, 2446, |
94 4520 , 6270, 5906, 5315, 4520, 3552, 2446, 1247 | |
0 | 95 }; |
96 | |
853
eacc2dd8fd9d
* using DSPContext - so each codec could use its local (sub)set of CPU extension
kabi
parents:
847
diff
changeset
|
97 static const uint8_t h263_chroma_roundtab[16] = { |
1013 | 98 // 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
0 | 99 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, |
100 }; | |
101 | |
1644 | 102 static const uint8_t ff_default_chroma_qscale_table[32]={ |
103 // 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 | |
104 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31 | |
105 }; | |
106 | |
1070
6da5ae9ee199
more #ifdef CONFIG_ENCODERS patch by (Wolfgang Hesseler <qv at multimediaware dot com>) with modifications by me (s/WOLFGANG/CONFIG_ENCODERS/ and some other fixes)
michaelni
parents:
1064
diff
changeset
|
107 #ifdef CONFIG_ENCODERS |
4655 | 108 static uint8_t default_mv_penalty[MAX_FCODE+1][MAX_MV*2+1]; |
1064 | 109 static uint8_t default_fcode_tab[MAX_MV*2+1]; |
277
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
271
diff
changeset
|
110 |
998 | 111 enum PixelFormat ff_yuv420p_list[2]= {PIX_FMT_YUV420P, -1}; |
112 | |
1579
039cb2296de2
make convert_matrix() independant of MpegEncContext
michael
parents:
1573
diff
changeset
|
113 static void convert_matrix(DSPContext *dsp, int (*qmat)[64], uint16_t (*qmat16)[2][64], |
2385
4605a8b188c3
warn the user if the quantization code could overflow with the selected custom matrix and qp limits
michael
parents:
2382
diff
changeset
|
114 const uint16_t *quant_matrix, int bias, int qmin, int qmax, int intra) |
0 | 115 { |
344 | 116 int qscale; |
2385
4605a8b188c3
warn the user if the quantization code could overflow with the selected custom matrix and qp limits
michael
parents:
2382
diff
changeset
|
117 int shift=0; |
0 | 118 |
709
afeff6ccb7f5
convert only needed matrixes in convert_matrix() (mjpeg calls it for every frame)
michaelni
parents:
706
diff
changeset
|
119 for(qscale=qmin; qscale<=qmax; qscale++){ |
344 | 120 int i; |
2967 | 121 if (dsp->fdct == ff_jpeg_fdct_islow |
1562
bf452704100f
optionally merge postscale into quantization table for the float aan dct
michael
parents:
1557
diff
changeset
|
122 #ifdef FAAN_POSTSCALE |
1579
039cb2296de2
make convert_matrix() independant of MpegEncContext
michael
parents:
1573
diff
changeset
|
123 || dsp->fdct == ff_faandct |
1562
bf452704100f
optionally merge postscale into quantization table for the float aan dct
michael
parents:
1557
diff
changeset
|
124 #endif |
bf452704100f
optionally merge postscale into quantization table for the float aan dct
michael
parents:
1557
diff
changeset
|
125 ) { |
625
bb6a69f9d409
slow but accurate integer dct from IJG (should be ok with the LGPL as the old DCT is the fast integer DCT from IJG)
michaelni
parents:
619
diff
changeset
|
126 for(i=0;i<64;i++) { |
1579
039cb2296de2
make convert_matrix() independant of MpegEncContext
michael
parents:
1573
diff
changeset
|
127 const int j= dsp->idct_permutation[i]; |
625
bb6a69f9d409
slow but accurate integer dct from IJG (should be ok with the LGPL as the old DCT is the fast integer DCT from IJG)
michaelni
parents:
619
diff
changeset
|
128 /* 16 <= qscale * quant_matrix[i] <= 7905 */ |
bb6a69f9d409
slow but accurate integer dct from IJG (should be ok with the LGPL as the old DCT is the fast integer DCT from IJG)
michaelni
parents:
619
diff
changeset
|
129 /* 19952 <= aanscales[i] * qscale * quant_matrix[i] <= 249205026 */ |
bb6a69f9d409
slow but accurate integer dct from IJG (should be ok with the LGPL as the old DCT is the fast integer DCT from IJG)
michaelni
parents:
619
diff
changeset
|
130 /* (1<<36)/19952 >= (1<<36)/(aanscales[i] * qscale * quant_matrix[i]) >= (1<<36)/249205026 */ |
bb6a69f9d409
slow but accurate integer dct from IJG (should be ok with the LGPL as the old DCT is the fast integer DCT from IJG)
michaelni
parents:
619
diff
changeset
|
131 /* 3444240 >= (1<<36)/(aanscales[i] * qscale * quant_matrix[i]) >= 275 */ |
2967 | 132 |
4274 | 133 qmat[qscale][i] = (int)((UINT64_C(1) << QMAT_SHIFT) / |
625
bb6a69f9d409
slow but accurate integer dct from IJG (should be ok with the LGPL as the old DCT is the fast integer DCT from IJG)
michaelni
parents:
619
diff
changeset
|
134 (qscale * quant_matrix[j])); |
bb6a69f9d409
slow but accurate integer dct from IJG (should be ok with the LGPL as the old DCT is the fast integer DCT from IJG)
michaelni
parents:
619
diff
changeset
|
135 } |
1579
039cb2296de2
make convert_matrix() independant of MpegEncContext
michael
parents:
1573
diff
changeset
|
136 } else if (dsp->fdct == fdct_ifast |
1562
bf452704100f
optionally merge postscale into quantization table for the float aan dct
michael
parents:
1557
diff
changeset
|
137 #ifndef FAAN_POSTSCALE |
1579
039cb2296de2
make convert_matrix() independant of MpegEncContext
michael
parents:
1573
diff
changeset
|
138 || dsp->fdct == ff_faandct |
1562
bf452704100f
optionally merge postscale into quantization table for the float aan dct
michael
parents:
1557
diff
changeset
|
139 #endif |
bf452704100f
optionally merge postscale into quantization table for the float aan dct
michael
parents:
1557
diff
changeset
|
140 ) { |
344 | 141 for(i=0;i<64;i++) { |
1579
039cb2296de2
make convert_matrix() independant of MpegEncContext
michael
parents:
1573
diff
changeset
|
142 const int j= dsp->idct_permutation[i]; |
344 | 143 /* 16 <= qscale * quant_matrix[i] <= 7905 */ |
144 /* 19952 <= aanscales[i] * qscale * quant_matrix[i] <= 249205026 */ | |
145 /* (1<<36)/19952 >= (1<<36)/(aanscales[i] * qscale * quant_matrix[i]) >= (1<<36)/249205026 */ | |
146 /* 3444240 >= (1<<36)/(aanscales[i] * qscale * quant_matrix[i]) >= 275 */ | |
2967 | 147 |
4274 | 148 qmat[qscale][i] = (int)((UINT64_C(1) << (QMAT_SHIFT + 14)) / |
344 | 149 (aanscales[i] * qscale * quant_matrix[j])); |
150 } | |
151 } else { | |
152 for(i=0;i<64;i++) { | |
1579
039cb2296de2
make convert_matrix() independant of MpegEncContext
michael
parents:
1573
diff
changeset
|
153 const int j= dsp->idct_permutation[i]; |
344 | 154 /* We can safely suppose that 16 <= quant_matrix[i] <= 255 |
155 So 16 <= qscale * quant_matrix[i] <= 7905 | |
156 so (1<<19) / 16 >= (1<<19) / (qscale * quant_matrix[i]) >= (1<<19) / 7905 | |
157 so 32768 >= (1<<19) / (qscale * quant_matrix[i]) >= 67 | |
158 */ | |
4274 | 159 qmat[qscale][i] = (int)((UINT64_C(1) << QMAT_SHIFT) / (qscale * quant_matrix[j])); |
945 | 160 // qmat [qscale][i] = (1 << QMAT_SHIFT_MMX) / (qscale * quant_matrix[i]); |
1554
d736e24bf303
move mmx quantizer matrixes out of MpegEncContext (23k -> 7k) (no meassureable slowdown)
michael
parents:
1553
diff
changeset
|
161 qmat16[qscale][0][i] = (1 << QMAT_SHIFT_MMX) / (qscale * quant_matrix[j]); |
d736e24bf303
move mmx quantizer matrixes out of MpegEncContext (23k -> 7k) (no meassureable slowdown)
michael
parents:
1553
diff
changeset
|
162 |
d736e24bf303
move mmx quantizer matrixes out of MpegEncContext (23k -> 7k) (no meassureable slowdown)
michael
parents:
1553
diff
changeset
|
163 if(qmat16[qscale][0][i]==0 || qmat16[qscale][0][i]==128*256) qmat16[qscale][0][i]=128*256-1; |
d736e24bf303
move mmx quantizer matrixes out of MpegEncContext (23k -> 7k) (no meassureable slowdown)
michael
parents:
1553
diff
changeset
|
164 qmat16[qscale][1][i]= ROUNDED_DIV(bias<<(16-QUANT_BIAS_SHIFT), qmat16[qscale][0][i]); |
344 | 165 } |
0 | 166 } |
2967 | 167 |
2385
4605a8b188c3
warn the user if the quantization code could overflow with the selected custom matrix and qp limits
michael
parents:
2382
diff
changeset
|
168 for(i=intra; i<64; i++){ |
2390 | 169 int64_t max= 8191; |
170 if (dsp->fdct == fdct_ifast | |
171 #ifndef FAAN_POSTSCALE | |
172 || dsp->fdct == ff_faandct | |
173 #endif | |
174 ) { | |
175 max= (8191LL*aanscales[i]) >> 14; | |
176 } | |
2967 | 177 while(((max * qmat[qscale][i]) >> shift) > INT_MAX){ |
2385
4605a8b188c3
warn the user if the quantization code could overflow with the selected custom matrix and qp limits
michael
parents:
2382
diff
changeset
|
178 shift++; |
4605a8b188c3
warn the user if the quantization code could overflow with the selected custom matrix and qp limits
michael
parents:
2382
diff
changeset
|
179 } |
4605a8b188c3
warn the user if the quantization code could overflow with the selected custom matrix and qp limits
michael
parents:
2382
diff
changeset
|
180 } |
4605a8b188c3
warn the user if the quantization code could overflow with the selected custom matrix and qp limits
michael
parents:
2382
diff
changeset
|
181 } |
4605a8b188c3
warn the user if the quantization code could overflow with the selected custom matrix and qp limits
michael
parents:
2382
diff
changeset
|
182 if(shift){ |
4525 | 183 av_log(NULL, AV_LOG_INFO, "Warning, QMAT_SHIFT is larger than %d, overflows possible\n", QMAT_SHIFT - shift); |
0 | 184 } |
185 } | |
1505
010f76d07a27
use lagrange multipler instead of qp for ratecontrol, this may break some things, tell me ASAP if u notice anything broken
michaelni
parents:
1497
diff
changeset
|
186 |
010f76d07a27
use lagrange multipler instead of qp for ratecontrol, this may break some things, tell me ASAP if u notice anything broken
michaelni
parents:
1497
diff
changeset
|
187 static inline void update_qscale(MpegEncContext *s){ |
010f76d07a27
use lagrange multipler instead of qp for ratecontrol, this may break some things, tell me ASAP if u notice anything broken
michaelni
parents:
1497
diff
changeset
|
188 s->qscale= (s->lambda*139 + FF_LAMBDA_SCALE*64) >> (FF_LAMBDA_SHIFT + 7); |
4594 | 189 s->qscale= av_clip(s->qscale, s->avctx->qmin, s->avctx->qmax); |
2967 | 190 |
1505
010f76d07a27
use lagrange multipler instead of qp for ratecontrol, this may break some things, tell me ASAP if u notice anything broken
michaelni
parents:
1497
diff
changeset
|
191 s->lambda2= (s->lambda*s->lambda + FF_LAMBDA_SCALE/2) >> FF_LAMBDA_SHIFT; |
010f76d07a27
use lagrange multipler instead of qp for ratecontrol, this may break some things, tell me ASAP if u notice anything broken
michaelni
parents:
1497
diff
changeset
|
192 } |
1070
6da5ae9ee199
more #ifdef CONFIG_ENCODERS patch by (Wolfgang Hesseler <qv at multimediaware dot com>) with modifications by me (s/WOLFGANG/CONFIG_ENCODERS/ and some other fixes)
michaelni
parents:
1064
diff
changeset
|
193 #endif //CONFIG_ENCODERS |
6da5ae9ee199
more #ifdef CONFIG_ENCODERS patch by (Wolfgang Hesseler <qv at multimediaware dot com>) with modifications by me (s/WOLFGANG/CONFIG_ENCODERS/ and some other fixes)
michaelni
parents:
1064
diff
changeset
|
194 |
1273 | 195 void ff_init_scantable(uint8_t *permutation, ScanTable *st, const uint8_t *src_scantable){ |
706
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
196 int i; |
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
197 int end; |
2967 | 198 |
764 | 199 st->scantable= src_scantable; |
706
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
200 |
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
201 for(i=0; i<64; i++){ |
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
202 int j; |
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
203 j = src_scantable[i]; |
1273 | 204 st->permutated[i] = permutation[j]; |
828
ace3ccd18dd2
Altivec Patch (Mark III) by (Dieter Shirley <dieters at schemasoft dot com>)
michaelni
parents:
815
diff
changeset
|
205 #ifdef ARCH_POWERPC |
ace3ccd18dd2
Altivec Patch (Mark III) by (Dieter Shirley <dieters at schemasoft dot com>)
michaelni
parents:
815
diff
changeset
|
206 st->inverse[j] = i; |
ace3ccd18dd2
Altivec Patch (Mark III) by (Dieter Shirley <dieters at schemasoft dot com>)
michaelni
parents:
815
diff
changeset
|
207 #endif |
706
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
208 } |
2967 | 209 |
706
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
210 end=-1; |
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
211 for(i=0; i<64; i++){ |
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
212 int j; |
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
213 j = st->permutated[i]; |
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
214 if(j>end) end=j; |
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
215 st->raster_end[i]= end; |
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
216 } |
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
217 } |
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
218 |
1530
3b31998fe22f
disable encoders where appropriate (patch courtesy of BERO
melanson
parents:
1523
diff
changeset
|
219 #ifdef CONFIG_ENCODERS |
3776 | 220 void ff_write_quant_matrix(PutBitContext *pb, uint16_t *matrix){ |
1411 | 221 int i; |
222 | |
223 if(matrix){ | |
224 put_bits(pb, 1, 1); | |
225 for(i=0;i<64;i++) { | |
226 put_bits(pb, 8, matrix[ ff_zigzag_direct[i] ]); | |
227 } | |
228 }else | |
229 put_bits(pb, 1, 0); | |
230 } | |
1530
3b31998fe22f
disable encoders where appropriate (patch courtesy of BERO
melanson
parents:
1523
diff
changeset
|
231 #endif //CONFIG_ENCODERS |
1411 | 232 |
3086 | 233 const uint8_t *ff_find_start_code(const uint8_t * restrict p, const uint8_t *end, uint32_t * restrict state){ |
234 int i; | |
235 | |
3092 | 236 assert(p<=end); |
237 if(p>=end) | |
238 return end; | |
239 | |
3086 | 240 for(i=0; i<3; i++){ |
241 uint32_t tmp= *state << 8; | |
242 *state= tmp + *(p++); | |
243 if(tmp == 0x100 || p==end) | |
244 return p; | |
245 } | |
246 | |
247 while(p<end){ | |
3087 | 248 if (p[-1] > 1 ) p+= 3; |
249 else if(p[-2] ) p+= 2; | |
250 else if(p[-3]|(p[-1]-1)) p++; | |
3086 | 251 else{ |
252 p++; | |
253 break; | |
254 } | |
255 } | |
256 | |
3087 | 257 p= FFMIN(p, end)-4; |
3086 | 258 *state= be2me_32(unaligned32(p)); |
259 | |
260 return p+4; | |
261 } | |
262 | |
726
a91203b34e71
moved dct init out from mpv_common_init to dct_common_init (for less-uglier way for dv)
al3x
parents:
721
diff
changeset
|
263 /* init common dct for both encoder and decoder */ |
a91203b34e71
moved dct init out from mpv_common_init to dct_common_init (for less-uglier way for dv)
al3x
parents:
721
diff
changeset
|
264 int DCT_common_init(MpegEncContext *s) |
0 | 265 { |
1689 | 266 s->dct_unquantize_h263_intra = dct_unquantize_h263_intra_c; |
267 s->dct_unquantize_h263_inter = dct_unquantize_h263_inter_c; | |
268 s->dct_unquantize_mpeg1_intra = dct_unquantize_mpeg1_intra_c; | |
269 s->dct_unquantize_mpeg1_inter = dct_unquantize_mpeg1_inter_c; | |
270 s->dct_unquantize_mpeg2_intra = dct_unquantize_mpeg2_intra_c; | |
3281
7fac25904a8b
missmatch control for mpeg2 intra dequantization if bitexact=1
michael
parents:
3268
diff
changeset
|
271 if(s->flags & CODEC_FLAG_BITEXACT) |
7fac25904a8b
missmatch control for mpeg2 intra dequantization if bitexact=1
michael
parents:
3268
diff
changeset
|
272 s->dct_unquantize_mpeg2_intra = dct_unquantize_mpeg2_intra_bitexact; |
1689 | 273 s->dct_unquantize_mpeg2_inter = dct_unquantize_mpeg2_inter_c; |
1092 | 274 |
1070
6da5ae9ee199
more #ifdef CONFIG_ENCODERS patch by (Wolfgang Hesseler <qv at multimediaware dot com>) with modifications by me (s/WOLFGANG/CONFIG_ENCODERS/ and some other fixes)
michaelni
parents:
1064
diff
changeset
|
275 #ifdef CONFIG_ENCODERS |
625
bb6a69f9d409
slow but accurate integer dct from IJG (should be ok with the LGPL as the old DCT is the fast integer DCT from IJG)
michaelni
parents:
619
diff
changeset
|
276 s->dct_quantize= dct_quantize_c; |
1719 | 277 s->denoise_dct= denoise_dct_c; |
2616
ba6530ae8e34
remove superfluous CONFIG_ENCODERS (entire function is already wrapped)
melanson
parents:
2584
diff
changeset
|
278 #endif //CONFIG_ENCODERS |
2967 | 279 |
5140 | 280 #if defined(HAVE_MMX) |
1422
efeed6e29f9b
oooooops, having 2 Eterms open and doing cvs diff in one and cvs commit in the other sucks, especially if they are in different directories (MPlayer/main/libavcodec vs. ffmpeg/libavcodec)
michaelni
parents:
1421
diff
changeset
|
281 MPV_common_init_mmx(s); |
5140 | 282 #elif defined(ARCH_ALPHA) |
514
c9f724e3a797
Update and activate dct_unquantize_h263_mvi. Thanks to M«©ns Rullg«©rd
mellum
parents:
506
diff
changeset
|
283 MPV_common_init_axp(s); |
5140 | 284 #elif defined(HAVE_MLIB) |
628
f596db4aa871
sun solaris compilation bugfix, patch by (Martin Olschewski <olschewski at zpr dot uni-koeln dot de>)
michaelni
parents:
625
diff
changeset
|
285 MPV_common_init_mlib(s); |
5140 | 286 #elif defined(HAVE_MMI) |
721
71f669e9f633
ps2 optimizations update patch by (Leon van Stuivenberg <leonvs at iae dot nl>)
michaelni
parents:
717
diff
changeset
|
287 MPV_common_init_mmi(s); |
5140 | 288 #elif defined(ARCH_ARMV4L) |
874 | 289 MPV_common_init_armv4l(s); |
5140 | 290 #elif defined(ARCH_POWERPC) |
828
ace3ccd18dd2
Altivec Patch (Mark III) by (Dieter Shirley <dieters at schemasoft dot com>)
michaelni
parents:
815
diff
changeset
|
291 MPV_common_init_ppc(s); |
5140 | 292 #elif defined(ARCH_BFIN) |
5132
a3b82ca01e68
integrating MPV_common_init_bfin into the build system and mpegvideo.c
mhoffman
parents:
5129
diff
changeset
|
293 MPV_common_init_bfin(s); |
a3b82ca01e68
integrating MPV_common_init_bfin into the build system and mpegvideo.c
mhoffman
parents:
5129
diff
changeset
|
294 #endif |
730 | 295 |
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
|
296 #ifdef CONFIG_ENCODERS |
1007 | 297 s->fast_dct_quantize= s->dct_quantize; |
298 | |
945 | 299 if(s->flags&CODEC_FLAG_TRELLIS_QUANT){ |
300 s->dct_quantize= dct_quantize_trellis_c; //move before MPV_common_init_* | |
301 } | |
302 | |
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
|
303 #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
|
304 |
706
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
305 /* load & permutate scantables |
2967 | 306 note: only wmv uses different ones |
706
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
307 */ |
1708 | 308 if(s->alternate_scan){ |
309 ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable , ff_alternate_vertical_scan); | |
310 ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable , ff_alternate_vertical_scan); | |
311 }else{ | |
312 ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable , ff_zigzag_direct); | |
313 ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable , ff_zigzag_direct); | |
314 } | |
1273 | 315 ff_init_scantable(s->dsp.idct_permutation, &s->intra_h_scantable, ff_alternate_horizontal_scan); |
316 ff_init_scantable(s->dsp.idct_permutation, &s->intra_v_scantable, ff_alternate_vertical_scan); | |
591 | 317 |
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
|
318 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
|
319 } |
a91203b34e71
moved dct init out from mpv_common_init to dct_common_init (for less-uglier way for dv)
al3x
parents:
721
diff
changeset
|
320 |
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
|
321 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
|
322 *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
|
323 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
|
324 } |
14d01ccc0081
picture buffer cleanup, this fixes a assertion failure (if assertion checking was manualy enabled for utils.c) and a memleak at least
michael
parents:
1530
diff
changeset
|
325 |
3777 | 326 #ifdef CONFIG_ENCODERS |
1938
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1918
diff
changeset
|
327 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
|
328 int i; |
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1918
diff
changeset
|
329 |
1702 | 330 dst->pict_type = src->pict_type; |
331 dst->quality = src->quality; | |
332 dst->coded_picture_number = src->coded_picture_number; | |
333 dst->display_picture_number = src->display_picture_number; | |
334 // dst->reference = src->reference; | |
335 dst->pts = src->pts; | |
336 dst->interlaced_frame = src->interlaced_frame; | |
337 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
|
338 |
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
|
339 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
|
340 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
|
341 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
|
342 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
|
343 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
|
344 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
|
345 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
|
346 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
|
347 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
|
348 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
|
349 |
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 memcpy(dst->mb_type, src->mb_type, s->mb_stride * s->mb_height * sizeof(dst->mb_type[0])); |
2967 | 351 |
1945
32f68745c431
passing AVFrame instead of AVPicture around in ffmpeg, that way stuff like motion vectors can be passed from the decoder to the encoder
michael
parents:
1944
diff
changeset
|
352 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
|
353 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
|
354 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
|
355 |
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
|
356 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
|
357 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
|
358 } |
32f68745c431
passing AVFrame instead of AVPicture around in ffmpeg, that way stuff like motion vectors can be passed from the decoder to the encoder
michael
parents:
1944
diff
changeset
|
359 if(src->ref_index[i] && src->ref_index[i] != dst->ref_index[i]){ |
1948 | 360 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
|
361 } |
1938
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1918
diff
changeset
|
362 } |
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1918
diff
changeset
|
363 } |
1702 | 364 } |
3777 | 365 #endif |
1702 | 366 |
903 | 367 /** |
924 | 368 * allocates a Picture |
369 * The pixels are allocated/set by calling get_buffer() if shared=0 | |
903 | 370 */ |
924 | 371 static int alloc_picture(MpegEncContext *s, Picture *pic, int shared){ |
5127 | 372 const int big_mb_num= s->mb_stride*(s->mb_height+1) + 1; //the +1 is needed so memset(,,stride*height) does not sig11 |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1173
diff
changeset
|
373 const int mb_array_size= s->mb_stride*s->mb_height; |
1655 | 374 const int b8_array_size= s->b8_stride*s->mb_height*2; |
375 const int b4_array_size= s->b4_stride*s->mb_height*4; | |
1168 | 376 int i; |
2967 | 377 |
924 | 378 if(shared){ |
379 assert(pic->data[0]); | |
380 assert(pic->type == 0 || pic->type == FF_BUFFER_TYPE_SHARED); | |
381 pic->type= FF_BUFFER_TYPE_SHARED; | |
382 }else{ | |
383 int r; | |
2967 | 384 |
924 | 385 assert(!pic->data[0]); |
2967 | 386 |
925 | 387 r= s->avctx->get_buffer(s->avctx, (AVFrame*)pic); |
2967 | 388 |
924 | 389 if(r<0 || !pic->age || !pic->type || !pic->data[0]){ |
2979 | 390 av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed (%d %d %d %p)\n", r, pic->age, pic->type, pic->data[0]); |
924 | 391 return -1; |
392 } | |
393 | |
394 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
|
395 av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed (stride changed)\n"); |
924 | 396 return -1; |
397 } | |
398 | |
399 if(pic->linesize[1] != pic->linesize[2]){ | |
2764 | 400 av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed (uv stride mismatch)\n"); |
924 | 401 return -1; |
402 } | |
403 | |
404 s->linesize = pic->linesize[0]; | |
405 s->uvlinesize= pic->linesize[1]; | |
903 | 406 } |
2967 | 407 |
924 | 408 if(pic->qscale_table==NULL){ |
2967 | 409 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
|
410 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
|
411 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
|
412 CHECKED_ALLOCZ(pic->mb_mean , mb_array_size * sizeof(int8_t)) |
924 | 413 } |
414 | |
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->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
|
416 CHECKED_ALLOCZ(pic->qscale_table , mb_array_size * sizeof(uint8_t)) |
1742 | 417 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
|
418 pic->mb_type= pic->mb_type_base + s->mb_stride+1; |
1168 | 419 if(s->out_format == FMT_H264){ |
420 for(i=0; i<2; i++){ | |
2570 | 421 CHECKED_ALLOCZ(pic->motion_val_base[i], 2 * (b4_array_size+4) * sizeof(int16_t)) |
422 pic->motion_val[i]= pic->motion_val_base[i]+4; | |
1948 | 423 CHECKED_ALLOCZ(pic->ref_index[i], b8_array_size * sizeof(uint8_t)) |
1655 | 424 } |
1669 | 425 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
|
426 }else if(s->out_format == FMT_H263 || s->encoding || (s->avctx->debug&FF_DEBUG_MV) || (s->avctx->debug_mv)){ |
1655 | 427 for(i=0; i<2; i++){ |
2570 | 428 CHECKED_ALLOCZ(pic->motion_val_base[i], 2 * (b8_array_size+4) * sizeof(int16_t)) |
429 pic->motion_val[i]= pic->motion_val_base[i]+4; | |
1948 | 430 CHECKED_ALLOCZ(pic->ref_index[i], b8_array_size * sizeof(uint8_t)) |
1168 | 431 } |
1669 | 432 pic->motion_subsample_log2= 3; |
1168 | 433 } |
1833
ba27ce284d07
export DCT coefficients patch by (Wolfgang Hesseler <wolfgang.hesseler at imk dot fraunhofer dot de>)
michael
parents:
1831
diff
changeset
|
434 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
|
435 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
|
436 } |
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
|
437 pic->qstride= s->mb_stride; |
1546 | 438 CHECKED_ALLOCZ(pic->pan_scan , 1 * sizeof(AVPanScan)) |
924 | 439 } |
1168 | 440 |
5129 | 441 /* It might be nicer if the application would keep track of these |
442 * but it would require an API change. */ | |
1021
2d7c9f5738de
trying to fix mb skip bug in mpeg1/2 if slices are not used
michaelni
parents:
1014
diff
changeset
|
443 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
|
444 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
|
445 if(pic->age < PREV_PICT_TYPES_BUFFER_SIZE && s->prev_pict_types[pic->age] == B_TYPE) |
5129 | 446 pic->age= INT_MAX; // Skipped MBs in B-frames are quite rare in MPEG-1/2 and it is a bit tricky to skip them anyway. |
2967 | 447 |
903 | 448 return 0; |
449 fail: //for the CHECKED_ALLOCZ macro | |
450 return -1; | |
451 } | |
452 | |
924 | 453 /** |
454 * deallocates a picture | |
455 */ | |
903 | 456 static void free_picture(MpegEncContext *s, Picture *pic){ |
457 int i; | |
924 | 458 |
459 if(pic->data[0] && pic->type!=FF_BUFFER_TYPE_SHARED){ | |
925 | 460 s->avctx->release_buffer(s->avctx, (AVFrame*)pic); |
924 | 461 } |
462 | |
903 | 463 av_freep(&pic->mb_var); |
464 av_freep(&pic->mc_mb_var); | |
465 av_freep(&pic->mb_mean); | |
466 av_freep(&pic->mbskip_table); | |
467 av_freep(&pic->qscale_table); | |
1168 | 468 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
|
469 av_freep(&pic->dct_coeff); |
1546 | 470 av_freep(&pic->pan_scan); |
1168 | 471 pic->mb_type= NULL; |
472 for(i=0; i<2; i++){ | |
1655 | 473 av_freep(&pic->motion_val_base[i]); |
1168 | 474 av_freep(&pic->ref_index[i]); |
475 } | |
2967 | 476 |
1214 | 477 if(pic->type == FF_BUFFER_TYPE_SHARED){ |
924 | 478 for(i=0; i<4; i++){ |
479 pic->base[i]= | |
480 pic->data[i]= NULL; | |
481 } | |
2967 | 482 pic->type= 0; |
903 | 483 } |
484 } | |
485 | |
1799 | 486 static int init_duplicate_context(MpegEncContext *s, MpegEncContext *base){ |
487 int i; | |
488 | |
2967 | 489 // edge emu needs blocksize + filter length - 1 (=17x17 for halfpel / 21x21 for h264) |
3316 | 490 CHECKED_ALLOCZ(s->allocated_edge_emu_buffer, (s->width+64)*2*21*2); //(width + edge + align)*interlaced*MBsize*tolerance |
491 s->edge_emu_buffer= s->allocated_edge_emu_buffer + (s->width+64)*2*21; | |
1799 | 492 |
5127 | 493 //FIXME should be linesize instead of s->width*2 but that is not known before get_buffer() |
2967 | 494 CHECKED_ALLOCZ(s->me.scratchpad, (s->width+64)*4*16*2*sizeof(uint8_t)) |
1799 | 495 s->rd_scratchpad= s->me.scratchpad; |
496 s->b_scratchpad= s->me.scratchpad; | |
497 s->obmc_scratchpad= s->me.scratchpad + 16; | |
498 if (s->encoding) { | |
499 CHECKED_ALLOCZ(s->me.map , ME_MAP_SIZE*sizeof(uint32_t)) | |
500 CHECKED_ALLOCZ(s->me.score_map, ME_MAP_SIZE*sizeof(uint32_t)) | |
501 if(s->avctx->noise_reduction){ | |
502 CHECKED_ALLOCZ(s->dct_error_sum, 2 * 64 * sizeof(int)) | |
503 } | |
2967 | 504 } |
1848
c72589baee53
initial chroma_format changes,xvmc tweaks and codec_cap
iive
parents:
1846
diff
changeset
|
505 CHECKED_ALLOCZ(s->blocks, 64*12*2 * sizeof(DCTELEM)) |
1799 | 506 s->block= s->blocks[0]; |
507 | |
508 for(i=0;i<12;i++){ | |
509 s->pblocks[i] = (short *)(&s->block[i]); | |
510 } | |
511 return 0; | |
512 fail: | |
513 return -1; //free() through MPV_common_end() | |
514 } | |
515 | |
516 static void free_duplicate_context(MpegEncContext *s){ | |
517 if(s==NULL) return; | |
518 | |
519 av_freep(&s->allocated_edge_emu_buffer); s->edge_emu_buffer= NULL; | |
520 av_freep(&s->me.scratchpad); | |
2967 | 521 s->rd_scratchpad= |
522 s->b_scratchpad= | |
1799 | 523 s->obmc_scratchpad= NULL; |
2967 | 524 |
1799 | 525 av_freep(&s->dct_error_sum); |
526 av_freep(&s->me.map); | |
527 av_freep(&s->me.score_map); | |
528 av_freep(&s->blocks); | |
529 s->block= NULL; | |
530 } | |
531 | |
532 static void backup_duplicate_context(MpegEncContext *bak, MpegEncContext *src){ | |
533 #define COPY(a) bak->a= src->a | |
534 COPY(allocated_edge_emu_buffer); | |
535 COPY(edge_emu_buffer); | |
536 COPY(me.scratchpad); | |
537 COPY(rd_scratchpad); | |
538 COPY(b_scratchpad); | |
539 COPY(obmc_scratchpad); | |
540 COPY(me.map); | |
541 COPY(me.score_map); | |
542 COPY(blocks); | |
543 COPY(block); | |
544 COPY(start_mb_y); | |
545 COPY(end_mb_y); | |
546 COPY(me.map_generation); | |
547 COPY(pb); | |
548 COPY(dct_error_sum); | |
1810 | 549 COPY(dct_count[0]); |
550 COPY(dct_count[1]); | |
1799 | 551 #undef COPY |
552 } | |
553 | |
1827 | 554 void ff_update_duplicate_context(MpegEncContext *dst, MpegEncContext *src){ |
1799 | 555 MpegEncContext bak; |
1827 | 556 int i; |
1799 | 557 //FIXME copy only needed parts |
558 //START_TIMER | |
559 backup_duplicate_context(&bak, dst); | |
560 memcpy(dst, src, sizeof(MpegEncContext)); | |
561 backup_duplicate_context(dst, &bak); | |
1827 | 562 for(i=0;i<12;i++){ |
563 dst->pblocks[i] = (short *)(&dst->block[i]); | |
564 } | |
1799 | 565 //STOP_TIMER("update_duplicate_context") //about 10k cycles / 0.01 sec for 1000frames on 1ghz with 2 threads |
566 } | |
567 | |
3777 | 568 #ifdef CONFIG_ENCODERS |
1799 | 569 static void update_duplicate_context_after_me(MpegEncContext *dst, MpegEncContext *src){ |
570 #define COPY(a) dst->a= src->a | |
571 COPY(pict_type); | |
572 COPY(current_picture); | |
573 COPY(f_code); | |
574 COPY(b_code); | |
575 COPY(qscale); | |
576 COPY(lambda); | |
577 COPY(lambda2); | |
578 COPY(picture_in_gop_number); | |
579 COPY(gop_picture_number); | |
2764 | 580 COPY(frame_pred_frame_dct); //FIXME don't set in encode_header |
581 COPY(progressive_frame); //FIXME don't set in encode_header | |
582 COPY(partitioned_frame); //FIXME don't set in encode_header | |
1799 | 583 #undef COPY |
584 } | |
3777 | 585 #endif |
1799 | 586 |
1892 | 587 /** |
588 * sets the given MpegEncContext to common defaults (same for encoding and decoding). | |
589 * the changed fields will not depend upon the prior state of the MpegEncContext. | |
590 */ | |
591 static void MPV_common_defaults(MpegEncContext *s){ | |
592 s->y_dc_scale_table= | |
593 s->c_dc_scale_table= ff_mpeg1_dc_scale_table; | |
594 s->chroma_qscale_table= ff_default_chroma_qscale_table; | |
595 s->progressive_frame= 1; | |
596 s->progressive_sequence= 1; | |
597 s->picture_structure= PICT_FRAME; | |
598 | |
599 s->coded_picture_number = 0; | |
600 s->picture_number = 0; | |
601 s->input_picture_number = 0; | |
602 | |
603 s->picture_in_gop_number = 0; | |
1894 | 604 |
605 s->f_code = 1; | |
606 s->b_code = 1; | |
1892 | 607 } |
608 | |
609 /** | |
610 * sets the given MpegEncContext to defaults for decoding. | |
611 * the changed fields will not depend upon the prior state of the MpegEncContext. | |
612 */ | |
613 void MPV_decode_defaults(MpegEncContext *s){ | |
614 MPV_common_defaults(s); | |
615 } | |
616 | |
617 /** | |
618 * sets the given MpegEncContext to defaults for encoding. | |
619 * the changed fields will not depend upon the prior state of the MpegEncContext. | |
620 */ | |
1902
a5588762c4fa
Compile fix by (Chip <szarlada at freemail dot hu>)
michael
parents:
1894
diff
changeset
|
621 |
a5588762c4fa
Compile fix by (Chip <szarlada at freemail dot hu>)
michael
parents:
1894
diff
changeset
|
622 #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
|
623 static void MPV_encode_defaults(MpegEncContext *s){ |
4658 | 624 int i; |
1892 | 625 MPV_common_defaults(s); |
2967 | 626 |
4658 | 627 for(i=-16; i<16; i++){ |
628 default_fcode_tab[i + MAX_MV]= 1; | |
1892 | 629 } |
630 s->me.mv_penalty= default_mv_penalty; | |
631 s->fcode_tab= default_fcode_tab; | |
632 } | |
1902
a5588762c4fa
Compile fix by (Chip <szarlada at freemail dot hu>)
michael
parents:
1894
diff
changeset
|
633 #endif //CONFIG_ENCODERS |
1892 | 634 |
2967 | 635 /** |
1892 | 636 * init common structure for both encoder and decoder. |
637 * this assumes that some variables like width/height are already set | |
638 */ | |
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
|
639 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
|
640 { |
1708 | 641 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
|
642 |
3070 | 643 s->mb_height = (s->height + 15) / 16; |
644 | |
645 if(s->avctx->thread_count > MAX_THREADS || (s->avctx->thread_count > s->mb_height && s->mb_height)){ | |
1989 | 646 av_log(s->avctx, AV_LOG_ERROR, "too many threads\n"); |
647 return -1; | |
648 } | |
649 | |
2422 | 650 if((s->width || s->height) && avcodec_check_dimensions(s->avctx, s->width, s->height)) |
651 return -1; | |
652 | |
1092 | 653 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
|
654 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
|
655 |
754 | 656 s->flags= s->avctx->flags; |
1754
bdf3927bf8c5
closed gop support & flags2 as all bits in flags are used
michael
parents:
1751
diff
changeset
|
657 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
|
658 |
903 | 659 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
|
660 s->mb_stride = s->mb_width + 1; |
1655 | 661 s->b8_stride = s->mb_width*2 + 1; |
662 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
|
663 mb_array_size= s->mb_height * s->mb_stride; |
1708 | 664 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
|
665 |
2074
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
666 /* set chroma shifts */ |
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
667 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
|
668 &(s->chroma_y_shift) ); |
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
669 |
853
eacc2dd8fd9d
* using DSPContext - so each codec could use its local (sub)set of CPU extension
kabi
parents:
847
diff
changeset
|
670 /* 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
|
671 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
|
672 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
|
673 |
eacc2dd8fd9d
* using DSPContext - so each codec could use its local (sub)set of CPU extension
kabi
parents:
847
diff
changeset
|
674 s->mb_num = s->mb_width * s->mb_height; |
2967 | 675 |
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 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
|
677 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
|
678 s->block_wrap[2]= |
1938
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1918
diff
changeset
|
679 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
|
680 s->block_wrap[4]= |
1938
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1918
diff
changeset
|
681 s->block_wrap[5]= s->mb_stride; |
2967 | 682 |
1938
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1918
diff
changeset
|
683 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
|
684 c_size = s->mb_stride * (s->mb_height + 1); |
756 | 685 yc_size = y_size + 2 * c_size; |
2967 | 686 |
701 | 687 /* 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
|
688 s->codec_tag= toupper( s->avctx->codec_tag &0xFF) |
1116 | 689 + (toupper((s->avctx->codec_tag>>8 )&0xFF)<<8 ) |
2967 | 690 + (toupper((s->avctx->codec_tag>>16)&0xFF)<<16) |
1116 | 691 + (toupper((s->avctx->codec_tag>>24)&0xFF)<<24); |
582
5132a4ee50cd
different edge positions fixed with edge emu / dr1
michaelni
parents:
575
diff
changeset
|
692 |
4155
0f28fc219799
add codec_tag and codec_stream_tag to MpegEncContext to not alter avctx values
bcoudurier
parents:
4122
diff
changeset
|
693 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
|
694 + (toupper((s->avctx->stream_codec_tag>>8 )&0xFF)<<8 ) |
2967 | 695 + (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
|
696 + (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
|
697 |
925 | 698 s->avctx->coded_frame= (AVFrame*)&s->current_picture; |
903 | 699 |
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
|
700 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
|
701 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
|
702 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
|
703 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
|
704 } |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1173
diff
changeset
|
705 } |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1173
diff
changeset
|
706 s->mb_index2xy[ s->mb_height*s->mb_width ] = (s->mb_height-1)*s->mb_stride + s->mb_width; //FIXME really needed? |
2967 | 707 |
232
b640ec5948b0
- Now the ME is done for the entire picture when enconding, the
pulento
parents:
231
diff
changeset
|
708 if (s->encoding) { |
324 | 709 /* 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
|
710 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
|
711 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
|
712 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
|
713 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
|
714 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
|
715 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
|
716 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
|
717 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
|
718 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
|
719 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
|
720 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
|
721 s->b_direct_mv_table = s->b_direct_mv_table_base + s->mb_stride + 1; |
324 | 722 |
650
ef4a33aad86e
reducing sizeof MpegEncContext to avoid stack overflow on crap M$ windo$
michaelni
parents:
635
diff
changeset
|
723 if(s->msmpeg4_version){ |
ef4a33aad86e
reducing sizeof MpegEncContext to avoid stack overflow on crap M$ windo$
michaelni
parents:
635
diff
changeset
|
724 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
|
725 } |
612 | 726 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
|
727 |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead 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 /* Allocate MB type table */ |
1708 | 729 CHECKED_ALLOCZ(s->mb_type , mb_array_size * sizeof(uint16_t)) //needed for encoding |
2967 | 730 |
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
|
731 CHECKED_ALLOCZ(s->lambda_table, mb_array_size * sizeof(int)) |
2967 | 732 |
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
|
733 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
|
734 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
|
735 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
|
736 CHECKED_ALLOCZ(s->q_inter_matrix16, 64*32*2 * sizeof(uint16_t)) |
1556 | 737 CHECKED_ALLOCZ(s->input_picture, MAX_PICTURE_COUNT * sizeof(Picture*)) |
738 CHECKED_ALLOCZ(s->reordered_input_picture, MAX_PICTURE_COUNT * sizeof(Picture*)) | |
2967 | 739 |
1597 | 740 if(s->avctx->noise_reduction){ |
741 CHECKED_ALLOCZ(s->dct_offset, 2 * 64 * sizeof(uint16_t)) | |
742 } | |
232
b640ec5948b0
- Now the ME is done for the entire picture when enconding, the
pulento
parents:
231
diff
changeset
|
743 } |
1552
26c6ecba99a1
dynamic alloc of picture structs instead of putting them in MpegEncContext
michael
parents:
1546
diff
changeset
|
744 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
|
745 |
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
|
746 CHECKED_ALLOCZ(s->error_status_table, mb_array_size*sizeof(uint8_t)) |
2967 | 747 |
1708 | 748 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
|
749 /* interlaced direct mode decoding tables */ |
1708 | 750 for(i=0; i<2; i++){ |
751 int j, k; | |
752 for(j=0; j<2; j++){ | |
753 for(k=0; k<2; k++){ | |
754 CHECKED_ALLOCZ(s->b_field_mv_table_base[i][j][k] , mv_table_size * 2 * sizeof(int16_t)) | |
755 s->b_field_mv_table[i][j][k] = s->b_field_mv_table_base[i][j][k] + s->mb_stride + 1; | |
756 } | |
757 CHECKED_ALLOCZ(s->b_field_select_table[i][j] , mb_array_size * 2 * sizeof(uint8_t)) | |
758 CHECKED_ALLOCZ(s->p_field_mv_table_base[i][j] , mv_table_size * 2 * sizeof(int16_t)) | |
759 s->p_field_mv_table[i][j] = s->p_field_mv_table_base[i][j] + s->mb_stride + 1; | |
760 } | |
761 CHECKED_ALLOCZ(s->p_field_select_table[i] , mb_array_size * 2 * sizeof(uint8_t)) | |
762 } | |
0 | 763 } |
767 | 764 if (s->out_format == FMT_H263) { |
0 | 765 /* ac values */ |
1938
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1918
diff
changeset
|
766 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
|
767 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
|
768 s->ac_val[1] = s->ac_val_base + y_size + s->mb_stride + 1; |
0 | 769 s->ac_val[2] = s->ac_val[1] + c_size; |
2967 | 770 |
0 | 771 /* cbp values */ |
1938
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1918
diff
changeset
|
772 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
|
773 s->coded_block= s->coded_block_base + s->b8_stride + 1; |
2967 | 774 |
456 | 775 /* 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
|
776 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
|
777 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
|
778 } |
2967 | 779 |
756 | 780 if (s->h263_pred || s->h263_plus || !s->encoding) { |
781 /* dc values */ | |
782 //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
|
783 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
|
784 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
|
785 s->dc_val[1] = s->dc_val_base + y_size + s->mb_stride + 1; |
756 | 786 s->dc_val[2] = s->dc_val[1] + c_size; |
787 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
|
788 s->dc_val_base[i] = 1024; |
756 | 789 } |
790 | |
611
3214d3f4519e
error concealment needs the mbintra_table so it should allways be allocated
michaelni
parents:
608
diff
changeset
|
791 /* 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
|
792 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
|
793 memset(s->mbintra_table, 1, mb_array_size); |
2967 | 794 |
7
1d3ac9654178
added skip macroblock optimization (big perf win on black regions for example)
glantau
parents:
0
diff
changeset
|
795 /* 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
|
796 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
|
797 //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
|
798 CHECKED_ALLOCZ(s->prev_pict_types, PREV_PICT_TYPES_BUFFER_SIZE); |
2967 | 799 |
842
e460775adb38
cleanup (breaks compatibility, requested by fabrice)
michaelni
parents:
828
diff
changeset
|
800 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
|
801 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
|
802 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
|
803 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
|
804 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
|
805 } |
842
e460775adb38
cleanup (breaks compatibility, requested by fabrice)
michaelni
parents:
828
diff
changeset
|
806 |
0 | 807 s->context_initialized = 1; |
1799 | 808 |
809 s->thread_context[0]= s; | |
810 for(i=1; i<s->avctx->thread_count; i++){ | |
811 s->thread_context[i]= av_malloc(sizeof(MpegEncContext)); | |
812 memcpy(s->thread_context[i], s, sizeof(MpegEncContext)); | |
813 } | |
814 | |
815 for(i=0; i<s->avctx->thread_count; i++){ | |
816 if(init_duplicate_context(s->thread_context[i], s) < 0) | |
817 goto fail; | |
818 s->thread_context[i]->start_mb_y= (s->mb_height*(i ) + s->avctx->thread_count/2) / s->avctx->thread_count; | |
819 s->thread_context[i]->end_mb_y = (s->mb_height*(i+1) + s->avctx->thread_count/2) / s->avctx->thread_count; | |
820 } | |
821 | |
0 | 822 return 0; |
823 fail: | |
244 | 824 MPV_common_end(s); |
825 return -1; | |
826 } | |
827 | |
828 /* init common structure for both encoder and decoder */ | |
829 void MPV_common_end(MpegEncContext *s) | |
830 { | |
1708 | 831 int i, j, k; |
244 | 832 |
1799 | 833 for(i=0; i<s->avctx->thread_count; i++){ |
834 free_duplicate_context(s->thread_context[i]); | |
835 } | |
836 for(i=1; i<s->avctx->thread_count; i++){ | |
837 av_freep(&s->thread_context[i]); | |
838 } | |
839 | |
1344
447b88b784ee
memleak fix by (Jake Page <jake at CS dot Stanford dot EDU>)
michaelni
parents:
1339
diff
changeset
|
840 av_freep(&s->parse_context.buffer); |
447b88b784ee
memleak fix by (Jake Page <jake at CS dot Stanford dot EDU>)
michaelni
parents:
1339
diff
changeset
|
841 s->parse_context.buffer_size=0; |
447b88b784ee
memleak fix by (Jake Page <jake at CS dot Stanford dot EDU>)
michaelni
parents:
1339
diff
changeset
|
842 |
396
fce0a2520551
removed useless header includes - use av memory functions
glantau
parents:
376
diff
changeset
|
843 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
|
844 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
|
845 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
|
846 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
|
847 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
|
848 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
|
849 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
|
850 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
|
851 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
|
852 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
|
853 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
|
854 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
|
855 s->b_direct_mv_table= NULL; |
1708 | 856 for(i=0; i<2; i++){ |
857 for(j=0; j<2; j++){ | |
858 for(k=0; k<2; k++){ | |
859 av_freep(&s->b_field_mv_table_base[i][j][k]); | |
860 s->b_field_mv_table[i][j][k]=NULL; | |
861 } | |
862 av_freep(&s->b_field_select_table[i][j]); | |
863 av_freep(&s->p_field_mv_table_base[i][j]); | |
864 s->p_field_mv_table[i][j]=NULL; | |
865 } | |
866 av_freep(&s->p_field_select_table[i]); | |
867 } | |
2967 | 868 |
1938
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1918
diff
changeset
|
869 av_freep(&s->dc_val_base); |
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1918
diff
changeset
|
870 av_freep(&s->ac_val_base); |
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1918
diff
changeset
|
871 av_freep(&s->coded_block_base); |
396
fce0a2520551
removed useless header includes - use av memory functions
glantau
parents:
376
diff
changeset
|
872 av_freep(&s->mbintra_table); |
456 | 873 av_freep(&s->cbp_table); |
874 av_freep(&s->pred_dir_table); | |
2967 | 875 |
396
fce0a2520551
removed useless header includes - use av memory functions
glantau
parents:
376
diff
changeset
|
876 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
|
877 av_freep(&s->prev_pict_types); |
396
fce0a2520551
removed useless header includes - use av memory functions
glantau
parents:
376
diff
changeset
|
878 av_freep(&s->bitstream_buffer); |
2422 | 879 s->allocated_bitstream_buffer_size=0; |
880 | |
612 | 881 av_freep(&s->avctx->stats_out); |
650
ef4a33aad86e
reducing sizeof MpegEncContext to avoid stack overflow on crap M$ windo$
michaelni
parents:
635
diff
changeset
|
882 av_freep(&s->ac_stats); |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
731
diff
changeset
|
883 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
|
884 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
|
885 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
|
886 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
|
887 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
|
888 av_freep(&s->q_intra_matrix16); |
d736e24bf303
move mmx quantizer matrixes out of MpegEncContext (23k -> 7k) (no meassureable slowdown)
michael
parents:
1553
diff
changeset
|
889 av_freep(&s->q_inter_matrix16); |
1556 | 890 av_freep(&s->input_picture); |
891 av_freep(&s->reordered_input_picture); | |
1597 | 892 av_freep(&s->dct_offset); |
903 | 893 |
1573 | 894 if(s->picture){ |
895 for(i=0; i<MAX_PICTURE_COUNT; i++){ | |
896 free_picture(s, &s->picture[i]); | |
897 } | |
0 | 898 } |
1552
26c6ecba99a1
dynamic alloc of picture structs instead of putting them in MpegEncContext
michael
parents:
1546
diff
changeset
|
899 av_freep(&s->picture); |
0 | 900 s->context_initialized = 0; |
1523 | 901 s->last_picture_ptr= |
902 s->next_picture_ptr= | |
903 s->current_picture_ptr= NULL; | |
2231 | 904 s->linesize= s->uvlinesize= 0; |
1918
ea20f38b8d57
nicer looking arrows for the motion vector vissualization
michael
parents:
1916
diff
changeset
|
905 |
1706
3ba5c493db6f
motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1705
diff
changeset
|
906 for(i=0; i<3; i++) |
1918
ea20f38b8d57
nicer looking arrows for the motion vector vissualization
michael
parents:
1916
diff
changeset
|
907 av_freep(&s->visualization_buffer[i]); |
2231 | 908 |
909 avcodec_default_free_buffers(s->avctx); | |
0 | 910 } |
911 | |
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
|
912 #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
|
913 |
0 | 914 /* init video encoder */ |
915 int MPV_encode_init(AVCodecContext *avctx) | |
916 { | |
917 MpegEncContext *s = avctx->priv_data; | |
2834 | 918 int i; |
1315
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1288
diff
changeset
|
919 int chroma_h_shift, chroma_v_shift; |
2967 | 920 |
1892 | 921 MPV_encode_defaults(s); |
315 | 922 |
3309 | 923 switch (avctx->codec_id) { |
924 case CODEC_ID_MPEG2VIDEO: | |
925 if(avctx->pix_fmt != PIX_FMT_YUV420P && avctx->pix_fmt != PIX_FMT_YUV422P){ | |
926 av_log(avctx, AV_LOG_ERROR, "only YUV420 and YUV422 are supported\n"); | |
927 return -1; | |
928 } | |
929 break; | |
930 case CODEC_ID_LJPEG: | |
931 case CODEC_ID_MJPEG: | |
3929 | 932 if(avctx->pix_fmt != PIX_FMT_YUVJ420P && avctx->pix_fmt != PIX_FMT_YUVJ422P && |
933 ((avctx->pix_fmt != PIX_FMT_YUV420P && avctx->pix_fmt != PIX_FMT_YUV422P) || avctx->strict_std_compliance>FF_COMPLIANCE_INOFFICIAL)){ | |
2442 | 934 av_log(avctx, AV_LOG_ERROR, "colorspace not supported in jpeg\n"); |
935 return -1; | |
936 } | |
3309 | 937 break; |
938 default: | |
939 if(avctx->pix_fmt != PIX_FMT_YUV420P){ | |
940 av_log(avctx, AV_LOG_ERROR, "only YUV420 is supported\n"); | |
2442 | 941 return -1; |
942 } | |
943 } | |
1402
f662e9c86cf2
* fixing a regression in mpeg encoder (not setting pix_fmt),
romansh
parents:
1397
diff
changeset
|
944 |
3309 | 945 switch (avctx->pix_fmt) { |
946 case PIX_FMT_YUVJ422P: | |
947 case PIX_FMT_YUV422P: | |
948 s->chroma_format = CHROMA_422; | |
949 break; | |
950 case PIX_FMT_YUVJ420P: | |
951 case PIX_FMT_YUV420P: | |
952 default: | |
953 s->chroma_format = CHROMA_420; | |
954 break; | |
955 } | |
956 | |
0 | 957 s->bit_rate = avctx->bit_rate; |
958 s->width = avctx->width; | |
959 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
|
960 if(avctx->gop_size > 600 && avctx->strict_std_compliance>FF_COMPLIANCE_EXPERIMENTAL){ |
2979 | 961 av_log(avctx, AV_LOG_ERROR, "Warning keyframe interval too large! reducing it ...\n"); |
456 | 962 avctx->gop_size=600; |
963 } | |
0 | 964 s->gop_size = avctx->gop_size; |
194
27d1773552c9
mpeg4 encoder fix by Michael Niedermayer <michaelni@gmx.at>
arpi_esp
parents:
191
diff
changeset
|
965 s->avctx = avctx; |
294 | 966 s->flags= avctx->flags; |
1754
bdf3927bf8c5
closed gop support & flags2 as all bits in flags are used
michael
parents:
1751
diff
changeset
|
967 s->flags2= avctx->flags2; |
324 | 968 s->max_b_frames= avctx->max_b_frames; |
344 | 969 s->codec_id= avctx->codec->id; |
456 | 970 s->luma_elim_threshold = avctx->luma_elim_threshold; |
971 s->chroma_elim_threshold= avctx->chroma_elim_threshold; | |
972 s->strict_std_compliance= avctx->strict_std_compliance; | |
973 s->data_partitioning= avctx->flags & CODEC_FLAG_PART; | |
936 | 974 s->quarter_sample= (avctx->flags & CODEC_FLAG_QPEL)!=0; |
599 | 975 s->mpeg_quant= avctx->mpeg_quant; |
1661 | 976 s->rtp_mode= !!avctx->rtp_payload_size; |
1992 | 977 s->intra_dc_precision= avctx->intra_dc_precision; |
2243
b8bad8bbbc64
check if the user specified timestamps are strictly monotone
michael
parents:
2235
diff
changeset
|
978 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
|
979 |
0 | 980 if (s->gop_size <= 1) { |
981 s->intra_only = 1; | |
982 s->gop_size = 12; | |
983 } else { | |
984 s->intra_only = 0; | |
985 } | |
693
b6a7ff92df57
darkness masking (lumi masking does only bright stuff now)
michaelni
parents:
690
diff
changeset
|
986 |
936 | 987 s->me_method = avctx->me_method; |
693
b6a7ff92df57
darkness masking (lumi masking does only bright stuff now)
michaelni
parents:
690
diff
changeset
|
988 |
320
cda7d0857baf
- ME setting moved to AVCodecContext/MpegEncContext, no longer a global.
pulento
parents:
315
diff
changeset
|
989 /* Fixed QSCALE */ |
1708 | 990 s->fixed_qscale = !!(avctx->flags & CODEC_FLAG_QSCALE); |
2967 | 991 |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
673
diff
changeset
|
992 s->adaptive_quant= ( s->avctx->lumi_masking |
693
b6a7ff92df57
darkness masking (lumi masking does only bright stuff now)
michaelni
parents:
690
diff
changeset
|
993 || s->avctx->dark_masking |
2967 | 994 || s->avctx->temporal_cplx_masking |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
673
diff
changeset
|
995 || s->avctx->spatial_cplx_masking |
1616 | 996 || s->avctx->p_masking |
2493
258120c61eea
Border processing adaptive quant patch by (Christophe Massiot |cmassiot freebox fr)
michael
parents:
2492
diff
changeset
|
997 || s->avctx->border_masking |
1616 | 998 || (s->flags&CODEC_FLAG_QP_RD)) |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
673
diff
changeset
|
999 && !s->fixed_qscale; |
2967 | 1000 |
1708 | 1001 s->obmc= !!(s->flags & CODEC_FLAG_OBMC); |
1002 s->loop_filter= !!(s->flags & CODEC_FLAG_LOOP_FILTER); | |
1003 s->alternate_scan= !!(s->flags & CODEC_FLAG_ALT_SCAN); | |
3305 | 1004 s->intra_vlc_format= !!(s->flags2 & CODEC_FLAG2_INTRA_VLC); |
4621 | 1005 s->q_scale_type= !!(s->flags2 & CODEC_FLAG2_NON_LINEAR_QUANT); |
1633 | 1006 |
1711 | 1007 if(avctx->rc_max_rate && !avctx->rc_buffer_size){ |
1008 av_log(avctx, AV_LOG_ERROR, "a vbv buffer size is needed, for encoding with a maximum bitrate\n"); | |
1009 return -1; | |
2967 | 1010 } |
1711 | 1011 |
1012 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
|
1013 av_log(avctx, AV_LOG_INFO, "Warning min_rate > 0 but min_rate != max_rate isn't recommended!\n"); |
1907 | 1014 } |
2967 | 1015 |
2063 | 1016 if(avctx->rc_min_rate && avctx->rc_min_rate > avctx->bit_rate){ |
5048 | 1017 av_log(avctx, AV_LOG_ERROR, "bitrate below min bitrate\n"); |
2063 | 1018 return -1; |
1019 } | |
2967 | 1020 |
2063 | 1021 if(avctx->rc_max_rate && avctx->rc_max_rate < avctx->bit_rate){ |
1022 av_log(avctx, AV_LOG_INFO, "bitrate above max bitrate\n"); | |
1023 return -1; | |
1024 } | |
2967 | 1025 |
5047
460a12052adf
sanity checks for bitrate tolerance and buffer size (= fail if a single frame at the
michael
parents:
5030
diff
changeset
|
1026 if(avctx->rc_buffer_size && avctx->bit_rate*av_q2d(avctx->time_base) > avctx->rc_buffer_size){ |
5048 | 1027 av_log(avctx, AV_LOG_ERROR, "VBV buffer too small for bitrate\n"); |
5047
460a12052adf
sanity checks for bitrate tolerance and buffer size (= fail if a single frame at the
michael
parents:
5030
diff
changeset
|
1028 return -1; |
460a12052adf
sanity checks for bitrate tolerance and buffer size (= fail if a single frame at the
michael
parents:
5030
diff
changeset
|
1029 } |
460a12052adf
sanity checks for bitrate tolerance and buffer size (= fail if a single frame at the
michael
parents:
5030
diff
changeset
|
1030 |
460a12052adf
sanity checks for bitrate tolerance and buffer size (= fail if a single frame at the
michael
parents:
5030
diff
changeset
|
1031 if(avctx->bit_rate*av_q2d(avctx->time_base) > avctx->bit_rate_tolerance){ |
5048 | 1032 av_log(avctx, AV_LOG_ERROR, "bitrate tolerance too small for bitrate\n"); |
5047
460a12052adf
sanity checks for bitrate tolerance and buffer size (= fail if a single frame at the
michael
parents:
5030
diff
changeset
|
1033 return -1; |
460a12052adf
sanity checks for bitrate tolerance and buffer size (= fail if a single frame at the
michael
parents:
5030
diff
changeset
|
1034 } |
460a12052adf
sanity checks for bitrate tolerance and buffer size (= fail if a single frame at the
michael
parents:
5030
diff
changeset
|
1035 |
2967 | 1036 if( s->avctx->rc_max_rate && s->avctx->rc_min_rate == s->avctx->rc_max_rate |
1907 | 1037 && (s->codec_id == CODEC_ID_MPEG1VIDEO || s->codec_id == CODEC_ID_MPEG2VIDEO) |
1038 && 90000LL * (avctx->rc_buffer_size-1) > s->avctx->rc_max_rate*0xFFFFLL){ | |
2967 | 1039 |
1907 | 1040 av_log(avctx, AV_LOG_INFO, "Warning vbv_delay will be set to 0xFFFF (=VBR) as the specified vbv buffer is too large for the given bitrate!\n"); |
1041 } | |
2967 | 1042 |
1043 if((s->flags & CODEC_FLAG_4MV) && s->codec_id != CODEC_ID_MPEG4 | |
1790 | 1044 && s->codec_id != CODEC_ID_H263 && s->codec_id != CODEC_ID_H263P && s->codec_id != CODEC_ID_FLV1){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1597
diff
changeset
|
1045 av_log(avctx, AV_LOG_ERROR, "4MV not supported by codec\n"); |
1188 | 1046 return -1; |
1047 } | |
2967 | 1048 |
1633 | 1049 if(s->obmc && s->avctx->mb_decision != FF_MB_DECISION_SIMPLE){ |
2627
bf158d23bbcc
Spelling errors patch by (Kevin Baragona | kevinmb500 gawab com)
michael
parents:
2620
diff
changeset
|
1050 av_log(avctx, AV_LOG_ERROR, "OBMC is only supported with simple mb decision\n"); |
1633 | 1051 return -1; |
1052 } | |
2967 | 1053 |
1644 | 1054 if(s->obmc && s->codec_id != CODEC_ID_H263 && s->codec_id != CODEC_ID_H263P){ |
1055 av_log(avctx, AV_LOG_ERROR, "OBMC is only supported with H263(+)\n"); | |
1056 return -1; | |
1057 } | |
2967 | 1058 |
1188 | 1059 if(s->quarter_sample && s->codec_id != CODEC_ID_MPEG4){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1597
diff
changeset
|
1060 av_log(avctx, AV_LOG_ERROR, "qpel not supported by codec\n"); |
1188 | 1061 return -1; |
1062 } | |
1063 | |
1064 if(s->data_partitioning && s->codec_id != CODEC_ID_MPEG4){ | |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1597
diff
changeset
|
1065 av_log(avctx, AV_LOG_ERROR, "data partitioning not supported by codec\n"); |
1188 | 1066 return -1; |
1067 } | |
2967 | 1068 |
1421 | 1069 if(s->max_b_frames && s->codec_id != CODEC_ID_MPEG4 && s->codec_id != CODEC_ID_MPEG1VIDEO && s->codec_id != CODEC_ID_MPEG2VIDEO){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1597
diff
changeset
|
1070 av_log(avctx, AV_LOG_ERROR, "b frames not supported by codec\n"); |
1188 | 1071 return -1; |
1072 } | |
1958 | 1073 |
2967 | 1074 if((s->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME|CODEC_FLAG_ALT_SCAN)) |
1958 | 1075 && s->codec_id != CODEC_ID_MPEG4 && s->codec_id != CODEC_ID_MPEG2VIDEO){ |
1076 av_log(avctx, AV_LOG_ERROR, "interlacing not supported by codec\n"); | |
1077 return -1; | |
1078 } | |
2967 | 1079 |
1188 | 1080 if(s->mpeg_quant && s->codec_id != CODEC_ID_MPEG4){ //FIXME mpeg2 uses that too |
2627
bf158d23bbcc
Spelling errors patch by (Kevin Baragona | kevinmb500 gawab com)
michael
parents:
2620
diff
changeset
|
1081 av_log(avctx, AV_LOG_ERROR, "mpeg2 style quantization not supported by codec\n"); |
1188 | 1082 return -1; |
1083 } | |
2967 | 1084 |
1490
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1480
diff
changeset
|
1085 if((s->flags & CODEC_FLAG_CBP_RD) && !(s->flags & CODEC_FLAG_TRELLIS_QUANT)){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1597
diff
changeset
|
1086 av_log(avctx, AV_LOG_ERROR, "CBP RD needs trellis quant\n"); |
1490
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1480
diff
changeset
|
1087 return -1; |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1480
diff
changeset
|
1088 } |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1480
diff
changeset
|
1089 |
1622 | 1090 if((s->flags & CODEC_FLAG_QP_RD) && s->avctx->mb_decision != FF_MB_DECISION_RD){ |
1091 av_log(avctx, AV_LOG_ERROR, "QP RD needs mbd=2\n"); | |
1092 return -1; | |
1093 } | |
2967 | 1094 |
1754
bdf3927bf8c5
closed gop support & flags2 as all bits in flags are used
michael
parents:
1751
diff
changeset
|
1095 if(s->avctx->scenechange_threshold < 1000000000 && (s->flags & CODEC_FLAG_CLOSED_GOP)){ |
4399
daa2a095181d
add hint for closed gop and sc threshold error message
bcoudurier
parents:
4396
diff
changeset
|
1096 av_log(avctx, AV_LOG_ERROR, "closed gop with scene change detection arent supported yet, set threshold to 1000000000\n"); |
1754
bdf3927bf8c5
closed gop support & flags2 as all bits in flags are used
michael
parents:
1751
diff
changeset
|
1097 return -1; |
bdf3927bf8c5
closed gop support & flags2 as all bits in flags are used
michael
parents:
1751
diff
changeset
|
1098 } |
2967 | 1099 |
3305 | 1100 if((s->flags2 & CODEC_FLAG2_INTRA_VLC) && s->codec_id != CODEC_ID_MPEG2VIDEO){ |
1101 av_log(avctx, AV_LOG_ERROR, "intra vlc table not supported by codec\n"); | |
1102 return -1; | |
1103 } | |
1104 | |
4189
3c98b0938897
add low delay forcing option for mpeg1/2 encoding
bcoudurier
parents:
4179
diff
changeset
|
1105 if(s->flags & CODEC_FLAG_LOW_DELAY){ |
3c98b0938897
add low delay forcing option for mpeg1/2 encoding
bcoudurier
parents:
4179
diff
changeset
|
1106 if (s->codec_id != CODEC_ID_MPEG2VIDEO && s->codec_id != CODEC_ID_MPEG1VIDEO){ |
3c98b0938897
add low delay forcing option for mpeg1/2 encoding
bcoudurier
parents:
4179
diff
changeset
|
1107 av_log(avctx, AV_LOG_ERROR, "low delay forcing is only available for mpeg1/2\n"); |
3c98b0938897
add low delay forcing option for mpeg1/2 encoding
bcoudurier
parents:
4179
diff
changeset
|
1108 return -1; |
3c98b0938897
add low delay forcing option for mpeg1/2 encoding
bcoudurier
parents:
4179
diff
changeset
|
1109 } |
3c98b0938897
add low delay forcing option for mpeg1/2 encoding
bcoudurier
parents:
4179
diff
changeset
|
1110 if (s->max_b_frames != 0){ |
3c98b0938897
add low delay forcing option for mpeg1/2 encoding
bcoudurier
parents:
4179
diff
changeset
|
1111 av_log(avctx, AV_LOG_ERROR, "b frames cannot be used with low delay\n"); |
3c98b0938897
add low delay forcing option for mpeg1/2 encoding
bcoudurier
parents:
4179
diff
changeset
|
1112 return -1; |
3c98b0938897
add low delay forcing option for mpeg1/2 encoding
bcoudurier
parents:
4179
diff
changeset
|
1113 } |
3c98b0938897
add low delay forcing option for mpeg1/2 encoding
bcoudurier
parents:
4179
diff
changeset
|
1114 } |
3c98b0938897
add low delay forcing option for mpeg1/2 encoding
bcoudurier
parents:
4179
diff
changeset
|
1115 |
4621 | 1116 if(s->q_scale_type == 1){ |
1117 if(s->codec_id != CODEC_ID_MPEG2VIDEO){ | |
1118 av_log(avctx, AV_LOG_ERROR, "non linear quant is only available for mpeg2\n"); | |
1119 return -1; | |
1120 } | |
1121 if(avctx->qmax > 12){ | |
1122 av_log(avctx, AV_LOG_ERROR, "non linear quant only supports qmax <= 12 currently\n"); | |
1123 return -1; | |
1124 } | |
1125 } | |
1126 | |
2967 | 1127 if(s->avctx->thread_count > 1 && s->codec_id != CODEC_ID_MPEG4 |
1128 && s->codec_id != CODEC_ID_MPEG1VIDEO && s->codec_id != CODEC_ID_MPEG2VIDEO | |
1799 | 1129 && (s->codec_id != CODEC_ID_H263P || !(s->flags & CODEC_FLAG_H263P_SLICE_STRUCT))){ |
1130 av_log(avctx, AV_LOG_ERROR, "multi threaded encoding not supported by codec\n"); | |
1131 return -1; | |
1132 } | |
2967 | 1133 |
1799 | 1134 if(s->avctx->thread_count > 1) |
1135 s->rtp_mode= 1; | |
1760 | 1136 |
2637 | 1137 if(!avctx->time_base.den || !avctx->time_base.num){ |
2450 | 1138 av_log(avctx, AV_LOG_ERROR, "framerate not set\n"); |
1139 return -1; | |
1140 } | |
2967 | 1141 |
2576
e237d9bd0f8c
check mb/me_threshold range, fixes assertion failure
michael
parents:
2570
diff
changeset
|
1142 i= (INT_MAX/2+128)>>8; |
e237d9bd0f8c
check mb/me_threshold range, fixes assertion failure
michael
parents:
2570
diff
changeset
|
1143 if(avctx->me_threshold >= i){ |
e237d9bd0f8c
check mb/me_threshold range, fixes assertion failure
michael
parents:
2570
diff
changeset
|
1144 av_log(avctx, AV_LOG_ERROR, "me_threshold too large, max is %d\n", i - 1); |
e237d9bd0f8c
check mb/me_threshold range, fixes assertion failure
michael
parents:
2570
diff
changeset
|
1145 return -1; |
e237d9bd0f8c
check mb/me_threshold range, fixes assertion failure
michael
parents:
2570
diff
changeset
|
1146 } |
e237d9bd0f8c
check mb/me_threshold range, fixes assertion failure
michael
parents:
2570
diff
changeset
|
1147 if(avctx->mb_threshold >= i){ |
e237d9bd0f8c
check mb/me_threshold range, fixes assertion failure
michael
parents:
2570
diff
changeset
|
1148 av_log(avctx, AV_LOG_ERROR, "mb_threshold too large, max is %d\n", i - 1); |
e237d9bd0f8c
check mb/me_threshold range, fixes assertion failure
michael
parents:
2570
diff
changeset
|
1149 return -1; |
e237d9bd0f8c
check mb/me_threshold range, fixes assertion failure
michael
parents:
2570
diff
changeset
|
1150 } |
2967 | 1151 |
2668 | 1152 if(avctx->b_frame_strategy && (avctx->flags&CODEC_FLAG_PASS2)){ |
3321
8869b4dd2ffe
Make b_frame_strategy not fail on pass 2, but still print a notice.
corey
parents:
3316
diff
changeset
|
1153 av_log(avctx, AV_LOG_INFO, "notice: b_frame_strategy only affects the first pass\n"); |
8869b4dd2ffe
Make b_frame_strategy not fail on pass 2, but still print a notice.
corey
parents:
3316
diff
changeset
|
1154 avctx->b_frame_strategy = 0; |
2668 | 1155 } |
1156 | |
2637 | 1157 i= ff_gcd(avctx->time_base.den, avctx->time_base.num); |
1760 | 1158 if(i > 1){ |
1159 av_log(avctx, AV_LOG_INFO, "removing common factors from framerate\n"); | |
2637 | 1160 avctx->time_base.den /= i; |
1161 avctx->time_base.num /= i; | |
1760 | 1162 // return -1; |
1163 } | |
2967 | 1164 |
1150 | 1165 if(s->codec_id==CODEC_ID_MJPEG){ |
1166 s->intra_quant_bias= 1<<(QUANT_BIAS_SHIFT-1); //(a + x/2)/x | |
1167 s->inter_quant_bias= 0; | |
1421 | 1168 }else if(s->mpeg_quant || s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO){ |
1150 | 1169 s->intra_quant_bias= 3<<(QUANT_BIAS_SHIFT-3); //(a + x*3/8)/x |
1170 s->inter_quant_bias= 0; | |
1171 }else{ | |
1172 s->intra_quant_bias=0; | |
1173 s->inter_quant_bias=-(1<<(QUANT_BIAS_SHIFT-2)); //(a - x/4)/x | |
1174 } | |
2967 | 1175 |
1150 | 1176 if(avctx->intra_quant_bias != FF_DEFAULT_QUANT_BIAS) |
1177 s->intra_quant_bias= avctx->intra_quant_bias; | |
1178 if(avctx->inter_quant_bias != FF_DEFAULT_QUANT_BIAS) | |
1179 s->inter_quant_bias= avctx->inter_quant_bias; | |
2967 | 1180 |
1315
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1288
diff
changeset
|
1181 avcodec_get_chroma_sub_sample(avctx->pix_fmt, &chroma_h_shift, &chroma_v_shift); |
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1288
diff
changeset
|
1182 |
2653
2515af7d3238
complain about mpeg4 limits only if codec_id == MPEG4
michael
parents:
2639
diff
changeset
|
1183 if(avctx->codec_id == CODEC_ID_MPEG4 && s->avctx->time_base.den > (1<<16)-1){ |
2637 | 1184 av_log(avctx, AV_LOG_ERROR, "timebase not supported by mpeg 4 standard\n"); |
2967 | 1185 return -1; |
2637 | 1186 } |
1187 s->time_increment_bits = av_log2(s->avctx->time_base.den - 1) + 1; | |
1424 | 1188 |
0 | 1189 switch(avctx->codec->id) { |
1190 case CODEC_ID_MPEG1VIDEO: | |
1191 s->out_format = FMT_MPEG1; | |
4189
3c98b0938897
add low delay forcing option for mpeg1/2 encoding
bcoudurier
parents:
4179
diff
changeset
|
1192 s->low_delay= !!(s->flags & CODEC_FLAG_LOW_DELAY); |
1126
77ccf7fe3bd0
per context frame_rate_base, this should finally fix frame_rate related av sync issues
michaelni
parents:
1124
diff
changeset
|
1193 avctx->delay= s->low_delay ? 0 : (s->max_b_frames + 1); |
0 | 1194 break; |
1421 | 1195 case CODEC_ID_MPEG2VIDEO: |
1196 s->out_format = FMT_MPEG1; | |
4189
3c98b0938897
add low delay forcing option for mpeg1/2 encoding
bcoudurier
parents:
4179
diff
changeset
|
1197 s->low_delay= !!(s->flags & CODEC_FLAG_LOW_DELAY); |
1421 | 1198 avctx->delay= s->low_delay ? 0 : (s->max_b_frames + 1); |
1661 | 1199 s->rtp_mode= 1; |
1421 | 1200 break; |
1315
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1288
diff
changeset
|
1201 case CODEC_ID_LJPEG: |
0 | 1202 case CODEC_ID_MJPEG: |
1203 s->out_format = FMT_MJPEG; | |
1204 s->intra_only = 1; /* force intra only for jpeg */ | |
3929 | 1205 s->mjpeg_vsample[0] = 2; |
1206 s->mjpeg_vsample[1] = 2>>chroma_v_shift; | |
1207 s->mjpeg_vsample[2] = 2>>chroma_v_shift; | |
1208 s->mjpeg_hsample[0] = 2; | |
1209 s->mjpeg_hsample[1] = 2>>chroma_h_shift; | |
1210 s->mjpeg_hsample[2] = 2>>chroma_h_shift; | |
5029
dbaa06366c3c
add a proper prefix to all mjpeg encoder exported functions
aurel
parents:
5028
diff
changeset
|
1211 if (!(ENABLE_MJPEG_ENCODER || ENABLE_LJPEG_ENCODER) |
dbaa06366c3c
add a proper prefix to all mjpeg encoder exported functions
aurel
parents:
5028
diff
changeset
|
1212 || ff_mjpeg_encode_init(s) < 0) |
0 | 1213 return -1; |
336 | 1214 avctx->delay=0; |
924 | 1215 s->low_delay=1; |
0 | 1216 break; |
2327
5e5cf598a48b
H.261 encoder by (Maarten Daniels <maarten dot daniels at luc dot ac dot be>)
michael
parents:
2298
diff
changeset
|
1217 case CODEC_ID_H261: |
4997 | 1218 if (!ENABLE_H261_ENCODER) return -1; |
4206
be94e97ecb6e
throw error if unsupported resolution is used with h261
bcoudurier
parents:
4189
diff
changeset
|
1219 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
|
1220 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
|
1221 return -1; |
be94e97ecb6e
throw error if unsupported resolution is used with h261
bcoudurier
parents:
4189
diff
changeset
|
1222 } |
2327
5e5cf598a48b
H.261 encoder by (Maarten Daniels <maarten dot daniels at luc dot ac dot be>)
michael
parents:
2298
diff
changeset
|
1223 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
|
1224 avctx->delay=0; |
5e5cf598a48b
H.261 encoder by (Maarten Daniels <maarten dot daniels at luc dot ac dot be>)
michael
parents:
2298
diff
changeset
|
1225 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
|
1226 break; |
0 | 1227 case CODEC_ID_H263: |
232
b640ec5948b0
- Now the ME is done for the entire picture when enconding, the
pulento
parents:
231
diff
changeset
|
1228 if (h263_get_picture_format(s->width, s->height) == 7) { |
3011 | 1229 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 | 1230 return -1; |
232
b640ec5948b0
- Now the ME is done for the entire picture when enconding, the
pulento
parents:
231
diff
changeset
|
1231 } |
0 | 1232 s->out_format = FMT_H263; |
2979 | 1233 s->obmc= (avctx->flags & CODEC_FLAG_OBMC) ? 1:0; |
336 | 1234 avctx->delay=0; |
924 | 1235 s->low_delay=1; |
0 | 1236 break; |
1237 case CODEC_ID_H263P: | |
1238 s->out_format = FMT_H263; | |
1239 s->h263_plus = 1; | |
2979 | 1240 /* Fx */ |
1644 | 1241 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
|
1242 s->h263_aic= (avctx->flags & CODEC_FLAG_AC_PRED) ? 1:0; |
2979 | 1243 s->modified_quant= s->h263_aic; |
1244 s->alt_inter_vlc= (avctx->flags & CODEC_FLAG_H263P_AIV) ? 1:0; | |
1245 s->obmc= (avctx->flags & CODEC_FLAG_OBMC) ? 1:0; | |
1246 s->loop_filter= (avctx->flags & CODEC_FLAG_LOOP_FILTER) ? 1:0; | |
1247 s->unrestricted_mv= s->obmc || s->loop_filter || s->umvplus; | |
1661 | 1248 s->h263_slice_structured= (s->flags & CODEC_FLAG_H263P_SLICE_STRUCT) ? 1:0; |
1644 | 1249 |
2979 | 1250 /* /Fx */ |
79
82e579c37bc3
Moved some H.263+ variables to MpegEncContext to be thread-safe.
pulento
parents:
78
diff
changeset
|
1251 /* These are just to be sure */ |
336 | 1252 avctx->delay=0; |
924 | 1253 s->low_delay=1; |
0 | 1254 break; |
1353
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1344
diff
changeset
|
1255 case CODEC_ID_FLV1: |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1344
diff
changeset
|
1256 s->out_format = FMT_H263; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1344
diff
changeset
|
1257 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
|
1258 s->unrestricted_mv = 1; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1344
diff
changeset
|
1259 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
|
1260 avctx->delay=0; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1344
diff
changeset
|
1261 s->low_delay=1; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1344
diff
changeset
|
1262 break; |
0 | 1263 case CODEC_ID_RV10: |
1264 s->out_format = FMT_H263; | |
336 | 1265 avctx->delay=0; |
924 | 1266 s->low_delay=1; |
0 | 1267 break; |
2380 | 1268 case CODEC_ID_RV20: |
1269 s->out_format = FMT_H263; | |
1270 avctx->delay=0; | |
1271 s->low_delay=1; | |
1272 s->modified_quant=1; | |
1273 s->h263_aic=1; | |
1274 s->h263_plus=1; | |
1275 s->loop_filter=1; | |
1276 s->unrestricted_mv= s->obmc || s->loop_filter || s->umvplus; | |
1277 break; | |
71 | 1278 case CODEC_ID_MPEG4: |
0 | 1279 s->out_format = FMT_H263; |
1280 s->h263_pred = 1; | |
1281 s->unrestricted_mv = 1; | |
924 | 1282 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
|
1283 avctx->delay= s->low_delay ? 0 : (s->max_b_frames + 1); |
0 | 1284 break; |
307 | 1285 case CODEC_ID_MSMPEG4V1: |
0 | 1286 s->out_format = FMT_H263; |
1287 s->h263_msmpeg4 = 1; | |
1288 s->h263_pred = 1; | |
1289 s->unrestricted_mv = 1; | |
307 | 1290 s->msmpeg4_version= 1; |
336 | 1291 avctx->delay=0; |
924 | 1292 s->low_delay=1; |
307 | 1293 break; |
1294 case CODEC_ID_MSMPEG4V2: | |
1295 s->out_format = FMT_H263; | |
1296 s->h263_msmpeg4 = 1; | |
1297 s->h263_pred = 1; | |
1298 s->unrestricted_mv = 1; | |
1299 s->msmpeg4_version= 2; | |
336 | 1300 avctx->delay=0; |
924 | 1301 s->low_delay=1; |
307 | 1302 break; |
1303 case CODEC_ID_MSMPEG4V3: | |
1304 s->out_format = FMT_H263; | |
1305 s->h263_msmpeg4 = 1; | |
1306 s->h263_pred = 1; | |
1307 s->unrestricted_mv = 1; | |
1308 s->msmpeg4_version= 3; | |
1163 | 1309 s->flipflop_rounding=1; |
336 | 1310 avctx->delay=0; |
924 | 1311 s->low_delay=1; |
0 | 1312 break; |
499 | 1313 case CODEC_ID_WMV1: |
1314 s->out_format = FMT_H263; | |
1315 s->h263_msmpeg4 = 1; | |
1316 s->h263_pred = 1; | |
1317 s->unrestricted_mv = 1; | |
1318 s->msmpeg4_version= 4; | |
1163 | 1319 s->flipflop_rounding=1; |
499 | 1320 avctx->delay=0; |
924 | 1321 s->low_delay=1; |
499 | 1322 break; |
1323 case CODEC_ID_WMV2: | |
1324 s->out_format = FMT_H263; | |
1325 s->h263_msmpeg4 = 1; | |
1326 s->h263_pred = 1; | |
1327 s->unrestricted_mv = 1; | |
1328 s->msmpeg4_version= 5; | |
1163 | 1329 s->flipflop_rounding=1; |
499 | 1330 avctx->delay=0; |
924 | 1331 s->low_delay=1; |
499 | 1332 break; |
0 | 1333 default: |
1334 return -1; | |
1335 } | |
2967 | 1336 |
2042 | 1337 avctx->has_b_frames= !s->low_delay; |
1749
7b11032507e2
removing broken framerate conversation hack in mpeg1/2
michael
parents:
1742
diff
changeset
|
1338 |
7
1d3ac9654178
added skip macroblock optimization (big perf win on black regions for example)
glantau
parents:
0
diff
changeset
|
1339 s->encoding = 1; |
1d3ac9654178
added skip macroblock optimization (big perf win on black regions for example)
glantau
parents:
0
diff
changeset
|
1340 |
0 | 1341 /* init */ |
1342 if (MPV_common_init(s) < 0) | |
1343 return -1; | |
1678 | 1344 |
1345 if(s->modified_quant) | |
1346 s->chroma_qscale_table= ff_h263_chroma_qscale_table; | |
2967 | 1347 s->progressive_frame= |
4121 | 1348 s->progressive_sequence= !(avctx->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME|CODEC_FLAG_ALT_SCAN)); |
1799 | 1349 s->quant_precision=5; |
2967 | 1350 |
1729 | 1351 ff_set_cmp(&s->dsp, s->dsp.ildct_cmp, s->avctx->ildct_cmp); |
2382 | 1352 ff_set_cmp(&s->dsp, s->dsp.frame_skip_cmp, s->avctx->frame_skip_cmp); |
2967 | 1353 |
4997 | 1354 if (ENABLE_H261_ENCODER && s->out_format == FMT_H261) |
2327
5e5cf598a48b
H.261 encoder by (Maarten Daniels <maarten dot daniels at luc dot ac dot be>)
michael
parents:
2298
diff
changeset
|
1355 ff_h261_encode_init(s); |
706
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
1356 if (s->out_format == FMT_H263) |
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
1357 h263_encode_init(s); |
4967
6d45158e0249
disable reference to msmpeg4 and wmv2 code when those codecs are not compiled in
aurel
parents:
4668
diff
changeset
|
1358 if (ENABLE_MSMPEG4_ENCODER && s->msmpeg4_version) |
706
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
1359 ff_msmpeg4_encode_init(s); |
1042 | 1360 if (s->out_format == FMT_MPEG1) |
1361 ff_mpeg1_encode_init(s); | |
706
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
1362 |
1892 | 1363 /* init q matrix */ |
60 | 1364 for(i=0;i<64;i++) { |
1092 | 1365 int j= s->dsp.idct_permutation[i]; |
599 | 1366 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
|
1367 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
|
1368 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
|
1369 }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
|
1370 s->intra_matrix[j] = |
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
1371 s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i]; |
1042 | 1372 }else |
1421 | 1373 { /* mpeg1/2 */ |
706
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
1374 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
|
1375 s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i]; |
599 | 1376 } |
1411 | 1377 if(s->avctx->intra_matrix) |
1378 s->intra_matrix[j] = s->avctx->intra_matrix[i]; | |
1379 if(s->avctx->inter_matrix) | |
1380 s->inter_matrix[j] = s->avctx->inter_matrix[i]; | |
344 | 1381 } |
1382 | |
1383 /* precompute matrix */ | |
350
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
347
diff
changeset
|
1384 /* for mjpeg, we do include qscale in the matrix */ |
344 | 1385 if (s->out_format != FMT_MJPEG) { |
2967 | 1386 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
|
1387 s->intra_matrix, s->intra_quant_bias, avctx->qmin, 31, 1); |
2967 | 1388 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
|
1389 s->inter_matrix, s->inter_quant_bias, avctx->qmin, 31, 0); |
60 | 1390 } |
1391 | |
329 | 1392 if(ff_rate_control_init(s) < 0) |
1393 return -1; | |
2967 | 1394 |
0 | 1395 return 0; |
1396 } | |
1397 | |
1398 int MPV_encode_end(AVCodecContext *avctx) | |
1399 { | |
1400 MpegEncContext *s = avctx->priv_data; | |
1401 | |
329 | 1402 ff_rate_control_uninit(s); |
1403 | |
0 | 1404 MPV_common_end(s); |
4995 | 1405 if ((ENABLE_MJPEG_ENCODER || ENABLE_LJPEG_ENCODER) && s->out_format == FMT_MJPEG) |
5029
dbaa06366c3c
add a proper prefix to all mjpeg encoder exported functions
aurel
parents:
5028
diff
changeset
|
1406 ff_mjpeg_encode_close(s); |
1458
40b69d238beb
AVI stream header FCC / more reliable detection of old xvid files
michaelni
parents:
1451
diff
changeset
|
1407 |
1424 | 1408 av_freep(&avctx->extradata); |
2967 | 1409 |
0 | 1410 return 0; |
1411 } | |
1412 | |
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
|
1413 #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
|
1414 |
4668 | 1415 void init_rl(RLTable *rl, uint8_t static_store[2][2*MAX_RUN + MAX_LEVEL + 3]) |
1042 | 1416 { |
1064 | 1417 int8_t max_level[MAX_RUN+1], max_run[MAX_LEVEL+1]; |
1418 uint8_t index_run[MAX_RUN+1]; | |
1042 | 1419 int last, run, level, start, end, i; |
1420 | |
2370
26560d4fdb1f
Memory leak fix patch by (Burkhard Plaum <plaum >at< ipf.uni-stuttgart )dot( de>)
michael
parents:
2364
diff
changeset
|
1421 /* If table is static, we can quit if rl->max_level[0] is not NULL */ |
4668 | 1422 if(static_store && rl->max_level[0]) |
2370
26560d4fdb1f
Memory leak fix patch by (Burkhard Plaum <plaum >at< ipf.uni-stuttgart )dot( de>)
michael
parents:
2364
diff
changeset
|
1423 return; |
26560d4fdb1f
Memory leak fix patch by (Burkhard Plaum <plaum >at< ipf.uni-stuttgart )dot( de>)
michael
parents:
2364
diff
changeset
|
1424 |
1042 | 1425 /* compute max_level[], max_run[] and index_run[] */ |
1426 for(last=0;last<2;last++) { | |
1427 if (last == 0) { | |
1428 start = 0; | |
1429 end = rl->last; | |
1430 } else { | |
1431 start = rl->last; | |
1432 end = rl->n; | |
1433 } | |
1434 | |
1435 memset(max_level, 0, MAX_RUN + 1); | |
1436 memset(max_run, 0, MAX_LEVEL + 1); | |
1437 memset(index_run, rl->n, MAX_RUN + 1); | |
1438 for(i=start;i<end;i++) { | |
1439 run = rl->table_run[i]; | |
1440 level = rl->table_level[i]; | |
1441 if (index_run[run] == rl->n) | |
1442 index_run[run] = i; | |
1443 if (level > max_level[run]) | |
1444 max_level[run] = level; | |
1445 if (run > max_run[level]) | |
1446 max_run[level] = run; | |
1447 } | |
4668 | 1448 if(static_store) |
1449 rl->max_level[last] = static_store[last]; | |
2370
26560d4fdb1f
Memory leak fix patch by (Burkhard Plaum <plaum >at< ipf.uni-stuttgart )dot( de>)
michael
parents:
2364
diff
changeset
|
1450 else |
26560d4fdb1f
Memory leak fix patch by (Burkhard Plaum <plaum >at< ipf.uni-stuttgart )dot( de>)
michael
parents:
2364
diff
changeset
|
1451 rl->max_level[last] = av_malloc(MAX_RUN + 1); |
1042 | 1452 memcpy(rl->max_level[last], max_level, MAX_RUN + 1); |
4668 | 1453 if(static_store) |
1454 rl->max_run[last] = static_store[last] + MAX_RUN + 1; | |
2370
26560d4fdb1f
Memory leak fix patch by (Burkhard Plaum <plaum >at< ipf.uni-stuttgart )dot( de>)
michael
parents:
2364
diff
changeset
|
1455 else |
26560d4fdb1f
Memory leak fix patch by (Burkhard Plaum <plaum >at< ipf.uni-stuttgart )dot( de>)
michael
parents:
2364
diff
changeset
|
1456 rl->max_run[last] = av_malloc(MAX_LEVEL + 1); |
1042 | 1457 memcpy(rl->max_run[last], max_run, MAX_LEVEL + 1); |
4668 | 1458 if(static_store) |
1459 rl->index_run[last] = static_store[last] + MAX_RUN + MAX_LEVEL + 2; | |
2370
26560d4fdb1f
Memory leak fix patch by (Burkhard Plaum <plaum >at< ipf.uni-stuttgart )dot( de>)
michael
parents:
2364
diff
changeset
|
1460 else |
26560d4fdb1f
Memory leak fix patch by (Burkhard Plaum <plaum >at< ipf.uni-stuttgart )dot( de>)
michael
parents:
2364
diff
changeset
|
1461 rl->index_run[last] = av_malloc(MAX_RUN + 1); |
1042 | 1462 memcpy(rl->index_run[last], index_run, MAX_RUN + 1); |
1463 } | |
1464 } | |
1465 | |
0 | 1466 /* 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
|
1467 //FIXME check that this is ok for mpeg4 interlaced |
1064 | 1468 static void draw_edges_c(uint8_t *buf, int wrap, int width, int height, int w) |
0 | 1469 { |
1064 | 1470 uint8_t *ptr, *last_line; |
0 | 1471 int i; |
1472 | |
1473 last_line = buf + (height - 1) * wrap; | |
1474 for(i=0;i<w;i++) { | |
1475 /* top and bottom */ | |
1476 memcpy(buf - (i + 1) * wrap, buf, width); | |
1477 memcpy(last_line + (i + 1) * wrap, last_line, width); | |
1478 } | |
1479 /* left and right */ | |
1480 ptr = buf; | |
1481 for(i=0;i<height;i++) { | |
1482 memset(ptr - w, ptr[0], w); | |
1483 memset(ptr + width, ptr[width-1], w); | |
1484 ptr += wrap; | |
1485 } | |
1486 /* corners */ | |
1487 for(i=0;i<w;i++) { | |
1488 memset(buf - (i + 1) * wrap - w, buf[0], w); /* top left */ | |
1489 memset(buf - (i + 1) * wrap + width, buf[width-1], w); /* top right */ | |
1490 memset(last_line + (i + 1) * wrap - w, last_line[0], w); /* top left */ | |
1491 memset(last_line + (i + 1) * wrap + width, last_line[width-1], w); /* top right */ | |
1492 } | |
1493 } | |
1494 | |
1586 | 1495 int ff_find_unused_picture(MpegEncContext *s, int shared){ |
924 | 1496 int i; |
2967 | 1497 |
924 | 1498 if(shared){ |
1499 for(i=0; i<MAX_PICTURE_COUNT; i++){ | |
1586 | 1500 if(s->picture[i].data[0]==NULL && s->picture[i].type==0) return i; |
924 | 1501 } |
1502 }else{ | |
1503 for(i=0; i<MAX_PICTURE_COUNT; i++){ | |
1586 | 1504 if(s->picture[i].data[0]==NULL && s->picture[i].type!=0) return i; //FIXME |
924 | 1505 } |
1506 for(i=0; i<MAX_PICTURE_COUNT; i++){ | |
1586 | 1507 if(s->picture[i].data[0]==NULL) return i; |
924 | 1508 } |
1509 } | |
1510 | |
1586 | 1511 assert(0); |
1512 return -1; | |
924 | 1513 } |
1514 | |
1597 | 1515 static void update_noise_reduction(MpegEncContext *s){ |
1516 int intra, i; | |
1517 | |
1518 for(intra=0; intra<2; intra++){ | |
1519 if(s->dct_count[intra] > (1<<16)){ | |
1520 for(i=0; i<64; i++){ | |
1521 s->dct_error_sum[intra][i] >>=1; | |
1522 } | |
1523 s->dct_count[intra] >>= 1; | |
1524 } | |
2967 | 1525 |
1597 | 1526 for(i=0; i<64; i++){ |
1527 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); | |
1528 } | |
1529 } | |
1530 } | |
1531 | |
1586 | 1532 /** |
1533 * generic function for encode/decode called after coding/decoding the header and before a frame is coded/decoded | |
1534 */ | |
771
d4cc92144266
handle direct rendering buffer allocation failure
michaelni
parents:
768
diff
changeset
|
1535 int MPV_frame_start(MpegEncContext *s, AVCodecContext *avctx) |
0 | 1536 { |
924 | 1537 int i; |
925 | 1538 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
|
1539 s->mb_skipped = 0; |
1168 | 1540 |
1234 | 1541 assert(s->last_picture_ptr==NULL || s->out_format != FMT_H264 || s->codec_id == CODEC_ID_SVQ3); |
1228 | 1542 |
903 | 1543 /* mark&release old frames */ |
1944 | 1544 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
|
1545 if(s->out_format != FMT_H264 || s->codec_id == CODEC_ID_SVQ3){ |
1138 | 1546 avctx->release_buffer(avctx, (AVFrame*)s->last_picture_ptr); |
903 | 1547 |
1548 /* release forgotten pictures */ | |
1549 /* if(mpeg124/h263) */ | |
1550 if(!s->encoding){ | |
1551 for(i=0; i<MAX_PICTURE_COUNT; i++){ | |
1138 | 1552 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
|
1553 av_log(avctx, AV_LOG_ERROR, "releasing zombie picture\n"); |
2967 | 1554 avctx->release_buffer(avctx, (AVFrame*)&s->picture[i]); |
903 | 1555 } |
1556 } | |
1557 } | |
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
|
1558 } |
903 | 1559 } |
910
eb448df811be
fixing files where the first frame isn a keyframe
michaelni
parents:
909
diff
changeset
|
1560 alloc: |
eb448df811be
fixing files where the first frame isn a keyframe
michaelni
parents:
909
diff
changeset
|
1561 if(!s->encoding){ |
2764 | 1562 /* release non reference frames */ |
1228 | 1563 for(i=0; i<MAX_PICTURE_COUNT; i++){ |
1564 if(s->picture[i].data[0] && !s->picture[i].reference /*&& s->picture[i].type!=FF_BUFFER_TYPE_SHARED*/){ | |
1565 s->avctx->release_buffer(s->avctx, (AVFrame*)&s->picture[i]); | |
1566 } | |
1567 } | |
1568 | |
1586 | 1569 if(s->current_picture_ptr && s->current_picture_ptr->data[0]==NULL) |
1570 pic= (AVFrame*)s->current_picture_ptr; //we allready have a unused image (maybe it was set before reading the header) | |
1571 else{ | |
1572 i= ff_find_unused_picture(s, 0); | |
1573 pic= (AVFrame*)&s->picture[i]; | |
1574 } | |
1575 | |
2537
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2534
diff
changeset
|
1576 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
|
1577 && !s->dropable ? 3 : 0; |
1138 | 1578 |
1705 | 1579 pic->coded_picture_number= s->coded_picture_number++; |
2967 | 1580 |
1384 | 1581 if( alloc_picture(s, (Picture*)pic, 0) < 0) |
1582 return -1; | |
903 | 1583 |
1586 | 1584 s->current_picture_ptr= (Picture*)pic; |
1658 | 1585 s->current_picture_ptr->top_field_first= s->top_field_first; //FIXME use only the vars from current_pic |
1659 | 1586 s->current_picture_ptr->interlaced_frame= !s->progressive_frame && !s->progressive_sequence; |
903 | 1587 } |
456 | 1588 |
1173 | 1589 s->current_picture_ptr->pict_type= s->pict_type; |
2967 | 1590 // 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
|
1591 // 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
|
1592 s->current_picture_ptr->key_frame= s->pict_type == I_TYPE; |
1173 | 1593 |
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
|
1594 copy_picture(&s->current_picture, s->current_picture_ptr); |
2967 | 1595 |
903 | 1596 if (s->pict_type != B_TYPE) { |
1138 | 1597 s->last_picture_ptr= s->next_picture_ptr; |
1944 | 1598 if(!s->dropable) |
1599 s->next_picture_ptr= s->current_picture_ptr; | |
1600 } | |
1601 /* 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 | 1602 s->last_picture_ptr ? s->last_picture_ptr->data[0] : NULL, |
1603 s->next_picture_ptr ? s->next_picture_ptr->data[0] : NULL, | |
1944 | 1604 s->current_picture_ptr ? s->current_picture_ptr->data[0] : NULL, |
1605 s->pict_type, s->dropable);*/ | |
2967 | 1606 |
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
|
1607 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
|
1608 if(s->next_picture_ptr) copy_picture(&s->next_picture, s->next_picture_ptr); |
2967 | 1609 |
4413
371bb9f644da
fix inifnite loop with http://sam.zoy.org/zzuf/lol-mplayer.mpg
michael
parents:
4399
diff
changeset
|
1610 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
|
1611 av_log(avctx, AV_LOG_ERROR, "warning: first frame is no keyframe\n"); |
2764 | 1612 assert(s->pict_type != B_TYPE); //these should have been dropped if we don't have a reference |
1393 | 1613 goto alloc; |
1614 } | |
1615 | |
1616 assert(s->pict_type == I_TYPE || (s->last_picture_ptr && s->last_picture_ptr->data[0])); | |
1617 | |
1138 | 1618 if(s->picture_structure!=PICT_FRAME){ |
1619 int i; | |
1620 for(i=0; i<4; i++){ | |
1621 if(s->picture_structure == PICT_BOTTOM_FIELD){ | |
1622 s->current_picture.data[i] += s->current_picture.linesize[i]; | |
2967 | 1623 } |
1138 | 1624 s->current_picture.linesize[i] *= 2; |
1625 s->last_picture.linesize[i] *=2; | |
1626 s->next_picture.linesize[i] *=2; | |
1627 } | |
553 | 1628 } |
2967 | 1629 |
910
eb448df811be
fixing files where the first frame isn a keyframe
michaelni
parents:
909
diff
changeset
|
1630 s->hurry_up= s->avctx->hurry_up; |
eb448df811be
fixing files where the first frame isn a keyframe
michaelni
parents:
909
diff
changeset
|
1631 s->error_resilience= avctx->error_resilience; |
eb448df811be
fixing files where the first frame isn a keyframe
michaelni
parents:
909
diff
changeset
|
1632 |
2764 | 1633 /* set dequantizer, we can't do it during init as it might change for mpeg4 |
5127 | 1634 and we can't do it in the header decode as init is not called for mpeg4 there yet */ |
1689 | 1635 if(s->mpeg_quant || s->codec_id == CODEC_ID_MPEG2VIDEO){ |
1636 s->dct_unquantize_intra = s->dct_unquantize_mpeg2_intra; | |
1637 s->dct_unquantize_inter = s->dct_unquantize_mpeg2_inter; | |
2345 | 1638 }else if(s->out_format == FMT_H263 || s->out_format == FMT_H261){ |
1689 | 1639 s->dct_unquantize_intra = s->dct_unquantize_h263_intra; |
1640 s->dct_unquantize_inter = s->dct_unquantize_h263_inter; | |
1641 }else{ | |
1642 s->dct_unquantize_intra = s->dct_unquantize_mpeg1_intra; | |
1643 s->dct_unquantize_inter = s->dct_unquantize_mpeg1_inter; | |
1644 } | |
771
d4cc92144266
handle direct rendering buffer allocation failure
michaelni
parents:
768
diff
changeset
|
1645 |
1597 | 1646 if(s->dct_error_sum){ |
1647 assert(s->avctx->noise_reduction && s->encoding); | |
1648 | |
1649 update_noise_reduction(s); | |
1650 } | |
2967 | 1651 |
1381 | 1652 #ifdef HAVE_XVMC |
1653 if(s->avctx->xvmc_acceleration) | |
1654 return XVMC_field_start(s, avctx); | |
1655 #endif | |
771
d4cc92144266
handle direct rendering buffer allocation failure
michaelni
parents:
768
diff
changeset
|
1656 return 0; |
0 | 1657 } |
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
|
1658 |
0 | 1659 /* generic function for encode/decode called after a frame has been coded/decoded */ |
1660 void MPV_frame_end(MpegEncContext *s) | |
1661 { | |
903 | 1662 int i; |
0 | 1663 /* draw edge for correct motion prediction if outside */ |
1381 | 1664 #ifdef HAVE_XVMC |
1665 //just to make sure that all data is rendered. | |
1666 if(s->avctx->xvmc_acceleration){ | |
1667 XVMC_field_end(s); | |
1668 }else | |
1669 #endif | |
2537
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2534
diff
changeset
|
1670 if(s->unrestricted_mv && s->current_picture.reference && !s->intra_only && !(s->flags&CODEC_FLAG_EMU_EDGE)) { |
903 | 1671 draw_edges(s->current_picture.data[0], s->linesize , s->h_edge_pos , s->v_edge_pos , EDGE_WIDTH ); |
1672 draw_edges(s->current_picture.data[1], s->uvlinesize, s->h_edge_pos>>1, s->v_edge_pos>>1, EDGE_WIDTH/2); | |
1673 draw_edges(s->current_picture.data[2], s->uvlinesize, s->h_edge_pos>>1, s->v_edge_pos>>1, EDGE_WIDTH/2); | |
0 | 1674 } |
207 | 1675 emms_c(); |
2967 | 1676 |
612 | 1677 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
|
1678 s->last_lambda_for[s->pict_type]= s->current_picture_ptr->quality; |
329 | 1679 if(s->pict_type!=B_TYPE){ |
1680 s->last_non_b_pict_type= s->pict_type; | |
1681 } | |
1138 | 1682 #if 0 |
1683 /* copy back current_picture variables */ | |
903 | 1684 for(i=0; i<MAX_PICTURE_COUNT; i++){ |
1685 if(s->picture[i].data[0] == s->current_picture.data[0]){ | |
1686 s->picture[i]= s->current_picture; | |
1687 break; | |
2967 | 1688 } |
903 | 1689 } |
1690 assert(i<MAX_PICTURE_COUNT); | |
2967 | 1691 #endif |
903 | 1692 |
1228 | 1693 if(s->encoding){ |
2764 | 1694 /* release non-reference frames */ |
1228 | 1695 for(i=0; i<MAX_PICTURE_COUNT; i++){ |
1696 if(s->picture[i].data[0] && !s->picture[i].reference /*&& s->picture[i].type!=FF_BUFFER_TYPE_SHARED*/){ | |
1697 s->avctx->release_buffer(s->avctx, (AVFrame*)&s->picture[i]); | |
1698 } | |
1699 } | |
324 | 1700 } |
1138 | 1701 // clear copies, to avoid confusion |
1702 #if 0 | |
1703 memset(&s->last_picture, 0, sizeof(Picture)); | |
1704 memset(&s->next_picture, 0, sizeof(Picture)); | |
1705 memset(&s->current_picture, 0, sizeof(Picture)); | |
1706 #endif | |
2213 | 1707 s->avctx->coded_frame= (AVFrame*)s->current_picture_ptr; |
903 | 1708 } |
1709 | |
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
|
1710 /** |
1285 | 1711 * draws an line from (ex, ey) -> (sx, sy). |
1712 * @param w width of the image | |
1713 * @param h height of the image | |
1714 * @param stride stride/linesize of the image | |
1715 * @param color color of the arrow | |
1716 */ | |
1717 static void draw_line(uint8_t *buf, int sx, int sy, int ex, int ey, int w, int h, int stride, int color){ | |
3595 | 1718 int x, y, fr, f; |
2967 | 1719 |
4594 | 1720 sx= av_clip(sx, 0, w-1); |
1721 sy= av_clip(sy, 0, h-1); | |
1722 ex= av_clip(ex, 0, w-1); | |
1723 ey= av_clip(ey, 0, h-1); | |
2967 | 1724 |
1285 | 1725 buf[sy*stride + sx]+= color; |
2967 | 1726 |
4001 | 1727 if(FFABS(ex - sx) > FFABS(ey - sy)){ |
1285 | 1728 if(sx > ex){ |
4120 | 1729 FFSWAP(int, sx, ex); |
1730 FFSWAP(int, sy, ey); | |
1285 | 1731 } |
1732 buf+= sx + sy*stride; | |
1733 ex-= sx; | |
1734 f= ((ey-sy)<<16)/ex; | |
1735 for(x= 0; x <= ex; x++){ | |
1918
ea20f38b8d57
nicer looking arrows for the motion vector vissualization
michael
parents:
1916
diff
changeset
|
1736 y = (x*f)>>16; |
ea20f38b8d57
nicer looking arrows for the motion vector vissualization
michael
parents:
1916
diff
changeset
|
1737 fr= (x*f)&0xFFFF; |
ea20f38b8d57
nicer looking arrows for the motion vector vissualization
michael
parents:
1916
diff
changeset
|
1738 buf[ y *stride + x]+= (color*(0x10000-fr))>>16; |
ea20f38b8d57
nicer looking arrows for the motion vector vissualization
michael
parents:
1916
diff
changeset
|
1739 buf[(y+1)*stride + x]+= (color* fr )>>16; |
1285 | 1740 } |
1741 }else{ | |
1742 if(sy > ey){ | |
4120 | 1743 FFSWAP(int, sx, ex); |
1744 FFSWAP(int, sy, ey); | |
1285 | 1745 } |
1746 buf+= sx + sy*stride; | |
1747 ey-= sy; | |
1748 if(ey) f= ((ex-sx)<<16)/ey; | |
1749 else f= 0; | |
1750 for(y= 0; y <= ey; y++){ | |
1918
ea20f38b8d57
nicer looking arrows for the motion vector vissualization
michael
parents:
1916
diff
changeset
|
1751 x = (y*f)>>16; |
ea20f38b8d57
nicer looking arrows for the motion vector vissualization
michael
parents:
1916
diff
changeset
|
1752 fr= (y*f)&0xFFFF; |
ea20f38b8d57
nicer looking arrows for the motion vector vissualization
michael
parents:
1916
diff
changeset
|
1753 buf[y*stride + x ]+= (color*(0x10000-fr))>>16;; |
ea20f38b8d57
nicer looking arrows for the motion vector vissualization
michael
parents:
1916
diff
changeset
|
1754 buf[y*stride + x+1]+= (color* fr )>>16;; |
1285 | 1755 } |
1756 } | |
1757 } | |
1758 | |
1759 /** | |
1760 * draws an arrow from (ex, ey) -> (sx, sy). | |
1761 * @param w width of the image | |
1762 * @param h height of the image | |
1763 * @param stride stride/linesize of the image | |
1764 * @param color color of the arrow | |
1765 */ | |
2967 | 1766 static void draw_arrow(uint8_t *buf, int sx, int sy, int ex, int ey, int w, int h, int stride, int color){ |
1285 | 1767 int dx,dy; |
1768 | |
4594 | 1769 sx= av_clip(sx, -100, w+100); |
1770 sy= av_clip(sy, -100, h+100); | |
1771 ex= av_clip(ex, -100, w+100); | |
1772 ey= av_clip(ey, -100, h+100); | |
2967 | 1773 |
1285 | 1774 dx= ex - sx; |
1775 dy= ey - sy; | |
2967 | 1776 |
1285 | 1777 if(dx*dx + dy*dy > 3*3){ |
1778 int rx= dx + dy; | |
1779 int ry= -dx + dy; | |
1780 int length= ff_sqrt((rx*rx + ry*ry)<<8); | |
2967 | 1781 |
1285 | 1782 //FIXME subpixel accuracy |
1783 rx= ROUNDED_DIV(rx*3<<4, length); | |
1784 ry= ROUNDED_DIV(ry*3<<4, length); | |
2967 | 1785 |
1285 | 1786 draw_line(buf, sx, sy, sx + rx, sy + ry, w, h, stride, color); |
1787 draw_line(buf, sx, sy, sx - ry, sy + rx, w, h, stride, color); | |
1788 } | |
1789 draw_line(buf, sx, sy, ex, ey, w, h, stride, color); | |
1790 } | |
1791 | |
1792 /** | |
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
|
1793 * 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
|
1794 */ |
1706
3ba5c493db6f
motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1705
diff
changeset
|
1795 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
|
1796 |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1173
diff
changeset
|
1797 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
|
1798 |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1173
diff
changeset
|
1799 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
|
1800 int x,y; |
2967 | 1801 |
1706
3ba5c493db6f
motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1705
diff
changeset
|
1802 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
|
1803 switch (pict->pict_type) { |
3ba5c493db6f
motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1705
diff
changeset
|
1804 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
|
1805 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
|
1806 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
|
1807 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
|
1808 case FF_SI_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"SI\n"); break; |
2967 | 1809 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
|
1810 } |
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
|
1811 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
|
1812 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
|
1813 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
|
1814 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
|
1815 if(count>9) count=9; |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1597
diff
changeset
|
1816 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
|
1817 } |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1173
diff
changeset
|
1818 if(s->avctx->debug&FF_DEBUG_QP){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1597
diff
changeset
|
1819 av_log(s->avctx, AV_LOG_DEBUG, "%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
|
1820 } |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1173
diff
changeset
|
1821 if(s->avctx->debug&FF_DEBUG_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
|
1822 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
|
1823 //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
|
1824 if(IS_PCM(mb_type)) |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1597
diff
changeset
|
1825 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
|
1826 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
|
1827 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
|
1828 else if(IS_INTRA4x4(mb_type)) |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1597
diff
changeset
|
1829 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
|
1830 else if(IS_INTRA16x16(mb_type)) |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1597
diff
changeset
|
1831 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
|
1832 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
|
1833 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
|
1834 else if(IS_DIRECT(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, "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
|
1836 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
|
1837 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
|
1838 else if(IS_GMC(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, "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
|
1840 else if(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, "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
|
1842 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
|
1843 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
|
1844 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
|
1845 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
|
1846 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
|
1847 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
|
1848 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
|
1849 } |
2967 | 1850 |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1173
diff
changeset
|
1851 //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
|
1852 if(IS_8X8(mb_type)) |
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 if(IS_16X8(mb_type)) |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1597
diff
changeset
|
1855 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
|
1856 else if(IS_8X16(mb_type)) |
2677 | 1857 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
|
1858 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
|
1859 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
|
1860 else |
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, "?"); |
2967 | 1862 |
1863 | |
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 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
|
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 |
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 } |
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, " "); |
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
|
1870 } |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1597
diff
changeset
|
1871 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
|
1872 } |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1173
diff
changeset
|
1873 } |
1668
30746f429df6
move motion_val & mb_type to AVFrame patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1662
diff
changeset
|
1874 |
1706
3ba5c493db6f
motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1705
diff
changeset
|
1875 if((s->avctx->debug&(FF_DEBUG_VIS_QP|FF_DEBUG_VIS_MB_TYPE)) || (s->avctx->debug_mv)){ |
1285 | 1876 const int shift= 1 + s->quarter_sample; |
1877 int mb_y; | |
1706
3ba5c493db6f
motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1705
diff
changeset
|
1878 uint8_t *ptr; |
1707 | 1879 int i; |
1723
033d889d7c2c
non YV12 vissualization fix by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1722
diff
changeset
|
1880 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
|
1881 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
|
1882 const int height= s->avctx->height; |
2395 | 1883 const int mv_sample_log2= 4 - pict->motion_subsample_log2; |
3268 | 1884 const int mv_stride= (s->mb_width << mv_sample_log2) + (s->codec_id == CODEC_ID_H264 ? 0 : 1); |
1285 | 1885 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
|
1886 |
1723
033d889d7c2c
non YV12 vissualization fix by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1722
diff
changeset
|
1887 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
|
1888 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
|
1889 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
|
1890 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
|
1891 } |
3ba5c493db6f
motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1705
diff
changeset
|
1892 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
|
1893 ptr= pict->data[0]; |
1285 | 1894 |
1895 for(mb_y=0; mb_y<s->mb_height; mb_y++){ | |
1896 int mb_x; | |
1897 for(mb_x=0; mb_x<s->mb_width; mb_x++){ | |
1898 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
|
1899 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
|
1900 int type; |
3ba5c493db6f
motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1705
diff
changeset
|
1901 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
|
1902 int direction = 0; |
1706
3ba5c493db6f
motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1705
diff
changeset
|
1903 switch (type) { |
3ba5c493db6f
motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1705
diff
changeset
|
1904 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
|
1905 continue; |
3ba5c493db6f
motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1705
diff
changeset
|
1906 direction = 0; |
3ba5c493db6f
motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1705
diff
changeset
|
1907 break; |
3ba5c493db6f
motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1705
diff
changeset
|
1908 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
|
1909 continue; |
3ba5c493db6f
motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1705
diff
changeset
|
1910 direction = 0; |
3ba5c493db6f
motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1705
diff
changeset
|
1911 break; |
3ba5c493db6f
motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1705
diff
changeset
|
1912 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
|
1913 continue; |
3ba5c493db6f
motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1705
diff
changeset
|
1914 direction = 1; |
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 } |
1712 | 1917 if(!USES_LIST(pict->mb_type[mb_index], direction)) |
1918 continue; | |
1919 | |
1706
3ba5c493db6f
motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1705
diff
changeset
|
1920 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
|
1921 int i; |
3ba5c493db6f
motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1705
diff
changeset
|
1922 for(i=0; i<4; i++){ |
1285 | 1923 int sx= mb_x*16 + 4 + 8*(i&1); |
1924 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
|
1925 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
|
1926 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
|
1927 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
|
1928 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
|
1929 } |
3ba5c493db6f
motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1705
diff
changeset
|
1930 }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
|
1931 int i; |
3ba5c493db6f
motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1705
diff
changeset
|
1932 for(i=0; i<2; i++){ |
1629
74685a0ec851
16x8 MV vissualization by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1628
diff
changeset
|
1933 int sx=mb_x*16 + 8; |
74685a0ec851
16x8 MV vissualization by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1628
diff
changeset
|
1934 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
|
1935 int xy= (mb_x*2 + (mb_y*2 + i)*mv_stride) << (mv_sample_log2-1); |
2395 | 1936 int mx=(pict->motion_val[direction][xy][0]>>shift); |
1937 int my=(pict->motion_val[direction][xy][1]>>shift); | |
2967 | 1938 |
2395 | 1939 if(IS_INTERLACED(pict->mb_type[mb_index])) |
1940 my*=2; | |
2967 | 1941 |
2395 | 1942 draw_arrow(ptr, sx, sy, mx+sx, my+sy, width, height, s->linesize, 100); |
1943 } | |
1944 }else if(IS_8X16(pict->mb_type[mb_index])){ | |
1945 int i; | |
1946 for(i=0; i<2; i++){ | |
1947 int sx=mb_x*16 + 4 + 8*i; | |
1948 int sy=mb_y*16 + 8; | |
2522
e25782262d7d
kill warnings patch by (M«©ns Rullg«©rd <mru inprovide com>)
michael
parents:
2514
diff
changeset
|
1949 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
|
1950 int mx=(pict->motion_val[direction][xy][0]>>shift); |
b306574523ad
fix y scale of mv vissualization of interlaced MVs
michael
parents:
1945
diff
changeset
|
1951 int my=(pict->motion_val[direction][xy][1]>>shift); |
2967 | 1952 |
1947
b306574523ad
fix y scale of mv vissualization of interlaced MVs
michael
parents:
1945
diff
changeset
|
1953 if(IS_INTERLACED(pict->mb_type[mb_index])) |
b306574523ad
fix y scale of mv vissualization of interlaced MVs
michael
parents:
1945
diff
changeset
|
1954 my*=2; |
2967 | 1955 |
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
|
1956 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
|
1957 } |
3ba5c493db6f
motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1705
diff
changeset
|
1958 }else{ |
3ba5c493db6f
motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1705
diff
changeset
|
1959 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
|
1960 int sy= mb_y*16 + 8; |
2395 | 1961 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
|
1962 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
|
1963 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
|
1964 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
|
1965 } |
2967 | 1966 } |
1685 | 1967 } |
1968 if((s->avctx->debug&FF_DEBUG_VIS_QP) && pict->motion_val){ | |
1969 uint64_t c= (pict->qscale_table[mb_index]*128/31) * 0x0101010101010101ULL; | |
1970 int y; | |
1971 for(y=0; y<8; y++){ | |
1972 *(uint64_t*)(pict->data[1] + 8*mb_x + (8*mb_y + y)*pict->linesize[1])= c; | |
1973 *(uint64_t*)(pict->data[2] + 8*mb_x + (8*mb_y + y)*pict->linesize[2])= c; | |
1974 } | |
1975 } | |
1976 if((s->avctx->debug&FF_DEBUG_VIS_MB_TYPE) && pict->motion_val){ | |
1977 int mb_type= pict->mb_type[mb_index]; | |
1978 uint64_t u,v; | |
1979 int y; | |
1980 #define COLOR(theta, r)\ | |
1981 u= (int)(128 + r*cos(theta*3.141592/180));\ | |
1982 v= (int)(128 + r*sin(theta*3.141592/180)); | |
1983 | |
2967 | 1984 |
1685 | 1985 u=v=128; |
1986 if(IS_PCM(mb_type)){ | |
1987 COLOR(120,48) | |
1988 }else if((IS_INTRA(mb_type) && IS_ACPRED(mb_type)) || IS_INTRA16x16(mb_type)){ | |
1989 COLOR(30,48) | |
1990 }else if(IS_INTRA4x4(mb_type)){ | |
1991 COLOR(90,48) | |
1992 }else if(IS_DIRECT(mb_type) && IS_SKIP(mb_type)){ | |
1993 // COLOR(120,48) | |
1994 }else if(IS_DIRECT(mb_type)){ | |
1995 COLOR(150,48) | |
1996 }else if(IS_GMC(mb_type) && IS_SKIP(mb_type)){ | |
1997 COLOR(170,48) | |
1998 }else if(IS_GMC(mb_type)){ | |
1999 COLOR(190,48) | |
2000 }else if(IS_SKIP(mb_type)){ | |
2001 // COLOR(180,48) | |
2002 }else if(!USES_LIST(mb_type, 1)){ | |
2003 COLOR(240,48) | |
2004 }else if(!USES_LIST(mb_type, 0)){ | |
2005 COLOR(0,48) | |
2006 }else{ | |
2007 assert(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1)); | |
2008 COLOR(300,48) | |
2009 } | |
2010 | |
2011 u*= 0x0101010101010101ULL; | |
2012 v*= 0x0101010101010101ULL; | |
2013 for(y=0; y<8; y++){ | |
2014 *(uint64_t*)(pict->data[1] + 8*mb_x + (8*mb_y + y)*pict->linesize[1])= u; | |
2015 *(uint64_t*)(pict->data[2] + 8*mb_x + (8*mb_y + y)*pict->linesize[2])= v; | |
2016 } | |
2017 | |
2018 //segmentation | |
2019 if(IS_8X8(mb_type) || IS_16X8(mb_type)){ | |
2020 *(uint64_t*)(pict->data[0] + 16*mb_x + 0 + (16*mb_y + 8)*pict->linesize[0])^= 0x8080808080808080ULL; | |
2021 *(uint64_t*)(pict->data[0] + 16*mb_x + 8 + (16*mb_y + 8)*pict->linesize[0])^= 0x8080808080808080ULL; | |
2022 } | |
2023 if(IS_8X8(mb_type) || IS_8X16(mb_type)){ | |
2024 for(y=0; y<16; y++) | |
2025 pict->data[0][16*mb_x + 8 + (16*mb_y + y)*pict->linesize[0]]^= 0x80; | |
2026 } | |
2534 | 2027 if(IS_8X8(mb_type) && mv_sample_log2 >= 2){ |
2028 int dm= 1 << (mv_sample_log2-2); | |
2029 for(i=0; i<4; i++){ | |
2030 int sx= mb_x*16 + 8*(i&1); | |
2031 int sy= mb_y*16 + 8*(i>>1); | |
2032 int xy= (mb_x*2 + (i&1) + (mb_y*2 + (i>>1))*mv_stride) << (mv_sample_log2-1); | |
2033 //FIXME bidir | |
2034 int32_t *mv = (int32_t*)&pict->motion_val[0][xy]; | |
2035 if(mv[0] != mv[dm] || mv[dm*mv_stride] != mv[dm*(mv_stride+1)]) | |
2036 for(y=0; y<8; y++) | |
2037 pict->data[0][sx + 4 + (sy + y)*pict->linesize[0]]^= 0x80; | |
2038 if(mv[0] != mv[dm*mv_stride] || mv[dm] != mv[dm*(mv_stride+1)]) | |
2039 *(uint64_t*)(pict->data[0] + sx + (sy + 4)*pict->linesize[0])^= 0x8080808080808080ULL; | |
2040 } | |
2041 } | |
2967 | 2042 |
1685 | 2043 if(IS_INTERLACED(mb_type) && s->codec_id == CODEC_ID_H264){ |
2044 // hmm | |
2045 } | |
1285 | 2046 } |
2047 s->mbskip_table[mb_index]=0; | |
2048 } | |
2049 } | |
2050 } | |
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
|
2051 } |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1173
diff
changeset
|
2052 |
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
|
2053 #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
|
2054 |
915 | 2055 static int get_sae(uint8_t *src, int ref, int stride){ |
2056 int x,y; | |
2057 int acc=0; | |
2967 | 2058 |
915 | 2059 for(y=0; y<16; y++){ |
2060 for(x=0; x<16; x++){ | |
4001 | 2061 acc+= FFABS(src[x+y*stride] - ref); |
915 | 2062 } |
2063 } | |
2967 | 2064 |
915 | 2065 return acc; |
2066 } | |
2067 | |
2068 static int get_intra_count(MpegEncContext *s, uint8_t *src, uint8_t *ref, int stride){ | |
2069 int x, y, w, h; | |
2070 int acc=0; | |
2967 | 2071 |
915 | 2072 w= s->width &~15; |
2073 h= s->height&~15; | |
2967 | 2074 |
915 | 2075 for(y=0; y<h; y+=16){ |
2076 for(x=0; x<w; x+=16){ | |
2077 int offset= x + y*stride; | |
1708 | 2078 int sad = s->dsp.sad[0](NULL, src + offset, ref + offset, stride, 16); |
915 | 2079 int mean= (s->dsp.pix_sum(src + offset, stride) + 128)>>8; |
2080 int sae = get_sae(src + offset, mean, stride); | |
2967 | 2081 |
915 | 2082 acc+= sae + 500 < sad; |
2083 } | |
2084 } | |
2085 return acc; | |
2086 } | |
2087 | |
924 | 2088 |
925 | 2089 static int load_input_picture(MpegEncContext *s, AVFrame *pic_arg){ |
1373 | 2090 AVFrame *pic=NULL; |
2427 | 2091 int64_t pts; |
924 | 2092 int i; |
903 | 2093 const int encoding_delay= s->max_b_frames; |
924 | 2094 int direct=1; |
2967 | 2095 |
2419 | 2096 if(pic_arg){ |
2427 | 2097 pts= pic_arg->pts; |
2098 pic_arg->display_picture_number= s->input_picture_number++; | |
2099 | |
2967 | 2100 if(pts != AV_NOPTS_VALUE){ |
2419 | 2101 if(s->user_specified_pts != AV_NOPTS_VALUE){ |
2637 | 2102 int64_t time= pts; |
2103 int64_t last= s->user_specified_pts; | |
2967 | 2104 |
2105 if(time <= last){ | |
2962 | 2106 av_log(s->avctx, AV_LOG_ERROR, "Error, Invalid timestamp=%"PRId64", last=%"PRId64"\n", pts, s->user_specified_pts); |
2419 | 2107 return -1; |
2108 } | |
2109 } | |
2427 | 2110 s->user_specified_pts= pts; |
2419 | 2111 }else{ |
2112 if(s->user_specified_pts != AV_NOPTS_VALUE){ | |
2967 | 2113 s->user_specified_pts= |
2637 | 2114 pts= s->user_specified_pts + 1; |
2962 | 2115 av_log(s->avctx, AV_LOG_INFO, "Warning: AVFrame.pts=? trying to guess (%"PRId64")\n", pts); |
2419 | 2116 }else{ |
2637 | 2117 pts= pic_arg->display_picture_number; |
2419 | 2118 } |
2119 } | |
2120 } | |
2121 | |
1373 | 2122 if(pic_arg){ |
924 | 2123 if(encoding_delay && !(s->flags&CODEC_FLAG_INPUT_PRESERVED)) direct=0; |
2124 if(pic_arg->linesize[0] != s->linesize) direct=0; | |
2125 if(pic_arg->linesize[1] != s->uvlinesize) direct=0; | |
2126 if(pic_arg->linesize[2] != s->uvlinesize) direct=0; | |
2967 | 2127 |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1597
diff
changeset
|
2128 // av_log(AV_LOG_DEBUG, "%d %d %d %d\n",pic_arg->linesize[0], pic_arg->linesize[1], s->linesize, s->uvlinesize); |
2967 | 2129 |
924 | 2130 if(direct){ |
1586 | 2131 i= ff_find_unused_picture(s, 1); |
924 | 2132 |
925 | 2133 pic= (AVFrame*)&s->picture[i]; |
1168 | 2134 pic->reference= 3; |
2967 | 2135 |
924 | 2136 for(i=0; i<4; i++){ |
2137 pic->data[i]= pic_arg->data[i]; | |
2138 pic->linesize[i]= pic_arg->linesize[i]; | |
2139 } | |
2140 alloc_picture(s, (Picture*)pic, 1); | |
2141 }else{ | |
1586 | 2142 i= ff_find_unused_picture(s, 0); |
924 | 2143 |
925 | 2144 pic= (AVFrame*)&s->picture[i]; |
1168 | 2145 pic->reference= 3; |
924 | 2146 |
2147 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
|
2148 |
3068 | 2149 if( pic->data[0] + INPLACE_OFFSET == pic_arg->data[0] |
2150 && pic->data[1] + INPLACE_OFFSET == pic_arg->data[1] | |
2151 && pic->data[2] + INPLACE_OFFSET == pic_arg->data[2]){ | |
924 | 2152 // empty |
2153 }else{ | |
2154 int h_chroma_shift, v_chroma_shift; | |
2155 avcodec_get_chroma_sub_sample(s->avctx->pix_fmt, &h_chroma_shift, &v_chroma_shift); | |
2967 | 2156 |
924 | 2157 for(i=0; i<3; i++){ |
2158 int src_stride= pic_arg->linesize[i]; | |
2159 int dst_stride= i ? s->uvlinesize : s->linesize; | |
2160 int h_shift= i ? h_chroma_shift : 0; | |
2161 int v_shift= i ? v_chroma_shift : 0; | |
2162 int w= s->width >>h_shift; | |
2163 int h= s->height>>v_shift; | |
2164 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
|
2165 uint8_t *dst= pic->data[i]; |
16ace038f452
fix buffer underflows by reencoding the current frame with a higher QP
michael
parents:
3929
diff
changeset
|
2166 |
16ace038f452
fix buffer underflows by reencoding the current frame with a higher QP
michael
parents:
3929
diff
changeset
|
2167 if(!s->avctx->rc_buffer_size) |
16ace038f452
fix buffer underflows by reencoding the current frame with a higher QP
michael
parents:
3929
diff
changeset
|
2168 dst +=INPLACE_OFFSET; |
2967 | 2169 |
924 | 2170 if(src_stride==dst_stride) |
2171 memcpy(dst, src, src_stride*h); | |
2172 else{ | |
2173 while(h--){ | |
2174 memcpy(dst, src, w); | |
2175 dst += dst_stride; | |
2176 src += src_stride; | |
2177 } | |
2178 } | |
2179 } | |
2180 } | |
324 | 2181 } |
1938
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1918
diff
changeset
|
2182 copy_picture_attributes(s, pic, pic_arg); |
2427 | 2183 pic->pts= pts; //we set this here to avoid modifiying pic_arg |
1373 | 2184 } |
2967 | 2185 |
903 | 2186 /* shift buffer entries */ |
2187 for(i=1; i<MAX_PICTURE_COUNT /*s->encoding_delay+1*/; i++) | |
2188 s->input_picture[i-1]= s->input_picture[i]; | |
2967 | 2189 |
903 | 2190 s->input_picture[encoding_delay]= (Picture*)pic; |
2191 | |
2192 return 0; | |
2193 } | |
2194 | |
2381 | 2195 static int skip_check(MpegEncContext *s, Picture *p, Picture *ref){ |
2196 int x, y, plane; | |
2197 int score=0; | |
2382 | 2198 int64_t score64=0; |
2381 | 2199 |
2200 for(plane=0; plane<3; plane++){ | |
2201 const int stride= p->linesize[plane]; | |
2202 const int bw= plane ? 1 : 2; | |
2203 for(y=0; y<s->mb_height*bw; y++){ | |
2204 for(x=0; x<s->mb_width*bw; x++){ | |
2931 | 2205 int off= p->type == FF_BUFFER_TYPE_SHARED ? 0: 16; |
2206 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 | 2207 |
2382 | 2208 switch(s->avctx->frame_skip_exp){ |
2209 case 0: score= FFMAX(score, v); break; | |
4001 | 2210 case 1: score+= FFABS(v);break; |
2382 | 2211 case 2: score+= v*v;break; |
4001 | 2212 case 3: score64+= FFABS(v*v*(int64_t)v);break; |
2382 | 2213 case 4: score64+= v*v*(int64_t)(v*v);break; |
2214 } | |
2381 | 2215 } |
2216 } | |
2217 } | |
2967 | 2218 |
2382 | 2219 if(score) score64= score; |
2220 | |
2221 if(score64 < s->avctx->frame_skip_threshold) | |
2381 | 2222 return 1; |
2382 | 2223 if(score64 < ((s->avctx->frame_skip_factor * (int64_t)s->lambda)>>8)) |
2381 | 2224 return 1; |
2225 return 0; | |
2226 } | |
2227 | |
2988 | 2228 static int estimate_best_b_count(MpegEncContext *s){ |
2229 AVCodec *codec= avcodec_find_encoder(s->avctx->codec_id); | |
2230 AVCodecContext *c= avcodec_alloc_context(); | |
2231 AVFrame input[FF_MAX_B_FRAMES+2]; | |
2990
0300c2647bc3
support downscaling frames for dynamic b frame decission
michael
parents:
2988
diff
changeset
|
2232 const int scale= s->avctx->brd_scale; |
3068 | 2233 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
|
2234 int outbuf_size= s->width * s->height; //FIXME |
2988 | 2235 uint8_t *outbuf= av_malloc(outbuf_size); |
2236 int64_t best_rd= INT64_MAX; | |
2237 int best_b_count= -1; | |
3068 | 2238 |
3245 | 2239 assert(scale>=0 && scale <=3); |
2240 | |
3068 | 2241 // emms_c(); |
2242 p_lambda= s->last_lambda_for[P_TYPE]; //s->next_picture_ptr->quality; | |
4001 | 2243 b_lambda= s->last_lambda_for[B_TYPE]; //p_lambda *FFABS(s->avctx->b_quant_factor) + s->avctx->b_quant_offset; |
3068 | 2244 if(!b_lambda) b_lambda= p_lambda; //FIXME we should do this somewhere else |
2245 lambda2= (b_lambda*b_lambda + (1<<FF_LAMBDA_SHIFT)/2 ) >> FF_LAMBDA_SHIFT; | |
2988 | 2246 |
2247 c->width = s->width >> scale; | |
2248 c->height= s->height>> scale; | |
2249 c->flags= CODEC_FLAG_QSCALE | CODEC_FLAG_PSNR | CODEC_FLAG_INPUT_PRESERVED /*| CODEC_FLAG_EMU_EDGE*/; | |
2250 c->flags|= s->avctx->flags & CODEC_FLAG_QPEL; | |
2251 c->mb_decision= s->avctx->mb_decision; | |
2252 c->me_cmp= s->avctx->me_cmp; | |
2253 c->mb_cmp= s->avctx->mb_cmp; | |
2254 c->me_sub_cmp= s->avctx->me_sub_cmp; | |
2255 c->pix_fmt = PIX_FMT_YUV420P; | |
2256 c->time_base= s->avctx->time_base; | |
2257 c->max_b_frames= s->max_b_frames; | |
2258 | |
2259 if (avcodec_open(c, codec) < 0) | |
2260 return -1; | |
2261 | |
2262 for(i=0; i<s->max_b_frames+2; i++){ | |
2263 int ysize= c->width*c->height; | |
2264 int csize= (c->width/2)*(c->height/2); | |
3068 | 2265 Picture pre_input, *pre_input_ptr= i ? s->input_picture[i-1] : s->next_picture_ptr; |
2266 | |
2988 | 2267 avcodec_get_frame_defaults(&input[i]); |
2268 input[i].data[0]= av_malloc(ysize + 2*csize); | |
2269 input[i].data[1]= input[i].data[0] + ysize; | |
2270 input[i].data[2]= input[i].data[1] + csize; | |
2271 input[i].linesize[0]= c->width; | |
2272 input[i].linesize[1]= | |
2273 input[i].linesize[2]= c->width/2; | |
2274 | |
4416 | 2275 if(pre_input_ptr && (!i || s->input_picture[i-1])) { |
2276 pre_input= *pre_input_ptr; | |
2277 | |
2278 if(pre_input.type != FF_BUFFER_TYPE_SHARED && i) { | |
2279 pre_input.data[0]+=INPLACE_OFFSET; | |
2280 pre_input.data[1]+=INPLACE_OFFSET; | |
2281 pre_input.data[2]+=INPLACE_OFFSET; | |
2282 } | |
2283 | |
3245 | 2284 s->dsp.shrink[scale](input[i].data[0], input[i].linesize[0], pre_input.data[0], pre_input.linesize[0], c->width, c->height); |
2285 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); | |
2286 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); | |
2287 } | |
2988 | 2288 } |
2289 | |
2290 for(j=0; j<s->max_b_frames+1; j++){ | |
2291 int64_t rd=0; | |
2292 | |
2293 if(!s->input_picture[j]) | |
2294 break; | |
2295 | |
2296 c->error[0]= c->error[1]= c->error[2]= 0; | |
2297 | |
2298 input[0].pict_type= I_TYPE; | |
3068 | 2299 input[0].quality= 1 * FF_QP2LAMBDA; |
2988 | 2300 out_size = avcodec_encode_video(c, outbuf, outbuf_size, &input[0]); |
3068 | 2301 // rd += (out_size * lambda2) >> FF_LAMBDA_SHIFT; |
2988 | 2302 |
2303 for(i=0; i<s->max_b_frames+1; i++){ | |
2304 int is_p= i % (j+1) == j || i==s->max_b_frames; | |
2305 | |
2306 input[i+1].pict_type= is_p ? P_TYPE : B_TYPE; | |
3068 | 2307 input[i+1].quality= is_p ? p_lambda : b_lambda; |
2988 | 2308 out_size = avcodec_encode_video(c, outbuf, outbuf_size, &input[i+1]); |
3068 | 2309 rd += (out_size * lambda2) >> (FF_LAMBDA_SHIFT - 3); |
2988 | 2310 } |
2311 | |
2312 /* get the delayed frames */ | |
2313 while(out_size){ | |
2314 out_size = avcodec_encode_video(c, outbuf, outbuf_size, NULL); | |
3068 | 2315 rd += (out_size * lambda2) >> (FF_LAMBDA_SHIFT - 3); |
2988 | 2316 } |
2317 | |
2318 rd += c->error[0] + c->error[1] + c->error[2]; | |
2319 | |
2320 if(rd < best_rd){ | |
2321 best_rd= rd; | |
2322 best_b_count= j; | |
2323 } | |
2324 } | |
2325 | |
2326 av_freep(&outbuf); | |
2327 avcodec_close(c); | |
2328 av_freep(&c); | |
2329 | |
2330 for(i=0; i<s->max_b_frames+2; i++){ | |
2331 av_freep(&input[i].data[0]); | |
2332 } | |
2333 | |
2334 return best_b_count; | |
2335 } | |
2336 | |
903 | 2337 static void select_input_picture(MpegEncContext *s){ |
2338 int i; | |
924 | 2339 |
903 | 2340 for(i=1; i<MAX_PICTURE_COUNT; i++) |
2341 s->reordered_input_picture[i-1]= s->reordered_input_picture[i]; | |
2342 s->reordered_input_picture[MAX_PICTURE_COUNT-1]= NULL; | |
2343 | |
2764 | 2344 /* set next picture type & ordering */ |
903 | 2345 if(s->reordered_input_picture[0]==NULL && s->input_picture[0]){ |
1138 | 2346 if(/*s->picture_in_gop_number >= s->gop_size ||*/ s->next_picture_ptr==NULL || s->intra_only){ |
915 | 2347 s->reordered_input_picture[0]= s->input_picture[0]; |
2348 s->reordered_input_picture[0]->pict_type= I_TYPE; | |
1705 | 2349 s->reordered_input_picture[0]->coded_picture_number= s->coded_picture_number++; |
915 | 2350 }else{ |
2351 int b_frames; | |
2381 | 2352 |
2353 if(s->avctx->frame_skip_threshold || s->avctx->frame_skip_factor){ | |
2931 | 2354 if(s->picture_in_gop_number < s->gop_size && skip_check(s, s->input_picture[0], s->next_picture_ptr)){ |
2355 //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
|
2356 //av_log(NULL, AV_LOG_DEBUG, "skip %p %"PRId64"\n", s->input_picture[0]->data[0], s->input_picture[0]->pts); |
2967 | 2357 |
2381 | 2358 if(s->input_picture[0]->type == FF_BUFFER_TYPE_SHARED){ |
2359 for(i=0; i<4; i++) | |
2360 s->input_picture[0]->data[i]= NULL; | |
2967 | 2361 s->input_picture[0]->type= 0; |
2381 | 2362 }else{ |
2967 | 2363 assert( s->input_picture[0]->type==FF_BUFFER_TYPE_USER |
2381 | 2364 || s->input_picture[0]->type==FF_BUFFER_TYPE_INTERNAL); |
2967 | 2365 |
2381 | 2366 s->avctx->release_buffer(s->avctx, (AVFrame*)s->input_picture[0]); |
2367 } | |
2967 | 2368 |
2931 | 2369 emms_c(); |
2370 ff_vbv_update(s, 0); | |
2381 | 2371 |
2372 goto no_output_pic; | |
2373 } | |
2374 } | |
2375 | |
915 | 2376 if(s->flags&CODEC_FLAG_PASS2){ |
2377 for(i=0; i<s->max_b_frames+1; i++){ | |
2378 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
|
2379 |
2967 | 2380 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
|
2381 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
|
2382 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
|
2383 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
|
2384 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
|
2385 } |
2364
f8a229dfa2e8
check num_entries too to avoid reading over the array end and dont check i>0 it must be >0 there
michael
parents:
2363
diff
changeset
|
2386 |
2967 | 2387 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
|
2388 s->rc_context.entry[pict_num].new_pict_type; |
915 | 2389 } |
2390 } | |
924 | 2391 |
2297 | 2392 if(s->avctx->b_frame_strategy==0){ |
915 | 2393 b_frames= s->max_b_frames; |
1373 | 2394 while(b_frames && !s->input_picture[b_frames]) b_frames--; |
1687 | 2395 }else if(s->avctx->b_frame_strategy==1){ |
915 | 2396 for(i=1; i<s->max_b_frames+1; i++){ |
1373 | 2397 if(s->input_picture[i] && s->input_picture[i]->b_frame_score==0){ |
2967 | 2398 s->input_picture[i]->b_frame_score= |
2399 get_intra_count(s, s->input_picture[i ]->data[0], | |
924 | 2400 s->input_picture[i-1]->data[0], s->linesize) + 1; |
915 | 2401 } |
2402 } | |
2728 | 2403 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
|
2404 if(s->input_picture[i]==NULL || s->input_picture[i]->b_frame_score - 1 > s->mb_num/s->avctx->b_sensitivity) break; |
915 | 2405 } |
2967 | 2406 |
915 | 2407 b_frames= FFMAX(0, i-1); |
2967 | 2408 |
915 | 2409 /* reset scores */ |
2410 for(i=0; i<b_frames+1; i++){ | |
2411 s->input_picture[i]->b_frame_score=0; | |
2412 } | |
2988 | 2413 }else if(s->avctx->b_frame_strategy==2){ |
2414 b_frames= estimate_best_b_count(s); | |
915 | 2415 }else{ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1597
diff
changeset
|
2416 av_log(s->avctx, AV_LOG_ERROR, "illegal b frame strategy\n"); |
915 | 2417 b_frames=0; |
909
8ae1e4c24e91
new PSNR code (now works with chroma, b frames, ...)
michaelni
parents:
903
diff
changeset
|
2418 } |
915 | 2419 |
2420 emms_c(); | |
2421 //static int b_count=0; | |
2422 //b_count+= b_frames; | |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1597
diff
changeset
|
2423 //av_log(s->avctx, AV_LOG_DEBUG, "b_frames: %d\n", b_count); |
2297 | 2424 |
2425 for(i= b_frames - 1; i>=0; i--){ | |
2426 int type= s->input_picture[i]->pict_type; | |
2427 if(type && type != B_TYPE) | |
2428 b_frames= i; | |
2429 } | |
2430 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
|
2431 av_log(s->avctx, AV_LOG_ERROR, "warning, too many b frames in a row\n"); |
2297 | 2432 } |
2433 | |
1754
bdf3927bf8c5
closed gop support & flags2 as all bits in flags are used
michael
parents:
1751
diff
changeset
|
2434 if(s->picture_in_gop_number + b_frames >= s->gop_size){ |
2298 | 2435 if((s->flags2 & CODEC_FLAG2_STRICT_GOP) && s->gop_size > s->picture_in_gop_number){ |
2436 b_frames= s->gop_size - s->picture_in_gop_number - 1; | |
2437 }else{ | |
1754
bdf3927bf8c5
closed gop support & flags2 as all bits in flags are used
michael
parents:
1751
diff
changeset
|
2438 if(s->flags & CODEC_FLAG_CLOSED_GOP) |
bdf3927bf8c5
closed gop support & flags2 as all bits in flags are used
michael
parents:
1751
diff
changeset
|
2439 b_frames=0; |
bdf3927bf8c5
closed gop support & flags2 as all bits in flags are used
michael
parents:
1751
diff
changeset
|
2440 s->input_picture[b_frames]->pict_type= I_TYPE; |
2298 | 2441 } |
1754
bdf3927bf8c5
closed gop support & flags2 as all bits in flags are used
michael
parents:
1751
diff
changeset
|
2442 } |
2967 | 2443 |
1754
bdf3927bf8c5
closed gop support & flags2 as all bits in flags are used
michael
parents:
1751
diff
changeset
|
2444 if( (s->flags & CODEC_FLAG_CLOSED_GOP) |
bdf3927bf8c5
closed gop support & flags2 as all bits in flags are used
michael
parents:
1751
diff
changeset
|
2445 && b_frames |
bdf3927bf8c5
closed gop support & flags2 as all bits in flags are used
michael
parents:
1751
diff
changeset
|
2446 && 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
|
2447 b_frames--; |
bdf3927bf8c5
closed gop support & flags2 as all bits in flags are used
michael
parents:
1751
diff
changeset
|
2448 |
915 | 2449 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
|
2450 if(s->reordered_input_picture[0]->pict_type != I_TYPE) |
915 | 2451 s->reordered_input_picture[0]->pict_type= P_TYPE; |
1705 | 2452 s->reordered_input_picture[0]->coded_picture_number= s->coded_picture_number++; |
915 | 2453 for(i=0; i<b_frames; i++){ |
2454 s->reordered_input_picture[i+1]= s->input_picture[i]; | |
2455 s->reordered_input_picture[i+1]->pict_type= B_TYPE; | |
1705 | 2456 s->reordered_input_picture[i+1]->coded_picture_number= s->coded_picture_number++; |
903 | 2457 } |
324 | 2458 } |
2459 } | |
2381 | 2460 no_output_pic: |
903 | 2461 if(s->reordered_input_picture[0]){ |
1168 | 2462 s->reordered_input_picture[0]->reference= s->reordered_input_picture[0]->pict_type!=B_TYPE ? 3 : 0; |
1138 | 2463 |
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
|
2464 copy_picture(&s->new_picture, s->reordered_input_picture[0]); |
924 | 2465 |
3939
16ace038f452
fix buffer underflows by reencoding the current frame with a higher QP
michael
parents:
3929
diff
changeset
|
2466 if(s->reordered_input_picture[0]->type == FF_BUFFER_TYPE_SHARED || s->avctx->rc_buffer_size){ |
2764 | 2467 // input is a shared pix, so we can't modifiy it -> alloc a new one & ensure that the shared one is reuseable |
2967 | 2468 |
1586 | 2469 int i= ff_find_unused_picture(s, 0); |
924 | 2470 Picture *pic= &s->picture[i]; |
2471 | |
3939
16ace038f452
fix buffer underflows by reencoding the current frame with a higher QP
michael
parents:
3929
diff
changeset
|
2472 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
|
2473 alloc_picture(s, pic, 0); |
16ace038f452
fix buffer underflows by reencoding the current frame with a higher QP
michael
parents:
3929
diff
changeset
|
2474 |
924 | 2475 /* 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
|
2476 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
|
2477 s->avctx->release_buffer(s->avctx, (AVFrame*)s->reordered_input_picture[0]); |
924 | 2478 for(i=0; i<4; i++) |
2479 s->reordered_input_picture[0]->data[i]= NULL; | |
2480 s->reordered_input_picture[0]->type= 0; | |
2967 | 2481 |
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
|
2482 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
|
2483 |
1138 | 2484 s->current_picture_ptr= pic; |
924 | 2485 }else{ |
1138 | 2486 // input is not a shared pix -> reuse buffer for current_pix |
2487 | |
2967 | 2488 assert( s->reordered_input_picture[0]->type==FF_BUFFER_TYPE_USER |
924 | 2489 || s->reordered_input_picture[0]->type==FF_BUFFER_TYPE_INTERNAL); |
2967 | 2490 |
1138 | 2491 s->current_picture_ptr= s->reordered_input_picture[0]; |
924 | 2492 for(i=0; i<4; i++){ |
3068 | 2493 s->new_picture.data[i]+= INPLACE_OFFSET; |
924 | 2494 } |
903 | 2495 } |
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
|
2496 copy_picture(&s->current_picture, s->current_picture_ptr); |
2967 | 2497 |
903 | 2498 s->picture_number= s->new_picture.display_picture_number; |
2499 //printf("dpn:%d\n", s->picture_number); | |
2500 }else{ | |
2501 memset(&s->new_picture, 0, sizeof(Picture)); | |
324 | 2502 } |
2503 } | |
2504 | |
0 | 2505 int MPV_encode_picture(AVCodecContext *avctx, |
2506 unsigned char *buf, int buf_size, void *data) | |
2507 { | |
2508 MpegEncContext *s = avctx->priv_data; | |
925 | 2509 AVFrame *pic_arg = data; |
1684 | 2510 int i, stuffing_count; |
0 | 2511 |
1799 | 2512 for(i=0; i<avctx->thread_count; i++){ |
1838 | 2513 int start_y= s->thread_context[i]->start_mb_y; |
2514 int end_y= s->thread_context[i]-> end_mb_y; | |
1799 | 2515 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
|
2516 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
|
2517 uint8_t *end = buf + (size_t)(((int64_t) buf_size)* end_y/h); |
1799 | 2518 |
2519 init_put_bits(&s->thread_context[i]->pb, start, end - start); | |
2520 } | |
0 | 2521 |
903 | 2522 s->picture_in_gop_number++; |
2523 | |
2243
b8bad8bbbc64
check if the user specified timestamps are strictly monotone
michael
parents:
2235
diff
changeset
|
2524 if(load_input_picture(s, pic_arg) < 0) |
b8bad8bbbc64
check if the user specified timestamps are strictly monotone
michael
parents:
2235
diff
changeset
|
2525 return -1; |
2967 | 2526 |
903 | 2527 select_input_picture(s); |
2967 | 2528 |
324 | 2529 /* output? */ |
903 | 2530 if(s->new_picture.data[0]){ |
2531 s->pict_type= s->new_picture.pict_type; | |
2532 //emms_c(); | |
2533 //printf("qs:%f %f %d\n", s->new_picture.quality, s->current_picture.quality, s->qscale); | |
553 | 2534 MPV_frame_start(s, avctx); |
3939
16ace038f452
fix buffer underflows by reencoding the current frame with a higher QP
michael
parents:
3929
diff
changeset
|
2535 vbv_retry: |
3766 | 2536 if (encode_picture(s, s->picture_number) < 0) |
2537 return -1; | |
2967 | 2538 |
376 | 2539 avctx->real_pict_num = s->picture_number; |
324 | 2540 avctx->header_bits = s->header_bits; |
2541 avctx->mv_bits = s->mv_bits; | |
2542 avctx->misc_bits = s->misc_bits; | |
2543 avctx->i_tex_bits = s->i_tex_bits; | |
2544 avctx->p_tex_bits = s->p_tex_bits; | |
2545 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
|
2546 avctx->p_count = s->mb_num - s->i_count - s->skip_count; //FIXME f/b_count in avctx |
324 | 2547 avctx->skip_count = s->skip_count; |
0 | 2548 |
324 | 2549 MPV_frame_end(s); |
2550 | |
4995 | 2551 if (ENABLE_MJPEG_ENCODER && s->out_format == FMT_MJPEG) |
5029
dbaa06366c3c
add a proper prefix to all mjpeg encoder exported functions
aurel
parents:
5028
diff
changeset
|
2552 ff_mjpeg_encode_picture_trailer(s); |
2967 | 2553 |
3939
16ace038f452
fix buffer underflows by reencoding the current frame with a higher QP
michael
parents:
3929
diff
changeset
|
2554 if(avctx->rc_buffer_size){ |
16ace038f452
fix buffer underflows by reencoding the current frame with a higher QP
michael
parents:
3929
diff
changeset
|
2555 RateControlContext *rcc= &s->rc_context; |
16ace038f452
fix buffer underflows by reencoding the current frame with a higher QP
michael
parents:
3929
diff
changeset
|
2556 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
|
2557 |
4096
99616a74260a
use lambda/lmax instead of qscale/qmax as end check for vbv retry
michael
parents:
4052
diff
changeset
|
2558 if(put_bits_count(&s->pb) > max_size && s->lambda < s->avctx->lmax){ |
4052 | 2559 s->next_lambda= FFMAX(s->lambda+1, s->lambda*(s->qscale+1) / s->qscale); |
4218 | 2560 if(s->adaptive_quant){ |
2561 int i; | |
4223 | 2562 for(i=0; i<s->mb_height*s->mb_stride; i++) |
4218 | 2563 s->lambda_table[i]= FFMAX(s->lambda_table[i]+1, s->lambda_table[i]*(s->qscale+1) / s->qscale); |
2564 } | |
3939
16ace038f452
fix buffer underflows by reencoding the current frame with a higher QP
michael
parents:
3929
diff
changeset
|
2565 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
|
2566 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
|
2567 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
|
2568 s->no_rounding ^= 1; |
16ace038f452
fix buffer underflows by reencoding the current frame with a higher QP
michael
parents:
3929
diff
changeset
|
2569 } |
4111 | 2570 if(s->pict_type!=B_TYPE){ |
2571 s->time_base= s->last_time_base; | |
2572 s->last_non_b_time= s->time - s->pp_time; | |
2573 } | |
3939
16ace038f452
fix buffer underflows by reencoding the current frame with a higher QP
michael
parents:
3929
diff
changeset
|
2574 // 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
|
2575 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
|
2576 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
|
2577 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
|
2578 } |
16ace038f452
fix buffer underflows by reencoding the current frame with a higher QP
michael
parents:
3929
diff
changeset
|
2579 goto vbv_retry; |
16ace038f452
fix buffer underflows by reencoding the current frame with a higher QP
michael
parents:
3929
diff
changeset
|
2580 } |
16ace038f452
fix buffer underflows by reencoding the current frame with a higher QP
michael
parents:
3929
diff
changeset
|
2581 |
16ace038f452
fix buffer underflows by reencoding the current frame with a higher QP
michael
parents:
3929
diff
changeset
|
2582 assert(s->avctx->rc_max_rate); |
16ace038f452
fix buffer underflows by reencoding the current frame with a higher QP
michael
parents:
3929
diff
changeset
|
2583 } |
16ace038f452
fix buffer underflows by reencoding the current frame with a higher QP
michael
parents:
3929
diff
changeset
|
2584 |
329 | 2585 if(s->flags&CODEC_FLAG_PASS1) |
2586 ff_write_pass1_stats(s); | |
1138 | 2587 |
2588 for(i=0; i<4; i++){ | |
2955 | 2589 s->current_picture_ptr->error[i]= s->current_picture.error[i]; |
1138 | 2590 avctx->error[i] += s->current_picture_ptr->error[i]; |
2591 } | |
1766 | 2592 |
2428
548c87c06dbb
assertion about bits statistic and minor bits stat fix
michael
parents:
2427
diff
changeset
|
2593 if(s->flags&CODEC_FLAG_PASS1) |
548c87c06dbb
assertion about bits statistic and minor bits stat fix
michael
parents:
2427
diff
changeset
|
2594 assert(avctx->header_bits + avctx->mv_bits + avctx->misc_bits + avctx->i_tex_bits + avctx->p_tex_bits == put_bits_count(&s->pb)); |
1684 | 2595 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
|
2596 s->frame_bits = put_bits_count(&s->pb); |
1766 | 2597 |
2598 stuffing_count= ff_vbv_update(s, s->frame_bits); | |
2599 if(stuffing_count){ | |
2422 | 2600 if(s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb)>>3) < stuffing_count + 50){ |
2601 av_log(s->avctx, AV_LOG_ERROR, "stuffing too large\n"); | |
2602 return -1; | |
2603 } | |
2604 | |
1766 | 2605 switch(s->codec_id){ |
2606 case CODEC_ID_MPEG1VIDEO: | |
2607 case CODEC_ID_MPEG2VIDEO: | |
2608 while(stuffing_count--){ | |
2609 put_bits(&s->pb, 8, 0); | |
2610 } | |
2611 break; | |
2612 case CODEC_ID_MPEG4: | |
2613 put_bits(&s->pb, 16, 0); | |
2614 put_bits(&s->pb, 16, 0x1C3); | |
2615 stuffing_count -= 4; | |
2616 while(stuffing_count--){ | |
2617 put_bits(&s->pb, 8, 0xFF); | |
2618 } | |
2619 break; | |
2620 default: | |
2621 av_log(s->avctx, AV_LOG_ERROR, "vbv buffer overflow\n"); | |
2622 } | |
2623 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
|
2624 s->frame_bits = put_bits_count(&s->pb); |
1766 | 2625 } |
2626 | |
2967 | 2627 /* update mpeg1/2 vbv_delay for CBR */ |
1907 | 2628 if(s->avctx->rc_max_rate && s->avctx->rc_min_rate == s->avctx->rc_max_rate && s->out_format == FMT_MPEG1 |
2629 && 90000LL * (avctx->rc_buffer_size-1) <= s->avctx->rc_max_rate*0xFFFFLL){ | |
1766 | 2630 int vbv_delay; |
2631 | |
2632 assert(s->repeat_first_field==0); | |
2967 | 2633 |
1766 | 2634 vbv_delay= lrintf(90000 * s->rc_context.buffer_index / s->avctx->rc_max_rate); |
2635 assert(vbv_delay < 0xFFFF); | |
2636 | |
2637 s->vbv_delay_ptr[0] &= 0xF8; | |
2638 s->vbv_delay_ptr[0] |= vbv_delay>>13; | |
2639 s->vbv_delay_ptr[1] = vbv_delay>>5; | |
2640 s->vbv_delay_ptr[2] &= 0x07; | |
2641 s->vbv_delay_ptr[2] |= vbv_delay<<3; | |
2642 } | |
2643 s->total_bits += s->frame_bits; | |
2644 avctx->frame_bits = s->frame_bits; | |
2645 }else{ | |
2646 assert((pbBufPtr(&s->pb) == s->pb.buf)); | |
2647 s->frame_bits=0; | |
1684 | 2648 } |
1766 | 2649 assert((s->frame_bits&7)==0); |
2967 | 2650 |
1684 | 2651 return s->frame_bits/8; |
0 | 2652 } |
2653 | |
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
|
2654 #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
|
2655 |
255 | 2656 static inline void gmc1_motion(MpegEncContext *s, |
1064 | 2657 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
|
2658 uint8_t **ref_picture) |
255 | 2659 { |
1064 | 2660 uint8_t *ptr; |
556 | 2661 int offset, src_x, src_y, linesize, uvlinesize; |
255 | 2662 int motion_x, motion_y; |
566 | 2663 int emu=0; |
255 | 2664 |
2665 motion_x= s->sprite_offset[0][0]; | |
2666 motion_y= s->sprite_offset[0][1]; | |
2667 src_x = s->mb_x * 16 + (motion_x >> (s->sprite_warping_accuracy+1)); | |
2668 src_y = s->mb_y * 16 + (motion_y >> (s->sprite_warping_accuracy+1)); | |
2669 motion_x<<=(3-s->sprite_warping_accuracy); | |
2670 motion_y<<=(3-s->sprite_warping_accuracy); | |
4594 | 2671 src_x = av_clip(src_x, -16, s->width); |
255 | 2672 if (src_x == s->width) |
2673 motion_x =0; | |
4594 | 2674 src_y = av_clip(src_y, -16, s->height); |
255 | 2675 if (src_y == s->height) |
2676 motion_y =0; | |
753 | 2677 |
255 | 2678 linesize = s->linesize; |
556 | 2679 uvlinesize = s->uvlinesize; |
2967 | 2680 |
1842
0d82db458a3c
interlaced mpeg4 + edge emu fix (fixes decoding of mermaid.avi)
michael
parents:
1838
diff
changeset
|
2681 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
|
2682 |
566 | 2683 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
|
2684 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
|
2685 || (unsigned)src_y >= s->v_edge_pos - 17){ |
1317
26c44d2433c1
make ff_emulated_edge_mc() independant of MpegEncContext
michaelni
parents:
1315
diff
changeset
|
2686 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 | 2687 ptr= s->edge_emu_buffer; |
2688 } | |
2689 } | |
2967 | 2690 |
753 | 2691 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
|
2692 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
|
2693 s->dsp.gmc1(dest_y+8, ptr+8, linesize, 16, motion_x&15, motion_y&15, 128 - s->no_rounding); |
753 | 2694 }else{ |
2695 int dxy; | |
2967 | 2696 |
753 | 2697 dxy= ((motion_x>>3)&1) | ((motion_y>>2)&2); |
2698 if (s->no_rounding){ | |
2979 | 2699 s->dsp.put_no_rnd_pixels_tab[0][dxy](dest_y, ptr, linesize, 16); |
753 | 2700 }else{ |
853
eacc2dd8fd9d
* using DSPContext - so each codec could use its local (sub)set of CPU extension
kabi
parents:
847
diff
changeset
|
2701 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
|
2702 } |
753 | 2703 } |
2967 | 2704 |
753 | 2705 if(s->flags&CODEC_FLAG_GRAY) return; |
255 | 2706 |
2707 motion_x= s->sprite_offset[1][0]; | |
2708 motion_y= s->sprite_offset[1][1]; | |
2709 src_x = s->mb_x * 8 + (motion_x >> (s->sprite_warping_accuracy+1)); | |
2710 src_y = s->mb_y * 8 + (motion_y >> (s->sprite_warping_accuracy+1)); | |
2711 motion_x<<=(3-s->sprite_warping_accuracy); | |
2712 motion_y<<=(3-s->sprite_warping_accuracy); | |
4594 | 2713 src_x = av_clip(src_x, -8, s->width>>1); |
255 | 2714 if (src_x == s->width>>1) |
2715 motion_x =0; | |
4594 | 2716 src_y = av_clip(src_y, -8, s->height>>1); |
255 | 2717 if (src_y == s->height>>1) |
2718 motion_y =0; | |
2719 | |
1842
0d82db458a3c
interlaced mpeg4 + edge emu fix (fixes decoding of mermaid.avi)
michael
parents:
1838
diff
changeset
|
2720 offset = (src_y * uvlinesize) + src_x; |
255 | 2721 ptr = ref_picture[1] + offset; |
1002 | 2722 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
|
2723 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
|
2724 || (unsigned)src_y >= (s->v_edge_pos>>1) - 9){ |
1317
26c44d2433c1
make ff_emulated_edge_mc() independant of MpegEncContext
michaelni
parents:
1315
diff
changeset
|
2725 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 | 2726 ptr= s->edge_emu_buffer; |
2727 emu=1; | |
2728 } | |
566 | 2729 } |
1842
0d82db458a3c
interlaced mpeg4 + edge emu fix (fixes decoding of mermaid.avi)
michael
parents:
1838
diff
changeset
|
2730 s->dsp.gmc1(dest_cb, ptr, uvlinesize, 8, motion_x&15, motion_y&15, 128 - s->no_rounding); |
2967 | 2731 |
255 | 2732 ptr = ref_picture[2] + offset; |
566 | 2733 if(emu){ |
1317
26c44d2433c1
make ff_emulated_edge_mc() independant of MpegEncContext
michaelni
parents:
1315
diff
changeset
|
2734 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 | 2735 ptr= s->edge_emu_buffer; |
2736 } | |
1842
0d82db458a3c
interlaced mpeg4 + edge emu fix (fixes decoding of mermaid.avi)
michael
parents:
1838
diff
changeset
|
2737 s->dsp.gmc1(dest_cr, ptr, uvlinesize, 8, motion_x&15, motion_y&15, 128 - s->no_rounding); |
2967 | 2738 |
255 | 2739 return; |
2740 } | |
2741 | |
753 | 2742 static inline void gmc_motion(MpegEncContext *s, |
1064 | 2743 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
|
2744 uint8_t **ref_picture) |
753 | 2745 { |
1064 | 2746 uint8_t *ptr; |
753 | 2747 int linesize, uvlinesize; |
2748 const int a= s->sprite_warping_accuracy; | |
2749 int ox, oy; | |
2750 | |
2751 linesize = s->linesize; | |
2752 uvlinesize = s->uvlinesize; | |
2753 | |
1842
0d82db458a3c
interlaced mpeg4 + edge emu fix (fixes decoding of mermaid.avi)
michael
parents:
1838
diff
changeset
|
2754 ptr = ref_picture[0]; |
0d82db458a3c
interlaced mpeg4 + edge emu fix (fixes decoding of mermaid.avi)
michael
parents:
1838
diff
changeset
|
2755 |
753 | 2756 ox= s->sprite_offset[0][0] + s->sprite_delta[0][0]*s->mb_x*16 + s->sprite_delta[0][1]*s->mb_y*16; |
2757 oy= s->sprite_offset[0][1] + s->sprite_delta[1][0]*s->mb_x*16 + s->sprite_delta[1][1]*s->mb_y*16; | |
2758 | |
853
eacc2dd8fd9d
* using DSPContext - so each codec could use its local (sub)set of CPU extension
kabi
parents:
847
diff
changeset
|
2759 s->dsp.gmc(dest_y, ptr, linesize, 16, |
2967 | 2760 ox, |
2761 oy, | |
753 | 2762 s->sprite_delta[0][0], s->sprite_delta[0][1], |
2967 | 2763 s->sprite_delta[1][0], s->sprite_delta[1][1], |
753 | 2764 a+1, (1<<(2*a+1)) - s->no_rounding, |
2765 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
|
2766 s->dsp.gmc(dest_y+8, ptr, linesize, 16, |
2967 | 2767 ox + s->sprite_delta[0][0]*8, |
2768 oy + s->sprite_delta[1][0]*8, | |
753 | 2769 s->sprite_delta[0][0], s->sprite_delta[0][1], |
2967 | 2770 s->sprite_delta[1][0], s->sprite_delta[1][1], |
753 | 2771 a+1, (1<<(2*a+1)) - s->no_rounding, |
2772 s->h_edge_pos, s->v_edge_pos); | |
2773 | |
2774 if(s->flags&CODEC_FLAG_GRAY) return; | |
2775 | |
2776 ox= s->sprite_offset[1][0] + s->sprite_delta[0][0]*s->mb_x*8 + s->sprite_delta[0][1]*s->mb_y*8; | |
2777 oy= s->sprite_offset[1][1] + s->sprite_delta[1][0]*s->mb_x*8 + s->sprite_delta[1][1]*s->mb_y*8; | |
2778 | |
1842
0d82db458a3c
interlaced mpeg4 + edge emu fix (fixes decoding of mermaid.avi)
michael
parents:
1838
diff
changeset
|
2779 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
|
2780 s->dsp.gmc(dest_cb, ptr, uvlinesize, 8, |
2967 | 2781 ox, |
2782 oy, | |
753 | 2783 s->sprite_delta[0][0], s->sprite_delta[0][1], |
2967 | 2784 s->sprite_delta[1][0], s->sprite_delta[1][1], |
753 | 2785 a+1, (1<<(2*a+1)) - s->no_rounding, |
2786 s->h_edge_pos>>1, s->v_edge_pos>>1); | |
2967 | 2787 |
1842
0d82db458a3c
interlaced mpeg4 + edge emu fix (fixes decoding of mermaid.avi)
michael
parents:
1838
diff
changeset
|
2788 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
|
2789 s->dsp.gmc(dest_cr, ptr, uvlinesize, 8, |
2967 | 2790 ox, |
2791 oy, | |
753 | 2792 s->sprite_delta[0][0], s->sprite_delta[0][1], |
2967 | 2793 s->sprite_delta[1][0], s->sprite_delta[1][1], |
753 | 2794 a+1, (1<<(2*a+1)) - s->no_rounding, |
2795 s->h_edge_pos>>1, s->v_edge_pos>>1); | |
2796 } | |
2797 | |
1317
26c44d2433c1
make ff_emulated_edge_mc() independant of MpegEncContext
michaelni
parents:
1315
diff
changeset
|
2798 /** |
26c44d2433c1
make ff_emulated_edge_mc() independant of MpegEncContext
michaelni
parents:
1315
diff
changeset
|
2799 * 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
|
2800 * @param buf destination buffer |
26c44d2433c1
make ff_emulated_edge_mc() independant of MpegEncContext
michaelni
parents:
1315
diff
changeset
|
2801 * @param src source buffer |
26c44d2433c1
make ff_emulated_edge_mc() independant of MpegEncContext
michaelni
parents:
1315
diff
changeset
|
2802 * @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
|
2803 * @param block_w width of block |
26c44d2433c1
make ff_emulated_edge_mc() independant of MpegEncContext
michaelni
parents:
1315
diff
changeset
|
2804 * @param block_h height of block |
26c44d2433c1
make ff_emulated_edge_mc() independant of MpegEncContext
michaelni
parents:
1315
diff
changeset
|
2805 * @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
|
2806 * @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
|
2807 * @param w width of the source buffer |
26c44d2433c1
make ff_emulated_edge_mc() independant of MpegEncContext
michaelni
parents:
1315
diff
changeset
|
2808 * @param h height of the source buffer |
26c44d2433c1
make ff_emulated_edge_mc() independant of MpegEncContext
michaelni
parents:
1315
diff
changeset
|
2809 */ |
2967 | 2810 void ff_emulated_edge_mc(uint8_t *buf, uint8_t *src, int linesize, int block_w, int block_h, |
553 | 2811 int src_x, int src_y, int w, int h){ |
2812 int x, y; | |
2813 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
|
2814 |
553 | 2815 if(src_y>= h){ |
2816 src+= (h-1-src_y)*linesize; | |
2817 src_y=h-1; | |
554 | 2818 }else if(src_y<=-block_h){ |
2819 src+= (1-block_h-src_y)*linesize; | |
2820 src_y=1-block_h; | |
553 | 2821 } |
2822 if(src_x>= w){ | |
2823 src+= (w-1-src_x); | |
2824 src_x=w-1; | |
554 | 2825 }else if(src_x<=-block_w){ |
2826 src+= (1-block_w-src_x); | |
2827 src_x=1-block_w; | |
553 | 2828 } |
2829 | |
847 | 2830 start_y= FFMAX(0, -src_y); |
2831 start_x= FFMAX(0, -src_x); | |
2832 end_y= FFMIN(block_h, h-src_y); | |
2833 end_x= FFMIN(block_w, w-src_x); | |
566 | 2834 |
553 | 2835 // copy existing part |
2836 for(y=start_y; y<end_y; y++){ | |
2837 for(x=start_x; x<end_x; x++){ | |
2838 buf[x + y*linesize]= src[x + y*linesize]; | |
2839 } | |
2840 } | |
2841 | |
2842 //top | |
2843 for(y=0; y<start_y; y++){ | |
2844 for(x=start_x; x<end_x; x++){ | |
2845 buf[x + y*linesize]= buf[x + start_y*linesize]; | |
2846 } | |
2847 } | |
2848 | |
2849 //bottom | |
2850 for(y=end_y; y<block_h; y++){ | |
2851 for(x=start_x; x<end_x; x++){ | |
2852 buf[x + y*linesize]= buf[x + (end_y-1)*linesize]; | |
2853 } | |
2854 } | |
2967 | 2855 |
553 | 2856 for(y=0; y<block_h; y++){ |
2857 //left | |
2858 for(x=0; x<start_x; x++){ | |
2859 buf[x + y*linesize]= buf[start_x + y*linesize]; | |
2860 } | |
2967 | 2861 |
553 | 2862 //right |
2863 for(x=end_x; x<block_w; x++){ | |
2864 buf[x + y*linesize]= buf[end_x - 1 + y*linesize]; | |
2865 } | |
2866 } | |
2867 } | |
2868 | |
2967 | 2869 static inline int hpel_motion(MpegEncContext *s, |
1842
0d82db458a3c
interlaced mpeg4 + edge emu fix (fixes decoding of mermaid.avi)
michael
parents:
1838
diff
changeset
|
2870 uint8_t *dest, uint8_t *src, |
0d82db458a3c
interlaced mpeg4 + edge emu fix (fixes decoding of mermaid.avi)
michael
parents:
1838
diff
changeset
|
2871 int field_based, int field_select, |
1633 | 2872 int src_x, int src_y, |
2873 int width, int height, int stride, | |
2874 int h_edge_pos, int v_edge_pos, | |
2875 int w, int h, op_pixels_func *pix_op, | |
2876 int motion_x, int motion_y) | |
2877 { | |
2878 int dxy; | |
2879 int emu=0; | |
2880 | |
2881 dxy = ((motion_y & 1) << 1) | (motion_x & 1); | |
2882 src_x += motion_x >> 1; | |
2883 src_y += motion_y >> 1; | |
2967 | 2884 |
1633 | 2885 /* WARNING: do no forget half pels */ |
4594 | 2886 src_x = av_clip(src_x, -16, width); //FIXME unneeded for emu? |
1633 | 2887 if (src_x == width) |
2888 dxy &= ~1; | |
4594 | 2889 src_y = av_clip(src_y, -16, height); |
1633 | 2890 if (src_y == height) |
2891 dxy &= ~2; | |
2892 src += src_y * stride + src_x; | |
2893 | |
2894 if(s->unrestricted_mv && (s->flags&CODEC_FLAG_EMU_EDGE)){ | |
2895 if( (unsigned)src_x > h_edge_pos - (motion_x&1) - w | |
2896 || (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
|
2897 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
|
2898 src_x, src_y<<field_based, h_edge_pos, s->v_edge_pos); |
1633 | 2899 src= s->edge_emu_buffer; |
2900 emu=1; | |
2901 } | |
2902 } | |
1842
0d82db458a3c
interlaced mpeg4 + edge emu fix (fixes decoding of mermaid.avi)
michael
parents:
1838
diff
changeset
|
2903 if(field_select) |
0d82db458a3c
interlaced mpeg4 + edge emu fix (fixes decoding of mermaid.avi)
michael
parents:
1838
diff
changeset
|
2904 src += s->linesize; |
1633 | 2905 pix_op[dxy](dest, src, stride, h); |
2906 return emu; | |
2907 } | |
553 | 2908 |
2967 | 2909 static inline int hpel_motion_lowres(MpegEncContext *s, |
2292 | 2910 uint8_t *dest, uint8_t *src, |
2911 int field_based, int field_select, | |
2912 int src_x, int src_y, | |
2913 int width, int height, int stride, | |
2914 int h_edge_pos, int v_edge_pos, | |
2915 int w, int h, h264_chroma_mc_func *pix_op, | |
2916 int motion_x, int motion_y) | |
2917 { | |
2918 const int lowres= s->avctx->lowres; | |
2919 const int s_mask= (2<<lowres)-1; | |
2920 int emu=0; | |
2921 int sx, sy; | |
2922 | |
2923 if(s->quarter_sample){ | |
2924 motion_x/=2; | |
2925 motion_y/=2; | |
2926 } | |
2927 | |
2928 sx= motion_x & s_mask; | |
2929 sy= motion_y & s_mask; | |
2930 src_x += motion_x >> (lowres+1); | |
2931 src_y += motion_y >> (lowres+1); | |
2967 | 2932 |
2292 | 2933 src += src_y * stride + src_x; |
2934 | |
2935 if( (unsigned)src_x > h_edge_pos - (!!sx) - w | |
2936 || (unsigned)src_y >(v_edge_pos >> field_based) - (!!sy) - h){ | |
2937 ff_emulated_edge_mc(s->edge_emu_buffer, src, s->linesize, w+1, (h+1)<<field_based, | |
2938 src_x, src_y<<field_based, h_edge_pos, v_edge_pos); | |
2939 src= s->edge_emu_buffer; | |
2940 emu=1; | |
2941 } | |
2942 | |
2943 sx <<= 2 - lowres; | |
2944 sy <<= 2 - lowres; | |
2945 if(field_select) | |
2946 src += s->linesize; | |
2947 pix_op[lowres](dest, src, stride, h, sx, sy); | |
2948 return emu; | |
2949 } | |
2950 | |
0 | 2951 /* 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
|
2952 static av_always_inline void mpeg_motion(MpegEncContext *s, |
1064 | 2953 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
|
2954 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
|
2955 uint8_t **ref_picture, op_pixels_func (*pix_op)[4], |
0 | 2956 int motion_x, int motion_y, int h) |
2957 { | |
1846 | 2958 uint8_t *ptr_y, *ptr_cb, *ptr_cr; |
2959 int dxy, uvdxy, mx, my, src_x, src_y, uvsrc_x, uvsrc_y, v_edge_pos, uvlinesize, linesize; | |
2967 | 2960 |
2961 #if 0 | |
255 | 2962 if(s->quarter_sample) |
2963 { | |
2964 motion_x>>=1; | |
2965 motion_y>>=1; | |
2966 } | |
651 | 2967 #endif |
1633 | 2968 |
582
5132a4ee50cd
different edge positions fixed with edge emu / dr1
michaelni
parents:
575
diff
changeset
|
2969 v_edge_pos = s->v_edge_pos >> field_based; |
1846 | 2970 linesize = s->current_picture.linesize[0] << field_based; |
1138 | 2971 uvlinesize = s->current_picture.linesize[1] << field_based; |
1633 | 2972 |
1846 | 2973 dxy = ((motion_y & 1) << 1) | (motion_x & 1); |
2974 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
|
2975 src_y =(s->mb_y<<(4-field_based)) + (motion_y >> 1); |
485 | 2976 |
0 | 2977 if (s->out_format == FMT_H263) { |
1916 | 2978 if((s->workaround_bugs & FF_BUG_HPEL_CHROMA) && field_based){ |
2979 mx = (motion_x>>1)|(motion_x&1); | |
2980 my = motion_y >>1; | |
2981 uvdxy = ((my & 1) << 1) | (mx & 1); | |
2982 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
|
2983 uvsrc_y = (s->mb_y<<(3-field_based)) + (my >> 1); |
1916 | 2984 }else{ |
2985 uvdxy = dxy | (motion_y & 2) | ((motion_x & 2) >> 1); | |
2986 uvsrc_x = src_x>>1; | |
2987 uvsrc_y = src_y>>1; | |
2988 } | |
2044
b6f2add2511e
h261 decoder by (Maarten Daniels <maarten.daniels at student dot luc dot ac dot be>)
michael
parents:
2042
diff
changeset
|
2989 }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
|
2990 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
|
2991 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
|
2992 uvdxy = 0; |
b6f2add2511e
h261 decoder by (Maarten Daniels <maarten.daniels at student dot luc dot ac dot be>)
michael
parents:
2042
diff
changeset
|
2993 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
|
2994 uvsrc_y = s->mb_y*8 + my; |
0 | 2995 } else { |
2074
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
2996 if(s->chroma_y_shift){ |
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
2997 mx = motion_x / 2; |
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
2998 my = motion_y / 2; |
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
2999 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
|
3000 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
|
3001 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
|
3002 } else { |
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
3003 if(s->chroma_x_shift){ |
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
3004 //Chroma422 |
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 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
|
3007 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
|
3008 uvsrc_y = src_y; |
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
3009 } else { |
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
3010 //Chroma444 |
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
3011 uvdxy = dxy; |
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
3012 uvsrc_x = src_x; |
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
3013 uvsrc_y = src_y; |
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
3014 } |
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
3015 } |
1846 | 3016 } |
3017 | |
3018 ptr_y = ref_picture[0] + src_y * linesize + src_x; | |
3019 ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x; | |
3020 ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x; | |
3021 | |
3022 if( (unsigned)src_x > s->h_edge_pos - (motion_x&1) - 16 | |
3023 || (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
|
3024 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
|
3025 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
|
3026 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
|
3027 return ; |
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
3028 } |
1846 | 3029 ff_emulated_edge_mc(s->edge_emu_buffer, ptr_y, s->linesize, 17, 17+field_based, |
3030 src_x, src_y<<field_based, s->h_edge_pos, s->v_edge_pos); | |
3031 ptr_y = s->edge_emu_buffer; | |
3032 if(!(s->flags&CODEC_FLAG_GRAY)){ | |
1874 | 3033 uint8_t *uvbuf= s->edge_emu_buffer+18*s->linesize; |
2967 | 3034 ff_emulated_edge_mc(uvbuf , ptr_cb, s->uvlinesize, 9, 9+field_based, |
1846 | 3035 uvsrc_x, uvsrc_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1); |
2967 | 3036 ff_emulated_edge_mc(uvbuf+16, ptr_cr, s->uvlinesize, 9, 9+field_based, |
1846 | 3037 uvsrc_x, uvsrc_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1); |
3038 ptr_cb= uvbuf; | |
3039 ptr_cr= uvbuf+16; | |
3040 } | |
3041 } | |
3042 | |
3043 if(bottom_field){ //FIXME use this for field pix too instead of the obnoxious hack which changes picture.data | |
3044 dest_y += s->linesize; | |
3045 dest_cb+= s->uvlinesize; | |
3046 dest_cr+= s->uvlinesize; | |
3047 } | |
3048 | |
3049 if(field_select){ | |
3050 ptr_y += s->linesize; | |
3051 ptr_cb+= s->uvlinesize; | |
3052 ptr_cr+= s->uvlinesize; | |
3053 } | |
3054 | |
3055 pix_op[0][dxy](dest_y, ptr_y, linesize, h); | |
2967 | 3056 |
1846 | 3057 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
|
3058 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
|
3059 pix_op[s->chroma_x_shift][uvdxy](dest_cr, ptr_cr, uvlinesize, h >> s->chroma_y_shift); |
1846 | 3060 } |
4997 | 3061 if((ENABLE_H261_ENCODER || ENABLE_H261_DECODER) && s->out_format == FMT_H261){ |
2291 | 3062 ff_h261_loop_filter(s); |
3063 } | |
0 | 3064 } |
2256 | 3065 |
3066 /* 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
|
3067 static av_always_inline void mpeg_motion_lowres(MpegEncContext *s, |
2256 | 3068 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr, |
3069 int field_based, int bottom_field, int field_select, | |
3070 uint8_t **ref_picture, h264_chroma_mc_func *pix_op, | |
3071 int motion_x, int motion_y, int h) | |
3072 { | |
3073 uint8_t *ptr_y, *ptr_cb, *ptr_cr; | |
3074 int mx, my, src_x, src_y, uvsrc_x, uvsrc_y, uvlinesize, linesize, sx, sy, uvsx, uvsy; | |
3075 const int lowres= s->avctx->lowres; | |
3076 const int block_s= 8>>lowres; | |
3077 const int s_mask= (2<<lowres)-1; | |
3078 const int h_edge_pos = s->h_edge_pos >> lowres; | |
3079 const int v_edge_pos = s->v_edge_pos >> lowres; | |
3080 linesize = s->current_picture.linesize[0] << field_based; | |
3081 uvlinesize = s->current_picture.linesize[1] << field_based; | |
3082 | |
2260 | 3083 if(s->quarter_sample){ //FIXME obviously not perfect but qpel wont work in lowres anyway |
3084 motion_x/=2; | |
3085 motion_y/=2; | |
3086 } | |
2967 | 3087 |
2260 | 3088 if(field_based){ |
3089 motion_y += (bottom_field - field_select)*((1<<lowres)-1); | |
3090 } | |
3091 | |
2256 | 3092 sx= motion_x & s_mask; |
3093 sy= motion_y & s_mask; | |
3094 src_x = s->mb_x*2*block_s + (motion_x >> (lowres+1)); | |
2260 | 3095 src_y =(s->mb_y*2*block_s>>field_based) + (motion_y >> (lowres+1)); |
2967 | 3096 |
2256 | 3097 if (s->out_format == FMT_H263) { |
2265 | 3098 uvsx = ((motion_x>>1) & s_mask) | (sx&1); |
3099 uvsy = ((motion_y>>1) & s_mask) | (sy&1); | |
2256 | 3100 uvsrc_x = src_x>>1; |
3101 uvsrc_y = src_y>>1; | |
3102 }else if(s->out_format == FMT_H261){//even chroma mv's are full pel in H261 | |
3103 mx = motion_x / 4; | |
3104 my = motion_y / 4; | |
3105 uvsx = (2*mx) & s_mask; | |
3106 uvsy = (2*my) & s_mask; | |
3107 uvsrc_x = s->mb_x*block_s + (mx >> lowres); | |
3108 uvsrc_y = s->mb_y*block_s + (my >> lowres); | |
3109 } else { | |
3110 mx = motion_x / 2; | |
3111 my = motion_y / 2; | |
3112 uvsx = mx & s_mask; | |
3113 uvsy = my & s_mask; | |
3114 uvsrc_x = s->mb_x*block_s + (mx >> (lowres+1)); | |
2260 | 3115 uvsrc_y =(s->mb_y*block_s>>field_based) + (my >> (lowres+1)); |
2256 | 3116 } |
3117 | |
3118 ptr_y = ref_picture[0] + src_y * linesize + src_x; | |
3119 ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x; | |
3120 ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x; | |
3121 | |
3122 if( (unsigned)src_x > h_edge_pos - (!!sx) - 2*block_s | |
3123 || (unsigned)src_y >(v_edge_pos >> field_based) - (!!sy) - h){ | |
3124 ff_emulated_edge_mc(s->edge_emu_buffer, ptr_y, s->linesize, 17, 17+field_based, | |
3125 src_x, src_y<<field_based, h_edge_pos, v_edge_pos); | |
3126 ptr_y = s->edge_emu_buffer; | |
3127 if(!(s->flags&CODEC_FLAG_GRAY)){ | |
3128 uint8_t *uvbuf= s->edge_emu_buffer+18*s->linesize; | |
2967 | 3129 ff_emulated_edge_mc(uvbuf , ptr_cb, s->uvlinesize, 9, 9+field_based, |
2256 | 3130 uvsrc_x, uvsrc_y<<field_based, h_edge_pos>>1, v_edge_pos>>1); |
2967 | 3131 ff_emulated_edge_mc(uvbuf+16, ptr_cr, s->uvlinesize, 9, 9+field_based, |
2256 | 3132 uvsrc_x, uvsrc_y<<field_based, h_edge_pos>>1, v_edge_pos>>1); |
3133 ptr_cb= uvbuf; | |
3134 ptr_cr= uvbuf+16; | |
3135 } | |
3136 } | |
3137 | |
2260 | 3138 if(bottom_field){ //FIXME use this for field pix too instead of the obnoxious hack which changes picture.data |
3139 dest_y += s->linesize; | |
3140 dest_cb+= s->uvlinesize; | |
3141 dest_cr+= s->uvlinesize; | |
3142 } | |
3143 | |
3144 if(field_select){ | |
3145 ptr_y += s->linesize; | |
3146 ptr_cb+= s->uvlinesize; | |
3147 ptr_cr+= s->uvlinesize; | |
3148 } | |
3149 | |
2256 | 3150 sx <<= 2 - lowres; |
3151 sy <<= 2 - lowres; | |
3152 pix_op[lowres-1](dest_y, ptr_y, linesize, h, sx, sy); | |
2967 | 3153 |
2256 | 3154 if(!(s->flags&CODEC_FLAG_GRAY)){ |
3155 uvsx <<= 2 - lowres; | |
3156 uvsy <<= 2 - lowres; | |
3157 pix_op[lowres](dest_cb, ptr_cb, uvlinesize, h >> s->chroma_y_shift, uvsx, uvsy); | |
3158 pix_op[lowres](dest_cr, ptr_cr, uvlinesize, h >> s->chroma_y_shift, uvsx, uvsy); | |
3159 } | |
2291 | 3160 //FIXME h261 lowres loop filter |
2256 | 3161 } |
3162 | |
1633 | 3163 //FIXME move to dsputil, avg variant, 16x16 version |
3164 static inline void put_obmc(uint8_t *dst, uint8_t *src[5], int stride){ | |
3165 int x; | |
3166 uint8_t * const top = src[1]; | |
3167 uint8_t * const left = src[2]; | |
3168 uint8_t * const mid = src[0]; | |
3169 uint8_t * const right = src[3]; | |
3170 uint8_t * const bottom= src[4]; | |
3171 #define OBMC_FILTER(x, t, l, m, r, b)\ | |
3172 dst[x]= (t*top[x] + l*left[x] + m*mid[x] + r*right[x] + b*bottom[x] + 4)>>3 | |
3173 #define OBMC_FILTER4(x, t, l, m, r, b)\ | |
3174 OBMC_FILTER(x , t, l, m, r, b);\ | |
3175 OBMC_FILTER(x+1 , t, l, m, r, b);\ | |
3176 OBMC_FILTER(x +stride, t, l, m, r, b);\ | |
3177 OBMC_FILTER(x+1+stride, t, l, m, r, b); | |
2967 | 3178 |
1633 | 3179 x=0; |
3180 OBMC_FILTER (x , 2, 2, 4, 0, 0); | |
3181 OBMC_FILTER (x+1, 2, 1, 5, 0, 0); | |
3182 OBMC_FILTER4(x+2, 2, 1, 5, 0, 0); | |
3183 OBMC_FILTER4(x+4, 2, 0, 5, 1, 0); | |
3184 OBMC_FILTER (x+6, 2, 0, 5, 1, 0); | |
3185 OBMC_FILTER (x+7, 2, 0, 4, 2, 0); | |
3186 x+= stride; | |
3187 OBMC_FILTER (x , 1, 2, 5, 0, 0); | |
3188 OBMC_FILTER (x+1, 1, 2, 5, 0, 0); | |
3189 OBMC_FILTER (x+6, 1, 0, 5, 2, 0); | |
3190 OBMC_FILTER (x+7, 1, 0, 5, 2, 0); | |
3191 x+= stride; | |
3192 OBMC_FILTER4(x , 1, 2, 5, 0, 0); | |
3193 OBMC_FILTER4(x+2, 1, 1, 6, 0, 0); | |
3194 OBMC_FILTER4(x+4, 1, 0, 6, 1, 0); | |
3195 OBMC_FILTER4(x+6, 1, 0, 5, 2, 0); | |
3196 x+= 2*stride; | |
3197 OBMC_FILTER4(x , 0, 2, 5, 0, 1); | |
3198 OBMC_FILTER4(x+2, 0, 1, 6, 0, 1); | |
3199 OBMC_FILTER4(x+4, 0, 0, 6, 1, 1); | |
3200 OBMC_FILTER4(x+6, 0, 0, 5, 2, 1); | |
3201 x+= 2*stride; | |
3202 OBMC_FILTER (x , 0, 2, 5, 0, 1); | |
3203 OBMC_FILTER (x+1, 0, 2, 5, 0, 1); | |
3204 OBMC_FILTER4(x+2, 0, 1, 5, 0, 2); | |
3205 OBMC_FILTER4(x+4, 0, 0, 5, 1, 2); | |
3206 OBMC_FILTER (x+6, 0, 0, 5, 2, 1); | |
3207 OBMC_FILTER (x+7, 0, 0, 5, 2, 1); | |
3208 x+= stride; | |
3209 OBMC_FILTER (x , 0, 2, 4, 0, 2); | |
3210 OBMC_FILTER (x+1, 0, 1, 5, 0, 2); | |
3211 OBMC_FILTER (x+6, 0, 0, 5, 1, 2); | |
3212 OBMC_FILTER (x+7, 0, 0, 4, 2, 2); | |
3213 } | |
3214 | |
3215 /* obmc for 1 8x8 luma block */ | |
3216 static inline void obmc_motion(MpegEncContext *s, | |
3217 uint8_t *dest, uint8_t *src, | |
3218 int src_x, int src_y, | |
3219 op_pixels_func *pix_op, | |
3220 int16_t mv[5][2]/* mid top left right bottom*/) | |
3221 #define MID 0 | |
3222 { | |
3223 int i; | |
3224 uint8_t *ptr[5]; | |
2967 | 3225 |
1633 | 3226 assert(s->quarter_sample==0); |
2967 | 3227 |
1633 | 3228 for(i=0; i<5; i++){ |
3229 if(i && mv[i][0]==mv[MID][0] && mv[i][1]==mv[MID][1]){ | |
3230 ptr[i]= ptr[MID]; | |
3231 }else{ | |
1799 | 3232 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
|
3233 hpel_motion(s, ptr[i], src, 0, 0, |
1633 | 3234 src_x, src_y, |
3235 s->width, s->height, s->linesize, | |
3236 s->h_edge_pos, s->v_edge_pos, | |
3237 8, 8, pix_op, | |
3238 mv[i][0], mv[i][1]); | |
3239 } | |
3240 } | |
3241 | |
2967 | 3242 put_obmc(dest, ptr, s->linesize); |
1633 | 3243 } |
0 | 3244 |
255 | 3245 static inline void qpel_motion(MpegEncContext *s, |
1064 | 3246 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
|
3247 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
|
3248 uint8_t **ref_picture, op_pixels_func (*pix_op)[4], |
651 | 3249 qpel_mc_func (*qpix_op)[16], |
255 | 3250 int motion_x, int motion_y, int h) |
3251 { | |
1846 | 3252 uint8_t *ptr_y, *ptr_cb, *ptr_cr; |
3253 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
|
3254 |
255 | 3255 dxy = ((motion_y & 3) << 2) | (motion_x & 3); |
1846 | 3256 src_x = s->mb_x * 16 + (motion_x >> 2); |
255 | 3257 src_y = s->mb_y * (16 >> field_based) + (motion_y >> 2); |
3258 | |
582
5132a4ee50cd
different edge positions fixed with edge emu / dr1
michaelni
parents:
575
diff
changeset
|
3259 v_edge_pos = s->v_edge_pos >> field_based; |
255 | 3260 linesize = s->linesize << field_based; |
671 | 3261 uvlinesize = s->uvlinesize << field_based; |
2967 | 3262 |
671 | 3263 if(field_based){ |
3264 mx= motion_x/2; | |
3265 my= motion_y>>1; | |
1048 | 3266 }else if(s->workaround_bugs&FF_BUG_QPEL_CHROMA2){ |
3267 static const int rtab[8]= {0,0,1,1,0,0,0,1}; | |
3268 mx= (motion_x>>1) + rtab[motion_x&7]; | |
3269 my= (motion_y>>1) + rtab[motion_y&7]; | |
760 | 3270 }else if(s->workaround_bugs&FF_BUG_QPEL_CHROMA){ |
671 | 3271 mx= (motion_x>>1)|(motion_x&1); |
3272 my= (motion_y>>1)|(motion_y&1); | |
3273 }else{ | |
3274 mx= motion_x/2; | |
3275 my= motion_y/2; | |
3276 } | |
3277 mx= (mx>>1)|(mx&1); | |
3278 my= (my>>1)|(my&1); | |
1048 | 3279 |
1846 | 3280 uvdxy= (mx&1) | ((my&1)<<1); |
671 | 3281 mx>>=1; |
3282 my>>=1; | |
255 | 3283 |
1846 | 3284 uvsrc_x = s->mb_x * 8 + mx; |
3285 uvsrc_y = s->mb_y * (8 >> field_based) + my; | |
3286 | |
3287 ptr_y = ref_picture[0] + src_y * linesize + src_x; | |
3288 ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x; | |
3289 ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x; | |
3290 | |
2967 | 3291 if( (unsigned)src_x > s->h_edge_pos - (motion_x&3) - 16 |
1846 | 3292 || (unsigned)src_y > v_edge_pos - (motion_y&3) - h ){ |
2967 | 3293 ff_emulated_edge_mc(s->edge_emu_buffer, ptr_y, s->linesize, 17, 17+field_based, |
1846 | 3294 src_x, src_y<<field_based, s->h_edge_pos, s->v_edge_pos); |
3295 ptr_y= s->edge_emu_buffer; | |
3296 if(!(s->flags&CODEC_FLAG_GRAY)){ | |
1874 | 3297 uint8_t *uvbuf= s->edge_emu_buffer + 18*s->linesize; |
2967 | 3298 ff_emulated_edge_mc(uvbuf, ptr_cb, s->uvlinesize, 9, 9 + field_based, |
1846 | 3299 uvsrc_x, uvsrc_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1); |
2967 | 3300 ff_emulated_edge_mc(uvbuf + 16, ptr_cr, s->uvlinesize, 9, 9 + field_based, |
1846 | 3301 uvsrc_x, uvsrc_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1); |
3302 ptr_cb= uvbuf; | |
3303 ptr_cr= uvbuf + 16; | |
3304 } | |
3305 } | |
3306 | |
3307 if(!field_based) | |
3308 qpix_op[0][dxy](dest_y, ptr_y, linesize); | |
3309 else{ | |
3310 if(bottom_field){ | |
3311 dest_y += s->linesize; | |
3312 dest_cb+= s->uvlinesize; | |
3313 dest_cr+= s->uvlinesize; | |
3314 } | |
3315 | |
3316 if(field_select){ | |
3317 ptr_y += s->linesize; | |
3318 ptr_cb += s->uvlinesize; | |
3319 ptr_cr += s->uvlinesize; | |
3320 } | |
3321 //damn interlaced mode | |
3322 //FIXME boundary mirroring is not exactly correct here | |
3323 qpix_op[1][dxy](dest_y , ptr_y , linesize); | |
3324 qpix_op[1][dxy](dest_y+8, ptr_y+8, linesize); | |
3325 } | |
3326 if(!(s->flags&CODEC_FLAG_GRAY)){ | |
3327 pix_op[1][uvdxy](dest_cr, ptr_cr, uvlinesize, h >> 1); | |
3328 pix_op[1][uvdxy](dest_cb, ptr_cb, uvlinesize, h >> 1); | |
3329 } | |
255 | 3330 } |
3331 | |
1013 | 3332 inline int ff_h263_round_chroma(int x){ |
3333 if (x >= 0) | |
3334 return (h263_chroma_roundtab[x & 0xf] + ((x >> 3) & ~1)); | |
3335 else { | |
3336 x = -x; | |
3337 return -(h263_chroma_roundtab[x & 0xf] + ((x >> 3) & ~1)); | |
3338 } | |
3339 } | |
255 | 3340 |
1225 | 3341 /** |
1633 | 3342 * h263 chorma 4mv motion compensation. |
3343 */ | |
3344 static inline void chroma_4mv_motion(MpegEncContext *s, | |
3345 uint8_t *dest_cb, uint8_t *dest_cr, | |
3346 uint8_t **ref_picture, | |
3347 op_pixels_func *pix_op, | |
3348 int mx, int my){ | |
3349 int dxy, emu=0, src_x, src_y, offset; | |
3350 uint8_t *ptr; | |
2967 | 3351 |
1633 | 3352 /* In case of 8X8, we construct a single chroma motion vector |
3353 with a special rounding */ | |
3354 mx= ff_h263_round_chroma(mx); | |
3355 my= ff_h263_round_chroma(my); | |
2967 | 3356 |
1633 | 3357 dxy = ((my & 1) << 1) | (mx & 1); |
3358 mx >>= 1; | |
3359 my >>= 1; | |
3360 | |
3361 src_x = s->mb_x * 8 + mx; | |
3362 src_y = s->mb_y * 8 + my; | |
4594 | 3363 src_x = av_clip(src_x, -8, s->width/2); |
1633 | 3364 if (src_x == s->width/2) |
3365 dxy &= ~1; | |
4594 | 3366 src_y = av_clip(src_y, -8, s->height/2); |
1633 | 3367 if (src_y == s->height/2) |
3368 dxy &= ~2; | |
2967 | 3369 |
1633 | 3370 offset = (src_y * (s->uvlinesize)) + src_x; |
3371 ptr = ref_picture[1] + offset; | |
3372 if(s->flags&CODEC_FLAG_EMU_EDGE){ | |
3373 if( (unsigned)src_x > (s->h_edge_pos>>1) - (dxy &1) - 8 | |
3374 || (unsigned)src_y > (s->v_edge_pos>>1) - (dxy>>1) - 8){ | |
3375 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); | |
3376 ptr= s->edge_emu_buffer; | |
3377 emu=1; | |
3378 } | |
3379 } | |
3380 pix_op[dxy](dest_cb, ptr, s->uvlinesize, 8); | |
3381 | |
3382 ptr = ref_picture[2] + offset; | |
3383 if(emu){ | |
3384 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); | |
3385 ptr= s->edge_emu_buffer; | |
3386 } | |
3387 pix_op[dxy](dest_cr, ptr, s->uvlinesize, 8); | |
3388 } | |
3389 | |
2292 | 3390 static inline void chroma_4mv_motion_lowres(MpegEncContext *s, |
3391 uint8_t *dest_cb, uint8_t *dest_cr, | |
3392 uint8_t **ref_picture, | |
3393 h264_chroma_mc_func *pix_op, | |
3394 int mx, int my){ | |
3395 const int lowres= s->avctx->lowres; | |
3396 const int block_s= 8>>lowres; | |
3397 const int s_mask= (2<<lowres)-1; | |
3398 const int h_edge_pos = s->h_edge_pos >> (lowres+1); | |
3399 const int v_edge_pos = s->v_edge_pos >> (lowres+1); | |
3400 int emu=0, src_x, src_y, offset, sx, sy; | |
3401 uint8_t *ptr; | |
2967 | 3402 |
2292 | 3403 if(s->quarter_sample){ |
3404 mx/=2; | |
3405 my/=2; | |
3406 } | |
3407 | |
3408 /* In case of 8X8, we construct a single chroma motion vector | |
3409 with a special rounding */ | |
3410 mx= ff_h263_round_chroma(mx); | |
3411 my= ff_h263_round_chroma(my); | |
2967 | 3412 |
2292 | 3413 sx= mx & s_mask; |
3414 sy= my & s_mask; | |
3415 src_x = s->mb_x*block_s + (mx >> (lowres+1)); | |
3416 src_y = s->mb_y*block_s + (my >> (lowres+1)); | |
2967 | 3417 |
2292 | 3418 offset = src_y * s->uvlinesize + src_x; |
3419 ptr = ref_picture[1] + offset; | |
3420 if(s->flags&CODEC_FLAG_EMU_EDGE){ | |
3421 if( (unsigned)src_x > h_edge_pos - (!!sx) - block_s | |
3422 || (unsigned)src_y > v_edge_pos - (!!sy) - block_s){ | |
3423 ff_emulated_edge_mc(s->edge_emu_buffer, ptr, s->uvlinesize, 9, 9, src_x, src_y, h_edge_pos, v_edge_pos); | |
3424 ptr= s->edge_emu_buffer; | |
3425 emu=1; | |
3426 } | |
2967 | 3427 } |
2292 | 3428 sx <<= 2 - lowres; |
3429 sy <<= 2 - lowres; | |
3430 pix_op[lowres](dest_cb, ptr, s->uvlinesize, block_s, sx, sy); | |
2967 | 3431 |
2292 | 3432 ptr = ref_picture[2] + offset; |
3433 if(emu){ | |
3434 ff_emulated_edge_mc(s->edge_emu_buffer, ptr, s->uvlinesize, 9, 9, src_x, src_y, h_edge_pos, v_edge_pos); | |
3435 ptr= s->edge_emu_buffer; | |
3436 } | |
3437 pix_op[lowres](dest_cr, ptr, s->uvlinesize, block_s, sx, sy); | |
3438 } | |
3439 | |
3216
4186eb8d29a1
prefetch pixels for future motion compensation. 4-10% faster mpeg1/2/4 decoding (on an athlon-xp).
lorenm
parents:
3145
diff
changeset
|
3440 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
|
3441 /* 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
|
3442 * 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
|
3443 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
|
3444 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
|
3445 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
|
3446 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
|
3447 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
|
3448 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
|
3449 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
|
3450 } |
4186eb8d29a1
prefetch pixels for future motion compensation. 4-10% faster mpeg1/2/4 decoding (on an athlon-xp).
lorenm
parents:
3145
diff
changeset
|
3451 |
1633 | 3452 /** |
2764 | 3453 * motion compensation of a single macroblock |
1225 | 3454 * @param s context |
3455 * @param dest_y luma destination pointer | |
3456 * @param dest_cb chroma cb/u destination pointer | |
3457 * @param dest_cr chroma cr/v destination pointer | |
3458 * @param dir direction (0->forward, 1->backward) | |
3459 * @param ref_picture array[3] of pointers to the 3 planes of the reference picture | |
3460 * @param pic_op halfpel motion compensation function (average or put normally) | |
3461 * @param pic_op qpel motion compensation function (average or put normally) | |
3462 * the motion vectors are taken from s->mv and the MV type from s->mv_type | |
3463 */ | |
2967 | 3464 static inline void MPV_motion(MpegEncContext *s, |
1064 | 3465 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr, |
2967 | 3466 int dir, uint8_t **ref_picture, |
651 | 3467 op_pixels_func (*pix_op)[4], qpel_mc_func (*qpix_op)[16]) |
0 | 3468 { |
1633 | 3469 int dxy, mx, my, src_x, src_y, motion_x, motion_y; |
0 | 3470 int mb_x, mb_y, i; |
1064 | 3471 uint8_t *ptr, *dest; |
0 | 3472 |
3473 mb_x = s->mb_x; | |
3474 mb_y = s->mb_y; | |
3475 | |
3216
4186eb8d29a1
prefetch pixels for future motion compensation. 4-10% faster mpeg1/2/4 decoding (on an athlon-xp).
lorenm
parents:
3145
diff
changeset
|
3476 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
|
3477 |
1655 | 3478 if(s->obmc && s->pict_type != B_TYPE){ |
1633 | 3479 int16_t mv_cache[4][4][2]; |
3480 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
|
3481 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
|
3482 const int mot_xy= mb_x*2 + mb_y*2*mot_stride; |
1633 | 3483 |
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
|
3484 assert(!s->mb_skipped); |
2967 | 3485 |
1668
30746f429df6
move motion_val & mb_type to AVFrame patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1662
diff
changeset
|
3486 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
|
3487 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
|
3488 memcpy(mv_cache[3][1], s->current_picture.motion_val[0][mot_xy+mot_stride], sizeof(int16_t)*4); |
1633 | 3489 |
3490 if(mb_y==0 || IS_INTRA(s->current_picture.mb_type[xy-s->mb_stride])){ | |
3491 memcpy(mv_cache[0][1], mv_cache[1][1], sizeof(int16_t)*4); | |
3492 }else{ | |
1668
30746f429df6
move motion_val & mb_type to AVFrame patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1662
diff
changeset
|
3493 memcpy(mv_cache[0][1], s->current_picture.motion_val[0][mot_xy-mot_stride], sizeof(int16_t)*4); |
1633 | 3494 } |
3495 | |
3496 if(mb_x==0 || IS_INTRA(s->current_picture.mb_type[xy-1])){ | |
3497 *(int32_t*)mv_cache[1][0]= *(int32_t*)mv_cache[1][1]; | |
3498 *(int32_t*)mv_cache[2][0]= *(int32_t*)mv_cache[2][1]; | |
3499 }else{ | |
1668
30746f429df6
move motion_val & mb_type to AVFrame patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1662
diff
changeset
|
3500 *(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
|
3501 *(int32_t*)mv_cache[2][0]= *(int32_t*)s->current_picture.motion_val[0][mot_xy-1+mot_stride]; |
1633 | 3502 } |
3503 | |
3504 if(mb_x+1>=s->mb_width || IS_INTRA(s->current_picture.mb_type[xy+1])){ | |
3505 *(int32_t*)mv_cache[1][3]= *(int32_t*)mv_cache[1][2]; | |
3506 *(int32_t*)mv_cache[2][3]= *(int32_t*)mv_cache[2][2]; | |
3507 }else{ | |
1668
30746f429df6
move motion_val & mb_type to AVFrame patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1662
diff
changeset
|
3508 *(int32_t*)mv_cache[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
|
3509 *(int32_t*)mv_cache[2][3]= *(int32_t*)s->current_picture.motion_val[0][mot_xy+2+mot_stride]; |
1633 | 3510 } |
2967 | 3511 |
1633 | 3512 mx = 0; |
3513 my = 0; | |
3514 for(i=0;i<4;i++) { | |
3515 const int x= (i&1)+1; | |
3516 const int y= (i>>1)+1; | |
3517 int16_t mv[5][2]= { | |
3518 {mv_cache[y][x ][0], mv_cache[y][x ][1]}, | |
3519 {mv_cache[y-1][x][0], mv_cache[y-1][x][1]}, | |
3520 {mv_cache[y][x-1][0], mv_cache[y][x-1][1]}, | |
3521 {mv_cache[y][x+1][0], mv_cache[y][x+1][1]}, | |
3522 {mv_cache[y+1][x][0], mv_cache[y+1][x][1]}}; | |
3523 //FIXME cleanup | |
3524 obmc_motion(s, dest_y + ((i & 1) * 8) + (i >> 1) * 8 * s->linesize, | |
3525 ref_picture[0], | |
3526 mb_x * 16 + (i & 1) * 8, mb_y * 16 + (i >>1) * 8, | |
3527 pix_op[1], | |
3528 mv); | |
3529 | |
3530 mx += mv[0][0]; | |
3531 my += mv[0][1]; | |
3532 } | |
3533 if(!(s->flags&CODEC_FLAG_GRAY)) | |
3534 chroma_4mv_motion(s, dest_cb, dest_cr, ref_picture, pix_op[1], mx, my); | |
3535 | |
3536 return; | |
3537 } | |
2967 | 3538 |
0 | 3539 switch(s->mv_type) { |
3540 case MV_TYPE_16X16: | |
255 | 3541 if(s->mcsel){ |
753 | 3542 if(s->real_sprite_warping_points==1){ |
1842
0d82db458a3c
interlaced mpeg4 + edge emu fix (fixes decoding of mermaid.avi)
michael
parents:
1838
diff
changeset
|
3543 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
|
3544 ref_picture); |
753 | 3545 }else{ |
1842
0d82db458a3c
interlaced mpeg4 + edge emu fix (fixes decoding of mermaid.avi)
michael
parents:
1838
diff
changeset
|
3546 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
|
3547 ref_picture); |
753 | 3548 } |
651 | 3549 }else if(s->quarter_sample){ |
2967 | 3550 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
|
3551 0, 0, 0, |
0d82db458a3c
interlaced mpeg4 + edge emu fix (fixes decoding of mermaid.avi)
michael
parents:
1838
diff
changeset
|
3552 ref_picture, pix_op, qpix_op, |
255 | 3553 s->mv[dir][0][0], s->mv[dir][0][1], 16); |
4967
6d45158e0249
disable reference to msmpeg4 and wmv2 code when those codecs are not compiled in
aurel
parents:
4668
diff
changeset
|
3554 }else if(ENABLE_WMV2 && s->mspel){ |
936 | 3555 ff_mspel_motion(s, dest_y, dest_cb, dest_cr, |
3556 ref_picture, pix_op, | |
3557 s->mv[dir][0][0], s->mv[dir][0][1], 16); | |
1042 | 3558 }else |
3559 { | |
2967 | 3560 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
|
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, |
255 | 3563 s->mv[dir][0][0], s->mv[dir][0][1], 16); |
2967 | 3564 } |
0 | 3565 break; |
3566 case MV_TYPE_8X8: | |
673 | 3567 mx = 0; |
3568 my = 0; | |
3569 if(s->quarter_sample){ | |
3570 for(i=0;i<4;i++) { | |
3571 motion_x = s->mv[dir][i][0]; | |
3572 motion_y = s->mv[dir][i][1]; | |
0 | 3573 |
673 | 3574 dxy = ((motion_y & 3) << 2) | (motion_x & 3); |
3575 src_x = mb_x * 16 + (motion_x >> 2) + (i & 1) * 8; | |
3576 src_y = mb_y * 16 + (motion_y >> 2) + (i >>1) * 8; | |
2967 | 3577 |
673 | 3578 /* WARNING: do no forget half pels */ |
4594 | 3579 src_x = av_clip(src_x, -16, s->width); |
673 | 3580 if (src_x == s->width) |
3581 dxy &= ~3; | |
4594 | 3582 src_y = av_clip(src_y, -16, s->height); |
673 | 3583 if (src_y == s->height) |
3584 dxy &= ~12; | |
2967 | 3585 |
673 | 3586 ptr = ref_picture[0] + (src_y * s->linesize) + (src_x); |
3587 if(s->flags&CODEC_FLAG_EMU_EDGE){ | |
2967 | 3588 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
|
3589 || (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
|
3590 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 | 3591 ptr= s->edge_emu_buffer; |
3592 } | |
3593 } | |
3594 dest = dest_y + ((i & 1) * 8) + (i >> 1) * 8 * s->linesize; | |
3595 qpix_op[1][dxy](dest, ptr, s->linesize); | |
3596 | |
3597 mx += s->mv[dir][i][0]/2; | |
3598 my += s->mv[dir][i][1]/2; | |
3599 } | |
3600 }else{ | |
3601 for(i=0;i<4;i++) { | |
1633 | 3602 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
|
3603 ref_picture[0], 0, 0, |
1633 | 3604 mb_x * 16 + (i & 1) * 8, mb_y * 16 + (i >>1) * 8, |
3605 s->width, s->height, s->linesize, | |
3606 s->h_edge_pos, s->v_edge_pos, | |
3607 8, 8, pix_op[1], | |
3608 s->mv[dir][i][0], s->mv[dir][i][1]); | |
673 | 3609 |
3610 mx += s->mv[dir][i][0]; | |
3611 my += s->mv[dir][i][1]; | |
554 | 3612 } |
0 | 3613 } |
673 | 3614 |
1633 | 3615 if(!(s->flags&CODEC_FLAG_GRAY)) |
3616 chroma_4mv_motion(s, dest_cb, dest_cr, ref_picture, pix_op[1], mx, my); | |
0 | 3617 break; |
3618 case MV_TYPE_FIELD: | |
3619 if (s->picture_structure == PICT_FRAME) { | |
671 | 3620 if(s->quarter_sample){ |
1843 | 3621 for(i=0; i<2; i++){ |
3622 qpel_motion(s, dest_y, dest_cb, dest_cr, | |
3623 1, i, s->field_select[dir][i], | |
3624 ref_picture, pix_op, qpix_op, | |
3625 s->mv[dir][i][0], s->mv[dir][i][1], 8); | |
3626 } | |
671 | 3627 }else{ |
2967 | 3628 /* top field */ |
1842
0d82db458a3c
interlaced mpeg4 + edge emu fix (fixes decoding of mermaid.avi)
michael
parents:
1838
diff
changeset
|
3629 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
|
3630 1, 0, s->field_select[dir][0], |
0d82db458a3c
interlaced mpeg4 + edge emu fix (fixes decoding of mermaid.avi)
michael
parents:
1838
diff
changeset
|
3631 ref_picture, pix_op, |
671 | 3632 s->mv[dir][0][0], s->mv[dir][0][1], 8); |
3633 /* bottom field */ | |
1842
0d82db458a3c
interlaced mpeg4 + edge emu fix (fixes decoding of mermaid.avi)
michael
parents:
1838
diff
changeset
|
3634 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
|
3635 1, 1, s->field_select[dir][1], |
0d82db458a3c
interlaced mpeg4 + edge emu fix (fixes decoding of mermaid.avi)
michael
parents:
1838
diff
changeset
|
3636 ref_picture, pix_op, |
671 | 3637 s->mv[dir][1][0], s->mv[dir][1][1], 8); |
3638 } | |
0 | 3639 } else { |
1842
0d82db458a3c
interlaced mpeg4 + edge emu fix (fixes decoding of mermaid.avi)
michael
parents:
1838
diff
changeset
|
3640 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
|
3641 ref_picture= s->current_picture_ptr->data; |
2967 | 3642 } |
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
|
3643 |
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 0, 0, s->field_select[dir][0], |
0d82db458a3c
interlaced mpeg4 + edge emu fix (fixes decoding of mermaid.avi)
michael
parents:
1838
diff
changeset
|
3646 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
|
3647 s->mv[dir][0][0], s->mv[dir][0][1], 16); |
0 | 3648 } |
3649 break; | |
1843 | 3650 case MV_TYPE_16X8: |
3651 for(i=0; i<2; i++){ | |
3652 uint8_t ** ref2picture; | |
3653 | |
3654 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
|
3655 ref2picture= ref_picture; |
338a2f6e6402
Mpeg2 16x8 Patch by ("Ivan Kalvachev" <ivan at cacad dot com>)
michaelni
parents:
1328
diff
changeset
|
3656 }else{ |
1842
0d82db458a3c
interlaced mpeg4 + edge emu fix (fixes decoding of mermaid.avi)
michael
parents:
1838
diff
changeset
|
3657 ref2picture= s->current_picture_ptr->data; |
2967 | 3658 } |
3659 | |
3660 mpeg_motion(s, dest_y, dest_cb, dest_cr, | |
1843 | 3661 0, 0, s->field_select[dir][i], |
1842
0d82db458a3c
interlaced mpeg4 + edge emu fix (fixes decoding of mermaid.avi)
michael
parents:
1838
diff
changeset
|
3662 ref2picture, pix_op, |
1843 | 3663 s->mv[dir][i][0], s->mv[dir][i][1] + 16*i, 8); |
2967 | 3664 |
1843 | 3665 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
|
3666 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
|
3667 dest_cr+= (16>>s->chroma_y_shift)*s->uvlinesize; |
2967 | 3668 } |
1339
338a2f6e6402
Mpeg2 16x8 Patch by ("Ivan Kalvachev" <ivan at cacad dot com>)
michaelni
parents:
1328
diff
changeset
|
3669 break; |
1326
6cdd3b8f4fd3
DMV support patch by ("Ivan Kalvachev" <ivan at cacad dot com>)
michaelni
parents:
1317
diff
changeset
|
3670 case MV_TYPE_DMV: |
6cdd3b8f4fd3
DMV support patch by ("Ivan Kalvachev" <ivan at cacad dot com>)
michaelni
parents:
1317
diff
changeset
|
3671 if(s->picture_structure == PICT_FRAME){ |
1843 | 3672 for(i=0; i<2; i++){ |
3673 int j; | |
3674 for(j=0; j<2; j++){ | |
3675 mpeg_motion(s, dest_y, dest_cb, dest_cr, | |
3676 1, j, j^i, | |
3677 ref_picture, pix_op, | |
3678 s->mv[dir][2*i + j][0], s->mv[dir][2*i + j][1], 8); | |
3679 } | |
2967 | 3680 pix_op = s->dsp.avg_pixels_tab; |
1843 | 3681 } |
1326
6cdd3b8f4fd3
DMV support patch by ("Ivan Kalvachev" <ivan at cacad dot com>)
michaelni
parents:
1317
diff
changeset
|
3682 }else{ |
1843 | 3683 for(i=0; i<2; i++){ |
2967 | 3684 mpeg_motion(s, dest_y, dest_cb, dest_cr, |
1843 | 3685 0, 0, s->picture_structure != i+1, |
3686 ref_picture, pix_op, | |
3687 s->mv[dir][2*i][0],s->mv[dir][2*i][1],16); | |
3688 | |
3689 // after put we make avg of the same block | |
2967 | 3690 pix_op=s->dsp.avg_pixels_tab; |
1843 | 3691 |
3692 //opposite parity is always in the same frame if this is second field | |
3693 if(!s->first_field){ | |
2967 | 3694 ref_picture = s->current_picture_ptr->data; |
1843 | 3695 } |
1842
0d82db458a3c
interlaced mpeg4 + edge emu fix (fixes decoding of mermaid.avi)
michael
parents:
1838
diff
changeset
|
3696 } |
1326
6cdd3b8f4fd3
DMV support patch by ("Ivan Kalvachev" <ivan at cacad dot com>)
michaelni
parents:
1317
diff
changeset
|
3697 } |
6cdd3b8f4fd3
DMV support patch by ("Ivan Kalvachev" <ivan at cacad dot com>)
michaelni
parents:
1317
diff
changeset
|
3698 break; |
1633 | 3699 default: assert(0); |
0 | 3700 } |
3701 } | |
3702 | |
2256 | 3703 /** |
2764 | 3704 * motion compensation of a single macroblock |
2256 | 3705 * @param s context |
3706 * @param dest_y luma destination pointer | |
3707 * @param dest_cb chroma cb/u destination pointer | |
3708 * @param dest_cr chroma cr/v destination pointer | |
3709 * @param dir direction (0->forward, 1->backward) | |
3710 * @param ref_picture array[3] of pointers to the 3 planes of the reference picture | |
3711 * @param pic_op halfpel motion compensation function (average or put normally) | |
3712 * the motion vectors are taken from s->mv and the MV type from s->mv_type | |
3713 */ | |
2967 | 3714 static inline void MPV_motion_lowres(MpegEncContext *s, |
2256 | 3715 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr, |
2967 | 3716 int dir, uint8_t **ref_picture, |
2256 | 3717 h264_chroma_mc_func *pix_op) |
3718 { | |
2292 | 3719 int mx, my; |
2260 | 3720 int mb_x, mb_y, i; |
3721 const int lowres= s->avctx->lowres; | |
2967 | 3722 const int block_s= 8>>lowres; |
2260 | 3723 |
3724 mb_x = s->mb_x; | |
3725 mb_y = s->mb_y; | |
3726 | |
3727 switch(s->mv_type) { | |
3728 case MV_TYPE_16X16: | |
2967 | 3729 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr, |
2260 | 3730 0, 0, 0, |
3731 ref_picture, pix_op, | |
3732 s->mv[dir][0][0], s->mv[dir][0][1], 2*block_s); | |
3733 break; | |
2292 | 3734 case MV_TYPE_8X8: |
2260 | 3735 mx = 0; |
3736 my = 0; | |
3737 for(i=0;i<4;i++) { | |
2292 | 3738 hpel_motion_lowres(s, dest_y + ((i & 1) + (i >> 1) * s->linesize)*block_s, |
2260 | 3739 ref_picture[0], 0, 0, |
2292 | 3740 (2*mb_x + (i & 1))*block_s, (2*mb_y + (i >>1))*block_s, |
2260 | 3741 s->width, s->height, s->linesize, |
2292 | 3742 s->h_edge_pos >> lowres, s->v_edge_pos >> lowres, |
3743 block_s, block_s, pix_op, | |
2260 | 3744 s->mv[dir][i][0], s->mv[dir][i][1]); |
3745 | |
3746 mx += s->mv[dir][i][0]; | |
3747 my += s->mv[dir][i][1]; | |
3748 } | |
3749 | |
3750 if(!(s->flags&CODEC_FLAG_GRAY)) | |
2292 | 3751 chroma_4mv_motion_lowres(s, dest_cb, dest_cr, ref_picture, pix_op, mx, my); |
3752 break; | |
2260 | 3753 case MV_TYPE_FIELD: |
3754 if (s->picture_structure == PICT_FRAME) { | |
2967 | 3755 /* top field */ |
2260 | 3756 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr, |
3757 1, 0, s->field_select[dir][0], | |
3758 ref_picture, pix_op, | |
3759 s->mv[dir][0][0], s->mv[dir][0][1], block_s); | |
3760 /* bottom field */ | |
3761 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr, | |
3762 1, 1, s->field_select[dir][1], | |
3763 ref_picture, pix_op, | |
3764 s->mv[dir][1][0], s->mv[dir][1][1], block_s); | |
3765 } else { | |
3766 if(s->picture_structure != s->field_select[dir][0] + 1 && s->pict_type != B_TYPE && !s->first_field){ | |
3767 ref_picture= s->current_picture_ptr->data; | |
2967 | 3768 } |
2260 | 3769 |
3770 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr, | |
3771 0, 0, s->field_select[dir][0], | |
3772 ref_picture, pix_op, | |
3773 s->mv[dir][0][0], s->mv[dir][0][1], 2*block_s); | |
3774 } | |
3775 break; | |
3776 case MV_TYPE_16X8: | |
3777 for(i=0; i<2; i++){ | |
3778 uint8_t ** ref2picture; | |
3779 | |
3780 if(s->picture_structure == s->field_select[dir][i] + 1 || s->pict_type == B_TYPE || s->first_field){ | |
3781 ref2picture= ref_picture; | |
3782 }else{ | |
3783 ref2picture= s->current_picture_ptr->data; | |
2967 | 3784 } |
3785 | |
3786 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr, | |
2260 | 3787 0, 0, s->field_select[dir][i], |
3788 ref2picture, pix_op, | |
3789 s->mv[dir][i][0], s->mv[dir][i][1] + 2*block_s*i, block_s); | |
2967 | 3790 |
2260 | 3791 dest_y += 2*block_s*s->linesize; |
3792 dest_cb+= (2*block_s>>s->chroma_y_shift)*s->uvlinesize; | |
3793 dest_cr+= (2*block_s>>s->chroma_y_shift)*s->uvlinesize; | |
2967 | 3794 } |
2260 | 3795 break; |
3796 case MV_TYPE_DMV: | |
3797 if(s->picture_structure == PICT_FRAME){ | |
3798 for(i=0; i<2; i++){ | |
3799 int j; | |
3800 for(j=0; j<2; j++){ | |
3801 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr, | |
3802 1, j, j^i, | |
3803 ref_picture, pix_op, | |
3804 s->mv[dir][2*i + j][0], s->mv[dir][2*i + j][1], block_s); | |
3805 } | |
3806 pix_op = s->dsp.avg_h264_chroma_pixels_tab; | |
3807 } | |
3808 }else{ | |
3809 for(i=0; i<2; i++){ | |
2967 | 3810 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr, |
2260 | 3811 0, 0, s->picture_structure != i+1, |
3812 ref_picture, pix_op, | |
3813 s->mv[dir][2*i][0],s->mv[dir][2*i][1],2*block_s); | |
3814 | |
3815 // after put we make avg of the same block | |
3816 pix_op = s->dsp.avg_h264_chroma_pixels_tab; | |
3817 | |
3818 //opposite parity is always in the same frame if this is second field | |
3819 if(!s->first_field){ | |
2967 | 3820 ref_picture = s->current_picture_ptr->data; |
2260 | 3821 } |
3822 } | |
3823 } | |
3824 break; | |
3825 default: assert(0); | |
3826 } | |
2256 | 3827 } |
0 | 3828 |
3829 /* put block[] to dest[] */ | |
2967 | 3830 static inline void put_dct(MpegEncContext *s, |
1651 | 3831 DCTELEM *block, int i, uint8_t *dest, int line_size, int qscale) |
0 | 3832 { |
1689 | 3833 s->dct_unquantize_intra(s, block, i, qscale); |
1092 | 3834 s->dsp.idct_put (dest, line_size, block); |
0 | 3835 } |
3836 | |
3837 /* add block[] to dest[] */ | |
2967 | 3838 static inline void add_dct(MpegEncContext *s, |
1064 | 3839 DCTELEM *block, int i, uint8_t *dest, int line_size) |
0 | 3840 { |
3841 if (s->block_last_index[i] >= 0) { | |
1092 | 3842 s->dsp.idct_add (dest, line_size, block); |
481 | 3843 } |
3844 } | |
3845 | |
2967 | 3846 static inline void add_dequant_dct(MpegEncContext *s, |
1644 | 3847 DCTELEM *block, int i, uint8_t *dest, int line_size, int qscale) |
481 | 3848 { |
3849 if (s->block_last_index[i] >= 0) { | |
1689 | 3850 s->dct_unquantize_inter(s, block, i, qscale); |
324 | 3851 |
1092 | 3852 s->dsp.idct_add (dest, line_size, block); |
0 | 3853 } |
3854 } | |
3855 | |
456 | 3856 /** |
3857 * cleans dc, ac, coded_block for the current non intra MB | |
3858 */ | |
3859 void ff_clean_intra_table_entries(MpegEncContext *s) | |
3860 { | |
1938
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1918
diff
changeset
|
3861 int wrap = s->b8_stride; |
456 | 3862 int xy = s->block_index[0]; |
2967 | 3863 |
3864 s->dc_val[0][xy ] = | |
3865 s->dc_val[0][xy + 1 ] = | |
456 | 3866 s->dc_val[0][xy + wrap] = |
3867 s->dc_val[0][xy + 1 + wrap] = 1024; | |
3868 /* ac pred */ | |
1064 | 3869 memset(s->ac_val[0][xy ], 0, 32 * sizeof(int16_t)); |
3870 memset(s->ac_val[0][xy + wrap], 0, 32 * sizeof(int16_t)); | |
456 | 3871 if (s->msmpeg4_version>=3) { |
3872 s->coded_block[xy ] = | |
3873 s->coded_block[xy + 1 ] = | |
3874 s->coded_block[xy + wrap] = | |
3875 s->coded_block[xy + 1 + wrap] = 0; | |
3876 } | |
3877 /* chroma */ | |
1938
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1918
diff
changeset
|
3878 wrap = s->mb_stride; |
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1918
diff
changeset
|
3879 xy = s->mb_x + s->mb_y * wrap; |
456 | 3880 s->dc_val[1][xy] = |
3881 s->dc_val[2][xy] = 1024; | |
3882 /* ac pred */ | |
1064 | 3883 memset(s->ac_val[1][xy], 0, 16 * sizeof(int16_t)); |
3884 memset(s->ac_val[2][xy], 0, 16 * sizeof(int16_t)); | |
2967 | 3885 |
1938
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1918
diff
changeset
|
3886 s->mbintra_table[xy]= 0; |
456 | 3887 } |
3888 | |
0 | 3889 /* generic function called after a macroblock has been parsed by the |
3890 decoder or after it has been encoded by the encoder. | |
3891 | |
3892 Important variables used: | |
3893 s->mb_intra : true if intra macroblock | |
3894 s->mv_dir : motion vector direction | |
3895 s->mv_type : motion vector type | |
3896 s->mv : motion vector | |
3897 s->interlaced_dct : true if interlaced dct used (mpeg2) | |
3898 */ | |
4283
d6f83e2f8804
rename always_inline to av_always_inline and move to common.h
mru
parents:
4281
diff
changeset
|
3899 static av_always_inline void MPV_decode_mb_internal(MpegEncContext *s, DCTELEM block[12][64], int lowres_flag) |
0 | 3900 { |
244 | 3901 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
|
3902 const int mb_xy = s->mb_y * s->mb_stride + s->mb_x; |
1381 | 3903 #ifdef HAVE_XVMC |
3904 if(s->avctx->xvmc_acceleration){ | |
1580
628bf341e099
XvMC speedup by removing one memcpy and doing MB packing
iive
parents:
1579
diff
changeset
|
3905 XVMC_decode_mb(s);//xvmc uses pblocks |
1381 | 3906 return; |
3907 } | |
3908 #endif | |
0 | 3909 |
3910 mb_x = s->mb_x; | |
3911 mb_y = s->mb_y; | |
3912 | |
1833
ba27ce284d07
export DCT coefficients patch by (Wolfgang Hesseler <wolfgang.hesseler at imk dot fraunhofer dot de>)
michael
parents:
1831
diff
changeset
|
3913 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
|
3914 /* save DCT coefficients */ |
ba27ce284d07
export DCT coefficients patch by (Wolfgang Hesseler <wolfgang.hesseler at imk dot fraunhofer dot de>)
michael
parents:
1831
diff
changeset
|
3915 int i,j; |
ba27ce284d07
export DCT coefficients patch by (Wolfgang Hesseler <wolfgang.hesseler at imk dot fraunhofer dot de>)
michael
parents:
1831
diff
changeset
|
3916 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
|
3917 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
|
3918 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
|
3919 *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
|
3920 } |
ba27ce284d07
export DCT coefficients patch by (Wolfgang Hesseler <wolfgang.hesseler at imk dot fraunhofer dot de>)
michael
parents:
1831
diff
changeset
|
3921 |
903 | 3922 s->current_picture.qscale_table[mb_xy]= s->qscale; |
108
1e4a4af694d1
exporting qscale data for postprocessing (for MPlayer)
arpi_esp
parents:
79
diff
changeset
|
3923 |
0 | 3924 /* update DC predictors for P macroblocks */ |
3925 if (!s->mb_intra) { | |
249
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
3926 if (s->h263_pred || s->h263_aic) { |
481 | 3927 if(s->mbintra_table[mb_xy]) |
456 | 3928 ff_clean_intra_table_entries(s); |
0 | 3929 } else { |
456 | 3930 s->last_dc[0] = |
3931 s->last_dc[1] = | |
0 | 3932 s->last_dc[2] = 128 << s->intra_dc_precision; |
3933 } | |
3934 } | |
249
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
3935 else if (s->h263_pred || s->h263_aic) |
481 | 3936 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
|
3937 |
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
|
3938 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 | 3939 uint8_t *dest_y, *dest_cb, *dest_cr; |
481 | 3940 int dct_linesize, dct_offset; |
651 | 3941 op_pixels_func (*op_pix)[4]; |
3942 qpel_mc_func (*op_qpix)[16]; | |
2627
bf158d23bbcc
Spelling errors patch by (Kevin Baragona | kevinmb500 gawab com)
michael
parents:
2620
diff
changeset
|
3943 const int linesize= s->current_picture.linesize[0]; //not s->linesize as this would be wrong for field pics |
1138 | 3944 const int uvlinesize= s->current_picture.linesize[1]; |
2256 | 3945 const int readable= s->pict_type != B_TYPE || s->encoding || s->avctx->draw_horiz_band || lowres_flag; |
3946 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
|
3947 |
903 | 3948 /* avoid copy if macroblock skipped in last frame too */ |
3949 /* skip only during decoding as we might trash the buffers during encoding a bit */ | |
3950 if(!s->encoding){ | |
1064 | 3951 uint8_t *mbskip_ptr = &s->mbskip_table[mb_xy]; |
903 | 3952 const int age= s->current_picture.age; |
3953 | |
3954 assert(age); | |
3955 | |
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
|
3956 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
|
3957 s->mb_skipped= 0; |
903 | 3958 assert(s->pict_type!=I_TYPE); |
2967 | 3959 |
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
|
3960 (*mbskip_ptr) ++; /* indicate that this time we skipped it */ |
556 | 3961 if(*mbskip_ptr >99) *mbskip_ptr= 99; |
3962 | |
903 | 3963 /* 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
|
3964 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
|
3965 return; |
903 | 3966 } |
1021
2d7c9f5738de
trying to fix mb skip bug in mpeg1/2 if slices are not used
michaelni
parents:
1014
diff
changeset
|
3967 } 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
|
3968 (*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
|
3969 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
|
3970 } else{ |
7
1d3ac9654178
added skip macroblock optimization (big perf win on black regions for example)
glantau
parents:
0
diff
changeset
|
3971 *mbskip_ptr = 0; /* not skipped */ |
1d3ac9654178
added skip macroblock optimization (big perf win on black regions for example)
glantau
parents:
0
diff
changeset
|
3972 } |
717 | 3973 } |
2967 | 3974 |
2074
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
3975 dct_linesize = linesize << s->interlaced_dct; |
2256 | 3976 dct_offset =(s->interlaced_dct)? linesize : linesize*block_size; |
2967 | 3977 |
1632 | 3978 if(readable){ |
3979 dest_y= s->dest[0]; | |
3980 dest_cb= s->dest[1]; | |
3981 dest_cr= s->dest[2]; | |
3982 }else{ | |
1799 | 3983 dest_y = s->b_scratchpad; |
1834 | 3984 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
|
3985 dest_cr= s->b_scratchpad+32*linesize; |
1632 | 3986 } |
2256 | 3987 |
0 | 3988 if (!s->mb_intra) { |
3989 /* motion handling */ | |
2627
bf158d23bbcc
Spelling errors patch by (Kevin Baragona | kevinmb500 gawab com)
michael
parents:
2620
diff
changeset
|
3990 /* decoding or more than one mb_type (MC was already done otherwise) */ |
1389 | 3991 if(!s->encoding){ |
2256 | 3992 if(lowres_flag){ |
3993 h264_chroma_mc_func *op_pix = s->dsp.put_h264_chroma_pixels_tab; | |
3994 | |
3995 if (s->mv_dir & MV_DIR_FORWARD) { | |
3996 MPV_motion_lowres(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.data, op_pix); | |
3997 op_pix = s->dsp.avg_h264_chroma_pixels_tab; | |
3998 } | |
3999 if (s->mv_dir & MV_DIR_BACKWARD) { | |
4000 MPV_motion_lowres(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.data, op_pix); | |
4001 } | |
324 | 4002 }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
|
4003 op_qpix= s->me.qpel_put; |
2967 | 4004 if ((!s->no_rounding) || s->pict_type==B_TYPE){ |
2256 | 4005 op_pix = s->dsp.put_pixels_tab; |
4006 }else{ | |
4007 op_pix = s->dsp.put_no_rnd_pixels_tab; | |
4008 } | |
4009 if (s->mv_dir & MV_DIR_FORWARD) { | |
4010 MPV_motion(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.data, op_pix, op_qpix); | |
4011 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
|
4012 op_qpix= s->me.qpel_avg; |
2256 | 4013 } |
4014 if (s->mv_dir & MV_DIR_BACKWARD) { | |
4015 MPV_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.data, op_pix, op_qpix); | |
4016 } | |
324 | 4017 } |
0 | 4018 } |
4019 | |
481 | 4020 /* skip dequant / idct if we are really late ;) */ |
2792 | 4021 if(s->hurry_up>1) goto skip_idct; |
4022 if(s->avctx->skip_idct){ | |
4023 if( (s->avctx->skip_idct >= AVDISCARD_NONREF && s->pict_type == B_TYPE) | |
4024 ||(s->avctx->skip_idct >= AVDISCARD_NONKEY && s->pict_type != I_TYPE) | |
4025 || s->avctx->skip_idct >= AVDISCARD_ALL) | |
4026 goto skip_idct; | |
4027 } | |
481 | 4028 |
0 | 4029 /* add dct residue */ |
1421 | 4030 if(s->encoding || !( s->h263_msmpeg4 || s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO |
711 | 4031 || (s->codec_id==CODEC_ID_MPEG4 && !s->mpeg_quant))){ |
2256 | 4032 add_dequant_dct(s, block[0], 0, dest_y , dct_linesize, s->qscale); |
4033 add_dequant_dct(s, block[1], 1, dest_y + block_size, dct_linesize, s->qscale); | |
4034 add_dequant_dct(s, block[2], 2, dest_y + dct_offset , dct_linesize, s->qscale); | |
4035 add_dequant_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize, s->qscale); | |
0 | 4036 |
485 | 4037 if(!(s->flags&CODEC_FLAG_GRAY)){ |
3309 | 4038 if (s->chroma_y_shift){ |
4039 add_dequant_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale); | |
4040 add_dequant_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale); | |
4041 }else{ | |
4042 dct_linesize >>= 1; | |
4043 dct_offset >>=1; | |
4044 add_dequant_dct(s, block[4], 4, dest_cb, dct_linesize, s->chroma_qscale); | |
4045 add_dequant_dct(s, block[5], 5, dest_cr, dct_linesize, s->chroma_qscale); | |
4046 add_dequant_dct(s, block[6], 6, dest_cb + dct_offset, dct_linesize, s->chroma_qscale); | |
4047 add_dequant_dct(s, block[7], 7, dest_cr + dct_offset, dct_linesize, s->chroma_qscale); | |
4048 } | |
485 | 4049 } |
936 | 4050 } else if(s->codec_id != CODEC_ID_WMV2){ |
2256 | 4051 add_dct(s, block[0], 0, dest_y , dct_linesize); |
4052 add_dct(s, block[1], 1, dest_y + block_size, dct_linesize); | |
4053 add_dct(s, block[2], 2, dest_y + dct_offset , dct_linesize); | |
4054 add_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize); | |
481 | 4055 |
485 | 4056 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
|
4057 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
|
4058 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
|
4059 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
|
4060 }else{ |
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
4061 //chroma422 |
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
4062 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
|
4063 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
|
4064 |
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
4065 add_dct(s, block[4], 4, dest_cb, dct_linesize); |
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
4066 add_dct(s, block[5], 5, dest_cr, dct_linesize); |
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
4067 add_dct(s, block[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
|
4068 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
|
4069 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
|
4070 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
|
4071 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
|
4072 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
|
4073 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
|
4074 } |
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
4075 } |
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
4076 }//fi gray |
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
4077 } |
4967
6d45158e0249
disable reference to msmpeg4 and wmv2 code when those codecs are not compiled in
aurel
parents:
4668
diff
changeset
|
4078 else if (ENABLE_WMV2) { |
936 | 4079 ff_wmv2_add_mb(s, block, dest_y, dest_cb, dest_cr); |
481 | 4080 } |
0 | 4081 } else { |
4082 /* dct only in intra block */ | |
1421 | 4083 if(s->encoding || !(s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO)){ |
2256 | 4084 put_dct(s, block[0], 0, dest_y , dct_linesize, s->qscale); |
4085 put_dct(s, block[1], 1, dest_y + block_size, dct_linesize, s->qscale); | |
4086 put_dct(s, block[2], 2, dest_y + dct_offset , dct_linesize, s->qscale); | |
4087 put_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize, s->qscale); | |
0 | 4088 |
711 | 4089 if(!(s->flags&CODEC_FLAG_GRAY)){ |
3309 | 4090 if(s->chroma_y_shift){ |
4091 put_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale); | |
4092 put_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale); | |
4093 }else{ | |
4094 dct_offset >>=1; | |
4095 dct_linesize >>=1; | |
4096 put_dct(s, block[4], 4, dest_cb, dct_linesize, s->chroma_qscale); | |
4097 put_dct(s, block[5], 5, dest_cr, dct_linesize, s->chroma_qscale); | |
4098 put_dct(s, block[6], 6, dest_cb + dct_offset, dct_linesize, s->chroma_qscale); | |
4099 put_dct(s, block[7], 7, dest_cr + dct_offset, dct_linesize, s->chroma_qscale); | |
4100 } | |
711 | 4101 } |
4102 }else{ | |
2256 | 4103 s->dsp.idct_put(dest_y , dct_linesize, block[0]); |
4104 s->dsp.idct_put(dest_y + block_size, dct_linesize, block[1]); | |
4105 s->dsp.idct_put(dest_y + dct_offset , dct_linesize, block[2]); | |
4106 s->dsp.idct_put(dest_y + dct_offset + block_size, dct_linesize, block[3]); | |
711 | 4107 |
4108 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
|
4109 if(s->chroma_y_shift){ |
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
4110 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
|
4111 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
|
4112 }else{ |
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
4113 |
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
4114 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
|
4115 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
|
4116 |
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
4117 s->dsp.idct_put(dest_cb, dct_linesize, block[4]); |
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
4118 s->dsp.idct_put(dest_cr, dct_linesize, block[5]); |
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
4119 s->dsp.idct_put(dest_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
|
4120 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
|
4121 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
|
4122 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
|
4123 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
|
4124 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
|
4125 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
|
4126 } |
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
4127 } |
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
4128 }//gray |
485 | 4129 } |
0 | 4130 } |
2792 | 4131 skip_idct: |
1632 | 4132 if(!readable){ |
4133 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
|
4134 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
|
4135 s->dsp.put_pixels_tab[s->chroma_x_shift][0](s->dest[2], dest_cr, uvlinesize,16 >> s->chroma_y_shift); |
1632 | 4136 } |
0 | 4137 } |
294 | 4138 } |
4139 | |
2256 | 4140 void MPV_decode_mb(MpegEncContext *s, DCTELEM block[12][64]){ |
4141 if(s->avctx->lowres) MPV_decode_mb_internal(s, block, 1); | |
4142 else MPV_decode_mb_internal(s, block, 0); | |
4143 } | |
4144 | |
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
|
4145 #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
|
4146 |
605
40874804a5af
same dc skip behavior for chroma & luma elimination, its confusing otherwise imho
michaelni
parents:
604
diff
changeset
|
4147 static inline void dct_single_coeff_elimination(MpegEncContext *s, int n, int threshold) |
456 | 4148 { |
4149 static const char tab[64]= | |
4150 {3,2,2,1,1,1,1,1, | |
4151 1,1,1,1,1,1,1,1, | |
4152 1,1,1,1,1,1,1,1, | |
4153 0,0,0,0,0,0,0,0, | |
4154 0,0,0,0,0,0,0,0, | |
4155 0,0,0,0,0,0,0,0, | |
4156 0,0,0,0,0,0,0,0, | |
4157 0,0,0,0,0,0,0,0}; | |
4158 int score=0; | |
4159 int run=0; | |
4160 int i; | |
4161 DCTELEM *block= s->block[n]; | |
4162 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
|
4163 int skip_dc; |
456 | 4164 |
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
|
4165 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
|
4166 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
|
4167 threshold= -threshold; |
605
40874804a5af
same dc skip behavior for chroma & luma elimination, its confusing otherwise imho
michaelni
parents:
604
diff
changeset
|
4168 }else |
40874804a5af
same dc skip behavior for chroma & luma elimination, its confusing otherwise imho
michaelni
parents:
604
diff
changeset
|
4169 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
|
4170 |
456 | 4171 /* are all which we could set to zero are allready zero? */ |
4172 if(last_index<=skip_dc - 1) return; | |
4173 | |
4174 for(i=0; i<=last_index; i++){ | |
706
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
4175 const int j = s->intra_scantable.permutated[i]; |
4001 | 4176 const int level = FFABS(block[j]); |
456 | 4177 if(level==1){ |
4178 if(skip_dc && i==0) continue; | |
4179 score+= tab[run]; | |
4180 run=0; | |
4181 }else if(level>1){ | |
4182 return; | |
4183 }else{ | |
4184 run++; | |
4185 } | |
4186 } | |
4187 if(score >= threshold) return; | |
4188 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
|
4189 const int j = s->intra_scantable.permutated[i]; |
456 | 4190 block[j]=0; |
4191 } | |
4192 if(block[0]) s->block_last_index[n]= 0; | |
4193 else s->block_last_index[n]= -1; | |
4194 } | |
4195 | |
344 | 4196 static inline void clip_coeffs(MpegEncContext *s, DCTELEM *block, int last_index) |
4197 { | |
4198 int i; | |
4199 const int maxlevel= s->max_qcoeff; | |
4200 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
|
4201 int overflow=0; |
2967 | 4202 |
706
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
4203 if(s->mb_intra){ |
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
4204 i=1; //skip clipping of intra dc |
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
4205 }else |
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
4206 i=0; |
2967 | 4207 |
706
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
4208 for(;i<=last_index; i++){ |
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
4209 const int j= s->intra_scantable.permutated[i]; |
344 | 4210 int level = block[j]; |
2967 | 4211 |
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
|
4212 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
|
4213 level=maxlevel; |
7e040c2a86e4
warn the user if we had to clip some dct coefficient due to a crappy format which doenst support the whole needed range (msmpeg4/wmv mostly but mpeg1 too to a lesser extend)
michael
parents:
1719
diff
changeset
|
4214 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
|
4215 }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
|
4216 level=minlevel; |
7e040c2a86e4
warn the user if we had to clip some dct coefficient due to a crappy format which doenst support the whole needed range (msmpeg4/wmv mostly but mpeg1 too to a lesser extend)
michael
parents:
1719
diff
changeset
|
4217 overflow++; |
7e040c2a86e4
warn the user if we had to clip some dct coefficient due to a crappy format which doenst support the whole needed range (msmpeg4/wmv mostly but mpeg1 too to a lesser extend)
michael
parents:
1719
diff
changeset
|
4218 } |
2967 | 4219 |
344 | 4220 block[j]= level; |
4221 } | |
2967 | 4222 |
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
|
4223 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
|
4224 av_log(s->avctx, AV_LOG_INFO, "warning, clipping %d dct coefficients to %d..%d\n", overflow, minlevel, maxlevel); |
344 | 4225 } |
324 | 4226 |
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
|
4227 #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
|
4228 |
1098
b7f267d168b7
mpeg2 field pictures + sliced mode (doesnt work with mplayer though, dunno why)
michaelni
parents:
1096
diff
changeset
|
4229 /** |
b7f267d168b7
mpeg2 field pictures + sliced mode (doesnt work with mplayer though, dunno why)
michaelni
parents:
1096
diff
changeset
|
4230 * |
b7f267d168b7
mpeg2 field pictures + sliced mode (doesnt work with mplayer though, dunno why)
michaelni
parents:
1096
diff
changeset
|
4231 * @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
|
4232 */ |
b7f267d168b7
mpeg2 field pictures + sliced mode (doesnt work with mplayer though, dunno why)
michaelni
parents:
1096
diff
changeset
|
4233 void ff_draw_horiz_band(MpegEncContext *s, int y, int h){ |
1368 | 4234 if (s->avctx->draw_horiz_band) { |
1370 | 4235 AVFrame *src; |
1368 | 4236 int offset[4]; |
2967 | 4237 |
1370 | 4238 if(s->picture_structure != PICT_FRAME){ |
4239 h <<= 1; | |
4240 y <<= 1; | |
4241 if(s->first_field && !(s->avctx->slice_flags&SLICE_FLAG_ALLOW_FIELD)) return; | |
4242 } | |
4243 | |
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
|
4244 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
|
4245 |
2967 | 4246 if(s->pict_type==B_TYPE || s->low_delay || (s->avctx->slice_flags&SLICE_FLAG_CODED_ORDER)) |
1370 | 4247 src= (AVFrame*)s->current_picture_ptr; |
4248 else if(s->last_picture_ptr) | |
4249 src= (AVFrame*)s->last_picture_ptr; | |
4250 else | |
4251 return; | |
2967 | 4252 |
1369 | 4253 if(s->pict_type==B_TYPE && s->picture_structure == PICT_FRAME && s->out_format != FMT_H264){ |
1368 | 4254 offset[0]= |
4255 offset[1]= | |
4256 offset[2]= | |
4257 offset[3]= 0; | |
4258 }else{ | |
4259 offset[0]= y * s->linesize;; | |
2967 | 4260 offset[1]= |
2074
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
4261 offset[2]= (y >> s->chroma_y_shift) * s->uvlinesize; |
1368 | 4262 offset[3]= 0; |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
731
diff
changeset
|
4263 } |
1368 | 4264 |
813 | 4265 emms_c(); |
4266 | |
1370 | 4267 s->avctx->draw_horiz_band(s->avctx, src, offset, |
4268 y, s->picture_structure, h); | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
731
diff
changeset
|
4269 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
731
diff
changeset
|
4270 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
731
diff
changeset
|
4271 |
1389 | 4272 void ff_init_block_index(MpegEncContext *s){ //FIXME maybe rename |
2764 | 4273 const int linesize= s->current_picture.linesize[0]; //not s->linesize as this would be wrong for field pics |
1389 | 4274 const int uvlinesize= s->current_picture.linesize[1]; |
2256 | 4275 const int mb_size= 4 - s->avctx->lowres; |
2967 | 4276 |
1938
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1918
diff
changeset
|
4277 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
|
4278 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
|
4279 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
|
4280 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
|
4281 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
|
4282 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
|
4283 //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
|
4284 |
2256 | 4285 s->dest[0] = s->current_picture.data[0] + ((s->mb_x - 1) << mb_size); |
4286 s->dest[1] = s->current_picture.data[1] + ((s->mb_x - 1) << (mb_size - s->chroma_x_shift)); | |
4287 s->dest[2] = s->current_picture.data[2] + ((s->mb_x - 1) << (mb_size - s->chroma_x_shift)); | |
2168 | 4288 |
2074
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
4289 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
|
4290 { |
2256 | 4291 s->dest[0] += s->mb_y * linesize << mb_size; |
4292 s->dest[1] += s->mb_y * uvlinesize << (mb_size - s->chroma_y_shift); | |
4293 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
|
4294 } |
1389 | 4295 } |
4296 | |
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
|
4297 #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
|
4298 |
1777 | 4299 static void get_vissual_weight(int16_t *weight, uint8_t *ptr, int stride){ |
4300 int x, y; | |
4301 //FIXME optimize | |
4302 for(y=0; y<8; y++){ | |
4303 for(x=0; x<8; x++){ | |
4304 int x2, y2; | |
4305 int sum=0; | |
4306 int sqr=0; | |
4307 int count=0; | |
4308 | |
4309 for(y2= FFMAX(y-1, 0); y2 < FFMIN(8, y+2); y2++){ | |
4310 for(x2= FFMAX(x-1, 0); x2 < FFMIN(8, x+2); x2++){ | |
4311 int v= ptr[x2 + y2*stride]; | |
4312 sum += v; | |
4313 sqr += v*v; | |
4314 count++; | |
4315 } | |
4316 } | |
4317 weight[x + 8*y]= (36*ff_sqrt(count*sqr - sum*sum)) / count; | |
4318 } | |
4319 } | |
4320 } | |
4321 | |
4283
d6f83e2f8804
rename always_inline to av_always_inline and move to common.h
mru
parents:
4281
diff
changeset
|
4322 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 | 4323 { |
3309 | 4324 int16_t weight[8][64]; |
4325 DCTELEM orig[8][64]; | |
294 | 4326 const int mb_x= s->mb_x; |
4327 const int mb_y= s->mb_y; | |
4328 int i; | |
3309 | 4329 int skip_dct[8]; |
697 | 4330 int dct_offset = s->linesize*8; //default for progressive frames |
1778 | 4331 uint8_t *ptr_y, *ptr_cb, *ptr_cr; |
4332 int wrap_y, wrap_c; | |
2967 | 4333 |
4327 | 4334 for(i=0; i<mb_block_count; i++) skip_dct[i]=s->skipdct; |
2967 | 4335 |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
673
diff
changeset
|
4336 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
|
4337 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
|
4338 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
|
4339 |
010f76d07a27
use lagrange multipler instead of qp for ratecontrol, this may break some things, tell me ASAP if u notice anything broken
michaelni
parents:
1497
diff
changeset
|
4340 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
|
4341 update_qscale(s); |
2967 | 4342 |
1616 | 4343 if(!(s->flags&CODEC_FLAG_QP_RD)){ |
4320 | 4344 s->qscale= s->current_picture_ptr->qscale_table[mb_xy]; |
1616 | 4345 s->dquant= s->qscale - last_qp; |
4346 | |
1805
5dd5b2052f5b
mpeg4 b frame + adaptive quantization assertion failure fix
michael
parents:
1804
diff
changeset
|
4347 if(s->out_format==FMT_H263){ |
4594 | 4348 s->dquant= av_clip(s->dquant, -2, 2); |
2967 | 4349 |
4350 if(s->codec_id==CODEC_ID_MPEG4){ | |
1805
5dd5b2052f5b
mpeg4 b frame + adaptive quantization assertion failure fix
michael
parents:
1804
diff
changeset
|
4351 if(!s->mb_intra){ |
5dd5b2052f5b
mpeg4 b frame + adaptive quantization assertion failure fix
michael
parents:
1804
diff
changeset
|
4352 if(s->pict_type == B_TYPE){ |
4324 | 4353 if(s->dquant&1 || s->mv_dir&MV_DIRECT) |
1805
5dd5b2052f5b
mpeg4 b frame + adaptive quantization assertion failure fix
michael
parents:
1804
diff
changeset
|
4354 s->dquant= 0; |
5dd5b2052f5b
mpeg4 b frame + adaptive quantization assertion failure fix
michael
parents:
1804
diff
changeset
|
4355 } |
5dd5b2052f5b
mpeg4 b frame + adaptive quantization assertion failure fix
michael
parents:
1804
diff
changeset
|
4356 if(s->mv_type==MV_TYPE_8X8) |
5dd5b2052f5b
mpeg4 b frame + adaptive quantization assertion failure fix
michael
parents:
1804
diff
changeset
|
4357 s->dquant=0; |
5dd5b2052f5b
mpeg4 b frame + adaptive quantization assertion failure fix
michael
parents:
1804
diff
changeset
|
4358 } |
1616 | 4359 } |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
673
diff
changeset
|
4360 } |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
673
diff
changeset
|
4361 } |
1652 | 4362 ff_set_qscale(s, last_qp + s->dquant); |
2054 | 4363 }else if(s->flags&CODEC_FLAG_QP_RD) |
4364 ff_set_qscale(s, s->qscale + s->dquant); | |
294 | 4365 |
1778 | 4366 wrap_y = s->linesize; |
4367 wrap_c = s->uvlinesize; | |
4368 ptr_y = s->new_picture.data[0] + (mb_y * 16 * wrap_y) + mb_x * 16; | |
3309 | 4369 ptr_cb = s->new_picture.data[1] + (mb_y * mb_block_height * wrap_c) + mb_x * 8; |
4370 ptr_cr = s->new_picture.data[2] + (mb_y * mb_block_height * wrap_c) + mb_x * 8; | |
1778 | 4371 |
4372 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
|
4373 uint8_t *ebuf= s->edge_emu_buffer + 32; |
5ca07515a309
10l (dont store 2 different things at the same place ...)
michael
parents:
2132
diff
changeset
|
4374 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
|
4375 ptr_y= ebuf; |
3309 | 4376 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
|
4377 ptr_cb= ebuf+18*wrap_y; |
3309 | 4378 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
|
4379 ptr_cr= ebuf+18*wrap_y+8; |
1778 | 4380 } |
4381 | |
324 | 4382 if (s->mb_intra) { |
697 | 4383 if(s->flags&CODEC_FLAG_INTERLACED_DCT){ |
4384 int progressive_score, interlaced_score; | |
1708 | 4385 |
1729 | 4386 s->interlaced_dct=0; |
2967 | 4387 progressive_score= s->dsp.ildct_cmp[4](s, ptr_y , NULL, wrap_y, 8) |
1777 | 4388 +s->dsp.ildct_cmp[4](s, ptr_y + wrap_y*8, NULL, wrap_y, 8) - 400; |
1729 | 4389 |
4390 if(progressive_score > 0){ | |
2967 | 4391 interlaced_score = s->dsp.ildct_cmp[4](s, ptr_y , NULL, wrap_y*2, 8) |
1777 | 4392 +s->dsp.ildct_cmp[4](s, ptr_y + wrap_y , NULL, wrap_y*2, 8); |
1729 | 4393 if(progressive_score > interlaced_score){ |
4394 s->interlaced_dct=1; | |
2967 | 4395 |
1729 | 4396 dct_offset= wrap_y; |
4397 wrap_y<<=1; | |
3309 | 4398 if (s->chroma_format == CHROMA_422) |
4399 wrap_c<<=1; | |
1729 | 4400 } |
4401 } | |
697 | 4402 } |
2967 | 4403 |
2979 | 4404 s->dsp.get_pixels(s->block[0], ptr_y , wrap_y); |
1777 | 4405 s->dsp.get_pixels(s->block[1], ptr_y + 8, wrap_y); |
4406 s->dsp.get_pixels(s->block[2], ptr_y + dct_offset , wrap_y); | |
4407 s->dsp.get_pixels(s->block[3], ptr_y + dct_offset + 8, wrap_y); | |
294 | 4408 |
487 | 4409 if(s->flags&CODEC_FLAG_GRAY){ |
4410 skip_dct[4]= 1; | |
4411 skip_dct[5]= 1; | |
4412 }else{ | |
2979 | 4413 s->dsp.get_pixels(s->block[4], ptr_cb, wrap_c); |
1777 | 4414 s->dsp.get_pixels(s->block[5], ptr_cr, wrap_c); |
3309 | 4415 if(!s->chroma_y_shift){ /* 422 */ |
4416 s->dsp.get_pixels(s->block[6], ptr_cb + (dct_offset>>1), wrap_c); | |
4417 s->dsp.get_pixels(s->block[7], ptr_cr + (dct_offset>>1), wrap_c); | |
4418 } | |
1777 | 4419 } |
324 | 4420 }else{ |
651 | 4421 op_pixels_func (*op_pix)[4]; |
4422 qpel_mc_func (*op_qpix)[16]; | |
1064 | 4423 uint8_t *dest_y, *dest_cb, *dest_cr; |
294 | 4424 |
1389 | 4425 dest_y = s->dest[0]; |
4426 dest_cb = s->dest[1]; | |
4427 dest_cr = s->dest[2]; | |
324 | 4428 |
327 | 4429 if ((!s->no_rounding) || s->pict_type==B_TYPE){ |
2979 | 4430 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
|
4431 op_qpix= s->dsp.put_qpel_pixels_tab; |
295 | 4432 }else{ |
853
eacc2dd8fd9d
* using DSPContext - so each codec could use its local (sub)set of CPU extension
kabi
parents:
847
diff
changeset
|
4433 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
|
4434 op_qpix= s->dsp.put_no_rnd_qpel_pixels_tab; |
324 | 4435 } |
295 | 4436 |
324 | 4437 if (s->mv_dir & MV_DIR_FORWARD) { |
903 | 4438 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
|
4439 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
|
4440 op_qpix= s->dsp.avg_qpel_pixels_tab; |
324 | 4441 } |
4442 if (s->mv_dir & MV_DIR_BACKWARD) { | |
903 | 4443 MPV_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.data, op_pix, op_qpix); |
324 | 4444 } |
295 | 4445 |
697 | 4446 if(s->flags&CODEC_FLAG_INTERLACED_DCT){ |
4447 int progressive_score, interlaced_score; | |
1729 | 4448 |
4449 s->interlaced_dct=0; | |
2967 | 4450 progressive_score= s->dsp.ildct_cmp[0](s, dest_y , ptr_y , wrap_y, 8) |
1729 | 4451 +s->dsp.ildct_cmp[0](s, dest_y + wrap_y*8, ptr_y + wrap_y*8, wrap_y, 8) - 400; |
2967 | 4452 |
1729 | 4453 if(s->avctx->ildct_cmp == FF_CMP_VSSE) progressive_score -= 400; |
4454 | |
4455 if(progressive_score>0){ | |
2967 | 4456 interlaced_score = s->dsp.ildct_cmp[0](s, dest_y , ptr_y , wrap_y*2, 8) |
1729 | 4457 +s->dsp.ildct_cmp[0](s, dest_y + wrap_y , ptr_y + wrap_y , wrap_y*2, 8); |
2967 | 4458 |
1729 | 4459 if(progressive_score > interlaced_score){ |
4460 s->interlaced_dct=1; | |
2967 | 4461 |
1729 | 4462 dct_offset= wrap_y; |
4463 wrap_y<<=1; | |
3309 | 4464 if (s->chroma_format == CHROMA_422) |
4465 wrap_c<<=1; | |
1729 | 4466 } |
4467 } | |
697 | 4468 } |
2967 | 4469 |
2979 | 4470 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
|
4471 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
|
4472 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
|
4473 s->dsp.diff_pixels(s->block[3], ptr_y + dct_offset + 8, dest_y + dct_offset + 8, wrap_y); |
2967 | 4474 |
487 | 4475 if(s->flags&CODEC_FLAG_GRAY){ |
4476 skip_dct[4]= 1; | |
4477 skip_dct[5]= 1; | |
4478 }else{ | |
853
eacc2dd8fd9d
* using DSPContext - so each codec could use its local (sub)set of CPU extension
kabi
parents:
847
diff
changeset
|
4479 s->dsp.diff_pixels(s->block[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
|
4480 s->dsp.diff_pixels(s->block[5], ptr_cr, dest_cr, wrap_c); |
3309 | 4481 if(!s->chroma_y_shift){ /* 422 */ |
4482 s->dsp.diff_pixels(s->block[6], ptr_cb + (dct_offset>>1), dest_cb + (dct_offset>>1), wrap_c); | |
4483 s->dsp.diff_pixels(s->block[7], ptr_cr + (dct_offset>>1), dest_cr + (dct_offset>>1), wrap_c); | |
4484 } | |
487 | 4485 } |
2967 | 4486 /* 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
|
4487 if(s->current_picture.mc_mb_var[s->mb_stride*mb_y+ mb_x]<2*s->qscale*s->qscale){ |
697 | 4488 //FIXME optimize |
2979 | 4489 if(s->dsp.sad[1](NULL, ptr_y , dest_y , wrap_y, 8) < 20*s->qscale) skip_dct[0]= 1; |
1708 | 4490 if(s->dsp.sad[1](NULL, ptr_y + 8, dest_y + 8, wrap_y, 8) < 20*s->qscale) skip_dct[1]= 1; |
4491 if(s->dsp.sad[1](NULL, ptr_y +dct_offset , dest_y +dct_offset , wrap_y, 8) < 20*s->qscale) skip_dct[2]= 1; | |
4492 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; | |
4493 if(s->dsp.sad[1](NULL, ptr_cb , dest_cb , wrap_c, 8) < 20*s->qscale) skip_dct[4]= 1; | |
4494 if(s->dsp.sad[1](NULL, ptr_cr , dest_cr , wrap_c, 8) < 20*s->qscale) skip_dct[5]= 1; | |
3309 | 4495 if(!s->chroma_y_shift){ /* 422 */ |
4496 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; | |
4497 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; | |
4498 } | |
456 | 4499 } |
1778 | 4500 } |
4501 | |
4502 if(s->avctx->quantizer_noise_shaping){ | |
4503 if(!skip_dct[0]) get_vissual_weight(weight[0], ptr_y , wrap_y); | |
4504 if(!skip_dct[1]) get_vissual_weight(weight[1], ptr_y + 8, wrap_y); | |
4505 if(!skip_dct[2]) get_vissual_weight(weight[2], ptr_y + dct_offset , wrap_y); | |
4506 if(!skip_dct[3]) get_vissual_weight(weight[3], ptr_y + dct_offset + 8, wrap_y); | |
4507 if(!skip_dct[4]) get_vissual_weight(weight[4], ptr_cb , wrap_c); | |
4508 if(!skip_dct[5]) get_vissual_weight(weight[5], ptr_cr , wrap_c); | |
3309 | 4509 if(!s->chroma_y_shift){ /* 422 */ |
4510 if(!skip_dct[6]) get_vissual_weight(weight[6], ptr_cb + (dct_offset>>1), wrap_c); | |
4511 if(!skip_dct[7]) get_vissual_weight(weight[7], ptr_cr + (dct_offset>>1), wrap_c); | |
4512 } | |
4513 memcpy(orig[0], s->block[0], sizeof(DCTELEM)*64*mb_block_count); | |
294 | 4514 } |
2967 | 4515 |
294 | 4516 /* DCT & quantize */ |
1778 | 4517 assert(s->out_format!=FMT_MJPEG || s->qscale==8); |
4518 { | |
3309 | 4519 for(i=0;i<mb_block_count;i++) { |
456 | 4520 if(!skip_dct[i]){ |
4521 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
|
4522 s->block_last_index[i] = s->dct_quantize(s, s->block[i], i, s->qscale, &overflow); |
344 | 4523 // 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
|
4524 // 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
|
4525 // of improve it. Just INTRADC clipping deserves changes in quantizer |
456 | 4526 if (overflow) clip_coeffs(s, s->block[i], s->block_last_index[i]); |
4527 }else | |
4528 s->block_last_index[i]= -1; | |
344 | 4529 } |
1777 | 4530 if(s->avctx->quantizer_noise_shaping){ |
3309 | 4531 for(i=0;i<mb_block_count;i++) { |
1777 | 4532 if(!skip_dct[i]){ |
4533 s->block_last_index[i] = dct_quantize_refine(s, s->block[i], weight[i], orig[i], i, s->qscale); | |
4534 } | |
4535 } | |
4536 } | |
2967 | 4537 |
456 | 4538 if(s->luma_elim_threshold && !s->mb_intra) |
4539 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
|
4540 dct_single_coeff_elimination(s, i, s->luma_elim_threshold); |
456 | 4541 if(s->chroma_elim_threshold && !s->mb_intra) |
3309 | 4542 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
|
4543 dct_single_coeff_elimination(s, i, s->chroma_elim_threshold); |
1497 | 4544 |
4545 if(s->flags & CODEC_FLAG_CBP_RD){ | |
3309 | 4546 for(i=0;i<mb_block_count;i++) { |
1497 | 4547 if(s->block_last_index[i] == -1) |
4548 s->coded_score[i]= INT_MAX/256; | |
4549 } | |
4550 } | |
294 | 4551 } |
4552 | |
487 | 4553 if((s->flags&CODEC_FLAG_GRAY) && s->mb_intra){ |
4554 s->block_last_index[4]= | |
4555 s->block_last_index[5]= 0; | |
4556 s->block[4][0]= | |
1011 | 4557 s->block[5][0]= (1024 + s->c_dc_scale/2)/ s->c_dc_scale; |
487 | 4558 } |
4559 | |
1708 | 4560 //non c quantize code returns incorrect block_last_index FIXME |
4561 if(s->alternate_scan && s->dct_quantize != dct_quantize_c){ | |
3309 | 4562 for(i=0; i<mb_block_count; i++){ |
1708 | 4563 int j; |
4564 if(s->block_last_index[i]>0){ | |
4565 for(j=63; j>0; j--){ | |
4566 if(s->block[i][ s->intra_scantable.permutated[j] ]) break; | |
4567 } | |
4568 s->block_last_index[i]= j; | |
4569 } | |
4570 } | |
4571 } | |
4572 | |
294 | 4573 /* huffman encode */ |
936 | 4574 switch(s->codec_id){ //FIXME funct ptr could be slightly faster |
4575 case CODEC_ID_MPEG1VIDEO: | |
1421 | 4576 case CODEC_ID_MPEG2VIDEO: |
936 | 4577 mpeg1_encode_mb(s, s->block, motion_x, motion_y); break; |
4578 case CODEC_ID_MPEG4: | |
4579 mpeg4_encode_mb(s, s->block, motion_x, motion_y); break; | |
4580 case CODEC_ID_MSMPEG4V2: | |
4581 case CODEC_ID_MSMPEG4V3: | |
4582 case CODEC_ID_WMV1: | |
4967
6d45158e0249
disable reference to msmpeg4 and wmv2 code when those codecs are not compiled in
aurel
parents:
4668
diff
changeset
|
4583 if (ENABLE_MSMPEG4_ENCODER) |
4976 | 4584 msmpeg4_encode_mb(s, s->block, motion_x, motion_y); |
4585 break; | |
936 | 4586 case CODEC_ID_WMV2: |
4967
6d45158e0249
disable reference to msmpeg4 and wmv2 code when those codecs are not compiled in
aurel
parents:
4668
diff
changeset
|
4587 if (ENABLE_WMV2_ENCODER) |
4976 | 4588 ff_wmv2_encode_mb(s, s->block, motion_x, motion_y); |
4589 break; | |
2327
5e5cf598a48b
H.261 encoder by (Maarten Daniels <maarten dot daniels at luc dot ac dot be>)
michael
parents:
2298
diff
changeset
|
4590 case CODEC_ID_H261: |
4997 | 4591 if (ENABLE_H261_ENCODER) |
4998 | 4592 ff_h261_encode_mb(s, s->block, motion_x, motion_y); |
4593 break; | |
936 | 4594 case CODEC_ID_H263: |
4595 case CODEC_ID_H263P: | |
1353
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1344
diff
changeset
|
4596 case CODEC_ID_FLV1: |
936 | 4597 case CODEC_ID_RV10: |
2380 | 4598 case CODEC_ID_RV20: |
936 | 4599 h263_encode_mb(s, s->block, motion_x, motion_y); break; |
1042 | 4600 case CODEC_ID_MJPEG: |
4995 | 4601 if (ENABLE_MJPEG_ENCODER) |
5029
dbaa06366c3c
add a proper prefix to all mjpeg encoder exported functions
aurel
parents:
5028
diff
changeset
|
4602 ff_mjpeg_encode_mb(s, s->block); |
4996 | 4603 break; |
936 | 4604 default: |
4605 assert(0); | |
294 | 4606 } |
4607 } | |
4608 | |
4283
d6f83e2f8804
rename always_inline to av_always_inline and move to common.h
mru
parents:
4281
diff
changeset
|
4609 static av_always_inline void encode_mb(MpegEncContext *s, int motion_x, int motion_y) |
3309 | 4610 { |
4611 if (s->chroma_format == CHROMA_420) encode_mb_internal(s, motion_x, motion_y, 8, 6); | |
4612 else encode_mb_internal(s, motion_x, motion_y, 16, 8); | |
4613 } | |
4614 | |
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
|
4615 #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
|
4616 |
1368 | 4617 void ff_mpeg_flush(AVCodecContext *avctx){ |
4618 int i; | |
4619 MpegEncContext *s = avctx->priv_data; | |
2967 | 4620 |
4621 if(s==NULL || s->picture==NULL) | |
1751 | 4622 return; |
2967 | 4623 |
1368 | 4624 for(i=0; i<MAX_PICTURE_COUNT; i++){ |
4625 if(s->picture[i].data[0] && ( s->picture[i].type == FF_BUFFER_TYPE_INTERNAL | |
4626 || s->picture[i].type == FF_BUFFER_TYPE_USER)) | |
4627 avctx->release_buffer(avctx, (AVFrame*)&s->picture[i]); | |
4628 } | |
1601 | 4629 s->current_picture_ptr = s->last_picture_ptr = s->next_picture_ptr = NULL; |
2967 | 4630 |
2380 | 4631 s->mb_x= s->mb_y= 0; |
2967 | 4632 |
1395 | 4633 s->parse_context.state= -1; |
4634 s->parse_context.frame_start_found= 0; | |
4635 s->parse_context.overread= 0; | |
4636 s->parse_context.overread_index= 0; | |
4637 s->parse_context.index= 0; | |
4638 s->parse_context.last_index= 0; | |
1851 | 4639 s->bitstream_buffer_size=0; |
4346 | 4640 s->pp_time=0; |
1368 | 4641 } |
4642 | |
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
|
4643 #ifdef CONFIG_ENCODERS |
1064 | 4644 void ff_copy_bits(PutBitContext *pb, uint8_t *src, int length) |
294 | 4645 { |
1810 | 4646 const uint16_t *srcw= (uint16_t*)src; |
1799 | 4647 int words= length>>4; |
326 | 4648 int bits= length&15; |
4649 int i; | |
4650 | |
456 | 4651 if(length==0) return; |
2967 | 4652 |
1803 | 4653 if(words < 16){ |
4654 for(i=0; i<words; i++) put_bits(pb, 16, be2me_16(srcw[i])); | |
4655 }else if(put_bits_count(pb)&7){ | |
4656 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
|
4657 }else{ |
1803 | 4658 for(i=0; put_bits_count(pb)&31; i++) |
4659 put_bits(pb, 8, src[i]); | |
1799 | 4660 flush_put_bits(pb); |
1803 | 4661 memcpy(pbBufPtr(pb), src+i, 2*words-i); |
4662 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
|
4663 } |
2967 | 4664 |
1803 | 4665 put_bits(pb, bits, be2me_16(srcw[words])>>(16-bits)); |
0 | 4666 } |
4667 | |
456 | 4668 static inline void copy_context_before_encode(MpegEncContext *d, MpegEncContext *s, int type){ |
326 | 4669 int i; |
4670 | |
4671 memcpy(d->last_mv, s->last_mv, 2*2*2*sizeof(int)); //FIXME is memcpy faster then a loop? | |
4672 | |
4673 /* mpeg1 */ | |
1160 | 4674 d->mb_skip_run= s->mb_skip_run; |
326 | 4675 for(i=0; i<3; i++) |
4676 d->last_dc[i]= s->last_dc[i]; | |
2967 | 4677 |
326 | 4678 /* statistics */ |
4679 d->mv_bits= s->mv_bits; | |
4680 d->i_tex_bits= s->i_tex_bits; | |
4681 d->p_tex_bits= s->p_tex_bits; | |
4682 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
|
4683 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
|
4684 d->b_count= s->b_count; |
326 | 4685 d->skip_count= s->skip_count; |
4686 d->misc_bits= s->misc_bits; | |
329 | 4687 d->last_bits= 0; |
327 | 4688 |
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
|
4689 d->mb_skipped= 0; |
912 | 4690 d->qscale= s->qscale; |
1616 | 4691 d->dquant= s->dquant; |
326 | 4692 } |
4693 | |
456 | 4694 static inline void copy_context_after_encode(MpegEncContext *d, MpegEncContext *s, int type){ |
326 | 4695 int i; |
4696 | |
2967 | 4697 memcpy(d->mv, s->mv, 2*4*2*sizeof(int)); |
326 | 4698 memcpy(d->last_mv, s->last_mv, 2*2*2*sizeof(int)); //FIXME is memcpy faster then a loop? |
2967 | 4699 |
326 | 4700 /* mpeg1 */ |
1160 | 4701 d->mb_skip_run= s->mb_skip_run; |
326 | 4702 for(i=0; i<3; i++) |
4703 d->last_dc[i]= s->last_dc[i]; | |
2967 | 4704 |
326 | 4705 /* statistics */ |
4706 d->mv_bits= s->mv_bits; | |
4707 d->i_tex_bits= s->i_tex_bits; | |
4708 d->p_tex_bits= s->p_tex_bits; | |
4709 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
|
4710 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
|
4711 d->b_count= s->b_count; |
326 | 4712 d->skip_count= s->skip_count; |
4713 d->misc_bits= s->misc_bits; | |
4714 | |
4715 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
|
4716 d->mb_skipped= s->mb_skipped; |
326 | 4717 d->mv_type= s->mv_type; |
4718 d->mv_dir= s->mv_dir; | |
4719 d->pb= s->pb; | |
456 | 4720 if(s->data_partitioning){ |
4721 d->pb2= s->pb2; | |
4722 d->tex_pb= s->tex_pb; | |
4723 } | |
326 | 4724 d->block= s->block; |
3309 | 4725 for(i=0; i<8; i++) |
326 | 4726 d->block_last_index[i]= s->block_last_index[i]; |
755 | 4727 d->interlaced_dct= s->interlaced_dct; |
912 | 4728 d->qscale= s->qscale; |
326 | 4729 } |
4730 | |
2967 | 4731 static inline void encode_mb_hq(MpegEncContext *s, MpegEncContext *backup, MpegEncContext *best, int type, |
456 | 4732 PutBitContext pb[2], PutBitContext pb2[2], PutBitContext tex_pb[2], |
4733 int *dmin, int *next_block, int motion_x, int motion_y) | |
4734 { | |
1389 | 4735 int score; |
4736 uint8_t *dest_backup[3]; | |
2967 | 4737 |
456 | 4738 copy_context_before_encode(s, backup, type); |
4739 | |
4740 s->block= s->blocks[*next_block]; | |
4741 s->pb= pb[*next_block]; | |
4742 if(s->data_partitioning){ | |
4743 s->pb2 = pb2 [*next_block]; | |
4744 s->tex_pb= tex_pb[*next_block]; | |
4745 } | |
2967 | 4746 |
1389 | 4747 if(*next_block){ |
4748 memcpy(dest_backup, s->dest, sizeof(s->dest)); | |
1799 | 4749 s->dest[0] = s->rd_scratchpad; |
4750 s->dest[1] = s->rd_scratchpad + 16*s->linesize; | |
4751 s->dest[2] = s->rd_scratchpad + 16*s->linesize + 8; | |
4752 assert(s->linesize >= 32); //FIXME | |
1389 | 4753 } |
456 | 4754 |
4755 encode_mb(s, motion_x, motion_y); | |
2967 | 4756 |
1786 | 4757 score= put_bits_count(&s->pb); |
456 | 4758 if(s->data_partitioning){ |
1786 | 4759 score+= put_bits_count(&s->pb2); |
4760 score+= put_bits_count(&s->tex_pb); | |
456 | 4761 } |
2967 | 4762 |
1389 | 4763 if(s->avctx->mb_decision == FF_MB_DECISION_RD){ |
4764 MPV_decode_mb(s, s->block); | |
4765 | |
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
|
4766 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
|
4767 score += sse_mb(s) << FF_LAMBDA_SHIFT; |
1389 | 4768 } |
2967 | 4769 |
1389 | 4770 if(*next_block){ |
4771 memcpy(s->dest, dest_backup, sizeof(s->dest)); | |
4772 } | |
4773 | |
4774 if(score<*dmin){ | |
4775 *dmin= score; | |
456 | 4776 *next_block^=1; |
4777 | |
4778 copy_context_after_encode(best, s, type); | |
4779 } | |
4780 } | |
2967 | 4781 |
1389 | 4782 static int sse(MpegEncContext *s, uint8_t *src1, uint8_t *src2, int w, int h, int stride){ |
4179 | 4783 uint32_t *sq = ff_squareTbl + 256; |
909
8ae1e4c24e91
new PSNR code (now works with chroma, b frames, ...)
michaelni
parents:
903
diff
changeset
|
4784 int acc=0; |
8ae1e4c24e91
new PSNR code (now works with chroma, b frames, ...)
michaelni
parents:
903
diff
changeset
|
4785 int x,y; |
2967 | 4786 |
4787 if(w==16 && h==16) | |
1708 | 4788 return s->dsp.sse[0](NULL, src1, src2, stride, 16); |
936 | 4789 else if(w==8 && h==8) |
1708 | 4790 return s->dsp.sse[1](NULL, src1, src2, stride, 8); |
2967 | 4791 |
909
8ae1e4c24e91
new PSNR code (now works with chroma, b frames, ...)
michaelni
parents:
903
diff
changeset
|
4792 for(y=0; y<h; y++){ |
8ae1e4c24e91
new PSNR code (now works with chroma, b frames, ...)
michaelni
parents:
903
diff
changeset
|
4793 for(x=0; x<w; x++){ |
8ae1e4c24e91
new PSNR code (now works with chroma, b frames, ...)
michaelni
parents:
903
diff
changeset
|
4794 acc+= sq[src1[x + y*stride] - src2[x + y*stride]]; |
2967 | 4795 } |
4796 } | |
4797 | |
936 | 4798 assert(acc>=0); |
2967 | 4799 |
909
8ae1e4c24e91
new PSNR code (now works with chroma, b frames, ...)
michaelni
parents:
903
diff
changeset
|
4800 return acc; |
8ae1e4c24e91
new PSNR code (now works with chroma, b frames, ...)
michaelni
parents:
903
diff
changeset
|
4801 } |
326 | 4802 |
1389 | 4803 static int sse_mb(MpegEncContext *s){ |
4804 int w= 16; | |
4805 int h= 16; | |
4806 | |
4807 if(s->mb_x*16 + 16 > s->width ) w= s->width - s->mb_x*16; | |
4808 if(s->mb_y*16 + 16 > s->height) h= s->height- s->mb_y*16; | |
4809 | |
4810 if(w==16 && h==16) | |
2065
9e4bebc39ade
noise preserving sum of squares comparission function
michael
parents:
2063
diff
changeset
|
4811 if(s->avctx->mb_cmp == FF_CMP_NSSE){ |
2066 | 4812 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) |
4813 +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) | |
4814 +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
|
4815 }else{ |
1708 | 4816 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) |
4817 +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) | |
4818 +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
|
4819 } |
1389 | 4820 else |
4821 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) | |
4822 +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) | |
4823 +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); | |
4824 } | |
4825 | |
1799 | 4826 static int pre_estimate_motion_thread(AVCodecContext *c, void *arg){ |
4827 MpegEncContext *s= arg; | |
4828 | |
2967 | 4829 |
1799 | 4830 s->me.pre_pass=1; |
4831 s->me.dia_size= s->avctx->pre_dia_size; | |
4832 s->first_slice_line=1; | |
4833 for(s->mb_y= s->end_mb_y-1; s->mb_y >= s->start_mb_y; s->mb_y--) { | |
4834 for(s->mb_x=s->mb_width-1; s->mb_x >=0 ;s->mb_x--) { | |
4835 ff_pre_estimate_p_frame_motion(s, s->mb_x, s->mb_y); | |
4836 } | |
4837 s->first_slice_line=0; | |
4838 } | |
2967 | 4839 |
1799 | 4840 s->me.pre_pass=0; |
2967 | 4841 |
1799 | 4842 return 0; |
4843 } | |
4844 | |
4845 static int estimate_motion_thread(AVCodecContext *c, void *arg){ | |
4846 MpegEncContext *s= arg; | |
4847 | |
4281
de525a2b41db
ff_check_alignment to warn the user about a missaligned stack
michael
parents:
4274
diff
changeset
|
4848 ff_check_alignment(); |
de525a2b41db
ff_check_alignment to warn the user about a missaligned stack
michael
parents:
4274
diff
changeset
|
4849 |
1799 | 4850 s->me.dia_size= s->avctx->dia_size; |
4851 s->first_slice_line=1; | |
4852 for(s->mb_y= s->start_mb_y; s->mb_y < s->end_mb_y; s->mb_y++) { | |
4853 s->mb_x=0; //for block init below | |
4854 ff_init_block_index(s); | |
4855 for(s->mb_x=0; s->mb_x < s->mb_width; s->mb_x++) { | |
4856 s->block_index[0]+=2; | |
4857 s->block_index[1]+=2; | |
4858 s->block_index[2]+=2; | |
4859 s->block_index[3]+=2; | |
2967 | 4860 |
1799 | 4861 /* compute motion vector & mb_type and store in context */ |
4862 if(s->pict_type==B_TYPE) | |
4863 ff_estimate_b_frame_motion(s, s->mb_x, s->mb_y); | |
4864 else | |
4865 ff_estimate_p_frame_motion(s, s->mb_x, s->mb_y); | |
4866 } | |
4867 s->first_slice_line=0; | |
4868 } | |
4869 return 0; | |
4870 } | |
4871 | |
1804
cc0a15943a87
multithreaded spatial complexity calculation for i frames
michael
parents:
1803
diff
changeset
|
4872 static int mb_var_thread(AVCodecContext *c, void *arg){ |
cc0a15943a87
multithreaded spatial complexity calculation for i frames
michael
parents:
1803
diff
changeset
|
4873 MpegEncContext *s= arg; |
cc0a15943a87
multithreaded spatial complexity calculation for i frames
michael
parents:
1803
diff
changeset
|
4874 int mb_x, mb_y; |
cc0a15943a87
multithreaded spatial complexity calculation for i frames
michael
parents:
1803
diff
changeset
|
4875 |
4281
de525a2b41db
ff_check_alignment to warn the user about a missaligned stack
michael
parents:
4274
diff
changeset
|
4876 ff_check_alignment(); |
de525a2b41db
ff_check_alignment to warn the user about a missaligned stack
michael
parents:
4274
diff
changeset
|
4877 |
1804
cc0a15943a87
multithreaded spatial complexity calculation for i frames
michael
parents:
1803
diff
changeset
|
4878 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
|
4879 for(mb_x=0; mb_x < s->mb_width; mb_x++) { |
cc0a15943a87
multithreaded spatial complexity calculation for i frames
michael
parents:
1803
diff
changeset
|
4880 int xx = mb_x * 16; |
cc0a15943a87
multithreaded spatial complexity calculation for i frames
michael
parents:
1803
diff
changeset
|
4881 int yy = mb_y * 16; |
cc0a15943a87
multithreaded spatial complexity calculation for i frames
michael
parents:
1803
diff
changeset
|
4882 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
|
4883 int varc; |
cc0a15943a87
multithreaded spatial complexity calculation for i frames
michael
parents:
1803
diff
changeset
|
4884 int sum = s->dsp.pix_sum(pix, s->linesize); |
2967 | 4885 |
1804
cc0a15943a87
multithreaded spatial complexity calculation for i frames
michael
parents:
1803
diff
changeset
|
4886 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
|
4887 |
cc0a15943a87
multithreaded spatial complexity calculation for i frames
michael
parents:
1803
diff
changeset
|
4888 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
|
4889 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
|
4890 s->me.mb_var_sum_temp += varc; |
1804
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 } |
1805
5dd5b2052f5b
mpeg4 b frame + adaptive quantization assertion failure fix
michael
parents:
1804
diff
changeset
|
4893 return 0; |
1804
cc0a15943a87
multithreaded spatial complexity calculation for i frames
michael
parents:
1803
diff
changeset
|
4894 } |
cc0a15943a87
multithreaded spatial complexity calculation for i frames
michael
parents:
1803
diff
changeset
|
4895 |
1799 | 4896 static void write_slice_end(MpegEncContext *s){ |
4897 if(s->codec_id==CODEC_ID_MPEG4){ | |
4898 if(s->partitioned_frame){ | |
4899 ff_mpeg4_merge_partitions(s); | |
4900 } | |
2967 | 4901 |
1799 | 4902 ff_mpeg4_stuffing(&s->pb); |
4995 | 4903 }else if(ENABLE_MJPEG_ENCODER && s->out_format == FMT_MJPEG){ |
5029
dbaa06366c3c
add a proper prefix to all mjpeg encoder exported functions
aurel
parents:
5028
diff
changeset
|
4904 ff_mjpeg_encode_stuffing(&s->pb); |
1799 | 4905 } |
4906 | |
4907 align_put_bits(&s->pb); | |
4908 flush_put_bits(&s->pb); | |
2967 | 4909 |
2428
548c87c06dbb
assertion about bits statistic and minor bits stat fix
michael
parents:
2427
diff
changeset
|
4910 if((s->flags&CODEC_FLAG_PASS1) && !s->partitioned_frame) |
548c87c06dbb
assertion about bits statistic and minor bits stat fix
michael
parents:
2427
diff
changeset
|
4911 s->misc_bits+= get_bits_diff(s); |
1799 | 4912 } |
4913 | |
4914 static int encode_thread(AVCodecContext *c, void *arg){ | |
4915 MpegEncContext *s= arg; | |
766 | 4916 int mb_x, mb_y, pdif = 0; |
1708 | 4917 int i, j; |
326 | 4918 MpegEncContext best_s, backup_s; |
2422 | 4919 uint8_t bit_buf[2][MAX_MB_BYTES]; |
4920 uint8_t bit_buf2[2][MAX_MB_BYTES]; | |
4921 uint8_t bit_buf_tex[2][MAX_MB_BYTES]; | |
456 | 4922 PutBitContext pb[2], pb2[2], tex_pb[2]; |
1799 | 4923 //printf("%d->%d\n", s->resync_mb_y, s->end_mb_y); |
456 | 4924 |
4281
de525a2b41db
ff_check_alignment to warn the user about a missaligned stack
michael
parents:
4274
diff
changeset
|
4925 ff_check_alignment(); |
de525a2b41db
ff_check_alignment to warn the user about a missaligned stack
michael
parents:
4274
diff
changeset
|
4926 |
456 | 4927 for(i=0; i<2; i++){ |
2422 | 4928 init_put_bits(&pb [i], bit_buf [i], MAX_MB_BYTES); |
4929 init_put_bits(&pb2 [i], bit_buf2 [i], MAX_MB_BYTES); | |
4930 init_put_bits(&tex_pb[i], bit_buf_tex[i], MAX_MB_BYTES); | |
456 | 4931 } |
0 | 4932 |
1786 | 4933 s->last_bits= put_bits_count(&s->pb); |
286 | 4934 s->mv_bits=0; |
4935 s->misc_bits=0; | |
4936 s->i_tex_bits=0; | |
4937 s->p_tex_bits=0; | |
4938 s->i_count=0; | |
656
e47fa3e3f2d5
statistics for forw & back p-MBs instead of just one counter for both
michaelni
parents:
652
diff
changeset
|
4939 s->f_count=0; |
e47fa3e3f2d5
statistics for forw & back p-MBs instead of just one counter for both
michaelni
parents:
652
diff
changeset
|
4940 s->b_count=0; |
286 | 4941 s->skip_count=0; |
4942 | |
909
8ae1e4c24e91
new PSNR code (now works with chroma, b frames, ...)
michaelni
parents:
903
diff
changeset
|
4943 for(i=0; i<3; i++){ |
8ae1e4c24e91
new PSNR code (now works with chroma, b frames, ...)
michaelni
parents:
903
diff
changeset
|
4944 /* init last dc values */ |
8ae1e4c24e91
new PSNR code (now works with chroma, b frames, ...)
michaelni
parents:
903
diff
changeset
|
4945 /* note: quant matrix value (8) is implied here */ |
1992 | 4946 s->last_dc[i] = 128 << s->intra_dc_precision; |
2967 | 4947 |
2955 | 4948 s->current_picture.error[i] = 0; |
909
8ae1e4c24e91
new PSNR code (now works with chroma, b frames, ...)
michaelni
parents:
903
diff
changeset
|
4949 } |
1160 | 4950 s->mb_skip_run = 0; |
1708 | 4951 memset(s->last_mv, 0, sizeof(s->last_mv)); |
2967 | 4952 |
1051
e5a9dbf597d4
mpeg1 bframe encoding patch by (Rapha«³l LEGRAND) with some modifications by me
michaelni
parents:
1048
diff
changeset
|
4953 s->last_mv_dir = 0; |
0 | 4954 |
1353
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1344
diff
changeset
|
4955 switch(s->codec_id){ |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1344
diff
changeset
|
4956 case CODEC_ID_H263: |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1344
diff
changeset
|
4957 case CODEC_ID_H263P: |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1344
diff
changeset
|
4958 case CODEC_ID_FLV1: |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
731
diff
changeset
|
4959 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
|
4960 break; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1344
diff
changeset
|
4961 case CODEC_ID_MPEG4: |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1344
diff
changeset
|
4962 if(s->partitioned_frame) |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1344
diff
changeset
|
4963 ff_mpeg4_init_partitions(s); |
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 } |
456 | 4966 |
4967 s->resync_mb_x=0; | |
2967 | 4968 s->resync_mb_y=0; |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
731
diff
changeset
|
4969 s->first_slice_line = 1; |
766 | 4970 s->ptr_lastgob = s->pb.buf; |
1799 | 4971 for(mb_y= s->start_mb_y; mb_y < s->end_mb_y; mb_y++) { |
4972 // printf("row %d at %X\n", s->mb_y, (int)s); | |
1389 | 4973 s->mb_x=0; |
4974 s->mb_y= mb_y; | |
4975 | |
1652 | 4976 ff_set_qscale(s, s->qscale); |
1389 | 4977 ff_init_block_index(s); |
2967 | 4978 |
232
b640ec5948b0
- Now the ME is done for the entire picture when enconding, the
pulento
parents:
231
diff
changeset
|
4979 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
|
4980 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
|
4981 int mb_type= s->mb_type[xy]; |
456 | 4982 // int d; |
1389 | 4983 int dmin= INT_MAX; |
1708 | 4984 int dir; |
0 | 4985 |
2422 | 4986 if(s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb)>>3) < MAX_MB_BYTES){ |
4987 av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n"); | |
4988 return -1; | |
4989 } | |
4990 if(s->data_partitioning){ | |
4991 if( s->pb2 .buf_end - s->pb2 .buf - (put_bits_count(&s-> pb2)>>3) < MAX_MB_BYTES | |
4992 || s->tex_pb.buf_end - s->tex_pb.buf - (put_bits_count(&s->tex_pb )>>3) < MAX_MB_BYTES){ | |
4993 av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n"); | |
4994 return -1; | |
4995 } | |
4996 } | |
4997 | |
232
b640ec5948b0
- Now the ME is done for the entire picture when enconding, the
pulento
parents:
231
diff
changeset
|
4998 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
|
4999 s->mb_y = mb_y; // moved into loop, can get changed by H.261 |
1389 | 5000 ff_update_block_index(s); |
456 | 5001 |
4997 | 5002 if(ENABLE_H261_ENCODER && s->codec_id == CODEC_ID_H261){ |
2327
5e5cf598a48b
H.261 encoder by (Maarten Daniels <maarten dot daniels at luc dot ac dot be>)
michael
parents:
2298
diff
changeset
|
5003 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
|
5004 xy= s->mb_y*s->mb_stride + s->mb_x; |
2345 | 5005 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
|
5006 } |
5e5cf598a48b
H.261 encoder by (Maarten Daniels <maarten dot daniels at luc dot ac dot be>)
michael
parents:
2298
diff
changeset
|
5007 |
766 | 5008 /* write gob / video packet header */ |
1661 | 5009 if(s->rtp_mode){ |
766 | 5010 int current_packet_size, is_gob_start; |
2967 | 5011 |
1801
3f26dfb3eba4
replace a few pbBufPtr() by put_bits_count(), one of them was actually wrong
michael
parents:
1799
diff
changeset
|
5012 current_packet_size= ((put_bits_count(&s->pb)+7)>>3) - (s->ptr_lastgob - s->pb.buf); |
2967 | 5013 |
5014 is_gob_start= s->avctx->rtp_payload_size && current_packet_size >= s->avctx->rtp_payload_size && mb_y + mb_x>0; | |
5015 | |
1799 | 5016 if(s->start_mb_y == mb_y && mb_y > 0 && mb_x==0) is_gob_start=1; |
2967 | 5017 |
1661 | 5018 switch(s->codec_id){ |
5019 case CODEC_ID_H263: | |
5020 case CODEC_ID_H263P: | |
5021 if(!s->h263_slice_structured) | |
5022 if(s->mb_x || s->mb_y%s->gob_index) is_gob_start=0; | |
5023 break; | |
5024 case CODEC_ID_MPEG2VIDEO: | |
5025 if(s->mb_x==0 && s->mb_y!=0) is_gob_start=1; | |
5026 case CODEC_ID_MPEG1VIDEO: | |
5027 if(s->mb_skip_run) is_gob_start=0; | |
5028 break; | |
5029 } | |
1799 | 5030 |
1661 | 5031 if(is_gob_start){ |
1799 | 5032 if(s->start_mb_y != mb_y || mb_x!=0){ |
5033 write_slice_end(s); | |
5034 | |
5035 if(s->codec_id==CODEC_ID_MPEG4 && s->partitioned_frame){ | |
5036 ff_mpeg4_init_partitions(s); | |
5037 } | |
1661 | 5038 } |
2967 | 5039 |
1786 | 5040 assert((put_bits_count(&s->pb)&7) == 0); |
1661 | 5041 current_packet_size= pbBufPtr(&s->pb) - s->ptr_lastgob; |
2967 | 5042 |
1688 | 5043 if(s->avctx->error_rate && s->resync_mb_x + s->resync_mb_y > 0){ |
2371 | 5044 int r= put_bits_count(&s->pb)/8 + s->picture_number + 16 + s->mb_x + s->mb_y; |
1688 | 5045 int d= 100 / s->avctx->error_rate; |
5046 if(r % d == 0){ | |
5047 current_packet_size=0; | |
5048 #ifndef ALT_BITSTREAM_WRITER | |
5049 s->pb.buf_ptr= s->ptr_lastgob; | |
5050 #endif | |
5051 assert(pbBufPtr(&s->pb) == s->ptr_lastgob); | |
5052 } | |
5053 } | |
2492
57ba17bd3924
rtp_callback: send number of mb patch by (Johan Bilien {jobi via.ecp fr)
michael
parents:
2450
diff
changeset
|
5054 |
57ba17bd3924
rtp_callback: send number of mb patch by (Johan Bilien {jobi via.ecp fr)
michael
parents:
2450
diff
changeset
|
5055 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
|
5056 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
|
5057 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
|
5058 } |
2967 | 5059 |
1661 | 5060 switch(s->codec_id){ |
5061 case CODEC_ID_MPEG4: | |
456 | 5062 ff_mpeg4_encode_video_packet_header(s); |
5063 ff_mpeg4_clean_buffers(s); | |
1661 | 5064 break; |
5065 case CODEC_ID_MPEG1VIDEO: | |
5066 case CODEC_ID_MPEG2VIDEO: | |
1421 | 5067 ff_mpeg1_encode_slice_header(s); |
5068 ff_mpeg1_clean_buffers(s); | |
1661 | 5069 break; |
5070 case CODEC_ID_H263: | |
5071 case CODEC_ID_H263P: | |
2967 | 5072 h263_encode_gob_header(s, mb_y); |
1661 | 5073 break; |
1160 | 5074 } |
1661 | 5075 |
5076 if(s->flags&CODEC_FLAG_PASS1){ | |
1786 | 5077 int bits= put_bits_count(&s->pb); |
1661 | 5078 s->misc_bits+= bits - s->last_bits; |
5079 s->last_bits= bits; | |
766 | 5080 } |
2967 | 5081 |
1662 | 5082 s->ptr_lastgob += current_packet_size; |
456 | 5083 s->first_slice_line=1; |
5084 s->resync_mb_x=mb_x; | |
5085 s->resync_mb_y=mb_y; | |
5086 } | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
731
diff
changeset
|
5087 } |
456 | 5088 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
731
diff
changeset
|
5089 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
|
5090 && s->resync_mb_y+1 == s->mb_y){ |
2967 | 5091 s->first_slice_line=0; |
456 | 5092 } |
5093 | |
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
|
5094 s->mb_skipped=0; |
1616 | 5095 s->dquant=0; //only for QP_RD |
5096 | |
2230 | 5097 if(mb_type & (mb_type-1) || (s->flags & CODEC_FLAG_QP_RD)){ // more than 1 MB type possible or CODEC_FLAG_QP_RD |
327 | 5098 int next_block=0; |
456 | 5099 int pb_bits_count, pb2_bits_count, tex_pb_bits_count; |
326 | 5100 |
5101 copy_context_before_encode(&backup_s, s, -1); | |
456 | 5102 backup_s.pb= s->pb; |
5103 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
|
5104 best_s.partitioned_frame= s->partitioned_frame; |
456 | 5105 if(s->data_partitioning){ |
5106 backup_s.pb2= s->pb2; | |
5107 backup_s.tex_pb= s->tex_pb; | |
5108 } | |
326 | 5109 |
1708 | 5110 if(mb_type&CANDIDATE_MB_TYPE_INTER){ |
327 | 5111 s->mv_dir = MV_DIR_FORWARD; |
295 | 5112 s->mv_type = MV_TYPE_16X16; |
294 | 5113 s->mb_intra= 0; |
324 | 5114 s->mv[0][0][0] = s->p_mv_table[xy][0]; |
5115 s->mv[0][0][1] = s->p_mv_table[xy][1]; | |
2967 | 5116 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER, pb, pb2, tex_pb, |
456 | 5117 &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]); |
0 | 5118 } |
2967 | 5119 if(mb_type&CANDIDATE_MB_TYPE_INTER_I){ |
1708 | 5120 s->mv_dir = MV_DIR_FORWARD; |
5121 s->mv_type = MV_TYPE_FIELD; | |
5122 s->mb_intra= 0; | |
5123 for(i=0; i<2; i++){ | |
5124 j= s->field_select[0][i] = s->p_field_select_table[i][xy]; | |
5125 s->mv[0][i][0] = s->p_field_mv_table[i][j][xy][0]; | |
5126 s->mv[0][i][1] = s->p_field_mv_table[i][j][xy][1]; | |
5127 } | |
2967 | 5128 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER_I, pb, pb2, tex_pb, |
1708 | 5129 &dmin, &next_block, 0, 0); |
5130 } | |
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
|
5131 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
|
5132 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
|
5133 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
|
5134 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
|
5135 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
|
5136 s->mv[0][0][1] = 0; |
2967 | 5137 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
|
5138 &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
|
5139 } |
2967 | 5140 if(mb_type&CANDIDATE_MB_TYPE_INTER4V){ |
327 | 5141 s->mv_dir = MV_DIR_FORWARD; |
295 | 5142 s->mv_type = MV_TYPE_8X8; |
5143 s->mb_intra= 0; | |
5144 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
|
5145 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
|
5146 s->mv[0][i][1] = s->current_picture.motion_val[0][s->block_index[i]][1]; |
295 | 5147 } |
2967 | 5148 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER4V, pb, pb2, tex_pb, |
456 | 5149 &dmin, &next_block, 0, 0); |
327 | 5150 } |
1708 | 5151 if(mb_type&CANDIDATE_MB_TYPE_FORWARD){ |
327 | 5152 s->mv_dir = MV_DIR_FORWARD; |
5153 s->mv_type = MV_TYPE_16X16; | |
5154 s->mb_intra= 0; | |
5155 s->mv[0][0][0] = s->b_forw_mv_table[xy][0]; | |
5156 s->mv[0][0][1] = s->b_forw_mv_table[xy][1]; | |
2967 | 5157 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_FORWARD, pb, pb2, tex_pb, |
456 | 5158 &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]); |
327 | 5159 } |
1708 | 5160 if(mb_type&CANDIDATE_MB_TYPE_BACKWARD){ |
327 | 5161 s->mv_dir = MV_DIR_BACKWARD; |
5162 s->mv_type = MV_TYPE_16X16; | |
5163 s->mb_intra= 0; | |
5164 s->mv[1][0][0] = s->b_back_mv_table[xy][0]; | |
5165 s->mv[1][0][1] = s->b_back_mv_table[xy][1]; | |
2967 | 5166 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BACKWARD, pb, pb2, tex_pb, |
456 | 5167 &dmin, &next_block, s->mv[1][0][0], s->mv[1][0][1]); |
327 | 5168 } |
1708 | 5169 if(mb_type&CANDIDATE_MB_TYPE_BIDIR){ |
327 | 5170 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD; |
5171 s->mv_type = MV_TYPE_16X16; | |
5172 s->mb_intra= 0; | |
5173 s->mv[0][0][0] = s->b_bidir_forw_mv_table[xy][0]; | |
5174 s->mv[0][0][1] = s->b_bidir_forw_mv_table[xy][1]; | |
5175 s->mv[1][0][0] = s->b_bidir_back_mv_table[xy][0]; | |
5176 s->mv[1][0][1] = s->b_bidir_back_mv_table[xy][1]; | |
2967 | 5177 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BIDIR, pb, pb2, tex_pb, |
456 | 5178 &dmin, &next_block, 0, 0); |
327 | 5179 } |
2967 | 5180 if(mb_type&CANDIDATE_MB_TYPE_FORWARD_I){ |
1708 | 5181 s->mv_dir = MV_DIR_FORWARD; |
5182 s->mv_type = MV_TYPE_FIELD; | |
5183 s->mb_intra= 0; | |
5184 for(i=0; i<2; i++){ | |
5185 j= s->field_select[0][i] = s->b_field_select_table[0][i][xy]; | |
5186 s->mv[0][i][0] = s->b_field_mv_table[0][i][j][xy][0]; | |
5187 s->mv[0][i][1] = s->b_field_mv_table[0][i][j][xy][1]; | |
5188 } | |
2967 | 5189 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_FORWARD_I, pb, pb2, tex_pb, |
1708 | 5190 &dmin, &next_block, 0, 0); |
5191 } | |
2967 | 5192 if(mb_type&CANDIDATE_MB_TYPE_BACKWARD_I){ |
1708 | 5193 s->mv_dir = MV_DIR_BACKWARD; |
5194 s->mv_type = MV_TYPE_FIELD; | |
5195 s->mb_intra= 0; | |
5196 for(i=0; i<2; i++){ | |
5197 j= s->field_select[1][i] = s->b_field_select_table[1][i][xy]; | |
5198 s->mv[1][i][0] = s->b_field_mv_table[1][i][j][xy][0]; | |
5199 s->mv[1][i][1] = s->b_field_mv_table[1][i][j][xy][1]; | |
5200 } | |
2967 | 5201 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BACKWARD_I, pb, pb2, tex_pb, |
1708 | 5202 &dmin, &next_block, 0, 0); |
5203 } | |
2967 | 5204 if(mb_type&CANDIDATE_MB_TYPE_BIDIR_I){ |
1708 | 5205 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD; |
5206 s->mv_type = MV_TYPE_FIELD; | |
5207 s->mb_intra= 0; | |
5208 for(dir=0; dir<2; dir++){ | |
5209 for(i=0; i<2; i++){ | |
5210 j= s->field_select[dir][i] = s->b_field_select_table[dir][i][xy]; | |
5211 s->mv[dir][i][0] = s->b_field_mv_table[dir][i][j][xy][0]; | |
5212 s->mv[dir][i][1] = s->b_field_mv_table[dir][i][j][xy][1]; | |
5213 } | |
5214 } | |
2967 | 5215 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BIDIR_I, pb, pb2, tex_pb, |
1708 | 5216 &dmin, &next_block, 0, 0); |
5217 } | |
5218 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
|
5219 s->mv_dir = 0; |
295 | 5220 s->mv_type = MV_TYPE_16X16; |
294 | 5221 s->mb_intra= 1; |
5222 s->mv[0][0][0] = 0; | |
5223 s->mv[0][0][1] = 0; | |
2967 | 5224 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTRA, pb, pb2, tex_pb, |
456 | 5225 &dmin, &next_block, 0, 0); |
1389 | 5226 if(s->h263_pred || s->h263_aic){ |
5227 if(best_s.mb_intra) | |
5228 s->mbintra_table[mb_x + mb_y*s->mb_stride]=1; | |
5229 else | |
5230 ff_clean_intra_table_entries(s); //old mode? | |
5231 } | |
295 | 5232 } |
1616 | 5233 |
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
|
5234 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
|
5235 if(best_s.mv_type==MV_TYPE_16X16){ //FIXME move 4mv after QPRD |
1616 | 5236 const int last_qp= backup_s.qscale; |
4217 | 5237 int qpi, qp, dc[6]; |
1617 | 5238 DCTELEM ac[6][16]; |
1623 | 5239 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
|
5240 static const int dquant_tab[4]={-1,1,-2,2}; |
2967 | 5241 |
1616 | 5242 assert(backup_s.dquant == 0); |
5243 | |
5244 //FIXME intra | |
5245 s->mv_dir= best_s.mv_dir; | |
5246 s->mv_type = MV_TYPE_16X16; | |
5247 s->mb_intra= best_s.mb_intra; | |
5248 s->mv[0][0][0] = best_s.mv[0][0][0]; | |
5249 s->mv[0][0][1] = best_s.mv[0][0][1]; | |
5250 s->mv[1][0][0] = best_s.mv[1][0][0]; | |
5251 s->mv[1][0][1] = best_s.mv[1][0][1]; | |
2967 | 5252 |
4215
7583920b3217
testing all dquant for qp_rd fixes the qp runaway to 31 bug
michael
parents:
4206
diff
changeset
|
5253 qpi = s->pict_type == B_TYPE ? 2 : 0; |
4217 | 5254 for(; qpi<4; qpi++){ |
5255 int dquant= dquant_tab[qpi]; | |
1616 | 5256 qp= last_qp + dquant; |
5257 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
|
5258 continue; |
1616 | 5259 backup_s.dquant= dquant; |
2229 | 5260 if(s->mb_intra && s->dc_val[0]){ |
1617 | 5261 for(i=0; i<6; i++){ |
5262 dc[i]= s->dc_val[0][ s->block_index[i] ]; | |
5263 memcpy(ac[i], s->ac_val[0][s->block_index[i]], sizeof(DCTELEM)*16); | |
5264 } | |
1616 | 5265 } |
1617 | 5266 |
2967 | 5267 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER /* wrong but unused */, pb, pb2, tex_pb, |
1623 | 5268 &dmin, &next_block, s->mv[mvdir][0][0], s->mv[mvdir][0][1]); |
1616 | 5269 if(best_s.qscale != qp){ |
2229 | 5270 if(s->mb_intra && s->dc_val[0]){ |
1617 | 5271 for(i=0; i<6; i++){ |
5272 s->dc_val[0][ s->block_index[i] ]= dc[i]; | |
5273 memcpy(s->ac_val[0][s->block_index[i]], ac[i], sizeof(DCTELEM)*16); | |
5274 } | |
1616 | 5275 } |
5276 } | |
5277 } | |
5278 } | |
5279 } | |
4314
5ed8f8fd71e9
try direct mode MB after QPRD, slight PSNR/bitrate gain if b frames + QPRD
michael
parents:
4283
diff
changeset
|
5280 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
|
5281 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
|
5282 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
|
5283 |
5ed8f8fd71e9
try direct mode MB after QPRD, slight PSNR/bitrate gain if b frames + QPRD
michael
parents:
4283
diff
changeset
|
5284 backup_s.dquant = 0; |
5ed8f8fd71e9
try direct mode MB after QPRD, slight PSNR/bitrate gain if b frames + QPRD
michael
parents:
4283
diff
changeset
|
5285 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
|
5286 s->mb_intra= 0; |
5ed8f8fd71e9
try direct mode MB after QPRD, slight PSNR/bitrate gain if b frames + QPRD
michael
parents:
4283
diff
changeset
|
5287 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
|
5288 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
|
5289 &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
|
5290 } |
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
|
5291 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
|
5292 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
|
5293 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
|
5294 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
|
5295 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
|
5296 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
|
5297 &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
|
5298 } |
4327 | 5299 if(!best_s.mb_intra && s->flags2&CODEC_FLAG2_SKIP_RD){ |
5300 int coded=0; | |
5301 for(i=0; i<6; i++) | |
5302 coded |= s->block_last_index[i]; | |
5303 if(coded){ | |
5304 int mx,my; | |
5305 memcpy(s->mv, best_s.mv, sizeof(s->mv)); | |
5306 if(best_s.mv_dir & MV_DIRECT){ | |
5307 mx=my=0; //FIXME find the one we actually used | |
5308 ff_mpeg4_set_direct_mv(s, mx, my); | |
5309 }else if(best_s.mv_dir&MV_DIR_BACKWARD){ | |
5310 mx= s->mv[1][0][0]; | |
5311 my= s->mv[1][0][1]; | |
5312 }else{ | |
5313 mx= s->mv[0][0][0]; | |
5314 my= s->mv[0][0][1]; | |
5315 } | |
5316 | |
5317 s->mv_dir= best_s.mv_dir; | |
5318 s->mv_type = best_s.mv_type; | |
5319 s->mb_intra= 0; | |
5320 /* s->mv[0][0][0] = best_s.mv[0][0][0]; | |
5321 s->mv[0][0][1] = best_s.mv[0][0][1]; | |
5322 s->mv[1][0][0] = best_s.mv[1][0][0]; | |
5323 s->mv[1][0][1] = best_s.mv[1][0][1];*/ | |
5324 backup_s.dquant= 0; | |
5325 s->skipdct=1; | |
5326 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER /* wrong but unused */, pb, pb2, tex_pb, | |
5327 &dmin, &next_block, mx, my); | |
5328 s->skipdct=0; | |
5329 } | |
5330 } | |
5331 | |
4314
5ed8f8fd71e9
try direct mode MB after QPRD, slight PSNR/bitrate gain if b frames + QPRD
michael
parents:
4283
diff
changeset
|
5332 s->current_picture.qscale_table[xy]= best_s.qscale; |
1616 | 5333 |
326 | 5334 copy_context_after_encode(s, &best_s, -1); |
2967 | 5335 |
1786 | 5336 pb_bits_count= put_bits_count(&s->pb); |
456 | 5337 flush_put_bits(&s->pb); |
5338 ff_copy_bits(&backup_s.pb, bit_buf[next_block^1], pb_bits_count); | |
5339 s->pb= backup_s.pb; | |
2967 | 5340 |
456 | 5341 if(s->data_partitioning){ |
1786 | 5342 pb2_bits_count= put_bits_count(&s->pb2); |
456 | 5343 flush_put_bits(&s->pb2); |
5344 ff_copy_bits(&backup_s.pb2, bit_buf2[next_block^1], pb2_bits_count); | |
5345 s->pb2= backup_s.pb2; | |
2967 | 5346 |
1786 | 5347 tex_pb_bits_count= put_bits_count(&s->tex_pb); |
456 | 5348 flush_put_bits(&s->tex_pb); |
5349 ff_copy_bits(&backup_s.tex_pb, bit_buf_tex[next_block^1], tex_pb_bits_count); | |
5350 s->tex_pb= backup_s.tex_pb; | |
5351 } | |
1786 | 5352 s->last_bits= put_bits_count(&s->pb); |
2967 | 5353 |
1389 | 5354 if (s->out_format == FMT_H263 && s->pict_type!=B_TYPE) |
5355 ff_h263_update_motion_val(s); | |
2967 | 5356 |
1799 | 5357 if(next_block==0){ //FIXME 16 vs linesize16 |
5358 s->dsp.put_pixels_tab[0][0](s->dest[0], s->rd_scratchpad , s->linesize ,16); | |
5359 s->dsp.put_pixels_tab[1][0](s->dest[1], s->rd_scratchpad + 16*s->linesize , s->uvlinesize, 8); | |
5360 s->dsp.put_pixels_tab[1][0](s->dest[2], s->rd_scratchpad + 16*s->linesize + 8, s->uvlinesize, 8); | |
1389 | 5361 } |
5362 | |
5363 if(s->avctx->mb_decision == FF_MB_DECISION_BITS) | |
5364 MPV_decode_mb(s, s->block); | |
294 | 5365 } else { |
4416 | 5366 int motion_x = 0, motion_y = 0; |
324 | 5367 s->mv_type=MV_TYPE_16X16; |
294 | 5368 // only one MB-Type possible |
2967 | 5369 |
327 | 5370 switch(mb_type){ |
1708 | 5371 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
|
5372 s->mv_dir = 0; |
294 | 5373 s->mb_intra= 1; |
324 | 5374 motion_x= s->mv[0][0][0] = 0; |
5375 motion_y= s->mv[0][0][1] = 0; | |
327 | 5376 break; |
1708 | 5377 case CANDIDATE_MB_TYPE_INTER: |
324 | 5378 s->mv_dir = MV_DIR_FORWARD; |
5379 s->mb_intra= 0; | |
5380 motion_x= s->mv[0][0][0] = s->p_mv_table[xy][0]; | |
5381 motion_y= s->mv[0][0][1] = s->p_mv_table[xy][1]; | |
327 | 5382 break; |
1708 | 5383 case CANDIDATE_MB_TYPE_INTER_I: |
5384 s->mv_dir = MV_DIR_FORWARD; | |
5385 s->mv_type = MV_TYPE_FIELD; | |
5386 s->mb_intra= 0; | |
5387 for(i=0; i<2; i++){ | |
5388 j= s->field_select[0][i] = s->p_field_select_table[i][xy]; | |
5389 s->mv[0][i][0] = s->p_field_mv_table[i][j][xy][0]; | |
5390 s->mv[0][i][1] = s->p_field_mv_table[i][j][xy][1]; | |
5391 } | |
5392 break; | |
5393 case CANDIDATE_MB_TYPE_INTER4V: | |
456 | 5394 s->mv_dir = MV_DIR_FORWARD; |
5395 s->mv_type = MV_TYPE_8X8; | |
5396 s->mb_intra= 0; | |
5397 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
|
5398 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
|
5399 s->mv[0][i][1] = s->current_picture.motion_val[0][s->block_index[i]][1]; |
456 | 5400 } |
5401 break; | |
1708 | 5402 case CANDIDATE_MB_TYPE_DIRECT: |
324 | 5403 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT; |
5404 s->mb_intra= 0; | |
327 | 5405 motion_x=s->b_direct_mv_table[xy][0]; |
5406 motion_y=s->b_direct_mv_table[xy][1]; | |
936 | 5407 ff_mpeg4_set_direct_mv(s, motion_x, motion_y); |
327 | 5408 break; |
4323 | 5409 case CANDIDATE_MB_TYPE_DIRECT0: |
5410 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT; | |
5411 s->mb_intra= 0; | |
5412 ff_mpeg4_set_direct_mv(s, 0, 0); | |
5413 break; | |
1708 | 5414 case CANDIDATE_MB_TYPE_BIDIR: |
324 | 5415 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD; |
294 | 5416 s->mb_intra= 0; |
324 | 5417 s->mv[0][0][0] = s->b_bidir_forw_mv_table[xy][0]; |
5418 s->mv[0][0][1] = s->b_bidir_forw_mv_table[xy][1]; | |
5419 s->mv[1][0][0] = s->b_bidir_back_mv_table[xy][0]; | |
5420 s->mv[1][0][1] = s->b_bidir_back_mv_table[xy][1]; | |
327 | 5421 break; |
1708 | 5422 case CANDIDATE_MB_TYPE_BACKWARD: |
324 | 5423 s->mv_dir = MV_DIR_BACKWARD; |
5424 s->mb_intra= 0; | |
5425 motion_x= s->mv[1][0][0] = s->b_back_mv_table[xy][0]; | |
5426 motion_y= s->mv[1][0][1] = s->b_back_mv_table[xy][1]; | |
327 | 5427 break; |
1708 | 5428 case CANDIDATE_MB_TYPE_FORWARD: |
324 | 5429 s->mv_dir = MV_DIR_FORWARD; |
5430 s->mb_intra= 0; | |
5431 motion_x= s->mv[0][0][0] = s->b_forw_mv_table[xy][0]; | |
5432 motion_y= s->mv[0][0][1] = s->b_forw_mv_table[xy][1]; | |
5433 // printf(" %d %d ", motion_x, motion_y); | |
327 | 5434 break; |
1708 | 5435 case CANDIDATE_MB_TYPE_FORWARD_I: |
5436 s->mv_dir = MV_DIR_FORWARD; | |
5437 s->mv_type = MV_TYPE_FIELD; | |
5438 s->mb_intra= 0; | |
5439 for(i=0; i<2; i++){ | |
5440 j= s->field_select[0][i] = s->b_field_select_table[0][i][xy]; | |
5441 s->mv[0][i][0] = s->b_field_mv_table[0][i][j][xy][0]; | |
5442 s->mv[0][i][1] = s->b_field_mv_table[0][i][j][xy][1]; | |
5443 } | |
5444 break; | |
5445 case CANDIDATE_MB_TYPE_BACKWARD_I: | |
5446 s->mv_dir = MV_DIR_BACKWARD; | |
5447 s->mv_type = MV_TYPE_FIELD; | |
5448 s->mb_intra= 0; | |
5449 for(i=0; i<2; i++){ | |
5450 j= s->field_select[1][i] = s->b_field_select_table[1][i][xy]; | |
5451 s->mv[1][i][0] = s->b_field_mv_table[1][i][j][xy][0]; | |
5452 s->mv[1][i][1] = s->b_field_mv_table[1][i][j][xy][1]; | |
5453 } | |
5454 break; | |
5455 case CANDIDATE_MB_TYPE_BIDIR_I: | |
5456 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD; | |
5457 s->mv_type = MV_TYPE_FIELD; | |
5458 s->mb_intra= 0; | |
5459 for(dir=0; dir<2; dir++){ | |
5460 for(i=0; i<2; i++){ | |
5461 j= s->field_select[dir][i] = s->b_field_select_table[dir][i][xy]; | |
5462 s->mv[dir][i][0] = s->b_field_mv_table[dir][i][j][xy][0]; | |
5463 s->mv[dir][i][1] = s->b_field_mv_table[dir][i][j][xy][1]; | |
5464 } | |
5465 } | |
5466 break; | |
327 | 5467 default: |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1597
diff
changeset
|
5468 av_log(s->avctx, AV_LOG_ERROR, "illegal MB type\n"); |
294 | 5469 } |
1051
e5a9dbf597d4
mpeg1 bframe encoding patch by (Rapha«³l LEGRAND) with some modifications by me
michaelni
parents:
1048
diff
changeset
|
5470 |
324 | 5471 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
|
5472 |
2627
bf158d23bbcc
Spelling errors patch by (Kevin Baragona | kevinmb500 gawab com)
michael
parents:
2620
diff
changeset
|
5473 // 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
|
5474 s->last_mv_dir = s->mv_dir; |
2967 | 5475 |
1389 | 5476 if (s->out_format == FMT_H263 && s->pict_type!=B_TYPE) |
5477 ff_h263_update_motion_val(s); | |
2967 | 5478 |
1389 | 5479 MPV_decode_mb(s, s->block); |
248
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
244
diff
changeset
|
5480 } |
1051
e5a9dbf597d4
mpeg1 bframe encoding patch by (Rapha«³l LEGRAND) with some modifications by me
michaelni
parents:
1048
diff
changeset
|
5481 |
327 | 5482 /* clean the MV table in IPS frames for direct mode in B frames */ |
5483 if(s->mb_intra /* && I,P,S_TYPE */){ | |
5484 s->p_mv_table[xy][0]=0; | |
5485 s->p_mv_table[xy][1]=0; | |
5486 } | |
2967 | 5487 |
909
8ae1e4c24e91
new PSNR code (now works with chroma, b frames, ...)
michaelni
parents:
903
diff
changeset
|
5488 if(s->flags&CODEC_FLAG_PSNR){ |
8ae1e4c24e91
new PSNR code (now works with chroma, b frames, ...)
michaelni
parents:
903
diff
changeset
|
5489 int w= 16; |
8ae1e4c24e91
new PSNR code (now works with chroma, b frames, ...)
michaelni
parents:
903
diff
changeset
|
5490 int h= 16; |
8ae1e4c24e91
new PSNR code (now works with chroma, b frames, ...)
michaelni
parents:
903
diff
changeset
|
5491 |
8ae1e4c24e91
new PSNR code (now works with chroma, b frames, ...)
michaelni
parents:
903
diff
changeset
|
5492 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
|
5493 if(s->mb_y*16 + 16 > s->height) h= s->height- s->mb_y*16; |
936 | 5494 |
2955 | 5495 s->current_picture.error[0] += sse( |
1389 | 5496 s, s->new_picture.data[0] + s->mb_x*16 + s->mb_y*s->linesize*16, |
5497 s->dest[0], w, h, s->linesize); | |
2955 | 5498 s->current_picture.error[1] += sse( |
1389 | 5499 s, s->new_picture.data[1] + s->mb_x*8 + s->mb_y*s->uvlinesize*8, |
5500 s->dest[1], w>>1, h>>1, s->uvlinesize); | |
2955 | 5501 s->current_picture.error[2] += sse( |
1389 | 5502 s, s->new_picture .data[2] + s->mb_x*8 + s->mb_y*s->uvlinesize*8, |
5503 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
|
5504 } |
2345 | 5505 if(s->loop_filter){ |
5506 if(s->out_format == FMT_H263) | |
5507 ff_h263_loop_filter(s); | |
5508 } | |
1786 | 5509 //printf("MB %d %d bits\n", s->mb_x+s->mb_y*s->mb_stride, put_bits_count(&s->pb)); |
0 | 5510 } |
5511 } | |
286 | 5512 |
2627
bf158d23bbcc
Spelling errors patch by (Kevin Baragona | kevinmb500 gawab com)
michael
parents:
2620
diff
changeset
|
5513 //not beautiful here but we must write it before flushing so it has to be here |
4967
6d45158e0249
disable reference to msmpeg4 and wmv2 code when those codecs are not compiled in
aurel
parents:
4668
diff
changeset
|
5514 if (ENABLE_MSMPEG4_ENCODER && s->msmpeg4_version && s->msmpeg4_version<4 && s->pict_type == I_TYPE) |
208 | 5515 msmpeg4_encode_ext_header(s); |
456 | 5516 |
1799 | 5517 write_slice_end(s); |
5518 | |
2967 | 5519 /* Send the last GOB if RTP */ |
1661 | 5520 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
|
5521 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
|
5522 pdif = pbBufPtr(&s->pb) - s->ptr_lastgob; |
231 | 5523 /* Call the RTP callback to send the last GOB */ |
1799 | 5524 emms_c(); |
2492
57ba17bd3924
rtp_callback: send number of mb patch by (Johan Bilien {jobi via.ecp fr)
michael
parents:
2450
diff
changeset
|
5525 s->avctx->rtp_callback(s->avctx, s->ptr_lastgob, pdif, number_mb); |
231 | 5526 } |
1799 | 5527 |
5528 return 0; | |
5529 } | |
5530 | |
5531 #define MERGE(field) dst->field += src->field; src->field=0 | |
5532 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
|
5533 MERGE(me.scene_change_score); |
3ab8f3e2ae6a
moving motion estimation specific variables from MpegEncContext -> MotionEstContext
michael
parents:
1994
diff
changeset
|
5534 MERGE(me.mc_mb_var_sum_temp); |
3ab8f3e2ae6a
moving motion estimation specific variables from MpegEncContext -> MotionEstContext
michael
parents:
1994
diff
changeset
|
5535 MERGE(me.mb_var_sum_temp); |
1799 | 5536 } |
5537 | |
5538 static void merge_context_after_encode(MpegEncContext *dst, MpegEncContext *src){ | |
5539 int i; | |
5540 | |
5541 MERGE(dct_count[0]); //note, the other dct vars are not part of the context | |
5542 MERGE(dct_count[1]); | |
5543 MERGE(mv_bits); | |
5544 MERGE(i_tex_bits); | |
5545 MERGE(p_tex_bits); | |
5546 MERGE(i_count); | |
5547 MERGE(f_count); | |
5548 MERGE(b_count); | |
5549 MERGE(skip_count); | |
5550 MERGE(misc_bits); | |
5551 MERGE(error_count); | |
5552 MERGE(padding_bug_score); | |
2955 | 5553 MERGE(current_picture.error[0]); |
5554 MERGE(current_picture.error[1]); | |
5555 MERGE(current_picture.error[2]); | |
1799 | 5556 |
5557 if(dst->avctx->noise_reduction){ | |
5558 for(i=0; i<64; i++){ | |
5559 MERGE(dct_error_sum[0][i]); | |
5560 MERGE(dct_error_sum[1][i]); | |
5561 } | |
5562 } | |
2967 | 5563 |
1799 | 5564 assert(put_bits_count(&src->pb) % 8 ==0); |
5565 assert(put_bits_count(&dst->pb) % 8 ==0); | |
5566 ff_copy_bits(&dst->pb, src->pb.buf, put_bits_count(&src->pb)); | |
5567 flush_put_bits(&dst->pb); | |
5568 } | |
5569 | |
3766 | 5570 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
|
5571 if (s->next_lambda){ |
16ace038f452
fix buffer underflows by reencoding the current frame with a higher QP
michael
parents:
3929
diff
changeset
|
5572 s->current_picture_ptr->quality= |
16ace038f452
fix buffer underflows by reencoding the current frame with a higher QP
michael
parents:
3929
diff
changeset
|
5573 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
|
5574 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
|
5575 } else if (!s->fixed_qscale) { |
2974 | 5576 s->current_picture_ptr->quality= |
5577 s->current_picture.quality = ff_rate_estimate_qscale(s, dry_run); | |
3766 | 5578 if (s->current_picture.quality < 0) |
5579 return -1; | |
5580 } | |
2974 | 5581 |
5582 if(s->adaptive_quant){ | |
5583 switch(s->codec_id){ | |
5584 case CODEC_ID_MPEG4: | |
5585 ff_clean_mpeg4_qscales(s); | |
5586 break; | |
5587 case CODEC_ID_H263: | |
5588 case CODEC_ID_H263P: | |
5589 case CODEC_ID_FLV1: | |
5590 ff_clean_h263_qscales(s); | |
5591 break; | |
5592 } | |
5593 | |
5594 s->lambda= s->lambda_table[0]; | |
5595 //FIXME broken | |
5596 }else | |
5597 s->lambda= s->current_picture.quality; | |
5598 //printf("%d %d\n", s->avctx->global_quality, s->current_picture.quality); | |
5599 update_qscale(s); | |
3780
6741c0e88310
return 0 from encode_picture() and estimate_qp() on success
mru
parents:
3777
diff
changeset
|
5600 return 0; |
2974 | 5601 } |
5602 | |
3766 | 5603 static int encode_picture(MpegEncContext *s, int picture_number) |
1799 | 5604 { |
2024
f65d87bfdd5a
some of the warning fixes by (Michael Roitzsch <mroi at users dot sourceforge dot net>)
michael
parents:
2015
diff
changeset
|
5605 int i; |
1799 | 5606 int bits; |
5607 | |
5608 s->picture_number = picture_number; | |
2967 | 5609 |
1799 | 5610 /* Reset the average MB variance */ |
2015
3ab8f3e2ae6a
moving motion estimation specific variables from MpegEncContext -> MotionEstContext
michael
parents:
1994
diff
changeset
|
5611 s->me.mb_var_sum_temp = |
3ab8f3e2ae6a
moving motion estimation specific variables from MpegEncContext -> MotionEstContext
michael
parents:
1994
diff
changeset
|
5612 s->me.mc_mb_var_sum_temp = 0; |
1799 | 5613 |
5614 /* we need to initialize some time vars before we can encode b-frames */ | |
5615 // RAL: Condition added for MPEG1VIDEO | |
5616 if (s->codec_id == CODEC_ID_MPEG1VIDEO || s->codec_id == CODEC_ID_MPEG2VIDEO || (s->h263_pred && !s->h263_msmpeg4)) | |
1834 | 5617 ff_set_mpeg4_time(s, s->picture_number); //FIXME rename and use has_b_frames or similar |
2967 | 5618 |
2015
3ab8f3e2ae6a
moving motion estimation specific variables from MpegEncContext -> MotionEstContext
michael
parents:
1994
diff
changeset
|
5619 s->me.scene_change_score=0; |
2967 | 5620 |
2053 | 5621 // s->lambda= s->current_picture_ptr->quality; //FIXME qscale / ... stuff for ME ratedistoration |
2967 | 5622 |
1799 | 5623 if(s->pict_type==I_TYPE){ |
5624 if(s->msmpeg4_version >= 3) s->no_rounding=1; | |
5625 else s->no_rounding=0; | |
5626 }else if(s->pict_type!=B_TYPE){ | |
5627 if(s->flipflop_rounding || s->codec_id == CODEC_ID_H263P || s->codec_id == CODEC_ID_MPEG4) | |
2967 | 5628 s->no_rounding ^= 1; |
5629 } | |
5630 | |
2981 | 5631 if(s->flags & CODEC_FLAG_PASS2){ |
3766 | 5632 if (estimate_qp(s,1) < 0) |
5633 return -1; | |
2981 | 5634 ff_get_2pass_fcode(s); |
5635 }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
|
5636 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
|
5637 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
|
5638 else |
2997
188f4ef688f2
second try of improved lambda/qp guessing for motion estimation RD in first pass
michael
parents:
2990
diff
changeset
|
5639 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
|
5640 update_qscale(s); |
529163f99474
improved lambda/qp guessing for motion estimation RD in first pass
michael
parents:
2979
diff
changeset
|
5641 } |
2974 | 5642 |
2627
bf158d23bbcc
Spelling errors patch by (Kevin Baragona | kevinmb500 gawab com)
michael
parents:
2620
diff
changeset
|
5643 s->mb_intra=0; //for the rate distortion & bit compare functions |
1799 | 5644 for(i=1; i<s->avctx->thread_count; i++){ |
1827 | 5645 ff_update_duplicate_context(s->thread_context[i], s); |
1799 | 5646 } |
1962 | 5647 |
5648 ff_init_me(s); | |
5649 | |
1799 | 5650 /* Estimate motion for every MB */ |
5651 if(s->pict_type != I_TYPE){ | |
2584 | 5652 s->lambda = (s->lambda * s->avctx->me_penalty_compensation + 128)>>8; |
4097 | 5653 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
|
5654 if(s->pict_type != B_TYPE && s->avctx->me_threshold==0){ |
1799 | 5655 if((s->avctx->pre_me && s->last_non_b_pict_type==I_TYPE) || s->avctx->pre_me==2){ |
5656 s->avctx->execute(s->avctx, pre_estimate_motion_thread, (void**)&(s->thread_context[0]), NULL, s->avctx->thread_count); | |
5657 } | |
5658 } | |
5659 | |
5660 s->avctx->execute(s->avctx, estimate_motion_thread, (void**)&(s->thread_context[0]), NULL, s->avctx->thread_count); | |
5661 }else /* if(s->pict_type == I_TYPE) */{ | |
5662 /* I-Frame */ | |
5663 for(i=0; i<s->mb_stride*s->mb_height; i++) | |
5664 s->mb_type[i]= CANDIDATE_MB_TYPE_INTRA; | |
2967 | 5665 |
1799 | 5666 if(!s->fixed_qscale){ |
5667 /* finding spatial complexity for I-frame rate control */ | |
1804
cc0a15943a87
multithreaded spatial complexity calculation for i frames
michael
parents:
1803
diff
changeset
|
5668 s->avctx->execute(s->avctx, mb_var_thread, (void**)&(s->thread_context[0]), NULL, s->avctx->thread_count); |
1799 | 5669 } |
5670 } | |
1804
cc0a15943a87
multithreaded spatial complexity calculation for i frames
michael
parents:
1803
diff
changeset
|
5671 for(i=1; i<s->avctx->thread_count; i++){ |
cc0a15943a87
multithreaded spatial complexity calculation for i frames
michael
parents:
1803
diff
changeset
|
5672 merge_context_after_me(s, s->thread_context[i]); |
cc0a15943a87
multithreaded spatial complexity calculation for i frames
michael
parents:
1803
diff
changeset
|
5673 } |
2015
3ab8f3e2ae6a
moving motion estimation specific variables from MpegEncContext -> MotionEstContext
michael
parents:
1994
diff
changeset
|
5674 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
|
5675 s->current_picture. mb_var_sum= s->current_picture_ptr-> mb_var_sum= s->me. mb_var_sum_temp; |
1799 | 5676 emms_c(); |
5677 | |
2015
3ab8f3e2ae6a
moving motion estimation specific variables from MpegEncContext -> MotionEstContext
michael
parents:
1994
diff
changeset
|
5678 if(s->me.scene_change_score > s->avctx->scenechange_threshold && s->pict_type == P_TYPE){ |
1799 | 5679 s->pict_type= I_TYPE; |
5680 for(i=0; i<s->mb_stride*s->mb_height; i++) | |
5681 s->mb_type[i]= CANDIDATE_MB_TYPE_INTRA; | |
5682 //printf("Scene change detected, encoding as I Frame %d %d\n", s->current_picture.mb_var_sum, s->current_picture.mc_mb_var_sum); | |
5683 } | |
5684 | |
5685 if(!s->umvplus){ | |
5686 if(s->pict_type==P_TYPE || s->pict_type==S_TYPE) { | |
5687 s->f_code= ff_get_best_fcode(s, s->p_mv_table, CANDIDATE_MB_TYPE_INTER); | |
5688 | |
5689 if(s->flags & CODEC_FLAG_INTERLACED_ME){ | |
5690 int a,b; | |
5691 a= ff_get_best_fcode(s, s->p_field_mv_table[0][0], CANDIDATE_MB_TYPE_INTER_I); //FIXME field_select | |
5692 b= ff_get_best_fcode(s, s->p_field_mv_table[1][1], CANDIDATE_MB_TYPE_INTER_I); | |
5693 s->f_code= FFMAX(s->f_code, FFMAX(a,b)); | |
5694 } | |
2967 | 5695 |
1799 | 5696 ff_fix_long_p_mvs(s); |
5697 ff_fix_long_mvs(s, NULL, 0, s->p_mv_table, s->f_code, CANDIDATE_MB_TYPE_INTER, 0); | |
5698 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
|
5699 int j; |
1799 | 5700 for(i=0; i<2; i++){ |
5701 for(j=0; j<2; j++) | |
2967 | 5702 ff_fix_long_mvs(s, s->p_field_select_table[i], j, |
1799 | 5703 s->p_field_mv_table[i][j], s->f_code, CANDIDATE_MB_TYPE_INTER_I, 0); |
5704 } | |
5705 } | |
5706 } | |
5707 | |
5708 if(s->pict_type==B_TYPE){ | |
5709 int a, b; | |
5710 | |
5711 a = ff_get_best_fcode(s, s->b_forw_mv_table, CANDIDATE_MB_TYPE_FORWARD); | |
5712 b = ff_get_best_fcode(s, s->b_bidir_forw_mv_table, CANDIDATE_MB_TYPE_BIDIR); | |
5713 s->f_code = FFMAX(a, b); | |
5714 | |
5715 a = ff_get_best_fcode(s, s->b_back_mv_table, CANDIDATE_MB_TYPE_BACKWARD); | |
5716 b = ff_get_best_fcode(s, s->b_bidir_back_mv_table, CANDIDATE_MB_TYPE_BIDIR); | |
5717 s->b_code = FFMAX(a, b); | |
5718 | |
5719 ff_fix_long_mvs(s, NULL, 0, s->b_forw_mv_table, s->f_code, CANDIDATE_MB_TYPE_FORWARD, 1); | |
5720 ff_fix_long_mvs(s, NULL, 0, s->b_back_mv_table, s->b_code, CANDIDATE_MB_TYPE_BACKWARD, 1); | |
5721 ff_fix_long_mvs(s, NULL, 0, s->b_bidir_forw_mv_table, s->f_code, CANDIDATE_MB_TYPE_BIDIR, 1); | |
5722 ff_fix_long_mvs(s, NULL, 0, s->b_bidir_back_mv_table, s->b_code, CANDIDATE_MB_TYPE_BIDIR, 1); | |
5723 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
|
5724 int dir, j; |
1799 | 5725 for(dir=0; dir<2; dir++){ |
5726 for(i=0; i<2; i++){ | |
5727 for(j=0; j<2; j++){ | |
2967 | 5728 int type= dir ? (CANDIDATE_MB_TYPE_BACKWARD_I|CANDIDATE_MB_TYPE_BIDIR_I) |
1799 | 5729 : (CANDIDATE_MB_TYPE_FORWARD_I |CANDIDATE_MB_TYPE_BIDIR_I); |
2967 | 5730 ff_fix_long_mvs(s, s->b_field_select_table[dir][i], j, |
1799 | 5731 s->b_field_mv_table[dir][i][j], dir ? s->b_code : s->f_code, type, 1); |
5732 } | |
5733 } | |
5734 } | |
5735 } | |
5736 } | |
5737 } | |
5738 | |
3766 | 5739 if (estimate_qp(s, 0) < 0) |
5740 return -1; | |
2967 | 5741 |
5742 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
|
5743 s->qscale= 3; //reduce clipping problems |
2967 | 5744 |
1799 | 5745 if (s->out_format == FMT_MJPEG) { |
5746 /* for mjpeg, we do include qscale in the matrix */ | |
5747 s->intra_matrix[0] = ff_mpeg1_default_intra_matrix[0]; | |
5748 for(i=1;i<64;i++){ | |
5749 int j= s->dsp.idct_permutation[i]; | |
5750 | |
4594 | 5751 s->intra_matrix[j] = av_clip_uint8((ff_mpeg1_default_intra_matrix[i] * s->qscale) >> 3); |
1799 | 5752 } |
2967 | 5753 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
|
5754 s->intra_matrix, s->intra_quant_bias, 8, 8, 1); |
1799 | 5755 s->qscale= 8; |
5756 } | |
2967 | 5757 |
1799 | 5758 //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
|
5759 s->current_picture_ptr->key_frame= |
1799 | 5760 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
|
5761 s->current_picture_ptr->pict_type= |
1799 | 5762 s->current_picture.pict_type= s->pict_type; |
5763 | |
5764 if(s->current_picture.key_frame) | |
5765 s->picture_in_gop_number=0; | |
5766 | |
5767 s->last_bits= put_bits_count(&s->pb); | |
5768 switch(s->out_format) { | |
5769 case FMT_MJPEG: | |
4995 | 5770 if (ENABLE_MJPEG_ENCODER) |
5029
dbaa06366c3c
add a proper prefix to all mjpeg encoder exported functions
aurel
parents:
5028
diff
changeset
|
5771 ff_mjpeg_encode_picture_header(s); |
1799 | 5772 break; |
2327
5e5cf598a48b
H.261 encoder by (Maarten Daniels <maarten dot daniels at luc dot ac dot be>)
michael
parents:
2298
diff
changeset
|
5773 case FMT_H261: |
4997 | 5774 if (ENABLE_H261_ENCODER) |
4998 | 5775 ff_h261_encode_picture_header(s, picture_number); |
2327
5e5cf598a48b
H.261 encoder by (Maarten Daniels <maarten dot daniels at luc dot ac dot be>)
michael
parents:
2298
diff
changeset
|
5776 break; |
1799 | 5777 case FMT_H263: |
4967
6d45158e0249
disable reference to msmpeg4 and wmv2 code when those codecs are not compiled in
aurel
parents:
4668
diff
changeset
|
5778 if (ENABLE_WMV2_ENCODER && s->codec_id == CODEC_ID_WMV2) |
1799 | 5779 ff_wmv2_encode_picture_header(s, picture_number); |
4967
6d45158e0249
disable reference to msmpeg4 and wmv2 code when those codecs are not compiled in
aurel
parents:
4668
diff
changeset
|
5780 else if (ENABLE_MSMPEG4_ENCODER && s->h263_msmpeg4) |
1799 | 5781 msmpeg4_encode_picture_header(s, picture_number); |
5782 else if (s->h263_pred) | |
5783 mpeg4_encode_picture_header(s, picture_number); | |
4997 | 5784 else if (ENABLE_RV10_ENCODER && s->codec_id == CODEC_ID_RV10) |
1799 | 5785 rv10_encode_picture_header(s, picture_number); |
4997 | 5786 else if (ENABLE_RV20_ENCODER && s->codec_id == CODEC_ID_RV20) |
2380 | 5787 rv20_encode_picture_header(s, picture_number); |
1799 | 5788 else if (s->codec_id == CODEC_ID_FLV1) |
5789 ff_flv_encode_picture_header(s, picture_number); | |
5790 else | |
5791 h263_encode_picture_header(s, picture_number); | |
5792 break; | |
5793 case FMT_MPEG1: | |
5794 mpeg1_encode_picture_header(s, picture_number); | |
5795 break; | |
5796 case FMT_H264: | |
5797 break; | |
5798 default: | |
5799 assert(0); | |
5800 } | |
5801 bits= put_bits_count(&s->pb); | |
5802 s->header_bits= bits - s->last_bits; | |
2967 | 5803 |
1799 | 5804 for(i=1; i<s->avctx->thread_count; i++){ |
5805 update_duplicate_context_after_me(s->thread_context[i], s); | |
5806 } | |
5807 s->avctx->execute(s->avctx, encode_thread, (void**)&(s->thread_context[0]), NULL, s->avctx->thread_count); | |
5808 for(i=1; i<s->avctx->thread_count; i++){ | |
5809 merge_context_after_encode(s, s->thread_context[i]); | |
5810 } | |
5811 emms_c(); | |
3780
6741c0e88310
return 0 from encode_picture() and estimate_qp() on success
mru
parents:
3777
diff
changeset
|
5812 return 0; |
0 | 5813 } |
5814 | |
1719 | 5815 static void denoise_dct_c(MpegEncContext *s, DCTELEM *block){ |
1597 | 5816 const int intra= s->mb_intra; |
5817 int i; | |
5818 | |
1599 | 5819 s->dct_count[intra]++; |
5820 | |
1597 | 5821 for(i=0; i<64; i++){ |
5822 int level= block[i]; | |
5823 | |
5824 if(level){ | |
5825 if(level>0){ | |
5826 s->dct_error_sum[intra][i] += level; | |
5827 level -= s->dct_offset[intra][i]; | |
5828 if(level<0) level=0; | |
5829 }else{ | |
5830 s->dct_error_sum[intra][i] -= level; | |
5831 level += s->dct_offset[intra][i]; | |
5832 if(level>0) level=0; | |
5833 } | |
5834 block[i]= level; | |
5835 } | |
5836 } | |
5837 } | |
5838 | |
2967 | 5839 static int dct_quantize_trellis_c(MpegEncContext *s, |
945 | 5840 DCTELEM *block, int n, |
5841 int qscale, int *overflow){ | |
5842 const int *qmat; | |
1064 | 5843 const uint8_t *scantable= s->intra_scantable.scantable; |
1718 | 5844 const uint8_t *perm_scantable= s->intra_scantable.permutated; |
945 | 5845 int max=0; |
5846 unsigned int threshold1, threshold2; | |
5847 int bias=0; | |
5848 int run_tab[65]; | |
5849 int level_tab[65]; | |
5850 int score_tab[65]; | |
1718 | 5851 int survivor[65]; |
5852 int survivor_count; | |
946 | 5853 int last_run=0; |
5854 int last_level=0; | |
5855 int last_score= 0; | |
1718 | 5856 int last_i; |
1715 | 5857 int coeff[2][64]; |
945 | 5858 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
|
5859 int qmul, qadd, start_i, last_non_zero, i, dc; |
945 | 5860 const int esc_length= s->ac_esc_length; |
5861 uint8_t * length; | |
5862 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
|
5863 const int lambda= s->lambda2 >> (FF_LAMBDA_SHIFT - 6); |
2967 | 5864 |
1092 | 5865 s->dsp.fdct (block); |
2967 | 5866 |
1597 | 5867 if(s->dct_error_sum) |
1719 | 5868 s->denoise_dct(s, block); |
945 | 5869 qmul= qscale*16; |
5870 qadd= ((qscale-1)|1)*8; | |
946 | 5871 |
945 | 5872 if (s->mb_intra) { |
5873 int q; | |
5874 if (!s->h263_aic) { | |
5875 if (n < 4) | |
5876 q = s->y_dc_scale; | |
5877 else | |
5878 q = s->c_dc_scale; | |
5879 q = q << 3; | |
5880 } else{ | |
5881 /* For AIC we skip quant/dequant of INTRADC */ | |
5882 q = 1 << 3; | |
5883 qadd=0; | |
5884 } | |
2967 | 5885 |
945 | 5886 /* note: block[0] is assumed to be positive */ |
5887 block[0] = (block[0] + (q >> 1)) / q; | |
5888 start_i = 1; | |
5889 last_non_zero = 0; | |
5890 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
|
5891 if(s->mpeg_quant || s->out_format == FMT_MPEG1) |
945 | 5892 bias= 1<<(QMAT_SHIFT-1); |
5893 length = s->intra_ac_vlc_length; | |
5894 last_length= s->intra_ac_vlc_last_length; | |
5895 } else { | |
5896 start_i = 0; | |
5897 last_non_zero = -1; | |
5898 qmat = s->q_inter_matrix[qscale]; | |
5899 length = s->inter_ac_vlc_length; | |
5900 last_length= s->inter_ac_vlc_last_length; | |
5901 } | |
1718 | 5902 last_i= start_i; |
945 | 5903 |
5904 threshold1= (1<<QMAT_SHIFT) - bias - 1; | |
5905 threshold2= (threshold1<<1); | |
946 | 5906 |
1715 | 5907 for(i=63; i>=start_i; i--) { |
5908 const int j = scantable[i]; | |
5909 int level = block[j] * qmat[j]; | |
5910 | |
5911 if(((unsigned)(level+threshold1))>threshold2){ | |
5912 last_non_zero = i; | |
5913 break; | |
5914 } | |
5915 } | |
5916 | |
5917 for(i=start_i; i<=last_non_zero; i++) { | |
945 | 5918 const int j = scantable[i]; |
1715 | 5919 int level = block[j] * qmat[j]; |
945 | 5920 |
5921 // if( bias+level >= (1<<(QMAT_SHIFT - 3)) | |
5922 // || bias-level >= (1<<(QMAT_SHIFT - 3))){ | |
5923 if(((unsigned)(level+threshold1))>threshold2){ | |
5924 if(level>0){ | |
5925 level= (bias + level)>>QMAT_SHIFT; | |
1718 | 5926 coeff[0][i]= level; |
5927 coeff[1][i]= level-1; | |
946 | 5928 // coeff[2][k]= level-2; |
945 | 5929 }else{ |
5930 level= (bias - level)>>QMAT_SHIFT; | |
1718 | 5931 coeff[0][i]= -level; |
5932 coeff[1][i]= -level+1; | |
946 | 5933 // coeff[2][k]= -level+2; |
945 | 5934 } |
1718 | 5935 coeff_count[i]= FFMIN(level, 2); |
5936 assert(coeff_count[i]); | |
945 | 5937 max |=level; |
5938 }else{ | |
1718 | 5939 coeff[0][i]= (level>>31)|1; |
5940 coeff_count[i]= 1; | |
945 | 5941 } |
5942 } | |
2967 | 5943 |
2627
bf158d23bbcc
Spelling errors patch by (Kevin Baragona | kevinmb500 gawab com)
michael
parents:
2620
diff
changeset
|
5944 *overflow= s->max_qcoeff < max; //overflow might have happened |
2967 | 5945 |
945 | 5946 if(last_non_zero < start_i){ |
5947 memset(block + start_i, 0, (64-start_i)*sizeof(DCTELEM)); | |
5948 return last_non_zero; | |
5949 } | |
5950 | |
1718 | 5951 score_tab[start_i]= 0; |
5952 survivor[0]= start_i; | |
5953 survivor_count= 1; | |
2967 | 5954 |
1718 | 5955 for(i=start_i; i<=last_non_zero; i++){ |
5956 int level_index, j; | |
4001 | 5957 const int dct_coeff= FFABS(block[ scantable[i] ]); |
945 | 5958 const int zero_distoration= dct_coeff*dct_coeff; |
946 | 5959 int best_score=256*256*256*120; |
945 | 5960 for(level_index=0; level_index < coeff_count[i]; level_index++){ |
5961 int distoration; | |
5962 int level= coeff[level_index][i]; | |
4001 | 5963 const int alevel= FFABS(level); |
945 | 5964 int unquant_coeff; |
2967 | 5965 |
945 | 5966 assert(level); |
5967 | |
5968 if(s->out_format == FMT_H263){ | |
1716 | 5969 unquant_coeff= alevel*qmul + qadd; |
947 | 5970 }else{ //MPEG1 |
1718 | 5971 j= s->dsp.idct_permutation[ scantable[i] ]; //FIXME optimize |
947 | 5972 if(s->mb_intra){ |
1716 | 5973 unquant_coeff = (int)( alevel * qscale * s->intra_matrix[j]) >> 3; |
947 | 5974 unquant_coeff = (unquant_coeff - 1) | 1; |
5975 }else{ | |
1716 | 5976 unquant_coeff = ((( alevel << 1) + 1) * qscale * ((int) s->inter_matrix[j])) >> 4; |
947 | 5977 unquant_coeff = (unquant_coeff - 1) | 1; |
5978 } | |
5979 unquant_coeff<<= 3; | |
5980 } | |
946 | 5981 |
1715 | 5982 distoration= (unquant_coeff - dct_coeff) * (unquant_coeff - dct_coeff) - zero_distoration; |
945 | 5983 level+=64; |
5984 if((level&(~127)) == 0){ | |
1718 | 5985 for(j=survivor_count-1; j>=0; j--){ |
5986 int run= i - survivor[j]; | |
947 | 5987 int score= distoration + length[UNI_AC_ENC_INDEX(run, level)]*lambda; |
945 | 5988 score += score_tab[i-run]; |
2967 | 5989 |
945 | 5990 if(score < best_score){ |
1718 | 5991 best_score= score; |
945 | 5992 run_tab[i+1]= run; |
5993 level_tab[i+1]= level-64; | |
5994 } | |
5995 } | |
5996 | |
5997 if(s->out_format == FMT_H263){ | |
1718 | 5998 for(j=survivor_count-1; j>=0; j--){ |
5999 int run= i - survivor[j]; | |
947 | 6000 int score= distoration + last_length[UNI_AC_ENC_INDEX(run, level)]*lambda; |
945 | 6001 score += score_tab[i-run]; |
946 | 6002 if(score < last_score){ |
6003 last_score= score; | |
6004 last_run= run; | |
6005 last_level= level-64; | |
6006 last_i= i+1; | |
945 | 6007 } |
6008 } | |
6009 } | |
6010 }else{ | |
6011 distoration += esc_length*lambda; | |
1718 | 6012 for(j=survivor_count-1; j>=0; j--){ |
6013 int run= i - survivor[j]; | |
945 | 6014 int score= distoration + score_tab[i-run]; |
2967 | 6015 |
945 | 6016 if(score < best_score){ |
1718 | 6017 best_score= score; |
945 | 6018 run_tab[i+1]= run; |
6019 level_tab[i+1]= level-64; | |
6020 } | |
6021 } | |
6022 | |
6023 if(s->out_format == FMT_H263){ | |
1718 | 6024 for(j=survivor_count-1; j>=0; j--){ |
6025 int run= i - survivor[j]; | |
945 | 6026 int score= distoration + score_tab[i-run]; |
946 | 6027 if(score < last_score){ |
6028 last_score= score; | |
6029 last_run= run; | |
6030 last_level= level-64; | |
6031 last_i= i+1; | |
945 | 6032 } |
6033 } | |
6034 } | |
6035 } | |
6036 } | |
2967 | 6037 |
1718 | 6038 score_tab[i+1]= best_score; |
6039 | |
946 | 6040 //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 | 6041 if(last_non_zero <= 27){ |
6042 for(; survivor_count; survivor_count--){ | |
6043 if(score_tab[ survivor[survivor_count-1] ] <= best_score) | |
6044 break; | |
6045 } | |
6046 }else{ | |
6047 for(; survivor_count; survivor_count--){ | |
6048 if(score_tab[ survivor[survivor_count-1] ] <= best_score + lambda) | |
6049 break; | |
6050 } | |
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
|
6051 } |
1718 | 6052 |
6053 survivor[ survivor_count++ ]= i+1; | |
945 | 6054 } |
946 | 6055 |
945 | 6056 if(s->out_format != FMT_H263){ |
946 | 6057 last_score= 256*256*256*120; |
1718 | 6058 for(i= survivor[0]; i<=last_non_zero + 1; i++){ |
946 | 6059 int score= score_tab[i]; |
947 | 6060 if(i) score += lambda*2; //FIXME exacter? |
6061 | |
946 | 6062 if(score < last_score){ |
6063 last_score= score; | |
6064 last_i= i; | |
6065 last_level= level_tab[i]; | |
6066 last_run= run_tab[i]; | |
6067 } | |
945 | 6068 } |
6069 } | |
1490
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1480
diff
changeset
|
6070 |
1715 | 6071 s->coded_score[n] = last_score; |
2967 | 6072 |
4001 | 6073 dc= FFABS(block[0]); |
1718 | 6074 last_non_zero= last_i - 1; |
945 | 6075 memset(block + start_i, 0, (64-start_i)*sizeof(DCTELEM)); |
2967 | 6076 |
945 | 6077 if(last_non_zero < start_i) |
6078 return last_non_zero; | |
1490
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1480
diff
changeset
|
6079 |
1480
8657d6800d15
slight quality improvement ( < +0.04 PSNR) for high bitrate videos with trellis quantization
michaelni
parents:
1471
diff
changeset
|
6080 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
|
6081 int best_level= 0; |
8657d6800d15
slight quality improvement ( < +0.04 PSNR) for high bitrate videos with trellis quantization
michaelni
parents:
1471
diff
changeset
|
6082 int best_score= dc * dc; |
2967 | 6083 |
1480
8657d6800d15
slight quality improvement ( < +0.04 PSNR) for high bitrate videos with trellis quantization
michaelni
parents:
1471
diff
changeset
|
6084 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
|
6085 int level= coeff[i][0]; |
4001 | 6086 int alevel= FFABS(level); |
1716 | 6087 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
|
6088 |
8657d6800d15
slight quality improvement ( < +0.04 PSNR) for high bitrate videos with trellis quantization
michaelni
parents:
1471
diff
changeset
|
6089 if(s->out_format == FMT_H263){ |
1716 | 6090 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
|
6091 }else{ //MPEG1 |
1716 | 6092 unquant_coeff = ((( alevel << 1) + 1) * qscale * ((int) s->inter_matrix[0])) >> 4; |
6093 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
|
6094 } |
8657d6800d15
slight quality improvement ( < +0.04 PSNR) for high bitrate videos with trellis quantization
michaelni
parents:
1471
diff
changeset
|
6095 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
|
6096 unquant_coeff<<= 3 + 3; |
8657d6800d15
slight quality improvement ( < +0.04 PSNR) for high bitrate videos with trellis quantization
michaelni
parents:
1471
diff
changeset
|
6097 |
1716 | 6098 distortion= (unquant_coeff - dc) * (unquant_coeff - dc); |
1490
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1480
diff
changeset
|
6099 level+=64; |
1716 | 6100 if((level&(~127)) == 0) score= distortion + last_length[UNI_AC_ENC_INDEX(0, level)]*lambda; |
6101 else score= distortion + esc_length*lambda; | |
1490
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1480
diff
changeset
|
6102 |
1480
8657d6800d15
slight quality improvement ( < +0.04 PSNR) for high bitrate videos with trellis quantization
michaelni
parents:
1471
diff
changeset
|
6103 if(score < best_score){ |
8657d6800d15
slight quality improvement ( < +0.04 PSNR) for high bitrate videos with trellis quantization
michaelni
parents:
1471
diff
changeset
|
6104 best_score= score; |
1490
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1480
diff
changeset
|
6105 best_level= level - 64; |
1480
8657d6800d15
slight quality improvement ( < +0.04 PSNR) for high bitrate videos with trellis quantization
michaelni
parents:
1471
diff
changeset
|
6106 } |
8657d6800d15
slight quality improvement ( < +0.04 PSNR) for high bitrate videos with trellis quantization
michaelni
parents:
1471
diff
changeset
|
6107 } |
8657d6800d15
slight quality improvement ( < +0.04 PSNR) for high bitrate videos with trellis quantization
michaelni
parents:
1471
diff
changeset
|
6108 block[0]= best_level; |
1490
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1480
diff
changeset
|
6109 s->coded_score[n] = best_score - dc*dc; |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1480
diff
changeset
|
6110 if(best_level == 0) return -1; |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1480
diff
changeset
|
6111 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
|
6112 } |
1490
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1480
diff
changeset
|
6113 |
946 | 6114 i= last_i; |
6115 assert(last_level); | |
1718 | 6116 |
6117 block[ perm_scantable[last_non_zero] ]= last_level; | |
946 | 6118 i -= last_run + 1; |
2967 | 6119 |
1718 | 6120 for(; i>start_i; i -= run_tab[i] + 1){ |
6121 block[ perm_scantable[i-1] ]= level_tab[i]; | |
945 | 6122 } |
6123 | |
6124 return last_non_zero; | |
6125 } | |
6126 | |
1777 | 6127 //#define REFINE_STATS 1 |
6128 static int16_t basis[64][64]; | |
6129 | |
6130 static void build_basis(uint8_t *perm){ | |
6131 int i, j, x, y; | |
6132 emms_c(); | |
6133 for(i=0; i<8; i++){ | |
6134 for(j=0; j<8; j++){ | |
6135 for(y=0; y<8; y++){ | |
6136 for(x=0; x<8; x++){ | |
6137 double s= 0.25*(1<<BASIS_SHIFT); | |
6138 int index= 8*i + j; | |
6139 int perm_index= perm[index]; | |
6140 if(i==0) s*= sqrt(0.5); | |
6141 if(j==0) s*= sqrt(0.5); | |
6142 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))); | |
6143 } | |
6144 } | |
6145 } | |
6146 } | |
6147 } | |
6148 | |
6149 static int dct_quantize_refine(MpegEncContext *s, //FIXME breaks denoise? | |
6150 DCTELEM *block, int16_t *weight, DCTELEM *orig, | |
6151 int n, int qscale){ | |
6152 int16_t rem[64]; | |
3089 | 6153 DECLARE_ALIGNED_16(DCTELEM, d1[64]); |
1777 | 6154 const int *qmat; |
6155 const uint8_t *scantable= s->intra_scantable.scantable; | |
6156 const uint8_t *perm_scantable= s->intra_scantable.permutated; | |
6157 // unsigned int threshold1, threshold2; | |
6158 // int bias=0; | |
6159 int run_tab[65]; | |
6160 int prev_run=0; | |
6161 int prev_level=0; | |
6162 int qmul, qadd, start_i, last_non_zero, i, dc; | |
6163 uint8_t * length; | |
6164 uint8_t * last_length; | |
6165 int lambda; | |
4416 | 6166 int rle_index, run, q = 1, sum; //q is only used when s->mb_intra is true |
1777 | 6167 #ifdef REFINE_STATS |
6168 static int count=0; | |
6169 static int after_last=0; | |
6170 static int to_zero=0; | |
6171 static int from_zero=0; | |
6172 static int raise=0; | |
6173 static int lower=0; | |
6174 static int messed_sign=0; | |
6175 #endif | |
6176 | |
6177 if(basis[0][0] == 0) | |
6178 build_basis(s->dsp.idct_permutation); | |
2967 | 6179 |
1777 | 6180 qmul= qscale*2; |
6181 qadd= (qscale-1)|1; | |
6182 if (s->mb_intra) { | |
6183 if (!s->h263_aic) { | |
6184 if (n < 4) | |
6185 q = s->y_dc_scale; | |
6186 else | |
6187 q = s->c_dc_scale; | |
6188 } else{ | |
6189 /* For AIC we skip quant/dequant of INTRADC */ | |
6190 q = 1; | |
6191 qadd=0; | |
6192 } | |
6193 q <<= RECON_SHIFT-3; | |
6194 /* note: block[0] is assumed to be positive */ | |
6195 dc= block[0]*q; | |
6196 // block[0] = (block[0] + (q >> 1)) / q; | |
6197 start_i = 1; | |
6198 qmat = s->q_intra_matrix[qscale]; | |
6199 // if(s->mpeg_quant || s->out_format == FMT_MPEG1) | |
6200 // bias= 1<<(QMAT_SHIFT-1); | |
6201 length = s->intra_ac_vlc_length; | |
6202 last_length= s->intra_ac_vlc_last_length; | |
6203 } else { | |
6204 dc= 0; | |
6205 start_i = 0; | |
6206 qmat = s->q_inter_matrix[qscale]; | |
6207 length = s->inter_ac_vlc_length; | |
6208 last_length= s->inter_ac_vlc_last_length; | |
6209 } | |
6210 last_non_zero = s->block_last_index[n]; | |
6211 | |
6212 #ifdef REFINE_STATS | |
6213 {START_TIMER | |
6214 #endif | |
1784 | 6215 dc += (1<<(RECON_SHIFT-1)); |
6216 for(i=0; i<64; i++){ | |
2627
bf158d23bbcc
Spelling errors patch by (Kevin Baragona | kevinmb500 gawab com)
michael
parents:
2620
diff
changeset
|
6217 rem[i]= dc - (orig[i]<<RECON_SHIFT); //FIXME use orig dirrectly instead of copying to rem[] |
1777 | 6218 } |
6219 #ifdef REFINE_STATS | |
6220 STOP_TIMER("memset rem[]")} | |
6221 #endif | |
6222 sum=0; | |
6223 for(i=0; i<64; i++){ | |
6224 int one= 36; | |
6225 int qns=4; | |
6226 int w; | |
6227 | |
4001 | 6228 w= FFABS(weight[i]) + qns*one; |
1777 | 6229 w= 15 + (48*qns*one + w/2)/w; // 16 .. 63 |
6230 | |
6231 weight[i] = w; | |
6232 // w=weight[i] = (63*qns + (w/2)) / w; | |
2967 | 6233 |
1777 | 6234 assert(w>0); |
6235 assert(w<(1<<6)); | |
6236 sum += w*w; | |
6237 } | |
6238 lambda= sum*(uint64_t)s->lambda2 >> (FF_LAMBDA_SHIFT - 6 + 6 + 6 + 6); | |
6239 #ifdef REFINE_STATS | |
6240 {START_TIMER | |
6241 #endif | |
6242 run=0; | |
6243 rle_index=0; | |
6244 for(i=start_i; i<=last_non_zero; i++){ | |
6245 int j= perm_scantable[i]; | |
6246 const int level= block[j]; | |
6247 int coeff; | |
2967 | 6248 |
1777 | 6249 if(level){ |
6250 if(level<0) coeff= qmul*level - qadd; | |
6251 else coeff= qmul*level + qadd; | |
6252 run_tab[rle_index++]=run; | |
6253 run=0; | |
6254 | |
1784 | 6255 s->dsp.add_8x8basis(rem, basis[j], coeff); |
1777 | 6256 }else{ |
6257 run++; | |
6258 } | |
6259 } | |
6260 #ifdef REFINE_STATS | |
6261 if(last_non_zero>0){ | |
6262 STOP_TIMER("init rem[]") | |
6263 } | |
6264 } | |
6265 | |
6266 {START_TIMER | |
6267 #endif | |
6268 for(;;){ | |
1784 | 6269 int best_score=s->dsp.try_8x8basis(rem, weight, basis[0], 0); |
1777 | 6270 int best_coeff=0; |
6271 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
|
6272 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
|
6273 #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
|
6274 {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
|
6275 #endif |
14d918d0ef42
analyze the gradient of the error surface to avoid a few checks in the quantizing noise shaper
michael
parents:
1784
diff
changeset
|
6276 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
|
6277 |
14d918d0ef42
analyze the gradient of the error surface to avoid a few checks in the quantizing noise shaper
michael
parents:
1784
diff
changeset
|
6278 if(analyze_gradient){ |
1777 | 6279 #ifdef REFINE_STATS |
6280 {START_TIMER | |
6281 #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
|
6282 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
|
6283 int w= weight[i]; |
2967 | 6284 |
1785
14d918d0ef42
analyze the gradient of the error surface to avoid a few checks in the quantizing noise shaper
michael
parents:
1784
diff
changeset
|
6285 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
|
6286 } |
14d918d0ef42
analyze the gradient of the error surface to avoid a few checks in the quantizing noise shaper
michael
parents:
1784
diff
changeset
|
6287 #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
|
6288 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
|
6289 {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
|
6290 #endif |
14d918d0ef42
analyze the gradient of the error surface to avoid a few checks in the quantizing noise shaper
michael
parents:
1784
diff
changeset
|
6291 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
|
6292 #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
|
6293 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
|
6294 #endif |
14d918d0ef42
analyze the gradient of the error surface to avoid a few checks in the quantizing noise shaper
michael
parents:
1784
diff
changeset
|
6295 } |
14d918d0ef42
analyze the gradient of the error surface to avoid a few checks in the quantizing noise shaper
michael
parents:
1784
diff
changeset
|
6296 |
1777 | 6297 if(start_i){ |
6298 const int level= block[0]; | |
6299 int change, old_coeff; | |
6300 | |
6301 assert(s->mb_intra); | |
2967 | 6302 |
1777 | 6303 old_coeff= q*level; |
2967 | 6304 |
1777 | 6305 for(change=-1; change<=1; change+=2){ |
6306 int new_level= level + change; | |
6307 int score, new_coeff; | |
2967 | 6308 |
1777 | 6309 new_coeff= q*new_level; |
6310 if(new_coeff >= 2048 || new_coeff < 0) | |
6311 continue; | |
6312 | |
1784 | 6313 score= s->dsp.try_8x8basis(rem, weight, basis[0], new_coeff - old_coeff); |
1777 | 6314 if(score<best_score){ |
6315 best_score= score; | |
6316 best_coeff= 0; | |
6317 best_change= change; | |
6318 best_unquant_change= new_coeff - old_coeff; | |
6319 } | |
6320 } | |
6321 } | |
2967 | 6322 |
1777 | 6323 run=0; |
6324 rle_index=0; | |
6325 run2= run_tab[rle_index++]; | |
6326 prev_level=0; | |
6327 prev_run=0; | |
6328 | |
6329 for(i=start_i; i<64; i++){ | |
6330 int j= perm_scantable[i]; | |
6331 const int level= block[j]; | |
6332 int change, old_coeff; | |
6333 | |
6334 if(s->avctx->quantizer_noise_shaping < 3 && i > last_non_zero + 1) | |
6335 break; | |
6336 | |
6337 if(level){ | |
6338 if(level<0) old_coeff= qmul*level - qadd; | |
6339 else old_coeff= qmul*level + qadd; | |
6340 run2= run_tab[rle_index++]; //FIXME ! maybe after last | |
6341 }else{ | |
6342 old_coeff=0; | |
6343 run2--; | |
6344 assert(run2>=0 || i >= last_non_zero ); | |
6345 } | |
2967 | 6346 |
1777 | 6347 for(change=-1; change<=1; change+=2){ |
6348 int new_level= level + change; | |
6349 int score, new_coeff, unquant_change; | |
2967 | 6350 |
1777 | 6351 score=0; |
4001 | 6352 if(s->avctx->quantizer_noise_shaping < 2 && FFABS(new_level) > FFABS(level)) |
1777 | 6353 continue; |
6354 | |
6355 if(new_level){ | |
6356 if(new_level<0) new_coeff= qmul*new_level - qadd; | |
6357 else new_coeff= qmul*new_level + qadd; | |
6358 if(new_coeff >= 2048 || new_coeff <= -2048) | |
6359 continue; | |
6360 //FIXME check for overflow | |
2967 | 6361 |
1777 | 6362 if(level){ |
6363 if(level < 63 && level > -63){ | |
6364 if(i < last_non_zero) | |
6365 score += length[UNI_AC_ENC_INDEX(run, new_level+64)] | |
6366 - length[UNI_AC_ENC_INDEX(run, level+64)]; | |
6367 else | |
6368 score += last_length[UNI_AC_ENC_INDEX(run, new_level+64)] | |
6369 - last_length[UNI_AC_ENC_INDEX(run, level+64)]; | |
6370 } | |
6371 }else{ | |
4001 | 6372 assert(FFABS(new_level)==1); |
2967 | 6373 |
1785
14d918d0ef42
analyze the gradient of the error surface to avoid a few checks in the quantizing noise shaper
michael
parents:
1784
diff
changeset
|
6374 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
|
6375 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
|
6376 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
|
6377 continue; |
14d918d0ef42
analyze the gradient of the error surface to avoid a few checks in the quantizing noise shaper
michael
parents:
1784
diff
changeset
|
6378 } |
14d918d0ef42
analyze the gradient of the error surface to avoid a few checks in the quantizing noise shaper
michael
parents:
1784
diff
changeset
|
6379 |
1777 | 6380 if(i < last_non_zero){ |
6381 int next_i= i + run2 + 1; | |
6382 int next_level= block[ perm_scantable[next_i] ] + 64; | |
2967 | 6383 |
1777 | 6384 if(next_level&(~127)) |
6385 next_level= 0; | |
6386 | |
6387 if(next_i < last_non_zero) | |
6388 score += length[UNI_AC_ENC_INDEX(run, 65)] | |
6389 + length[UNI_AC_ENC_INDEX(run2, next_level)] | |
6390 - length[UNI_AC_ENC_INDEX(run + run2 + 1, next_level)]; | |
6391 else | |
6392 score += length[UNI_AC_ENC_INDEX(run, 65)] | |
6393 + last_length[UNI_AC_ENC_INDEX(run2, next_level)] | |
6394 - last_length[UNI_AC_ENC_INDEX(run + run2 + 1, next_level)]; | |
6395 }else{ | |
6396 score += last_length[UNI_AC_ENC_INDEX(run, 65)]; | |
6397 if(prev_level){ | |
6398 score += length[UNI_AC_ENC_INDEX(prev_run, prev_level)] | |
6399 - last_length[UNI_AC_ENC_INDEX(prev_run, prev_level)]; | |
6400 } | |
6401 } | |
6402 } | |
6403 }else{ | |
6404 new_coeff=0; | |
4001 | 6405 assert(FFABS(level)==1); |
1777 | 6406 |
6407 if(i < last_non_zero){ | |
6408 int next_i= i + run2 + 1; | |
6409 int next_level= block[ perm_scantable[next_i] ] + 64; | |
2967 | 6410 |
1777 | 6411 if(next_level&(~127)) |
6412 next_level= 0; | |
6413 | |
6414 if(next_i < last_non_zero) | |
6415 score += length[UNI_AC_ENC_INDEX(run + run2 + 1, next_level)] | |
6416 - length[UNI_AC_ENC_INDEX(run2, next_level)] | |
6417 - length[UNI_AC_ENC_INDEX(run, 65)]; | |
6418 else | |
6419 score += last_length[UNI_AC_ENC_INDEX(run + run2 + 1, next_level)] | |
6420 - last_length[UNI_AC_ENC_INDEX(run2, next_level)] | |
6421 - length[UNI_AC_ENC_INDEX(run, 65)]; | |
6422 }else{ | |
6423 score += -last_length[UNI_AC_ENC_INDEX(run, 65)]; | |
6424 if(prev_level){ | |
6425 score += last_length[UNI_AC_ENC_INDEX(prev_run, prev_level)] | |
6426 - length[UNI_AC_ENC_INDEX(prev_run, prev_level)]; | |
6427 } | |
6428 } | |
6429 } | |
2967 | 6430 |
1777 | 6431 score *= lambda; |
6432 | |
6433 unquant_change= new_coeff - old_coeff; | |
6434 assert((score < 100*lambda && score > -100*lambda) || lambda==0); | |
2967 | 6435 |
1784 | 6436 score+= s->dsp.try_8x8basis(rem, weight, basis[j], unquant_change); |
1777 | 6437 if(score<best_score){ |
6438 best_score= score; | |
6439 best_coeff= i; | |
6440 best_change= change; | |
6441 best_unquant_change= unquant_change; | |
6442 } | |
6443 } | |
6444 if(level){ | |
6445 prev_level= level + 64; | |
6446 if(prev_level&(~127)) | |
6447 prev_level= 0; | |
6448 prev_run= run; | |
6449 run=0; | |
6450 }else{ | |
6451 run++; | |
6452 } | |
6453 } | |
6454 #ifdef REFINE_STATS | |
6455 STOP_TIMER("iterative step")} | |
6456 #endif | |
6457 | |
6458 if(best_change){ | |
6459 int j= perm_scantable[ best_coeff ]; | |
2967 | 6460 |
1777 | 6461 block[j] += best_change; |
2967 | 6462 |
1777 | 6463 if(best_coeff > last_non_zero){ |
6464 last_non_zero= best_coeff; | |
6465 assert(block[j]); | |
6466 #ifdef REFINE_STATS | |
6467 after_last++; | |
6468 #endif | |
6469 }else{ | |
6470 #ifdef REFINE_STATS | |
6471 if(block[j]){ | |
6472 if(block[j] - best_change){ | |
4001 | 6473 if(FFABS(block[j]) > FFABS(block[j] - best_change)){ |
1777 | 6474 raise++; |
6475 }else{ | |
6476 lower++; | |
6477 } | |
6478 }else{ | |
6479 from_zero++; | |
6480 } | |
6481 }else{ | |
6482 to_zero++; | |
6483 } | |
6484 #endif | |
6485 for(; last_non_zero>=start_i; last_non_zero--){ | |
6486 if(block[perm_scantable[last_non_zero]]) | |
6487 break; | |
6488 } | |
6489 } | |
6490 #ifdef REFINE_STATS | |
6491 count++; | |
6492 if(256*256*256*64 % count == 0){ | |
6493 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); | |
6494 } | |
6495 #endif | |
6496 run=0; | |
6497 rle_index=0; | |
6498 for(i=start_i; i<=last_non_zero; i++){ | |
6499 int j= perm_scantable[i]; | |
6500 const int level= block[j]; | |
2967 | 6501 |
1777 | 6502 if(level){ |
6503 run_tab[rle_index++]=run; | |
6504 run=0; | |
6505 }else{ | |
6506 run++; | |
6507 } | |
6508 } | |
2967 | 6509 |
1784 | 6510 s->dsp.add_8x8basis(rem, basis[j], best_unquant_change); |
1777 | 6511 }else{ |
6512 break; | |
6513 } | |
6514 } | |
6515 #ifdef REFINE_STATS | |
6516 if(last_non_zero>0){ | |
6517 STOP_TIMER("iterative search") | |
6518 } | |
6519 } | |
6520 #endif | |
6521 | |
6522 return last_non_zero; | |
6523 } | |
6524 | |
2967 | 6525 static int dct_quantize_c(MpegEncContext *s, |
0 | 6526 DCTELEM *block, int n, |
344 | 6527 int qscale, int *overflow) |
0 | 6528 { |
1715 | 6529 int i, j, level, last_non_zero, q, start_i; |
0 | 6530 const int *qmat; |
1064 | 6531 const uint8_t *scantable= s->intra_scantable.scantable; |
344 | 6532 int bias; |
6533 int max=0; | |
6534 unsigned int threshold1, threshold2; | |
828
ace3ccd18dd2
Altivec Patch (Mark III) by (Dieter Shirley <dieters at schemasoft dot com>)
michaelni
parents:
815
diff
changeset
|
6535 |
1092 | 6536 s->dsp.fdct (block); |
0 | 6537 |
1597 | 6538 if(s->dct_error_sum) |
1719 | 6539 s->denoise_dct(s, block); |
1597 | 6540 |
0 | 6541 if (s->mb_intra) { |
350
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
347
diff
changeset
|
6542 if (!s->h263_aic) { |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
347
diff
changeset
|
6543 if (n < 4) |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
347
diff
changeset
|
6544 q = s->y_dc_scale; |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
347
diff
changeset
|
6545 else |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
347
diff
changeset
|
6546 q = s->c_dc_scale; |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
347
diff
changeset
|
6547 q = q << 3; |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
347
diff
changeset
|
6548 } else |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
347
diff
changeset
|
6549 /* 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
|
6550 q = 1 << 3; |
2967 | 6551 |
0 | 6552 /* note: block[0] is assumed to be positive */ |
6553 block[0] = (block[0] + (q >> 1)) / q; | |
1715 | 6554 start_i = 1; |
0 | 6555 last_non_zero = 0; |
344 | 6556 qmat = s->q_intra_matrix[qscale]; |
635 | 6557 bias= s->intra_quant_bias<<(QMAT_SHIFT - QUANT_BIAS_SHIFT); |
0 | 6558 } else { |
1715 | 6559 start_i = 0; |
0 | 6560 last_non_zero = -1; |
344 | 6561 qmat = s->q_inter_matrix[qscale]; |
635 | 6562 bias= s->inter_quant_bias<<(QMAT_SHIFT - QUANT_BIAS_SHIFT); |
0 | 6563 } |
635 | 6564 threshold1= (1<<QMAT_SHIFT) - bias - 1; |
6565 threshold2= (threshold1<<1); | |
1715 | 6566 for(i=63;i>=start_i;i--) { |
764 | 6567 j = scantable[i]; |
1715 | 6568 level = block[j] * qmat[j]; |
6569 | |
6570 if(((unsigned)(level+threshold1))>threshold2){ | |
6571 last_non_zero = i; | |
6572 break; | |
6573 }else{ | |
6574 block[j]=0; | |
6575 } | |
6576 } | |
6577 for(i=start_i; i<=last_non_zero; i++) { | |
6578 j = scantable[i]; | |
6579 level = block[j] * qmat[j]; | |
344 | 6580 |
1215 | 6581 // if( bias+level >= (1<<QMAT_SHIFT) |
6582 // || bias-level >= (1<<QMAT_SHIFT)){ | |
344 | 6583 if(((unsigned)(level+threshold1))>threshold2){ |
6584 if(level>0){ | |
635 | 6585 level= (bias + level)>>QMAT_SHIFT; |
344 | 6586 block[j]= level; |
6587 }else{ | |
635 | 6588 level= (bias - level)>>QMAT_SHIFT; |
344 | 6589 block[j]= -level; |
0 | 6590 } |
344 | 6591 max |=level; |
6592 }else{ | |
6593 block[j]=0; | |
0 | 6594 } |
6595 } | |
2627
bf158d23bbcc
Spelling errors patch by (Kevin Baragona | kevinmb500 gawab com)
michael
parents:
2620
diff
changeset
|
6596 *overflow= s->max_qcoeff < max; //overflow might have happened |
2967 | 6597 |
764 | 6598 /* we need this permutation so that we correct the IDCT, we only permute the !=0 elements */ |
1092 | 6599 if (s->dsp.idct_permutation_type != FF_NO_IDCT_PERM) |
2979 | 6600 ff_block_permute(block, s->dsp.idct_permutation, scantable, last_non_zero); |
764 | 6601 |
0 | 6602 return last_non_zero; |
6603 } | |
6604 | |
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
|
6605 #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
|
6606 |
2967 | 6607 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
|
6608 DCTELEM *block, int n, int qscale) |
0 | 6609 { |
200 | 6610 int i, level, nCoeffs; |
1064 | 6611 const uint16_t *quant_matrix; |
0 | 6612 |
706
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
6613 nCoeffs= s->block_last_index[n]; |
2967 | 6614 |
6615 if (n < 4) | |
1689 | 6616 block[0] = block[0] * s->y_dc_scale; |
6617 else | |
6618 block[0] = block[0] * s->c_dc_scale; | |
6619 /* XXX: only mpeg1 */ | |
6620 quant_matrix = s->intra_matrix; | |
6621 for(i=1;i<=nCoeffs;i++) { | |
6622 int j= s->intra_scantable.permutated[i]; | |
6623 level = block[j]; | |
6624 if (level) { | |
6625 if (level < 0) { | |
6626 level = -level; | |
6627 level = (int)(level * qscale * quant_matrix[j]) >> 3; | |
6628 level = (level - 1) | 1; | |
6629 level = -level; | |
6630 } else { | |
6631 level = (int)(level * qscale * quant_matrix[j]) >> 3; | |
6632 level = (level - 1) | 1; | |
0 | 6633 } |
1689 | 6634 block[j] = level; |
0 | 6635 } |
6636 } | |
6637 } | |
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
|
6638 |
2967 | 6639 static void dct_unquantize_mpeg1_inter_c(MpegEncContext *s, |
1689 | 6640 DCTELEM *block, int n, int qscale) |
6641 { | |
6642 int i, level, nCoeffs; | |
6643 const uint16_t *quant_matrix; | |
6644 | |
6645 nCoeffs= s->block_last_index[n]; | |
2967 | 6646 |
1689 | 6647 quant_matrix = s->inter_matrix; |
6648 for(i=0; i<=nCoeffs; i++) { | |
6649 int j= s->intra_scantable.permutated[i]; | |
6650 level = block[j]; | |
6651 if (level) { | |
6652 if (level < 0) { | |
6653 level = -level; | |
6654 level = (((level << 1) + 1) * qscale * | |
6655 ((int) (quant_matrix[j]))) >> 4; | |
6656 level = (level - 1) | 1; | |
6657 level = -level; | |
6658 } else { | |
6659 level = (((level << 1) + 1) * qscale * | |
6660 ((int) (quant_matrix[j]))) >> 4; | |
6661 level = (level - 1) | 1; | |
6662 } | |
6663 block[j] = level; | |
6664 } | |
6665 } | |
6666 } | |
6667 | |
2967 | 6668 static void dct_unquantize_mpeg2_intra_c(MpegEncContext *s, |
325 | 6669 DCTELEM *block, int n, int qscale) |
6670 { | |
6671 int i, level, nCoeffs; | |
1064 | 6672 const uint16_t *quant_matrix; |
325 | 6673 |
706
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
6674 if(s->alternate_scan) nCoeffs= 63; |
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
6675 else nCoeffs= s->block_last_index[n]; |
2967 | 6676 |
6677 if (n < 4) | |
1689 | 6678 block[0] = block[0] * s->y_dc_scale; |
6679 else | |
6680 block[0] = block[0] * s->c_dc_scale; | |
6681 quant_matrix = s->intra_matrix; | |
6682 for(i=1;i<=nCoeffs;i++) { | |
6683 int j= s->intra_scantable.permutated[i]; | |
6684 level = block[j]; | |
6685 if (level) { | |
6686 if (level < 0) { | |
6687 level = -level; | |
6688 level = (int)(level * qscale * quant_matrix[j]) >> 3; | |
6689 level = -level; | |
6690 } else { | |
6691 level = (int)(level * qscale * quant_matrix[j]) >> 3; | |
6692 } | |
6693 block[j] = level; | |
6694 } | |
6695 } | |
6696 } | |
6697 | |
3281
7fac25904a8b
missmatch control for mpeg2 intra dequantization if bitexact=1
michael
parents:
3268
diff
changeset
|
6698 static void dct_unquantize_mpeg2_intra_bitexact(MpegEncContext *s, |
7fac25904a8b
missmatch control for mpeg2 intra dequantization if bitexact=1
michael
parents:
3268
diff
changeset
|
6699 DCTELEM *block, int n, int qscale) |
7fac25904a8b
missmatch control for mpeg2 intra dequantization if bitexact=1
michael
parents:
3268
diff
changeset
|
6700 { |
7fac25904a8b
missmatch control for mpeg2 intra dequantization if bitexact=1
michael
parents:
3268
diff
changeset
|
6701 int i, level, nCoeffs; |
7fac25904a8b
missmatch control for mpeg2 intra dequantization if bitexact=1
michael
parents:
3268
diff
changeset
|
6702 const uint16_t *quant_matrix; |
7fac25904a8b
missmatch control for mpeg2 intra dequantization if bitexact=1
michael
parents:
3268
diff
changeset
|
6703 int sum=-1; |
7fac25904a8b
missmatch control for mpeg2 intra dequantization if bitexact=1
michael
parents:
3268
diff
changeset
|
6704 |
7fac25904a8b
missmatch control for mpeg2 intra dequantization if bitexact=1
michael
parents:
3268
diff
changeset
|
6705 if(s->alternate_scan) nCoeffs= 63; |
7fac25904a8b
missmatch control for mpeg2 intra dequantization if bitexact=1
michael
parents:
3268
diff
changeset
|
6706 else nCoeffs= s->block_last_index[n]; |
7fac25904a8b
missmatch control for mpeg2 intra dequantization if bitexact=1
michael
parents:
3268
diff
changeset
|
6707 |
7fac25904a8b
missmatch control for mpeg2 intra dequantization if bitexact=1
michael
parents:
3268
diff
changeset
|
6708 if (n < 4) |
7fac25904a8b
missmatch control for mpeg2 intra dequantization if bitexact=1
michael
parents:
3268
diff
changeset
|
6709 block[0] = block[0] * s->y_dc_scale; |
7fac25904a8b
missmatch control for mpeg2 intra dequantization if bitexact=1
michael
parents:
3268
diff
changeset
|
6710 else |
7fac25904a8b
missmatch control for mpeg2 intra dequantization if bitexact=1
michael
parents:
3268
diff
changeset
|
6711 block[0] = block[0] * s->c_dc_scale; |
7fac25904a8b
missmatch control for mpeg2 intra dequantization if bitexact=1
michael
parents:
3268
diff
changeset
|
6712 quant_matrix = s->intra_matrix; |
7fac25904a8b
missmatch control for mpeg2 intra dequantization if bitexact=1
michael
parents:
3268
diff
changeset
|
6713 for(i=1;i<=nCoeffs;i++) { |
7fac25904a8b
missmatch control for mpeg2 intra dequantization if bitexact=1
michael
parents:
3268
diff
changeset
|
6714 int j= s->intra_scantable.permutated[i]; |
7fac25904a8b
missmatch control for mpeg2 intra dequantization if bitexact=1
michael
parents:
3268
diff
changeset
|
6715 level = block[j]; |
7fac25904a8b
missmatch control for mpeg2 intra dequantization if bitexact=1
michael
parents:
3268
diff
changeset
|
6716 if (level) { |
7fac25904a8b
missmatch control for mpeg2 intra dequantization if bitexact=1
michael
parents:
3268
diff
changeset
|
6717 if (level < 0) { |
7fac25904a8b
missmatch control for mpeg2 intra dequantization if bitexact=1
michael
parents:
3268
diff
changeset
|
6718 level = -level; |
7fac25904a8b
missmatch control for mpeg2 intra dequantization if bitexact=1
michael
parents:
3268
diff
changeset
|
6719 level = (int)(level * qscale * quant_matrix[j]) >> 3; |
7fac25904a8b
missmatch control for mpeg2 intra dequantization if bitexact=1
michael
parents:
3268
diff
changeset
|
6720 level = -level; |
7fac25904a8b
missmatch control for mpeg2 intra dequantization if bitexact=1
michael
parents:
3268
diff
changeset
|
6721 } else { |
7fac25904a8b
missmatch control for mpeg2 intra dequantization if bitexact=1
michael
parents:
3268
diff
changeset
|
6722 level = (int)(level * qscale * quant_matrix[j]) >> 3; |
7fac25904a8b
missmatch control for mpeg2 intra dequantization if bitexact=1
michael
parents:
3268
diff
changeset
|
6723 } |
7fac25904a8b
missmatch control for mpeg2 intra dequantization if bitexact=1
michael
parents:
3268
diff
changeset
|
6724 block[j] = level; |
7fac25904a8b
missmatch control for mpeg2 intra dequantization if bitexact=1
michael
parents:
3268
diff
changeset
|
6725 sum+=level; |
7fac25904a8b
missmatch control for mpeg2 intra dequantization if bitexact=1
michael
parents:
3268
diff
changeset
|
6726 } |
7fac25904a8b
missmatch control for mpeg2 intra dequantization if bitexact=1
michael
parents:
3268
diff
changeset
|
6727 } |
7fac25904a8b
missmatch control for mpeg2 intra dequantization if bitexact=1
michael
parents:
3268
diff
changeset
|
6728 block[63]^=sum&1; |
7fac25904a8b
missmatch control for mpeg2 intra dequantization if bitexact=1
michael
parents:
3268
diff
changeset
|
6729 } |
7fac25904a8b
missmatch control for mpeg2 intra dequantization if bitexact=1
michael
parents:
3268
diff
changeset
|
6730 |
2967 | 6731 static void dct_unquantize_mpeg2_inter_c(MpegEncContext *s, |
1689 | 6732 DCTELEM *block, int n, int qscale) |
6733 { | |
6734 int i, level, nCoeffs; | |
6735 const uint16_t *quant_matrix; | |
6736 int sum=-1; | |
6737 | |
6738 if(s->alternate_scan) nCoeffs= 63; | |
6739 else nCoeffs= s->block_last_index[n]; | |
2967 | 6740 |
1689 | 6741 quant_matrix = s->inter_matrix; |
6742 for(i=0; i<=nCoeffs; i++) { | |
6743 int j= s->intra_scantable.permutated[i]; | |
6744 level = block[j]; | |
6745 if (level) { | |
6746 if (level < 0) { | |
6747 level = -level; | |
6748 level = (((level << 1) + 1) * qscale * | |
6749 ((int) (quant_matrix[j]))) >> 4; | |
6750 level = -level; | |
6751 } else { | |
6752 level = (((level << 1) + 1) * qscale * | |
6753 ((int) (quant_matrix[j]))) >> 4; | |
6754 } | |
6755 block[j] = level; | |
6756 sum+=level; | |
6757 } | |
6758 } | |
6759 block[63]^=sum&1; | |
6760 } | |
6761 | |
2967 | 6762 static void dct_unquantize_h263_intra_c(MpegEncContext *s, |
1689 | 6763 DCTELEM *block, int n, int qscale) |
6764 { | |
6765 int i, level, qmul, qadd; | |
6766 int nCoeffs; | |
2967 | 6767 |
1689 | 6768 assert(s->block_last_index[n]>=0); |
2967 | 6769 |
1689 | 6770 qmul = qscale << 1; |
2967 | 6771 |
1689 | 6772 if (!s->h263_aic) { |
2967 | 6773 if (n < 4) |
325 | 6774 block[0] = block[0] * s->y_dc_scale; |
6775 else | |
6776 block[0] = block[0] * s->c_dc_scale; | |
1689 | 6777 qadd = (qscale - 1) | 1; |
6778 }else{ | |
6779 qadd = 0; | |
6780 } | |
6781 if(s->ac_pred) | |
6782 nCoeffs=63; | |
6783 else | |
6784 nCoeffs= s->inter_scantable.raster_end[ s->block_last_index[n] ]; | |
6785 | |
6786 for(i=1; i<=nCoeffs; i++) { | |
6787 level = block[i]; | |
6788 if (level) { | |
6789 if (level < 0) { | |
6790 level = level * qmul - qadd; | |
6791 } else { | |
6792 level = level * qmul + qadd; | |
325 | 6793 } |
1689 | 6794 block[i] = level; |
325 | 6795 } |
6796 } | |
6797 } | |
6798 | |
2967 | 6799 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
|
6800 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
|
6801 { |
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
|
6802 int i, level, qmul, qadd; |
200 | 6803 int nCoeffs; |
2967 | 6804 |
706
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
6805 assert(s->block_last_index[n]>=0); |
2967 | 6806 |
706
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
6807 qadd = (qscale - 1) | 1; |
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
6808 qmul = qscale << 1; |
2967 | 6809 |
1689 | 6810 nCoeffs= s->inter_scantable.raster_end[ s->block_last_index[n] ]; |
6811 | |
6812 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
|
6813 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
|
6814 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
|
6815 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
|
6816 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
|
6817 } 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
|
6818 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
|
6819 } |
174ef88f619a
use block[] in structure to have it aligned on 8 bytes for mmx optimizations - dct_unquantize is always a function pointer - added specialized dct_unquantize_h263
glantau
parents:
8
diff
changeset
|
6820 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
|
6821 } |
174ef88f619a
use block[] in structure to have it aligned on 8 bytes for mmx optimizations - dct_unquantize is always a function pointer - added specialized dct_unquantize_h263
glantau
parents:
8
diff
changeset
|
6822 } |
174ef88f619a
use block[] in structure to have it aligned on 8 bytes for mmx optimizations - dct_unquantize is always a function pointer - added specialized dct_unquantize_h263
glantau
parents:
8
diff
changeset
|
6823 } |
0 | 6824 |
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
|
6825 #ifdef CONFIG_ENCODERS |
0 | 6826 AVCodec h263_encoder = { |
6827 "h263", | |
6828 CODEC_TYPE_VIDEO, | |
6829 CODEC_ID_H263, | |
6830 sizeof(MpegEncContext), | |
6831 MPV_encode_init, | |
6832 MPV_encode_picture, | |
6833 MPV_encode_end, | |
2524 | 6834 .pix_fmts= (enum PixelFormat[]){PIX_FMT_YUV420P, -1}, |
0 | 6835 }; |
6836 | |
6837 AVCodec h263p_encoder = { | |
6838 "h263p", | |
6839 CODEC_TYPE_VIDEO, | |
6840 CODEC_ID_H263P, | |
6841 sizeof(MpegEncContext), | |
6842 MPV_encode_init, | |
6843 MPV_encode_picture, | |
6844 MPV_encode_end, | |
2524 | 6845 .pix_fmts= (enum PixelFormat[]){PIX_FMT_YUV420P, -1}, |
0 | 6846 }; |
6847 | |
1353
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1344
diff
changeset
|
6848 AVCodec flv_encoder = { |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1344
diff
changeset
|
6849 "flv", |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1344
diff
changeset
|
6850 CODEC_TYPE_VIDEO, |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1344
diff
changeset
|
6851 CODEC_ID_FLV1, |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1344
diff
changeset
|
6852 sizeof(MpegEncContext), |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1344
diff
changeset
|
6853 MPV_encode_init, |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1344
diff
changeset
|
6854 MPV_encode_picture, |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1344
diff
changeset
|
6855 MPV_encode_end, |
2524 | 6856 .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
|
6857 }; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1344
diff
changeset
|
6858 |
0 | 6859 AVCodec rv10_encoder = { |
6860 "rv10", | |
6861 CODEC_TYPE_VIDEO, | |
6862 CODEC_ID_RV10, | |
6863 sizeof(MpegEncContext), | |
6864 MPV_encode_init, | |
6865 MPV_encode_picture, | |
6866 MPV_encode_end, | |
2524 | 6867 .pix_fmts= (enum PixelFormat[]){PIX_FMT_YUV420P, -1}, |
0 | 6868 }; |
6869 | |
2380 | 6870 AVCodec rv20_encoder = { |
6871 "rv20", | |
6872 CODEC_TYPE_VIDEO, | |
6873 CODEC_ID_RV20, | |
6874 sizeof(MpegEncContext), | |
6875 MPV_encode_init, | |
6876 MPV_encode_picture, | |
6877 MPV_encode_end, | |
2524 | 6878 .pix_fmts= (enum PixelFormat[]){PIX_FMT_YUV420P, -1}, |
2380 | 6879 }; |
6880 | |
71 | 6881 AVCodec mpeg4_encoder = { |
6882 "mpeg4", | |
0 | 6883 CODEC_TYPE_VIDEO, |
71 | 6884 CODEC_ID_MPEG4, |
0 | 6885 sizeof(MpegEncContext), |
6886 MPV_encode_init, | |
6887 MPV_encode_picture, | |
6888 MPV_encode_end, | |
2524 | 6889 .pix_fmts= (enum PixelFormat[]){PIX_FMT_YUV420P, -1}, |
2111 | 6890 .capabilities= CODEC_CAP_DELAY, |
0 | 6891 }; |
6892 | |
307 | 6893 AVCodec msmpeg4v1_encoder = { |
6894 "msmpeg4v1", | |
0 | 6895 CODEC_TYPE_VIDEO, |
307 | 6896 CODEC_ID_MSMPEG4V1, |
0 | 6897 sizeof(MpegEncContext), |
6898 MPV_encode_init, | |
6899 MPV_encode_picture, | |
6900 MPV_encode_end, | |
2524 | 6901 .pix_fmts= (enum PixelFormat[]){PIX_FMT_YUV420P, -1}, |
0 | 6902 }; |
307 | 6903 |
6904 AVCodec msmpeg4v2_encoder = { | |
6905 "msmpeg4v2", | |
6906 CODEC_TYPE_VIDEO, | |
6907 CODEC_ID_MSMPEG4V2, | |
6908 sizeof(MpegEncContext), | |
6909 MPV_encode_init, | |
6910 MPV_encode_picture, | |
6911 MPV_encode_end, | |
2524 | 6912 .pix_fmts= (enum PixelFormat[]){PIX_FMT_YUV420P, -1}, |
307 | 6913 }; |
6914 | |
6915 AVCodec msmpeg4v3_encoder = { | |
6916 "msmpeg4", | |
6917 CODEC_TYPE_VIDEO, | |
6918 CODEC_ID_MSMPEG4V3, | |
6919 sizeof(MpegEncContext), | |
6920 MPV_encode_init, | |
6921 MPV_encode_picture, | |
6922 MPV_encode_end, | |
2524 | 6923 .pix_fmts= (enum PixelFormat[]){PIX_FMT_YUV420P, -1}, |
307 | 6924 }; |
499 | 6925 |
6926 AVCodec wmv1_encoder = { | |
6927 "wmv1", | |
6928 CODEC_TYPE_VIDEO, | |
6929 CODEC_ID_WMV1, | |
6930 sizeof(MpegEncContext), | |
6931 MPV_encode_init, | |
6932 MPV_encode_picture, | |
6933 MPV_encode_end, | |
2524 | 6934 .pix_fmts= (enum PixelFormat[]){PIX_FMT_YUV420P, -1}, |
499 | 6935 }; |
6936 | |
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
|
6937 #endif //CONFIG_ENCODERS |