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