Mercurial > libavcodec.hg
annotate mpegvideo.c @ 4317:5a2ee0bc2739 libavcodec
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)
author | michael |
---|---|
date | Thu, 21 Dec 2006 15:20:02 +0000 |
parents | 5ed8f8fd71e9 |
children | 6c32aa2d9323 |
rev | line source |
---|---|
0 | 1 /* |
2 * The simplest mpeg encoder (well, it was the simplest!) | |
429 | 3 * Copyright (c) 2000,2001 Fabrice Bellard. |
1739
07a484280a82
copyright year update of the files i touched and remembered, things look annoyingly unmaintained otherwise
michael
parents:
1729
diff
changeset
|
4 * Copyright (c) 2002-2004 Michael Niedermayer <michaelni@gmx.at> |
0 | 5 * |
3947
c8c591fe26f8
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
3939
diff
changeset
|
6 * This file is part of FFmpeg. |
c8c591fe26f8
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
3939
diff
changeset
|
7 * |
c8c591fe26f8
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
3939
diff
changeset
|
8 * FFmpeg is free software; you can redistribute it and/or |
429 | 9 * modify it under the terms of the GNU Lesser General Public |
10 * License as published by the Free Software Foundation; either | |
3947
c8c591fe26f8
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
3939
diff
changeset
|
11 * version 2.1 of the License, or (at your option) any later version. |
0 | 12 * |
3947
c8c591fe26f8
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
3939
diff
changeset
|
13 * FFmpeg is distributed in the hope that it will be useful, |
0 | 14 * but WITHOUT ANY WARRANTY; without even the implied warranty of |
429 | 15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
16 * Lesser General Public License for more details. | |
0 | 17 * |
429 | 18 * You should have received a copy of the GNU Lesser General Public |
3947
c8c591fe26f8
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
3939
diff
changeset
|
19 * License along with FFmpeg; if not, write to the Free Software |
3036
0b546eab515d
Update licensing information: The FSF changed postal address.
diego
parents:
3011
diff
changeset
|
20 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA |
295 | 21 * |
325 | 22 * 4MV & hq & b-frame encoding stuff by Michael Niedermayer <michaelni@gmx.at> |
0 | 23 */ |
2967 | 24 |
1106 | 25 /** |
26 * @file mpegvideo.c | |
27 * The simplest mpeg encoder (well, it was the simplest!). | |
2967 | 28 */ |
29 | |
0 | 30 #include "avcodec.h" |
31 #include "dsputil.h" | |
32 #include "mpegvideo.h" | |
1557 | 33 #include "faandct.h" |
2024
f65d87bfdd5a
some of the warning fixes by (Michael Roitzsch <mroi at users dot sourceforge dot net>)
michael
parents:
2015
diff
changeset
|
34 #include <limits.h> |
0 | 35 |
17
b69fe46fd708
Adding fastmemcpy stuff to speedup mplayer project
nickols_k
parents:
13
diff
changeset
|
36 #ifdef USE_FASTMEMCPY |
3589 | 37 #include "libvo/fastmemcpy.h" |
17
b69fe46fd708
Adding fastmemcpy stuff to speedup mplayer project
nickols_k
parents:
13
diff
changeset
|
38 #endif |
b69fe46fd708
Adding fastmemcpy stuff to speedup mplayer project
nickols_k
parents:
13
diff
changeset
|
39 |
1422
efeed6e29f9b
oooooops, having 2 Eterms open and doing cvs diff in one and cvs commit in the other sucks, especially if they are in different directories (MPlayer/main/libavcodec vs. ffmpeg/libavcodec)
michaelni
parents:
1421
diff
changeset
|
40 //#undef NDEBUG |
efeed6e29f9b
oooooops, having 2 Eterms open and doing cvs diff in one and cvs commit in the other sucks, especially if they are in different directories (MPlayer/main/libavcodec vs. ffmpeg/libavcodec)
michaelni
parents:
1421
diff
changeset
|
41 //#include <assert.h> |
706
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
42 |
1070
6da5ae9ee199
more #ifdef CONFIG_ENCODERS patch by (Wolfgang Hesseler <qv at multimediaware dot com>) with modifications by me (s/WOLFGANG/CONFIG_ENCODERS/ and some other fixes)
michaelni
parents:
1064
diff
changeset
|
43 #ifdef CONFIG_ENCODERS |
3766 | 44 static int encode_picture(MpegEncContext *s, int picture_number); |
1070
6da5ae9ee199
more #ifdef CONFIG_ENCODERS patch by (Wolfgang Hesseler <qv at multimediaware dot com>) with modifications by me (s/WOLFGANG/CONFIG_ENCODERS/ and some other fixes)
michaelni
parents:
1064
diff
changeset
|
45 #endif //CONFIG_ENCODERS |
2967 | 46 static void dct_unquantize_mpeg1_intra_c(MpegEncContext *s, |
1689 | 47 DCTELEM *block, int n, int qscale); |
2967 | 48 static void dct_unquantize_mpeg1_inter_c(MpegEncContext *s, |
1689 | 49 DCTELEM *block, int n, int qscale); |
50 static void dct_unquantize_mpeg2_intra_c(MpegEncContext *s, | |
13
174ef88f619a
use block[] in structure to have it aligned on 8 bytes for mmx optimizations - dct_unquantize is always a function pointer - added specialized dct_unquantize_h263
glantau
parents:
8
diff
changeset
|
51 DCTELEM *block, int n, int qscale); |
3281
7fac25904a8b
missmatch control for mpeg2 intra dequantization if bitexact=1
michael
parents:
3268
diff
changeset
|
52 static void dct_unquantize_mpeg2_intra_bitexact(MpegEncContext *s, |
7fac25904a8b
missmatch control for mpeg2 intra dequantization if bitexact=1
michael
parents:
3268
diff
changeset
|
53 DCTELEM *block, int n, int qscale); |
1689 | 54 static void dct_unquantize_mpeg2_inter_c(MpegEncContext *s, |
325 | 55 DCTELEM *block, int n, int qscale); |
2967 | 56 static void dct_unquantize_h263_intra_c(MpegEncContext *s, |
1689 | 57 DCTELEM *block, int n, int qscale); |
2967 | 58 static void dct_unquantize_h263_inter_c(MpegEncContext *s, |
13
174ef88f619a
use block[] in structure to have it aligned on 8 bytes for mmx optimizations - dct_unquantize is always a function pointer - added specialized dct_unquantize_h263
glantau
parents:
8
diff
changeset
|
59 DCTELEM *block, int n, int qscale); |
1064 | 60 static void draw_edges_c(uint8_t *buf, int wrap, int width, int height, int w); |
1070
6da5ae9ee199
more #ifdef CONFIG_ENCODERS patch by (Wolfgang Hesseler <qv at multimediaware dot com>) with modifications by me (s/WOLFGANG/CONFIG_ENCODERS/ and some other fixes)
michaelni
parents:
1064
diff
changeset
|
61 #ifdef CONFIG_ENCODERS |
344 | 62 static int dct_quantize_c(MpegEncContext *s, DCTELEM *block, int n, int qscale, int *overflow); |
945 | 63 static int dct_quantize_trellis_c(MpegEncContext *s, DCTELEM *block, int n, int qscale, int *overflow); |
1777 | 64 static int dct_quantize_refine(MpegEncContext *s, DCTELEM *block, int16_t *weight, DCTELEM *orig, int n, int qscale); |
1389 | 65 static int sse_mb(MpegEncContext *s); |
1719 | 66 static void denoise_dct_c(MpegEncContext *s, DCTELEM *block); |
1070
6da5ae9ee199
more #ifdef CONFIG_ENCODERS patch by (Wolfgang Hesseler <qv at multimediaware dot com>) with modifications by me (s/WOLFGANG/CONFIG_ENCODERS/ and some other fixes)
michaelni
parents:
1064
diff
changeset
|
67 #endif //CONFIG_ENCODERS |
206 | 68 |
1381 | 69 #ifdef HAVE_XVMC |
70 extern int XVMC_field_start(MpegEncContext*s, AVCodecContext *avctx); | |
71 extern void XVMC_field_end(MpegEncContext *s); | |
1580
628bf341e099
XvMC speedup by removing one memcpy and doing MB packing
iive
parents:
1579
diff
changeset
|
72 extern void XVMC_decode_mb(MpegEncContext *s); |
1381 | 73 #endif |
74 | |
1064 | 75 void (*draw_edges)(uint8_t *buf, int wrap, int width, int height, int w)= draw_edges_c; |
206 | 76 |
0 | 77 |
78 /* enable all paranoid tests for rounding, overflows, etc... */ | |
79 //#define PARANOID | |
80 | |
81 //#define DEBUG | |
82 | |
321 | 83 |
0 | 84 /* for jpeg fast DCT */ |
85 #define CONST_BITS 14 | |
86 | |
853
eacc2dd8fd9d
* using DSPContext - so each codec could use its local (sub)set of CPU extension
kabi
parents:
847
diff
changeset
|
87 static const uint16_t aanscales[64] = { |
0 | 88 /* precomputed values scaled up by 14 bits */ |
89 16384, 22725, 21407, 19266, 16384, 12873, 8867, 4520, | |
90 22725, 31521, 29692, 26722, 22725, 17855, 12299, 6270, | |
91 21407, 29692, 27969, 25172, 21407, 16819, 11585, 5906, | |
92 19266, 26722, 25172, 22654, 19266, 15137, 10426, 5315, | |
93 16384, 22725, 21407, 19266, 16384, 12873, 8867, 4520, | |
94 12873, 17855, 16819, 15137, 12873, 10114, 6967, 3552, | |
936 | 95 8867 , 12299, 11585, 10426, 8867, 6967, 4799, 2446, |
96 4520 , 6270, 5906, 5315, 4520, 3552, 2446, 1247 | |
0 | 97 }; |
98 | |
853
eacc2dd8fd9d
* using DSPContext - so each codec could use its local (sub)set of CPU extension
kabi
parents:
847
diff
changeset
|
99 static const uint8_t h263_chroma_roundtab[16] = { |
1013 | 100 // 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
0 | 101 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, |
102 }; | |
103 | |
1644 | 104 static const uint8_t ff_default_chroma_qscale_table[32]={ |
105 // 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 | |
106 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31 | |
107 }; | |
108 | |
1070
6da5ae9ee199
more #ifdef CONFIG_ENCODERS patch by (Wolfgang Hesseler <qv at multimediaware dot com>) with modifications by me (s/WOLFGANG/CONFIG_ENCODERS/ and some other fixes)
michaelni
parents:
1064
diff
changeset
|
109 #ifdef CONFIG_ENCODERS |
1162 | 110 static uint8_t (*default_mv_penalty)[MAX_MV*2+1]=NULL; |
1064 | 111 static uint8_t default_fcode_tab[MAX_MV*2+1]; |
277
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
271
diff
changeset
|
112 |
998 | 113 enum PixelFormat ff_yuv420p_list[2]= {PIX_FMT_YUV420P, -1}; |
114 | |
1579
039cb2296de2
make convert_matrix() independant of MpegEncContext
michael
parents:
1573
diff
changeset
|
115 static void convert_matrix(DSPContext *dsp, int (*qmat)[64], uint16_t (*qmat16)[2][64], |
2385
4605a8b188c3
warn the user if the quantization code could overflow with the selected custom matrix and qp limits
michael
parents:
2382
diff
changeset
|
116 const uint16_t *quant_matrix, int bias, int qmin, int qmax, int intra) |
0 | 117 { |
344 | 118 int qscale; |
2385
4605a8b188c3
warn the user if the quantization code could overflow with the selected custom matrix and qp limits
michael
parents:
2382
diff
changeset
|
119 int shift=0; |
0 | 120 |
709
afeff6ccb7f5
convert only needed matrixes in convert_matrix() (mjpeg calls it for every frame)
michaelni
parents:
706
diff
changeset
|
121 for(qscale=qmin; qscale<=qmax; qscale++){ |
344 | 122 int i; |
2967 | 123 if (dsp->fdct == ff_jpeg_fdct_islow |
1562
bf452704100f
optionally merge postscale into quantization table for the float aan dct
michael
parents:
1557
diff
changeset
|
124 #ifdef FAAN_POSTSCALE |
1579
039cb2296de2
make convert_matrix() independant of MpegEncContext
michael
parents:
1573
diff
changeset
|
125 || dsp->fdct == ff_faandct |
1562
bf452704100f
optionally merge postscale into quantization table for the float aan dct
michael
parents:
1557
diff
changeset
|
126 #endif |
bf452704100f
optionally merge postscale into quantization table for the float aan dct
michael
parents:
1557
diff
changeset
|
127 ) { |
625
bb6a69f9d409
slow but accurate integer dct from IJG (should be ok with the LGPL as the old DCT is the fast integer DCT from IJG)
michaelni
parents:
619
diff
changeset
|
128 for(i=0;i<64;i++) { |
1579
039cb2296de2
make convert_matrix() independant of MpegEncContext
michael
parents:
1573
diff
changeset
|
129 const int j= dsp->idct_permutation[i]; |
625
bb6a69f9d409
slow but accurate integer dct from IJG (should be ok with the LGPL as the old DCT is the fast integer DCT from IJG)
michaelni
parents:
619
diff
changeset
|
130 /* 16 <= qscale * quant_matrix[i] <= 7905 */ |
bb6a69f9d409
slow but accurate integer dct from IJG (should be ok with the LGPL as the old DCT is the fast integer DCT from IJG)
michaelni
parents:
619
diff
changeset
|
131 /* 19952 <= aanscales[i] * qscale * quant_matrix[i] <= 249205026 */ |
bb6a69f9d409
slow but accurate integer dct from IJG (should be ok with the LGPL as the old DCT is the fast integer DCT from IJG)
michaelni
parents:
619
diff
changeset
|
132 /* (1<<36)/19952 >= (1<<36)/(aanscales[i] * qscale * quant_matrix[i]) >= (1<<36)/249205026 */ |
bb6a69f9d409
slow but accurate integer dct from IJG (should be ok with the LGPL as the old DCT is the fast integer DCT from IJG)
michaelni
parents:
619
diff
changeset
|
133 /* 3444240 >= (1<<36)/(aanscales[i] * qscale * quant_matrix[i]) >= 275 */ |
2967 | 134 |
4274 | 135 qmat[qscale][i] = (int)((UINT64_C(1) << QMAT_SHIFT) / |
625
bb6a69f9d409
slow but accurate integer dct from IJG (should be ok with the LGPL as the old DCT is the fast integer DCT from IJG)
michaelni
parents:
619
diff
changeset
|
136 (qscale * quant_matrix[j])); |
bb6a69f9d409
slow but accurate integer dct from IJG (should be ok with the LGPL as the old DCT is the fast integer DCT from IJG)
michaelni
parents:
619
diff
changeset
|
137 } |
1579
039cb2296de2
make convert_matrix() independant of MpegEncContext
michael
parents:
1573
diff
changeset
|
138 } else if (dsp->fdct == fdct_ifast |
1562
bf452704100f
optionally merge postscale into quantization table for the float aan dct
michael
parents:
1557
diff
changeset
|
139 #ifndef FAAN_POSTSCALE |
1579
039cb2296de2
make convert_matrix() independant of MpegEncContext
michael
parents:
1573
diff
changeset
|
140 || dsp->fdct == ff_faandct |
1562
bf452704100f
optionally merge postscale into quantization table for the float aan dct
michael
parents:
1557
diff
changeset
|
141 #endif |
bf452704100f
optionally merge postscale into quantization table for the float aan dct
michael
parents:
1557
diff
changeset
|
142 ) { |
344 | 143 for(i=0;i<64;i++) { |
1579
039cb2296de2
make convert_matrix() independant of MpegEncContext
michael
parents:
1573
diff
changeset
|
144 const int j= dsp->idct_permutation[i]; |
344 | 145 /* 16 <= qscale * quant_matrix[i] <= 7905 */ |
146 /* 19952 <= aanscales[i] * qscale * quant_matrix[i] <= 249205026 */ | |
147 /* (1<<36)/19952 >= (1<<36)/(aanscales[i] * qscale * quant_matrix[i]) >= (1<<36)/249205026 */ | |
148 /* 3444240 >= (1<<36)/(aanscales[i] * qscale * quant_matrix[i]) >= 275 */ | |
2967 | 149 |
4274 | 150 qmat[qscale][i] = (int)((UINT64_C(1) << (QMAT_SHIFT + 14)) / |
344 | 151 (aanscales[i] * qscale * quant_matrix[j])); |
152 } | |
153 } else { | |
154 for(i=0;i<64;i++) { | |
1579
039cb2296de2
make convert_matrix() independant of MpegEncContext
michael
parents:
1573
diff
changeset
|
155 const int j= dsp->idct_permutation[i]; |
344 | 156 /* We can safely suppose that 16 <= quant_matrix[i] <= 255 |
157 So 16 <= qscale * quant_matrix[i] <= 7905 | |
158 so (1<<19) / 16 >= (1<<19) / (qscale * quant_matrix[i]) >= (1<<19) / 7905 | |
159 so 32768 >= (1<<19) / (qscale * quant_matrix[i]) >= 67 | |
160 */ | |
4274 | 161 qmat[qscale][i] = (int)((UINT64_C(1) << QMAT_SHIFT) / (qscale * quant_matrix[j])); |
945 | 162 // qmat [qscale][i] = (1 << QMAT_SHIFT_MMX) / (qscale * quant_matrix[i]); |
1554
d736e24bf303
move mmx quantizer matrixes out of MpegEncContext (23k -> 7k) (no meassureable slowdown)
michael
parents:
1553
diff
changeset
|
163 qmat16[qscale][0][i] = (1 << QMAT_SHIFT_MMX) / (qscale * quant_matrix[j]); |
d736e24bf303
move mmx quantizer matrixes out of MpegEncContext (23k -> 7k) (no meassureable slowdown)
michael
parents:
1553
diff
changeset
|
164 |
d736e24bf303
move mmx quantizer matrixes out of MpegEncContext (23k -> 7k) (no meassureable slowdown)
michael
parents:
1553
diff
changeset
|
165 if(qmat16[qscale][0][i]==0 || qmat16[qscale][0][i]==128*256) qmat16[qscale][0][i]=128*256-1; |
d736e24bf303
move mmx quantizer matrixes out of MpegEncContext (23k -> 7k) (no meassureable slowdown)
michael
parents:
1553
diff
changeset
|
166 qmat16[qscale][1][i]= ROUNDED_DIV(bias<<(16-QUANT_BIAS_SHIFT), qmat16[qscale][0][i]); |
344 | 167 } |
0 | 168 } |
2967 | 169 |
2385
4605a8b188c3
warn the user if the quantization code could overflow with the selected custom matrix and qp limits
michael
parents:
2382
diff
changeset
|
170 for(i=intra; i<64; i++){ |
2390 | 171 int64_t max= 8191; |
172 if (dsp->fdct == fdct_ifast | |
173 #ifndef FAAN_POSTSCALE | |
174 || dsp->fdct == ff_faandct | |
175 #endif | |
176 ) { | |
177 max= (8191LL*aanscales[i]) >> 14; | |
178 } | |
2967 | 179 while(((max * qmat[qscale][i]) >> shift) > INT_MAX){ |
2385
4605a8b188c3
warn the user if the quantization code could overflow with the selected custom matrix and qp limits
michael
parents:
2382
diff
changeset
|
180 shift++; |
4605a8b188c3
warn the user if the quantization code could overflow with the selected custom matrix and qp limits
michael
parents:
2382
diff
changeset
|
181 } |
4605a8b188c3
warn the user if the quantization code could overflow with the selected custom matrix and qp limits
michael
parents:
2382
diff
changeset
|
182 } |
4605a8b188c3
warn the user if the quantization code could overflow with the selected custom matrix and qp limits
michael
parents:
2382
diff
changeset
|
183 } |
4605a8b188c3
warn the user if the quantization code could overflow with the selected custom matrix and qp limits
michael
parents:
2382
diff
changeset
|
184 if(shift){ |
4605a8b188c3
warn the user if the quantization code could overflow with the selected custom matrix and qp limits
michael
parents:
2382
diff
changeset
|
185 av_log(NULL, AV_LOG_INFO, "Warning, QMAT_SHIFT is larger then %d, overflows possible\n", QMAT_SHIFT - shift); |
0 | 186 } |
187 } | |
1505
010f76d07a27
use lagrange multipler instead of qp for ratecontrol, this may break some things, tell me ASAP if u notice anything broken
michaelni
parents:
1497
diff
changeset
|
188 |
010f76d07a27
use lagrange multipler instead of qp for ratecontrol, this may break some things, tell me ASAP if u notice anything broken
michaelni
parents:
1497
diff
changeset
|
189 static inline void update_qscale(MpegEncContext *s){ |
010f76d07a27
use lagrange multipler instead of qp for ratecontrol, this may break some things, tell me ASAP if u notice anything broken
michaelni
parents:
1497
diff
changeset
|
190 s->qscale= (s->lambda*139 + FF_LAMBDA_SCALE*64) >> (FF_LAMBDA_SHIFT + 7); |
010f76d07a27
use lagrange multipler instead of qp for ratecontrol, this may break some things, tell me ASAP if u notice anything broken
michaelni
parents:
1497
diff
changeset
|
191 s->qscale= clip(s->qscale, s->avctx->qmin, s->avctx->qmax); |
2967 | 192 |
1505
010f76d07a27
use lagrange multipler instead of qp for ratecontrol, this may break some things, tell me ASAP if u notice anything broken
michaelni
parents:
1497
diff
changeset
|
193 s->lambda2= (s->lambda*s->lambda + FF_LAMBDA_SCALE/2) >> FF_LAMBDA_SHIFT; |
010f76d07a27
use lagrange multipler instead of qp for ratecontrol, this may break some things, tell me ASAP if u notice anything broken
michaelni
parents:
1497
diff
changeset
|
194 } |
1070
6da5ae9ee199
more #ifdef CONFIG_ENCODERS patch by (Wolfgang Hesseler <qv at multimediaware dot com>) with modifications by me (s/WOLFGANG/CONFIG_ENCODERS/ and some other fixes)
michaelni
parents:
1064
diff
changeset
|
195 #endif //CONFIG_ENCODERS |
6da5ae9ee199
more #ifdef CONFIG_ENCODERS patch by (Wolfgang Hesseler <qv at multimediaware dot com>) with modifications by me (s/WOLFGANG/CONFIG_ENCODERS/ and some other fixes)
michaelni
parents:
1064
diff
changeset
|
196 |
1273 | 197 void ff_init_scantable(uint8_t *permutation, ScanTable *st, const uint8_t *src_scantable){ |
706
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
198 int i; |
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
199 int end; |
2967 | 200 |
764 | 201 st->scantable= src_scantable; |
706
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
202 |
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
203 for(i=0; i<64; i++){ |
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
204 int j; |
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
205 j = src_scantable[i]; |
1273 | 206 st->permutated[i] = permutation[j]; |
828
ace3ccd18dd2
Altivec Patch (Mark III) by (Dieter Shirley <dieters at schemasoft dot com>)
michaelni
parents:
815
diff
changeset
|
207 #ifdef ARCH_POWERPC |
ace3ccd18dd2
Altivec Patch (Mark III) by (Dieter Shirley <dieters at schemasoft dot com>)
michaelni
parents:
815
diff
changeset
|
208 st->inverse[j] = i; |
ace3ccd18dd2
Altivec Patch (Mark III) by (Dieter Shirley <dieters at schemasoft dot com>)
michaelni
parents:
815
diff
changeset
|
209 #endif |
706
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
210 } |
2967 | 211 |
706
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
212 end=-1; |
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
213 for(i=0; i<64; i++){ |
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
214 int j; |
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
215 j = st->permutated[i]; |
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
216 if(j>end) end=j; |
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
217 st->raster_end[i]= end; |
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
218 } |
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
219 } |
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
220 |
1530
3b31998fe22f
disable encoders where appropriate (patch courtesy of BERO
melanson
parents:
1523
diff
changeset
|
221 #ifdef CONFIG_ENCODERS |
3776 | 222 void ff_write_quant_matrix(PutBitContext *pb, uint16_t *matrix){ |
1411 | 223 int i; |
224 | |
225 if(matrix){ | |
226 put_bits(pb, 1, 1); | |
227 for(i=0;i<64;i++) { | |
228 put_bits(pb, 8, matrix[ ff_zigzag_direct[i] ]); | |
229 } | |
230 }else | |
231 put_bits(pb, 1, 0); | |
232 } | |
1530
3b31998fe22f
disable encoders where appropriate (patch courtesy of BERO
melanson
parents:
1523
diff
changeset
|
233 #endif //CONFIG_ENCODERS |
1411 | 234 |
3086 | 235 const uint8_t *ff_find_start_code(const uint8_t * restrict p, const uint8_t *end, uint32_t * restrict state){ |
236 int i; | |
237 | |
3092 | 238 assert(p<=end); |
239 if(p>=end) | |
240 return end; | |
241 | |
3086 | 242 for(i=0; i<3; i++){ |
243 uint32_t tmp= *state << 8; | |
244 *state= tmp + *(p++); | |
245 if(tmp == 0x100 || p==end) | |
246 return p; | |
247 } | |
248 | |
249 while(p<end){ | |
3087 | 250 if (p[-1] > 1 ) p+= 3; |
251 else if(p[-2] ) p+= 2; | |
252 else if(p[-3]|(p[-1]-1)) p++; | |
3086 | 253 else{ |
254 p++; | |
255 break; | |
256 } | |
257 } | |
258 | |
3087 | 259 p= FFMIN(p, end)-4; |
3086 | 260 *state= be2me_32(unaligned32(p)); |
261 | |
262 return p+4; | |
263 } | |
264 | |
726
a91203b34e71
moved dct init out from mpv_common_init to dct_common_init (for less-uglier way for dv)
al3x
parents:
721
diff
changeset
|
265 /* init common dct for both encoder and decoder */ |
a91203b34e71
moved dct init out from mpv_common_init to dct_common_init (for less-uglier way for dv)
al3x
parents:
721
diff
changeset
|
266 int DCT_common_init(MpegEncContext *s) |
0 | 267 { |
1689 | 268 s->dct_unquantize_h263_intra = dct_unquantize_h263_intra_c; |
269 s->dct_unquantize_h263_inter = dct_unquantize_h263_inter_c; | |
270 s->dct_unquantize_mpeg1_intra = dct_unquantize_mpeg1_intra_c; | |
271 s->dct_unquantize_mpeg1_inter = dct_unquantize_mpeg1_inter_c; | |
272 s->dct_unquantize_mpeg2_intra = dct_unquantize_mpeg2_intra_c; | |
3281
7fac25904a8b
missmatch control for mpeg2 intra dequantization if bitexact=1
michael
parents:
3268
diff
changeset
|
273 if(s->flags & CODEC_FLAG_BITEXACT) |
7fac25904a8b
missmatch control for mpeg2 intra dequantization if bitexact=1
michael
parents:
3268
diff
changeset
|
274 s->dct_unquantize_mpeg2_intra = dct_unquantize_mpeg2_intra_bitexact; |
1689 | 275 s->dct_unquantize_mpeg2_inter = dct_unquantize_mpeg2_inter_c; |
1092 | 276 |
1070
6da5ae9ee199
more #ifdef CONFIG_ENCODERS patch by (Wolfgang Hesseler <qv at multimediaware dot com>) with modifications by me (s/WOLFGANG/CONFIG_ENCODERS/ and some other fixes)
michaelni
parents:
1064
diff
changeset
|
277 #ifdef CONFIG_ENCODERS |
625
bb6a69f9d409
slow but accurate integer dct from IJG (should be ok with the LGPL as the old DCT is the fast integer DCT from IJG)
michaelni
parents:
619
diff
changeset
|
278 s->dct_quantize= dct_quantize_c; |
1719 | 279 s->denoise_dct= denoise_dct_c; |
2616
ba6530ae8e34
remove superfluous CONFIG_ENCODERS (entire function is already wrapped)
melanson
parents:
2584
diff
changeset
|
280 #endif //CONFIG_ENCODERS |
2967 | 281 |
13
174ef88f619a
use block[] in structure to have it aligned on 8 bytes for mmx optimizations - dct_unquantize is always a function pointer - added specialized dct_unquantize_h263
glantau
parents:
8
diff
changeset
|
282 #ifdef HAVE_MMX |
1422
efeed6e29f9b
oooooops, having 2 Eterms open and doing cvs diff in one and cvs commit in the other sucks, especially if they are in different directories (MPlayer/main/libavcodec vs. ffmpeg/libavcodec)
michaelni
parents:
1421
diff
changeset
|
283 MPV_common_init_mmx(s); |
8 | 284 #endif |
514
c9f724e3a797
Update and activate dct_unquantize_h263_mvi. Thanks to M«©ns Rullg«©rd
mellum
parents:
506
diff
changeset
|
285 #ifdef ARCH_ALPHA |
c9f724e3a797
Update and activate dct_unquantize_h263_mvi. Thanks to M«©ns Rullg«©rd
mellum
parents:
506
diff
changeset
|
286 MPV_common_init_axp(s); |
c9f724e3a797
Update and activate dct_unquantize_h263_mvi. Thanks to M«©ns Rullg«©rd
mellum
parents:
506
diff
changeset
|
287 #endif |
628
f596db4aa871
sun solaris compilation bugfix, patch by (Martin Olschewski <olschewski at zpr dot uni-koeln dot de>)
michaelni
parents:
625
diff
changeset
|
288 #ifdef HAVE_MLIB |
f596db4aa871
sun solaris compilation bugfix, patch by (Martin Olschewski <olschewski at zpr dot uni-koeln dot de>)
michaelni
parents:
625
diff
changeset
|
289 MPV_common_init_mlib(s); |
f596db4aa871
sun solaris compilation bugfix, patch by (Martin Olschewski <olschewski at zpr dot uni-koeln dot de>)
michaelni
parents:
625
diff
changeset
|
290 #endif |
721
71f669e9f633
ps2 optimizations update patch by (Leon van Stuivenberg <leonvs at iae dot nl>)
michaelni
parents:
717
diff
changeset
|
291 #ifdef HAVE_MMI |
71f669e9f633
ps2 optimizations update patch by (Leon van Stuivenberg <leonvs at iae dot nl>)
michaelni
parents:
717
diff
changeset
|
292 MPV_common_init_mmi(s); |
71f669e9f633
ps2 optimizations update patch by (Leon van Stuivenberg <leonvs at iae dot nl>)
michaelni
parents:
717
diff
changeset
|
293 #endif |
730 | 294 #ifdef ARCH_ARMV4L |
874 | 295 MPV_common_init_armv4l(s); |
730 | 296 #endif |
828
ace3ccd18dd2
Altivec Patch (Mark III) by (Dieter Shirley <dieters at schemasoft dot com>)
michaelni
parents:
815
diff
changeset
|
297 #ifdef ARCH_POWERPC |
ace3ccd18dd2
Altivec Patch (Mark III) by (Dieter Shirley <dieters at schemasoft dot com>)
michaelni
parents:
815
diff
changeset
|
298 MPV_common_init_ppc(s); |
ace3ccd18dd2
Altivec Patch (Mark III) by (Dieter Shirley <dieters at schemasoft dot com>)
michaelni
parents:
815
diff
changeset
|
299 #endif |
730 | 300 |
1070
6da5ae9ee199
more #ifdef CONFIG_ENCODERS patch by (Wolfgang Hesseler <qv at multimediaware dot com>) with modifications by me (s/WOLFGANG/CONFIG_ENCODERS/ and some other fixes)
michaelni
parents:
1064
diff
changeset
|
301 #ifdef CONFIG_ENCODERS |
1007 | 302 s->fast_dct_quantize= s->dct_quantize; |
303 | |
945 | 304 if(s->flags&CODEC_FLAG_TRELLIS_QUANT){ |
305 s->dct_quantize= dct_quantize_trellis_c; //move before MPV_common_init_* | |
306 } | |
307 | |
1070
6da5ae9ee199
more #ifdef CONFIG_ENCODERS patch by (Wolfgang Hesseler <qv at multimediaware dot com>) with modifications by me (s/WOLFGANG/CONFIG_ENCODERS/ and some other fixes)
michaelni
parents:
1064
diff
changeset
|
308 #endif //CONFIG_ENCODERS |
6da5ae9ee199
more #ifdef CONFIG_ENCODERS patch by (Wolfgang Hesseler <qv at multimediaware dot com>) with modifications by me (s/WOLFGANG/CONFIG_ENCODERS/ and some other fixes)
michaelni
parents:
1064
diff
changeset
|
309 |
706
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
310 /* load & permutate scantables |
2967 | 311 note: only wmv uses different ones |
706
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
312 */ |
1708 | 313 if(s->alternate_scan){ |
314 ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable , ff_alternate_vertical_scan); | |
315 ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable , ff_alternate_vertical_scan); | |
316 }else{ | |
317 ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable , ff_zigzag_direct); | |
318 ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable , ff_zigzag_direct); | |
319 } | |
1273 | 320 ff_init_scantable(s->dsp.idct_permutation, &s->intra_h_scantable, ff_alternate_horizontal_scan); |
321 ff_init_scantable(s->dsp.idct_permutation, &s->intra_v_scantable, ff_alternate_vertical_scan); | |
591 | 322 |
726
a91203b34e71
moved dct init out from mpv_common_init to dct_common_init (for less-uglier way for dv)
al3x
parents:
721
diff
changeset
|
323 return 0; |
a91203b34e71
moved dct init out from mpv_common_init to dct_common_init (for less-uglier way for dv)
al3x
parents:
721
diff
changeset
|
324 } |
a91203b34e71
moved dct init out from mpv_common_init to dct_common_init (for less-uglier way for dv)
al3x
parents:
721
diff
changeset
|
325 |
1539
14d01ccc0081
picture buffer cleanup, this fixes a assertion failure (if assertion checking was manualy enabled for utils.c) and a memleak at least
michael
parents:
1530
diff
changeset
|
326 static void copy_picture(Picture *dst, Picture *src){ |
14d01ccc0081
picture buffer cleanup, this fixes a assertion failure (if assertion checking was manualy enabled for utils.c) and a memleak at least
michael
parents:
1530
diff
changeset
|
327 *dst = *src; |
14d01ccc0081
picture buffer cleanup, this fixes a assertion failure (if assertion checking was manualy enabled for utils.c) and a memleak at least
michael
parents:
1530
diff
changeset
|
328 dst->type= FF_BUFFER_TYPE_COPY; |
14d01ccc0081
picture buffer cleanup, this fixes a assertion failure (if assertion checking was manualy enabled for utils.c) and a memleak at least
michael
parents:
1530
diff
changeset
|
329 } |
14d01ccc0081
picture buffer cleanup, this fixes a assertion failure (if assertion checking was manualy enabled for utils.c) and a memleak at least
michael
parents:
1530
diff
changeset
|
330 |
3777 | 331 #ifdef CONFIG_ENCODERS |
1938
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1918
diff
changeset
|
332 static void copy_picture_attributes(MpegEncContext *s, AVFrame *dst, AVFrame *src){ |
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1918
diff
changeset
|
333 int i; |
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1918
diff
changeset
|
334 |
1702 | 335 dst->pict_type = src->pict_type; |
336 dst->quality = src->quality; | |
337 dst->coded_picture_number = src->coded_picture_number; | |
338 dst->display_picture_number = src->display_picture_number; | |
339 // dst->reference = src->reference; | |
340 dst->pts = src->pts; | |
341 dst->interlaced_frame = src->interlaced_frame; | |
342 dst->top_field_first = src->top_field_first; | |
1938
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1918
diff
changeset
|
343 |
1945
32f68745c431
passing AVFrame instead of AVPicture around in ffmpeg, that way stuff like motion vectors can be passed from the decoder to the encoder
michael
parents:
1944
diff
changeset
|
344 if(s->avctx->me_threshold){ |
32f68745c431
passing AVFrame instead of AVPicture around in ffmpeg, that way stuff like motion vectors can be passed from the decoder to the encoder
michael
parents:
1944
diff
changeset
|
345 if(!src->motion_val[0]) |
32f68745c431
passing AVFrame instead of AVPicture around in ffmpeg, that way stuff like motion vectors can be passed from the decoder to the encoder
michael
parents:
1944
diff
changeset
|
346 av_log(s->avctx, AV_LOG_ERROR, "AVFrame.motion_val not set!\n"); |
32f68745c431
passing AVFrame instead of AVPicture around in ffmpeg, that way stuff like motion vectors can be passed from the decoder to the encoder
michael
parents:
1944
diff
changeset
|
347 if(!src->mb_type) |
32f68745c431
passing AVFrame instead of AVPicture around in ffmpeg, that way stuff like motion vectors can be passed from the decoder to the encoder
michael
parents:
1944
diff
changeset
|
348 av_log(s->avctx, AV_LOG_ERROR, "AVFrame.mb_type not set!\n"); |
32f68745c431
passing AVFrame instead of AVPicture around in ffmpeg, that way stuff like motion vectors can be passed from the decoder to the encoder
michael
parents:
1944
diff
changeset
|
349 if(!src->ref_index[0]) |
32f68745c431
passing AVFrame instead of AVPicture around in ffmpeg, that way stuff like motion vectors can be passed from the decoder to the encoder
michael
parents:
1944
diff
changeset
|
350 av_log(s->avctx, AV_LOG_ERROR, "AVFrame.ref_index not set!\n"); |
1938
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1918
diff
changeset
|
351 if(src->motion_subsample_log2 != dst->motion_subsample_log2) |
2627
bf158d23bbcc
Spelling errors patch by (Kevin Baragona | kevinmb500 gawab com)
michael
parents:
2620
diff
changeset
|
352 av_log(s->avctx, AV_LOG_ERROR, "AVFrame.motion_subsample_log2 doesn't match! (%d!=%d)\n", |
1955
5dafb10e0252
reuse motion vectors/mb types/field select values of the source video, if the SSE for a macroblock which is predicted with these values is below me_threshold
michael
parents:
1948
diff
changeset
|
353 src->motion_subsample_log2, dst->motion_subsample_log2); |
1945
32f68745c431
passing AVFrame instead of AVPicture around in ffmpeg, that way stuff like motion vectors can be passed from the decoder to the encoder
michael
parents:
1944
diff
changeset
|
354 |
32f68745c431
passing AVFrame instead of AVPicture around in ffmpeg, that way stuff like motion vectors can be passed from the decoder to the encoder
michael
parents:
1944
diff
changeset
|
355 memcpy(dst->mb_type, src->mb_type, s->mb_stride * s->mb_height * sizeof(dst->mb_type[0])); |
2967 | 356 |
1945
32f68745c431
passing AVFrame instead of AVPicture around in ffmpeg, that way stuff like motion vectors can be passed from the decoder to the encoder
michael
parents:
1944
diff
changeset
|
357 for(i=0; i<2; i++){ |
1938
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1918
diff
changeset
|
358 int stride= ((16*s->mb_width )>>src->motion_subsample_log2) + 1; |
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1918
diff
changeset
|
359 int height= ((16*s->mb_height)>>src->motion_subsample_log2); |
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1918
diff
changeset
|
360 |
1945
32f68745c431
passing AVFrame instead of AVPicture around in ffmpeg, that way stuff like motion vectors can be passed from the decoder to the encoder
michael
parents:
1944
diff
changeset
|
361 if(src->motion_val[i] && src->motion_val[i] != dst->motion_val[i]){ |
32f68745c431
passing AVFrame instead of AVPicture around in ffmpeg, that way stuff like motion vectors can be passed from the decoder to the encoder
michael
parents:
1944
diff
changeset
|
362 memcpy(dst->motion_val[i], src->motion_val[i], 2*stride*height*sizeof(int16_t)); |
32f68745c431
passing AVFrame instead of AVPicture around in ffmpeg, that way stuff like motion vectors can be passed from the decoder to the encoder
michael
parents:
1944
diff
changeset
|
363 } |
32f68745c431
passing AVFrame instead of AVPicture around in ffmpeg, that way stuff like motion vectors can be passed from the decoder to the encoder
michael
parents:
1944
diff
changeset
|
364 if(src->ref_index[i] && src->ref_index[i] != dst->ref_index[i]){ |
1948 | 365 memcpy(dst->ref_index[i], src->ref_index[i], s->b8_stride*2*s->mb_height*sizeof(int8_t)); |
1945
32f68745c431
passing AVFrame instead of AVPicture around in ffmpeg, that way stuff like motion vectors can be passed from the decoder to the encoder
michael
parents:
1944
diff
changeset
|
366 } |
1938
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1918
diff
changeset
|
367 } |
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1918
diff
changeset
|
368 } |
1702 | 369 } |
3777 | 370 #endif |
1702 | 371 |
903 | 372 /** |
924 | 373 * allocates a Picture |
374 * The pixels are allocated/set by calling get_buffer() if shared=0 | |
903 | 375 */ |
924 | 376 static int alloc_picture(MpegEncContext *s, Picture *pic, int shared){ |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1173
diff
changeset
|
377 const int big_mb_num= s->mb_stride*(s->mb_height+1) + 1; //the +1 is needed so memset(,,stride*height) doesnt sig11 |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1173
diff
changeset
|
378 const int mb_array_size= s->mb_stride*s->mb_height; |
1655 | 379 const int b8_array_size= s->b8_stride*s->mb_height*2; |
380 const int b4_array_size= s->b4_stride*s->mb_height*4; | |
1168 | 381 int i; |
2967 | 382 |
924 | 383 if(shared){ |
384 assert(pic->data[0]); | |
385 assert(pic->type == 0 || pic->type == FF_BUFFER_TYPE_SHARED); | |
386 pic->type= FF_BUFFER_TYPE_SHARED; | |
387 }else{ | |
388 int r; | |
2967 | 389 |
924 | 390 assert(!pic->data[0]); |
2967 | 391 |
925 | 392 r= s->avctx->get_buffer(s->avctx, (AVFrame*)pic); |
2967 | 393 |
924 | 394 if(r<0 || !pic->age || !pic->type || !pic->data[0]){ |
2979 | 395 av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed (%d %d %d %p)\n", r, pic->age, pic->type, pic->data[0]); |
924 | 396 return -1; |
397 } | |
398 | |
399 if(s->linesize && (s->linesize != pic->linesize[0] || s->uvlinesize != pic->linesize[1])){ | |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1597
diff
changeset
|
400 av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed (stride changed)\n"); |
924 | 401 return -1; |
402 } | |
403 | |
404 if(pic->linesize[1] != pic->linesize[2]){ | |
2764 | 405 av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed (uv stride mismatch)\n"); |
924 | 406 return -1; |
407 } | |
408 | |
409 s->linesize = pic->linesize[0]; | |
410 s->uvlinesize= pic->linesize[1]; | |
903 | 411 } |
2967 | 412 |
924 | 413 if(pic->qscale_table==NULL){ |
2967 | 414 if (s->encoding) { |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1173
diff
changeset
|
415 CHECKED_ALLOCZ(pic->mb_var , mb_array_size * sizeof(int16_t)) |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1173
diff
changeset
|
416 CHECKED_ALLOCZ(pic->mc_mb_var, mb_array_size * sizeof(int16_t)) |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1173
diff
changeset
|
417 CHECKED_ALLOCZ(pic->mb_mean , mb_array_size * sizeof(int8_t)) |
924 | 418 } |
419 | |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1173
diff
changeset
|
420 CHECKED_ALLOCZ(pic->mbskip_table , mb_array_size * sizeof(uint8_t)+2) //the +2 is for the slice end check |
1422
efeed6e29f9b
oooooops, having 2 Eterms open and doing cvs diff in one and cvs commit in the other sucks, especially if they are in different directories (MPlayer/main/libavcodec vs. ffmpeg/libavcodec)
michaelni
parents:
1421
diff
changeset
|
421 CHECKED_ALLOCZ(pic->qscale_table , mb_array_size * sizeof(uint8_t)) |
1742 | 422 CHECKED_ALLOCZ(pic->mb_type_base , big_mb_num * sizeof(uint32_t)) |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1173
diff
changeset
|
423 pic->mb_type= pic->mb_type_base + s->mb_stride+1; |
1168 | 424 if(s->out_format == FMT_H264){ |
425 for(i=0; i<2; i++){ | |
2570 | 426 CHECKED_ALLOCZ(pic->motion_val_base[i], 2 * (b4_array_size+4) * sizeof(int16_t)) |
427 pic->motion_val[i]= pic->motion_val_base[i]+4; | |
1948 | 428 CHECKED_ALLOCZ(pic->ref_index[i], b8_array_size * sizeof(uint8_t)) |
1655 | 429 } |
1669 | 430 pic->motion_subsample_log2= 2; |
1706
3ba5c493db6f
motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1705
diff
changeset
|
431 }else if(s->out_format == FMT_H263 || s->encoding || (s->avctx->debug&FF_DEBUG_MV) || (s->avctx->debug_mv)){ |
1655 | 432 for(i=0; i<2; i++){ |
2570 | 433 CHECKED_ALLOCZ(pic->motion_val_base[i], 2 * (b8_array_size+4) * sizeof(int16_t)) |
434 pic->motion_val[i]= pic->motion_val_base[i]+4; | |
1948 | 435 CHECKED_ALLOCZ(pic->ref_index[i], b8_array_size * sizeof(uint8_t)) |
1168 | 436 } |
1669 | 437 pic->motion_subsample_log2= 3; |
1168 | 438 } |
1833
ba27ce284d07
export DCT coefficients patch by (Wolfgang Hesseler <wolfgang.hesseler at imk dot fraunhofer dot de>)
michael
parents:
1831
diff
changeset
|
439 if(s->avctx->debug&FF_DEBUG_DCT_COEFF) { |
ba27ce284d07
export DCT coefficients patch by (Wolfgang Hesseler <wolfgang.hesseler at imk dot fraunhofer dot de>)
michael
parents:
1831
diff
changeset
|
440 CHECKED_ALLOCZ(pic->dct_coeff, 64 * mb_array_size * sizeof(DCTELEM)*6) |
ba27ce284d07
export DCT coefficients patch by (Wolfgang Hesseler <wolfgang.hesseler at imk dot fraunhofer dot de>)
michael
parents:
1831
diff
changeset
|
441 } |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1173
diff
changeset
|
442 pic->qstride= s->mb_stride; |
1546 | 443 CHECKED_ALLOCZ(pic->pan_scan , 1 * sizeof(AVPanScan)) |
924 | 444 } |
1168 | 445 |
1021
2d7c9f5738de
trying to fix mb skip bug in mpeg1/2 if slices are not used
michaelni
parents:
1014
diff
changeset
|
446 //it might be nicer if the application would keep track of these but it would require a API change |
2d7c9f5738de
trying to fix mb skip bug in mpeg1/2 if slices are not used
michaelni
parents:
1014
diff
changeset
|
447 memmove(s->prev_pict_types+1, s->prev_pict_types, PREV_PICT_TYPES_BUFFER_SIZE-1); |
2d7c9f5738de
trying to fix mb skip bug in mpeg1/2 if slices are not used
michaelni
parents:
1014
diff
changeset
|
448 s->prev_pict_types[0]= s->pict_type; |
2d7c9f5738de
trying to fix mb skip bug in mpeg1/2 if slices are not used
michaelni
parents:
1014
diff
changeset
|
449 if(pic->age < PREV_PICT_TYPES_BUFFER_SIZE && s->prev_pict_types[pic->age] == B_TYPE) |
2628
511e3afc43e1
Ministry of English Composition, reporting for duty (and the word is "skipped", not "skiped"; "skiped" would rhyme with "hyped")
melanson
parents:
2627
diff
changeset
|
450 pic->age= INT_MAX; // skipped MBs in b frames are quite rare in mpeg1/2 and its a bit tricky to skip them anyway |
2967 | 451 |
903 | 452 return 0; |
453 fail: //for the CHECKED_ALLOCZ macro | |
454 return -1; | |
455 } | |
456 | |
924 | 457 /** |
458 * deallocates a picture | |
459 */ | |
903 | 460 static void free_picture(MpegEncContext *s, Picture *pic){ |
461 int i; | |
924 | 462 |
463 if(pic->data[0] && pic->type!=FF_BUFFER_TYPE_SHARED){ | |
925 | 464 s->avctx->release_buffer(s->avctx, (AVFrame*)pic); |
924 | 465 } |
466 | |
903 | 467 av_freep(&pic->mb_var); |
468 av_freep(&pic->mc_mb_var); | |
469 av_freep(&pic->mb_mean); | |
470 av_freep(&pic->mbskip_table); | |
471 av_freep(&pic->qscale_table); | |
1168 | 472 av_freep(&pic->mb_type_base); |
1833
ba27ce284d07
export DCT coefficients patch by (Wolfgang Hesseler <wolfgang.hesseler at imk dot fraunhofer dot de>)
michael
parents:
1831
diff
changeset
|
473 av_freep(&pic->dct_coeff); |
1546 | 474 av_freep(&pic->pan_scan); |
1168 | 475 pic->mb_type= NULL; |
476 for(i=0; i<2; i++){ | |
1655 | 477 av_freep(&pic->motion_val_base[i]); |
1168 | 478 av_freep(&pic->ref_index[i]); |
479 } | |
2967 | 480 |
1214 | 481 if(pic->type == FF_BUFFER_TYPE_SHARED){ |
924 | 482 for(i=0; i<4; i++){ |
483 pic->base[i]= | |
484 pic->data[i]= NULL; | |
485 } | |
2967 | 486 pic->type= 0; |
903 | 487 } |
488 } | |
489 | |
1799 | 490 static int init_duplicate_context(MpegEncContext *s, MpegEncContext *base){ |
491 int i; | |
492 | |
2967 | 493 // edge emu needs blocksize + filter length - 1 (=17x17 for halfpel / 21x21 for h264) |
3316 | 494 CHECKED_ALLOCZ(s->allocated_edge_emu_buffer, (s->width+64)*2*21*2); //(width + edge + align)*interlaced*MBsize*tolerance |
495 s->edge_emu_buffer= s->allocated_edge_emu_buffer + (s->width+64)*2*21; | |
1799 | 496 |
497 //FIXME should be linesize instead of s->width*2 but that isnt known before get_buffer() | |
2967 | 498 CHECKED_ALLOCZ(s->me.scratchpad, (s->width+64)*4*16*2*sizeof(uint8_t)) |
1799 | 499 s->rd_scratchpad= s->me.scratchpad; |
500 s->b_scratchpad= s->me.scratchpad; | |
501 s->obmc_scratchpad= s->me.scratchpad + 16; | |
502 if (s->encoding) { | |
503 CHECKED_ALLOCZ(s->me.map , ME_MAP_SIZE*sizeof(uint32_t)) | |
504 CHECKED_ALLOCZ(s->me.score_map, ME_MAP_SIZE*sizeof(uint32_t)) | |
505 if(s->avctx->noise_reduction){ | |
506 CHECKED_ALLOCZ(s->dct_error_sum, 2 * 64 * sizeof(int)) | |
507 } | |
2967 | 508 } |
1848
c72589baee53
initial chroma_format changes,xvmc tweaks and codec_cap
iive
parents:
1846
diff
changeset
|
509 CHECKED_ALLOCZ(s->blocks, 64*12*2 * sizeof(DCTELEM)) |
1799 | 510 s->block= s->blocks[0]; |
511 | |
512 for(i=0;i<12;i++){ | |
513 s->pblocks[i] = (short *)(&s->block[i]); | |
514 } | |
515 return 0; | |
516 fail: | |
517 return -1; //free() through MPV_common_end() | |
518 } | |
519 | |
520 static void free_duplicate_context(MpegEncContext *s){ | |
521 if(s==NULL) return; | |
522 | |
523 av_freep(&s->allocated_edge_emu_buffer); s->edge_emu_buffer= NULL; | |
524 av_freep(&s->me.scratchpad); | |
2967 | 525 s->rd_scratchpad= |
526 s->b_scratchpad= | |
1799 | 527 s->obmc_scratchpad= NULL; |
2967 | 528 |
1799 | 529 av_freep(&s->dct_error_sum); |
530 av_freep(&s->me.map); | |
531 av_freep(&s->me.score_map); | |
532 av_freep(&s->blocks); | |
533 s->block= NULL; | |
534 } | |
535 | |
536 static void backup_duplicate_context(MpegEncContext *bak, MpegEncContext *src){ | |
537 #define COPY(a) bak->a= src->a | |
538 COPY(allocated_edge_emu_buffer); | |
539 COPY(edge_emu_buffer); | |
540 COPY(me.scratchpad); | |
541 COPY(rd_scratchpad); | |
542 COPY(b_scratchpad); | |
543 COPY(obmc_scratchpad); | |
544 COPY(me.map); | |
545 COPY(me.score_map); | |
546 COPY(blocks); | |
547 COPY(block); | |
548 COPY(start_mb_y); | |
549 COPY(end_mb_y); | |
550 COPY(me.map_generation); | |
551 COPY(pb); | |
552 COPY(dct_error_sum); | |
1810 | 553 COPY(dct_count[0]); |
554 COPY(dct_count[1]); | |
1799 | 555 #undef COPY |
556 } | |
557 | |
1827 | 558 void ff_update_duplicate_context(MpegEncContext *dst, MpegEncContext *src){ |
1799 | 559 MpegEncContext bak; |
1827 | 560 int i; |
1799 | 561 //FIXME copy only needed parts |
562 //START_TIMER | |
563 backup_duplicate_context(&bak, dst); | |
564 memcpy(dst, src, sizeof(MpegEncContext)); | |
565 backup_duplicate_context(dst, &bak); | |
1827 | 566 for(i=0;i<12;i++){ |
567 dst->pblocks[i] = (short *)(&dst->block[i]); | |
568 } | |
1799 | 569 //STOP_TIMER("update_duplicate_context") //about 10k cycles / 0.01 sec for 1000frames on 1ghz with 2 threads |
570 } | |
571 | |
3777 | 572 #ifdef CONFIG_ENCODERS |
1799 | 573 static void update_duplicate_context_after_me(MpegEncContext *dst, MpegEncContext *src){ |
574 #define COPY(a) dst->a= src->a | |
575 COPY(pict_type); | |
576 COPY(current_picture); | |
577 COPY(f_code); | |
578 COPY(b_code); | |
579 COPY(qscale); | |
580 COPY(lambda); | |
581 COPY(lambda2); | |
582 COPY(picture_in_gop_number); | |
583 COPY(gop_picture_number); | |
2764 | 584 COPY(frame_pred_frame_dct); //FIXME don't set in encode_header |
585 COPY(progressive_frame); //FIXME don't set in encode_header | |
586 COPY(partitioned_frame); //FIXME don't set in encode_header | |
1799 | 587 #undef COPY |
588 } | |
3777 | 589 #endif |
1799 | 590 |
1892 | 591 /** |
592 * sets the given MpegEncContext to common defaults (same for encoding and decoding). | |
593 * the changed fields will not depend upon the prior state of the MpegEncContext. | |
594 */ | |
595 static void MPV_common_defaults(MpegEncContext *s){ | |
596 s->y_dc_scale_table= | |
597 s->c_dc_scale_table= ff_mpeg1_dc_scale_table; | |
598 s->chroma_qscale_table= ff_default_chroma_qscale_table; | |
599 s->progressive_frame= 1; | |
600 s->progressive_sequence= 1; | |
601 s->picture_structure= PICT_FRAME; | |
602 | |
603 s->coded_picture_number = 0; | |
604 s->picture_number = 0; | |
605 s->input_picture_number = 0; | |
606 | |
607 s->picture_in_gop_number = 0; | |
1894 | 608 |
609 s->f_code = 1; | |
610 s->b_code = 1; | |
1892 | 611 } |
612 | |
613 /** | |
614 * sets the given MpegEncContext to defaults for decoding. | |
615 * the changed fields will not depend upon the prior state of the MpegEncContext. | |
616 */ | |
617 void MPV_decode_defaults(MpegEncContext *s){ | |
618 MPV_common_defaults(s); | |
619 } | |
620 | |
621 /** | |
622 * sets the given MpegEncContext to defaults for encoding. | |
623 * the changed fields will not depend upon the prior state of the MpegEncContext. | |
624 */ | |
1902
a5588762c4fa
Compile fix by (Chip <szarlada at freemail dot hu>)
michael
parents:
1894
diff
changeset
|
625 |
a5588762c4fa
Compile fix by (Chip <szarlada at freemail dot hu>)
michael
parents:
1894
diff
changeset
|
626 #ifdef CONFIG_ENCODERS |
2024
f65d87bfdd5a
some of the warning fixes by (Michael Roitzsch <mroi at users dot sourceforge dot net>)
michael
parents:
2015
diff
changeset
|
627 static void MPV_encode_defaults(MpegEncContext *s){ |
1892 | 628 static int done=0; |
2967 | 629 |
1892 | 630 MPV_common_defaults(s); |
2967 | 631 |
1892 | 632 if(!done){ |
633 int i; | |
634 done=1; | |
635 | |
636 default_mv_penalty= av_mallocz( sizeof(uint8_t)*(MAX_FCODE+1)*(2*MAX_MV+1) ); | |
637 memset(default_fcode_tab , 0, sizeof(uint8_t)*(2*MAX_MV+1)); | |
638 | |
639 for(i=-16; i<16; i++){ | |
640 default_fcode_tab[i + MAX_MV]= 1; | |
641 } | |
642 } | |
643 s->me.mv_penalty= default_mv_penalty; | |
644 s->fcode_tab= default_fcode_tab; | |
645 } | |
1902
a5588762c4fa
Compile fix by (Chip <szarlada at freemail dot hu>)
michael
parents:
1894
diff
changeset
|
646 #endif //CONFIG_ENCODERS |
1892 | 647 |
2967 | 648 /** |
1892 | 649 * init common structure for both encoder and decoder. |
650 * this assumes that some variables like width/height are already set | |
651 */ | |
726
a91203b34e71
moved dct init out from mpv_common_init to dct_common_init (for less-uglier way for dv)
al3x
parents:
721
diff
changeset
|
652 int MPV_common_init(MpegEncContext *s) |
a91203b34e71
moved dct init out from mpv_common_init to dct_common_init (for less-uglier way for dv)
al3x
parents:
721
diff
changeset
|
653 { |
1708 | 654 int y_size, c_size, yc_size, i, mb_array_size, mv_table_size, x, y; |
726
a91203b34e71
moved dct init out from mpv_common_init to dct_common_init (for less-uglier way for dv)
al3x
parents:
721
diff
changeset
|
655 |
3070 | 656 s->mb_height = (s->height + 15) / 16; |
657 | |
658 if(s->avctx->thread_count > MAX_THREADS || (s->avctx->thread_count > s->mb_height && s->mb_height)){ | |
1989 | 659 av_log(s->avctx, AV_LOG_ERROR, "too many threads\n"); |
660 return -1; | |
661 } | |
662 | |
2422 | 663 if((s->width || s->height) && avcodec_check_dimensions(s->avctx, s->width, s->height)) |
664 return -1; | |
665 | |
1092 | 666 dsputil_init(&s->dsp, s->avctx); |
726
a91203b34e71
moved dct init out from mpv_common_init to dct_common_init (for less-uglier way for dv)
al3x
parents:
721
diff
changeset
|
667 DCT_common_init(s); |
853
eacc2dd8fd9d
* using DSPContext - so each codec could use its local (sub)set of CPU extension
kabi
parents:
847
diff
changeset
|
668 |
754 | 669 s->flags= s->avctx->flags; |
1754
bdf3927bf8c5
closed gop support & flags2 as all bits in flags are used
michael
parents:
1751
diff
changeset
|
670 s->flags2= s->avctx->flags2; |
726
a91203b34e71
moved dct init out from mpv_common_init to dct_common_init (for less-uglier way for dv)
al3x
parents:
721
diff
changeset
|
671 |
903 | 672 s->mb_width = (s->width + 15) / 16; |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1173
diff
changeset
|
673 s->mb_stride = s->mb_width + 1; |
1655 | 674 s->b8_stride = s->mb_width*2 + 1; |
675 s->b4_stride = s->mb_width*4 + 1; | |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1173
diff
changeset
|
676 mb_array_size= s->mb_height * s->mb_stride; |
1708 | 677 mv_table_size= (s->mb_height+2) * s->mb_stride + 1; |
853
eacc2dd8fd9d
* using DSPContext - so each codec could use its local (sub)set of CPU extension
kabi
parents:
847
diff
changeset
|
678 |
2074
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
679 /* set chroma shifts */ |
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
680 avcodec_get_chroma_sub_sample(s->avctx->pix_fmt,&(s->chroma_x_shift), |
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
681 &(s->chroma_y_shift) ); |
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
682 |
853
eacc2dd8fd9d
* using DSPContext - so each codec could use its local (sub)set of CPU extension
kabi
parents:
847
diff
changeset
|
683 /* set default edge pos, will be overriden in decode_header if needed */ |
eacc2dd8fd9d
* using DSPContext - so each codec could use its local (sub)set of CPU extension
kabi
parents:
847
diff
changeset
|
684 s->h_edge_pos= s->mb_width*16; |
eacc2dd8fd9d
* using DSPContext - so each codec could use its local (sub)set of CPU extension
kabi
parents:
847
diff
changeset
|
685 s->v_edge_pos= s->mb_height*16; |
eacc2dd8fd9d
* using DSPContext - so each codec could use its local (sub)set of CPU extension
kabi
parents:
847
diff
changeset
|
686 |
eacc2dd8fd9d
* using DSPContext - so each codec could use its local (sub)set of CPU extension
kabi
parents:
847
diff
changeset
|
687 s->mb_num = s->mb_width * s->mb_height; |
2967 | 688 |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1173
diff
changeset
|
689 s->block_wrap[0]= |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1173
diff
changeset
|
690 s->block_wrap[1]= |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1173
diff
changeset
|
691 s->block_wrap[2]= |
1938
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1918
diff
changeset
|
692 s->block_wrap[3]= s->b8_stride; |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1173
diff
changeset
|
693 s->block_wrap[4]= |
1938
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1918
diff
changeset
|
694 s->block_wrap[5]= s->mb_stride; |
2967 | 695 |
1938
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1918
diff
changeset
|
696 y_size = s->b8_stride * (2 * s->mb_height + 1); |
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1918
diff
changeset
|
697 c_size = s->mb_stride * (s->mb_height + 1); |
756 | 698 yc_size = y_size + 2 * c_size; |
2967 | 699 |
701 | 700 /* convert fourcc to upper case */ |
4155
0f28fc219799
add codec_tag and codec_stream_tag to MpegEncContext to not alter avctx values
bcoudurier
parents:
4122
diff
changeset
|
701 s->codec_tag= toupper( s->avctx->codec_tag &0xFF) |
1116 | 702 + (toupper((s->avctx->codec_tag>>8 )&0xFF)<<8 ) |
2967 | 703 + (toupper((s->avctx->codec_tag>>16)&0xFF)<<16) |
1116 | 704 + (toupper((s->avctx->codec_tag>>24)&0xFF)<<24); |
582
5132a4ee50cd
different edge positions fixed with edge emu / dr1
michaelni
parents:
575
diff
changeset
|
705 |
4155
0f28fc219799
add codec_tag and codec_stream_tag to MpegEncContext to not alter avctx values
bcoudurier
parents:
4122
diff
changeset
|
706 s->stream_codec_tag= toupper( s->avctx->stream_codec_tag &0xFF) |
1458
40b69d238beb
AVI stream header FCC / more reliable detection of old xvid files
michaelni
parents:
1451
diff
changeset
|
707 + (toupper((s->avctx->stream_codec_tag>>8 )&0xFF)<<8 ) |
2967 | 708 + (toupper((s->avctx->stream_codec_tag>>16)&0xFF)<<16) |
1458
40b69d238beb
AVI stream header FCC / more reliable detection of old xvid files
michaelni
parents:
1451
diff
changeset
|
709 + (toupper((s->avctx->stream_codec_tag>>24)&0xFF)<<24); |
40b69d238beb
AVI stream header FCC / more reliable detection of old xvid files
michaelni
parents:
1451
diff
changeset
|
710 |
925 | 711 s->avctx->coded_frame= (AVFrame*)&s->current_picture; |
903 | 712 |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1173
diff
changeset
|
713 CHECKED_ALLOCZ(s->mb_index2xy, (s->mb_num+1)*sizeof(int)) //error ressilience code looks cleaner with this |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1173
diff
changeset
|
714 for(y=0; y<s->mb_height; y++){ |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1173
diff
changeset
|
715 for(x=0; x<s->mb_width; x++){ |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1173
diff
changeset
|
716 s->mb_index2xy[ x + y*s->mb_width ] = x + y*s->mb_stride; |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1173
diff
changeset
|
717 } |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1173
diff
changeset
|
718 } |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1173
diff
changeset
|
719 s->mb_index2xy[ s->mb_height*s->mb_width ] = (s->mb_height-1)*s->mb_stride + s->mb_width; //FIXME really needed? |
2967 | 720 |
232
b640ec5948b0
- Now the ME is done for the entire picture when enconding, the
pulento
parents:
231
diff
changeset
|
721 if (s->encoding) { |
324 | 722 /* Allocate MV tables */ |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1173
diff
changeset
|
723 CHECKED_ALLOCZ(s->p_mv_table_base , mv_table_size * 2 * sizeof(int16_t)) |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1173
diff
changeset
|
724 CHECKED_ALLOCZ(s->b_forw_mv_table_base , mv_table_size * 2 * sizeof(int16_t)) |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1173
diff
changeset
|
725 CHECKED_ALLOCZ(s->b_back_mv_table_base , mv_table_size * 2 * sizeof(int16_t)) |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1173
diff
changeset
|
726 CHECKED_ALLOCZ(s->b_bidir_forw_mv_table_base , mv_table_size * 2 * sizeof(int16_t)) |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1173
diff
changeset
|
727 CHECKED_ALLOCZ(s->b_bidir_back_mv_table_base , mv_table_size * 2 * sizeof(int16_t)) |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1173
diff
changeset
|
728 CHECKED_ALLOCZ(s->b_direct_mv_table_base , mv_table_size * 2 * sizeof(int16_t)) |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1173
diff
changeset
|
729 s->p_mv_table = s->p_mv_table_base + s->mb_stride + 1; |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1173
diff
changeset
|
730 s->b_forw_mv_table = s->b_forw_mv_table_base + s->mb_stride + 1; |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1173
diff
changeset
|
731 s->b_back_mv_table = s->b_back_mv_table_base + s->mb_stride + 1; |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1173
diff
changeset
|
732 s->b_bidir_forw_mv_table= s->b_bidir_forw_mv_table_base + s->mb_stride + 1; |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1173
diff
changeset
|
733 s->b_bidir_back_mv_table= s->b_bidir_back_mv_table_base + s->mb_stride + 1; |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1173
diff
changeset
|
734 s->b_direct_mv_table = s->b_direct_mv_table_base + s->mb_stride + 1; |
324 | 735 |
650
ef4a33aad86e
reducing sizeof MpegEncContext to avoid stack overflow on crap M$ windo$
michaelni
parents:
635
diff
changeset
|
736 if(s->msmpeg4_version){ |
ef4a33aad86e
reducing sizeof MpegEncContext to avoid stack overflow on crap M$ windo$
michaelni
parents:
635
diff
changeset
|
737 CHECKED_ALLOCZ(s->ac_stats, 2*2*(MAX_LEVEL+1)*(MAX_RUN+1)*2*sizeof(int)); |
ef4a33aad86e
reducing sizeof MpegEncContext to avoid stack overflow on crap M$ windo$
michaelni
parents:
635
diff
changeset
|
738 } |
612 | 739 CHECKED_ALLOCZ(s->avctx->stats_out, 256); |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1173
diff
changeset
|
740 |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1173
diff
changeset
|
741 /* Allocate MB type table */ |
1708 | 742 CHECKED_ALLOCZ(s->mb_type , mb_array_size * sizeof(uint16_t)) //needed for encoding |
2967 | 743 |
1505
010f76d07a27
use lagrange multipler instead of qp for ratecontrol, this may break some things, tell me ASAP if u notice anything broken
michaelni
parents:
1497
diff
changeset
|
744 CHECKED_ALLOCZ(s->lambda_table, mb_array_size * sizeof(int)) |
2967 | 745 |
1553
541681146f83
move q_*_matrix out of MpegEncContext (40k ->23k) dct_quantize() is even slightly faster now, dont ask my why ...
michael
parents:
1552
diff
changeset
|
746 CHECKED_ALLOCZ(s->q_intra_matrix, 64*32 * sizeof(int)) |
541681146f83
move q_*_matrix out of MpegEncContext (40k ->23k) dct_quantize() is even slightly faster now, dont ask my why ...
michael
parents:
1552
diff
changeset
|
747 CHECKED_ALLOCZ(s->q_inter_matrix, 64*32 * sizeof(int)) |
1554
d736e24bf303
move mmx quantizer matrixes out of MpegEncContext (23k -> 7k) (no meassureable slowdown)
michael
parents:
1553
diff
changeset
|
748 CHECKED_ALLOCZ(s->q_intra_matrix16, 64*32*2 * sizeof(uint16_t)) |
d736e24bf303
move mmx quantizer matrixes out of MpegEncContext (23k -> 7k) (no meassureable slowdown)
michael
parents:
1553
diff
changeset
|
749 CHECKED_ALLOCZ(s->q_inter_matrix16, 64*32*2 * sizeof(uint16_t)) |
1556 | 750 CHECKED_ALLOCZ(s->input_picture, MAX_PICTURE_COUNT * sizeof(Picture*)) |
751 CHECKED_ALLOCZ(s->reordered_input_picture, MAX_PICTURE_COUNT * sizeof(Picture*)) | |
2967 | 752 |
1597 | 753 if(s->avctx->noise_reduction){ |
754 CHECKED_ALLOCZ(s->dct_offset, 2 * 64 * sizeof(uint16_t)) | |
755 } | |
232
b640ec5948b0
- Now the ME is done for the entire picture when enconding, the
pulento
parents:
231
diff
changeset
|
756 } |
1552
26c6ecba99a1
dynamic alloc of picture structs instead of putting them in MpegEncContext
michael
parents:
1546
diff
changeset
|
757 CHECKED_ALLOCZ(s->picture, MAX_PICTURE_COUNT * sizeof(Picture)) |
26c6ecba99a1
dynamic alloc of picture structs instead of putting them in MpegEncContext
michael
parents:
1546
diff
changeset
|
758 |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1173
diff
changeset
|
759 CHECKED_ALLOCZ(s->error_status_table, mb_array_size*sizeof(uint8_t)) |
2967 | 760 |
1708 | 761 if(s->codec_id==CODEC_ID_MPEG4 || (s->flags & CODEC_FLAG_INTERLACED_ME)){ |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
731
diff
changeset
|
762 /* interlaced direct mode decoding tables */ |
1708 | 763 for(i=0; i<2; i++){ |
764 int j, k; | |
765 for(j=0; j<2; j++){ | |
766 for(k=0; k<2; k++){ | |
767 CHECKED_ALLOCZ(s->b_field_mv_table_base[i][j][k] , mv_table_size * 2 * sizeof(int16_t)) | |
768 s->b_field_mv_table[i][j][k] = s->b_field_mv_table_base[i][j][k] + s->mb_stride + 1; | |
769 } | |
770 CHECKED_ALLOCZ(s->b_field_select_table[i][j] , mb_array_size * 2 * sizeof(uint8_t)) | |
771 CHECKED_ALLOCZ(s->p_field_mv_table_base[i][j] , mv_table_size * 2 * sizeof(int16_t)) | |
772 s->p_field_mv_table[i][j] = s->p_field_mv_table_base[i][j] + s->mb_stride + 1; | |
773 } | |
774 CHECKED_ALLOCZ(s->p_field_select_table[i] , mb_array_size * 2 * sizeof(uint8_t)) | |
775 } | |
0 | 776 } |
767 | 777 if (s->out_format == FMT_H263) { |
0 | 778 /* ac values */ |
1938
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1918
diff
changeset
|
779 CHECKED_ALLOCZ(s->ac_val_base, yc_size * sizeof(int16_t) * 16); |
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1918
diff
changeset
|
780 s->ac_val[0] = s->ac_val_base + s->b8_stride + 1; |
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1918
diff
changeset
|
781 s->ac_val[1] = s->ac_val_base + y_size + s->mb_stride + 1; |
0 | 782 s->ac_val[2] = s->ac_val[1] + c_size; |
2967 | 783 |
0 | 784 /* cbp values */ |
1938
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1918
diff
changeset
|
785 CHECKED_ALLOCZ(s->coded_block_base, y_size); |
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1918
diff
changeset
|
786 s->coded_block= s->coded_block_base + s->b8_stride + 1; |
2967 | 787 |
456 | 788 /* cbp, ac_pred, pred_dir */ |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1173
diff
changeset
|
789 CHECKED_ALLOCZ(s->cbp_table , mb_array_size * sizeof(uint8_t)) |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1173
diff
changeset
|
790 CHECKED_ALLOCZ(s->pred_dir_table, mb_array_size * sizeof(uint8_t)) |
197
21abf1b20016
different fix, s->mbintra_table used only if h263_pred set. - patch by Michael Niedermayer <michaelni@gmx.at>
arpi_esp
parents:
196
diff
changeset
|
791 } |
2967 | 792 |
756 | 793 if (s->h263_pred || s->h263_plus || !s->encoding) { |
794 /* dc values */ | |
795 //MN: we need these for error resilience of intra-frames | |
1938
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1918
diff
changeset
|
796 CHECKED_ALLOCZ(s->dc_val_base, yc_size * sizeof(int16_t)); |
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1918
diff
changeset
|
797 s->dc_val[0] = s->dc_val_base + s->b8_stride + 1; |
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1918
diff
changeset
|
798 s->dc_val[1] = s->dc_val_base + y_size + s->mb_stride + 1; |
756 | 799 s->dc_val[2] = s->dc_val[1] + c_size; |
800 for(i=0;i<yc_size;i++) | |
1938
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1918
diff
changeset
|
801 s->dc_val_base[i] = 1024; |
756 | 802 } |
803 | |
611
3214d3f4519e
error concealment needs the mbintra_table so it should allways be allocated
michaelni
parents:
608
diff
changeset
|
804 /* which mb is a intra block */ |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1173
diff
changeset
|
805 CHECKED_ALLOCZ(s->mbintra_table, mb_array_size); |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1173
diff
changeset
|
806 memset(s->mbintra_table, 1, mb_array_size); |
2967 | 807 |
7
1d3ac9654178
added skip macroblock optimization (big perf win on black regions for example)
glantau
parents:
0
diff
changeset
|
808 /* init macroblock skip table */ |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1173
diff
changeset
|
809 CHECKED_ALLOCZ(s->mbskip_table, mb_array_size+2); |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
731
diff
changeset
|
810 //Note the +1 is for a quicker mpeg4 slice_end detection |
1021
2d7c9f5738de
trying to fix mb skip bug in mpeg1/2 if slices are not used
michaelni
parents:
1014
diff
changeset
|
811 CHECKED_ALLOCZ(s->prev_pict_types, PREV_PICT_TYPES_BUFFER_SIZE); |
2967 | 812 |
842
e460775adb38
cleanup (breaks compatibility, requested by fabrice)
michaelni
parents:
828
diff
changeset
|
813 s->parse_context.state= -1; |
1706
3ba5c493db6f
motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1705
diff
changeset
|
814 if((s->avctx->debug&(FF_DEBUG_VIS_QP|FF_DEBUG_VIS_MB_TYPE)) || (s->avctx->debug_mv)){ |
3ba5c493db6f
motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1705
diff
changeset
|
815 s->visualization_buffer[0] = av_malloc((s->mb_width*16 + 2*EDGE_WIDTH) * s->mb_height*16 + 2*EDGE_WIDTH); |
3ba5c493db6f
motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1705
diff
changeset
|
816 s->visualization_buffer[1] = av_malloc((s->mb_width*8 + EDGE_WIDTH) * s->mb_height*8 + EDGE_WIDTH); |
3ba5c493db6f
motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1705
diff
changeset
|
817 s->visualization_buffer[2] = av_malloc((s->mb_width*8 + EDGE_WIDTH) * s->mb_height*8 + EDGE_WIDTH); |
3ba5c493db6f
motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1705
diff
changeset
|
818 } |
842
e460775adb38
cleanup (breaks compatibility, requested by fabrice)
michaelni
parents:
828
diff
changeset
|
819 |
0 | 820 s->context_initialized = 1; |
1799 | 821 |
822 s->thread_context[0]= s; | |
823 for(i=1; i<s->avctx->thread_count; i++){ | |
824 s->thread_context[i]= av_malloc(sizeof(MpegEncContext)); | |
825 memcpy(s->thread_context[i], s, sizeof(MpegEncContext)); | |
826 } | |
827 | |
828 for(i=0; i<s->avctx->thread_count; i++){ | |
829 if(init_duplicate_context(s->thread_context[i], s) < 0) | |
830 goto fail; | |
831 s->thread_context[i]->start_mb_y= (s->mb_height*(i ) + s->avctx->thread_count/2) / s->avctx->thread_count; | |
832 s->thread_context[i]->end_mb_y = (s->mb_height*(i+1) + s->avctx->thread_count/2) / s->avctx->thread_count; | |
833 } | |
834 | |
0 | 835 return 0; |
836 fail: | |
244 | 837 MPV_common_end(s); |
838 return -1; | |
839 } | |
840 | |
841 /* init common structure for both encoder and decoder */ | |
842 void MPV_common_end(MpegEncContext *s) | |
843 { | |
1708 | 844 int i, j, k; |
244 | 845 |
1799 | 846 for(i=0; i<s->avctx->thread_count; i++){ |
847 free_duplicate_context(s->thread_context[i]); | |
848 } | |
849 for(i=1; i<s->avctx->thread_count; i++){ | |
850 av_freep(&s->thread_context[i]); | |
851 } | |
852 | |
1344
447b88b784ee
memleak fix by (Jake Page <jake at CS dot Stanford dot EDU>)
michaelni
parents:
1339
diff
changeset
|
853 av_freep(&s->parse_context.buffer); |
447b88b784ee
memleak fix by (Jake Page <jake at CS dot Stanford dot EDU>)
michaelni
parents:
1339
diff
changeset
|
854 s->parse_context.buffer_size=0; |
447b88b784ee
memleak fix by (Jake Page <jake at CS dot Stanford dot EDU>)
michaelni
parents:
1339
diff
changeset
|
855 |
396
fce0a2520551
removed useless header includes - use av memory functions
glantau
parents:
376
diff
changeset
|
856 av_freep(&s->mb_type); |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1173
diff
changeset
|
857 av_freep(&s->p_mv_table_base); |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1173
diff
changeset
|
858 av_freep(&s->b_forw_mv_table_base); |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1173
diff
changeset
|
859 av_freep(&s->b_back_mv_table_base); |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1173
diff
changeset
|
860 av_freep(&s->b_bidir_forw_mv_table_base); |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1173
diff
changeset
|
861 av_freep(&s->b_bidir_back_mv_table_base); |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1173
diff
changeset
|
862 av_freep(&s->b_direct_mv_table_base); |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1173
diff
changeset
|
863 s->p_mv_table= NULL; |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1173
diff
changeset
|
864 s->b_forw_mv_table= NULL; |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1173
diff
changeset
|
865 s->b_back_mv_table= NULL; |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1173
diff
changeset
|
866 s->b_bidir_forw_mv_table= NULL; |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1173
diff
changeset
|
867 s->b_bidir_back_mv_table= NULL; |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1173
diff
changeset
|
868 s->b_direct_mv_table= NULL; |
1708 | 869 for(i=0; i<2; i++){ |
870 for(j=0; j<2; j++){ | |
871 for(k=0; k<2; k++){ | |
872 av_freep(&s->b_field_mv_table_base[i][j][k]); | |
873 s->b_field_mv_table[i][j][k]=NULL; | |
874 } | |
875 av_freep(&s->b_field_select_table[i][j]); | |
876 av_freep(&s->p_field_mv_table_base[i][j]); | |
877 s->p_field_mv_table[i][j]=NULL; | |
878 } | |
879 av_freep(&s->p_field_select_table[i]); | |
880 } | |
2967 | 881 |
1938
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1918
diff
changeset
|
882 av_freep(&s->dc_val_base); |
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1918
diff
changeset
|
883 av_freep(&s->ac_val_base); |
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1918
diff
changeset
|
884 av_freep(&s->coded_block_base); |
396
fce0a2520551
removed useless header includes - use av memory functions
glantau
parents:
376
diff
changeset
|
885 av_freep(&s->mbintra_table); |
456 | 886 av_freep(&s->cbp_table); |
887 av_freep(&s->pred_dir_table); | |
2967 | 888 |
396
fce0a2520551
removed useless header includes - use av memory functions
glantau
parents:
376
diff
changeset
|
889 av_freep(&s->mbskip_table); |
1021
2d7c9f5738de
trying to fix mb skip bug in mpeg1/2 if slices are not used
michaelni
parents:
1014
diff
changeset
|
890 av_freep(&s->prev_pict_types); |
396
fce0a2520551
removed useless header includes - use av memory functions
glantau
parents:
376
diff
changeset
|
891 av_freep(&s->bitstream_buffer); |
2422 | 892 s->allocated_bitstream_buffer_size=0; |
893 | |
612 | 894 av_freep(&s->avctx->stats_out); |
650
ef4a33aad86e
reducing sizeof MpegEncContext to avoid stack overflow on crap M$ windo$
michaelni
parents:
635
diff
changeset
|
895 av_freep(&s->ac_stats); |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
731
diff
changeset
|
896 av_freep(&s->error_status_table); |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1173
diff
changeset
|
897 av_freep(&s->mb_index2xy); |
1505
010f76d07a27
use lagrange multipler instead of qp for ratecontrol, this may break some things, tell me ASAP if u notice anything broken
michaelni
parents:
1497
diff
changeset
|
898 av_freep(&s->lambda_table); |
1553
541681146f83
move q_*_matrix out of MpegEncContext (40k ->23k) dct_quantize() is even slightly faster now, dont ask my why ...
michael
parents:
1552
diff
changeset
|
899 av_freep(&s->q_intra_matrix); |
541681146f83
move q_*_matrix out of MpegEncContext (40k ->23k) dct_quantize() is even slightly faster now, dont ask my why ...
michael
parents:
1552
diff
changeset
|
900 av_freep(&s->q_inter_matrix); |
1554
d736e24bf303
move mmx quantizer matrixes out of MpegEncContext (23k -> 7k) (no meassureable slowdown)
michael
parents:
1553
diff
changeset
|
901 av_freep(&s->q_intra_matrix16); |
d736e24bf303
move mmx quantizer matrixes out of MpegEncContext (23k -> 7k) (no meassureable slowdown)
michael
parents:
1553
diff
changeset
|
902 av_freep(&s->q_inter_matrix16); |
1556 | 903 av_freep(&s->input_picture); |
904 av_freep(&s->reordered_input_picture); | |
1597 | 905 av_freep(&s->dct_offset); |
903 | 906 |
1573 | 907 if(s->picture){ |
908 for(i=0; i<MAX_PICTURE_COUNT; i++){ | |
909 free_picture(s, &s->picture[i]); | |
910 } | |
0 | 911 } |
1552
26c6ecba99a1
dynamic alloc of picture structs instead of putting them in MpegEncContext
michael
parents:
1546
diff
changeset
|
912 av_freep(&s->picture); |
0 | 913 s->context_initialized = 0; |
1523 | 914 s->last_picture_ptr= |
915 s->next_picture_ptr= | |
916 s->current_picture_ptr= NULL; | |
2231 | 917 s->linesize= s->uvlinesize= 0; |
1918
ea20f38b8d57
nicer looking arrows for the motion vector vissualization
michael
parents:
1916
diff
changeset
|
918 |
1706
3ba5c493db6f
motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1705
diff
changeset
|
919 for(i=0; i<3; i++) |
1918
ea20f38b8d57
nicer looking arrows for the motion vector vissualization
michael
parents:
1916
diff
changeset
|
920 av_freep(&s->visualization_buffer[i]); |
2231 | 921 |
922 avcodec_default_free_buffers(s->avctx); | |
0 | 923 } |
924 | |
1070
6da5ae9ee199
more #ifdef CONFIG_ENCODERS patch by (Wolfgang Hesseler <qv at multimediaware dot com>) with modifications by me (s/WOLFGANG/CONFIG_ENCODERS/ and some other fixes)
michaelni
parents:
1064
diff
changeset
|
925 #ifdef CONFIG_ENCODERS |
6da5ae9ee199
more #ifdef CONFIG_ENCODERS patch by (Wolfgang Hesseler <qv at multimediaware dot com>) with modifications by me (s/WOLFGANG/CONFIG_ENCODERS/ and some other fixes)
michaelni
parents:
1064
diff
changeset
|
926 |
0 | 927 /* init video encoder */ |
928 int MPV_encode_init(AVCodecContext *avctx) | |
929 { | |
930 MpegEncContext *s = avctx->priv_data; | |
2834 | 931 int i; |
1315
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1288
diff
changeset
|
932 int chroma_h_shift, chroma_v_shift; |
2967 | 933 |
1892 | 934 MPV_encode_defaults(s); |
315 | 935 |
3309 | 936 switch (avctx->codec_id) { |
937 case CODEC_ID_MPEG2VIDEO: | |
938 if(avctx->pix_fmt != PIX_FMT_YUV420P && avctx->pix_fmt != PIX_FMT_YUV422P){ | |
939 av_log(avctx, AV_LOG_ERROR, "only YUV420 and YUV422 are supported\n"); | |
940 return -1; | |
941 } | |
942 break; | |
943 case CODEC_ID_LJPEG: | |
944 case CODEC_ID_MJPEG: | |
3929 | 945 if(avctx->pix_fmt != PIX_FMT_YUVJ420P && avctx->pix_fmt != PIX_FMT_YUVJ422P && |
946 ((avctx->pix_fmt != PIX_FMT_YUV420P && avctx->pix_fmt != PIX_FMT_YUV422P) || avctx->strict_std_compliance>FF_COMPLIANCE_INOFFICIAL)){ | |
2442 | 947 av_log(avctx, AV_LOG_ERROR, "colorspace not supported in jpeg\n"); |
948 return -1; | |
949 } | |
3309 | 950 break; |
951 default: | |
952 if(avctx->pix_fmt != PIX_FMT_YUV420P){ | |
953 av_log(avctx, AV_LOG_ERROR, "only YUV420 is supported\n"); | |
2442 | 954 return -1; |
955 } | |
956 } | |
1402
f662e9c86cf2
* fixing a regression in mpeg encoder (not setting pix_fmt),
romansh
parents:
1397
diff
changeset
|
957 |
3309 | 958 switch (avctx->pix_fmt) { |
959 case PIX_FMT_YUVJ422P: | |
960 case PIX_FMT_YUV422P: | |
961 s->chroma_format = CHROMA_422; | |
962 break; | |
963 case PIX_FMT_YUVJ420P: | |
964 case PIX_FMT_YUV420P: | |
965 default: | |
966 s->chroma_format = CHROMA_420; | |
967 break; | |
968 } | |
969 | |
0 | 970 s->bit_rate = avctx->bit_rate; |
971 s->width = avctx->width; | |
972 s->height = avctx->height; | |
3296
d185908c71cb
allow insane gop sizes if the user doesnt care about playable streams (doesnt want compliance to any standard)
michael
parents:
3286
diff
changeset
|
973 if(avctx->gop_size > 600 && avctx->strict_std_compliance>FF_COMPLIANCE_EXPERIMENTAL){ |
2979 | 974 av_log(avctx, AV_LOG_ERROR, "Warning keyframe interval too large! reducing it ...\n"); |
456 | 975 avctx->gop_size=600; |
976 } | |
0 | 977 s->gop_size = avctx->gop_size; |
194
27d1773552c9
mpeg4 encoder fix by Michael Niedermayer <michaelni@gmx.at>
arpi_esp
parents:
191
diff
changeset
|
978 s->avctx = avctx; |
294 | 979 s->flags= avctx->flags; |
1754
bdf3927bf8c5
closed gop support & flags2 as all bits in flags are used
michael
parents:
1751
diff
changeset
|
980 s->flags2= avctx->flags2; |
324 | 981 s->max_b_frames= avctx->max_b_frames; |
344 | 982 s->codec_id= avctx->codec->id; |
456 | 983 s->luma_elim_threshold = avctx->luma_elim_threshold; |
984 s->chroma_elim_threshold= avctx->chroma_elim_threshold; | |
985 s->strict_std_compliance= avctx->strict_std_compliance; | |
986 s->data_partitioning= avctx->flags & CODEC_FLAG_PART; | |
936 | 987 s->quarter_sample= (avctx->flags & CODEC_FLAG_QPEL)!=0; |
599 | 988 s->mpeg_quant= avctx->mpeg_quant; |
1661 | 989 s->rtp_mode= !!avctx->rtp_payload_size; |
1992 | 990 s->intra_dc_precision= avctx->intra_dc_precision; |
2243
b8bad8bbbc64
check if the user specified timestamps are strictly monotone
michael
parents:
2235
diff
changeset
|
991 s->user_specified_pts = AV_NOPTS_VALUE; |
1422
efeed6e29f9b
oooooops, having 2 Eterms open and doing cvs diff in one and cvs commit in the other sucks, especially if they are in different directories (MPlayer/main/libavcodec vs. ffmpeg/libavcodec)
michaelni
parents:
1421
diff
changeset
|
992 |
0 | 993 if (s->gop_size <= 1) { |
994 s->intra_only = 1; | |
995 s->gop_size = 12; | |
996 } else { | |
997 s->intra_only = 0; | |
998 } | |
693
b6a7ff92df57
darkness masking (lumi masking does only bright stuff now)
michaelni
parents:
690
diff
changeset
|
999 |
936 | 1000 s->me_method = avctx->me_method; |
693
b6a7ff92df57
darkness masking (lumi masking does only bright stuff now)
michaelni
parents:
690
diff
changeset
|
1001 |
320
cda7d0857baf
- ME setting moved to AVCodecContext/MpegEncContext, no longer a global.
pulento
parents:
315
diff
changeset
|
1002 /* Fixed QSCALE */ |
1708 | 1003 s->fixed_qscale = !!(avctx->flags & CODEC_FLAG_QSCALE); |
2967 | 1004 |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
673
diff
changeset
|
1005 s->adaptive_quant= ( s->avctx->lumi_masking |
693
b6a7ff92df57
darkness masking (lumi masking does only bright stuff now)
michaelni
parents:
690
diff
changeset
|
1006 || s->avctx->dark_masking |
2967 | 1007 || s->avctx->temporal_cplx_masking |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
673
diff
changeset
|
1008 || s->avctx->spatial_cplx_masking |
1616 | 1009 || s->avctx->p_masking |
2493
258120c61eea
Border processing adaptive quant patch by (Christophe Massiot |cmassiot freebox fr)
michael
parents:
2492
diff
changeset
|
1010 || s->avctx->border_masking |
1616 | 1011 || (s->flags&CODEC_FLAG_QP_RD)) |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
673
diff
changeset
|
1012 && !s->fixed_qscale; |
2967 | 1013 |
1708 | 1014 s->obmc= !!(s->flags & CODEC_FLAG_OBMC); |
1015 s->loop_filter= !!(s->flags & CODEC_FLAG_LOOP_FILTER); | |
1016 s->alternate_scan= !!(s->flags & CODEC_FLAG_ALT_SCAN); | |
3305 | 1017 s->intra_vlc_format= !!(s->flags2 & CODEC_FLAG2_INTRA_VLC); |
1633 | 1018 |
1711 | 1019 if(avctx->rc_max_rate && !avctx->rc_buffer_size){ |
1020 av_log(avctx, AV_LOG_ERROR, "a vbv buffer size is needed, for encoding with a maximum bitrate\n"); | |
1021 return -1; | |
2967 | 1022 } |
1711 | 1023 |
1024 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
|
1025 av_log(avctx, AV_LOG_INFO, "Warning min_rate > 0 but min_rate != max_rate isn't recommended!\n"); |
1907 | 1026 } |
2967 | 1027 |
2063 | 1028 if(avctx->rc_min_rate && avctx->rc_min_rate > avctx->bit_rate){ |
1029 av_log(avctx, AV_LOG_INFO, "bitrate below min bitrate\n"); | |
1030 return -1; | |
1031 } | |
2967 | 1032 |
2063 | 1033 if(avctx->rc_max_rate && avctx->rc_max_rate < avctx->bit_rate){ |
1034 av_log(avctx, AV_LOG_INFO, "bitrate above max bitrate\n"); | |
1035 return -1; | |
1036 } | |
2967 | 1037 |
1038 if( s->avctx->rc_max_rate && s->avctx->rc_min_rate == s->avctx->rc_max_rate | |
1907 | 1039 && (s->codec_id == CODEC_ID_MPEG1VIDEO || s->codec_id == CODEC_ID_MPEG2VIDEO) |
1040 && 90000LL * (avctx->rc_buffer_size-1) > s->avctx->rc_max_rate*0xFFFFLL){ | |
2967 | 1041 |
1907 | 1042 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"); |
1043 } | |
2967 | 1044 |
1045 if((s->flags & CODEC_FLAG_4MV) && s->codec_id != CODEC_ID_MPEG4 | |
1790 | 1046 && 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
|
1047 av_log(avctx, AV_LOG_ERROR, "4MV not supported by codec\n"); |
1188 | 1048 return -1; |
1049 } | |
2967 | 1050 |
1633 | 1051 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
|
1052 av_log(avctx, AV_LOG_ERROR, "OBMC is only supported with simple mb decision\n"); |
1633 | 1053 return -1; |
1054 } | |
2967 | 1055 |
1644 | 1056 if(s->obmc && s->codec_id != CODEC_ID_H263 && s->codec_id != CODEC_ID_H263P){ |
1057 av_log(avctx, AV_LOG_ERROR, "OBMC is only supported with H263(+)\n"); | |
1058 return -1; | |
1059 } | |
2967 | 1060 |
1188 | 1061 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
|
1062 av_log(avctx, AV_LOG_ERROR, "qpel not supported by codec\n"); |
1188 | 1063 return -1; |
1064 } | |
1065 | |
1066 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
|
1067 av_log(avctx, AV_LOG_ERROR, "data partitioning not supported by codec\n"); |
1188 | 1068 return -1; |
1069 } | |
2967 | 1070 |
1421 | 1071 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
|
1072 av_log(avctx, AV_LOG_ERROR, "b frames not supported by codec\n"); |
1188 | 1073 return -1; |
1074 } | |
1958 | 1075 |
2967 | 1076 if((s->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME|CODEC_FLAG_ALT_SCAN)) |
1958 | 1077 && s->codec_id != CODEC_ID_MPEG4 && s->codec_id != CODEC_ID_MPEG2VIDEO){ |
1078 av_log(avctx, AV_LOG_ERROR, "interlacing not supported by codec\n"); | |
1079 return -1; | |
1080 } | |
2967 | 1081 |
1188 | 1082 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
|
1083 av_log(avctx, AV_LOG_ERROR, "mpeg2 style quantization not supported by codec\n"); |
1188 | 1084 return -1; |
1085 } | |
2967 | 1086 |
1490
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1480
diff
changeset
|
1087 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
|
1088 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
|
1089 return -1; |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1480
diff
changeset
|
1090 } |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1480
diff
changeset
|
1091 |
1622 | 1092 if((s->flags & CODEC_FLAG_QP_RD) && s->avctx->mb_decision != FF_MB_DECISION_RD){ |
1093 av_log(avctx, AV_LOG_ERROR, "QP RD needs mbd=2\n"); | |
1094 return -1; | |
1095 } | |
2967 | 1096 |
1754
bdf3927bf8c5
closed gop support & flags2 as all bits in flags are used
michael
parents:
1751
diff
changeset
|
1097 if(s->avctx->scenechange_threshold < 1000000000 && (s->flags & CODEC_FLAG_CLOSED_GOP)){ |
bdf3927bf8c5
closed gop support & flags2 as all bits in flags are used
michael
parents:
1751
diff
changeset
|
1098 av_log(avctx, AV_LOG_ERROR, "closed gop with scene change detection arent supported yet\n"); |
bdf3927bf8c5
closed gop support & flags2 as all bits in flags are used
michael
parents:
1751
diff
changeset
|
1099 return -1; |
bdf3927bf8c5
closed gop support & flags2 as all bits in flags are used
michael
parents:
1751
diff
changeset
|
1100 } |
2967 | 1101 |
3305 | 1102 if((s->flags2 & CODEC_FLAG2_INTRA_VLC) && s->codec_id != CODEC_ID_MPEG2VIDEO){ |
1103 av_log(avctx, AV_LOG_ERROR, "intra vlc table not supported by codec\n"); | |
1104 return -1; | |
1105 } | |
1106 | |
4189
3c98b0938897
add low delay forcing option for mpeg1/2 encoding
bcoudurier
parents:
4179
diff
changeset
|
1107 if(s->flags & CODEC_FLAG_LOW_DELAY){ |
3c98b0938897
add low delay forcing option for mpeg1/2 encoding
bcoudurier
parents:
4179
diff
changeset
|
1108 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
|
1109 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
|
1110 return -1; |
3c98b0938897
add low delay forcing option for mpeg1/2 encoding
bcoudurier
parents:
4179
diff
changeset
|
1111 } |
3c98b0938897
add low delay forcing option for mpeg1/2 encoding
bcoudurier
parents:
4179
diff
changeset
|
1112 if (s->max_b_frames != 0){ |
3c98b0938897
add low delay forcing option for mpeg1/2 encoding
bcoudurier
parents:
4179
diff
changeset
|
1113 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
|
1114 return -1; |
3c98b0938897
add low delay forcing option for mpeg1/2 encoding
bcoudurier
parents:
4179
diff
changeset
|
1115 } |
3c98b0938897
add low delay forcing option for mpeg1/2 encoding
bcoudurier
parents:
4179
diff
changeset
|
1116 } |
3c98b0938897
add low delay forcing option for mpeg1/2 encoding
bcoudurier
parents:
4179
diff
changeset
|
1117 |
2967 | 1118 if(s->avctx->thread_count > 1 && s->codec_id != CODEC_ID_MPEG4 |
1119 && s->codec_id != CODEC_ID_MPEG1VIDEO && s->codec_id != CODEC_ID_MPEG2VIDEO | |
1799 | 1120 && (s->codec_id != CODEC_ID_H263P || !(s->flags & CODEC_FLAG_H263P_SLICE_STRUCT))){ |
1121 av_log(avctx, AV_LOG_ERROR, "multi threaded encoding not supported by codec\n"); | |
1122 return -1; | |
1123 } | |
2967 | 1124 |
1799 | 1125 if(s->avctx->thread_count > 1) |
1126 s->rtp_mode= 1; | |
1760 | 1127 |
2637 | 1128 if(!avctx->time_base.den || !avctx->time_base.num){ |
2450 | 1129 av_log(avctx, AV_LOG_ERROR, "framerate not set\n"); |
1130 return -1; | |
1131 } | |
2967 | 1132 |
2576
e237d9bd0f8c
check mb/me_threshold range, fixes assertion failure
michael
parents:
2570
diff
changeset
|
1133 i= (INT_MAX/2+128)>>8; |
e237d9bd0f8c
check mb/me_threshold range, fixes assertion failure
michael
parents:
2570
diff
changeset
|
1134 if(avctx->me_threshold >= i){ |
e237d9bd0f8c
check mb/me_threshold range, fixes assertion failure
michael
parents:
2570
diff
changeset
|
1135 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
|
1136 return -1; |
e237d9bd0f8c
check mb/me_threshold range, fixes assertion failure
michael
parents:
2570
diff
changeset
|
1137 } |
e237d9bd0f8c
check mb/me_threshold range, fixes assertion failure
michael
parents:
2570
diff
changeset
|
1138 if(avctx->mb_threshold >= i){ |
e237d9bd0f8c
check mb/me_threshold range, fixes assertion failure
michael
parents:
2570
diff
changeset
|
1139 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
|
1140 return -1; |
e237d9bd0f8c
check mb/me_threshold range, fixes assertion failure
michael
parents:
2570
diff
changeset
|
1141 } |
2967 | 1142 |
2668 | 1143 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
|
1144 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
|
1145 avctx->b_frame_strategy = 0; |
2668 | 1146 } |
1147 | |
2637 | 1148 i= ff_gcd(avctx->time_base.den, avctx->time_base.num); |
1760 | 1149 if(i > 1){ |
1150 av_log(avctx, AV_LOG_INFO, "removing common factors from framerate\n"); | |
2637 | 1151 avctx->time_base.den /= i; |
1152 avctx->time_base.num /= i; | |
1760 | 1153 // return -1; |
1154 } | |
2967 | 1155 |
1150 | 1156 if(s->codec_id==CODEC_ID_MJPEG){ |
1157 s->intra_quant_bias= 1<<(QUANT_BIAS_SHIFT-1); //(a + x/2)/x | |
1158 s->inter_quant_bias= 0; | |
1421 | 1159 }else if(s->mpeg_quant || s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO){ |
1150 | 1160 s->intra_quant_bias= 3<<(QUANT_BIAS_SHIFT-3); //(a + x*3/8)/x |
1161 s->inter_quant_bias= 0; | |
1162 }else{ | |
1163 s->intra_quant_bias=0; | |
1164 s->inter_quant_bias=-(1<<(QUANT_BIAS_SHIFT-2)); //(a - x/4)/x | |
1165 } | |
2967 | 1166 |
1150 | 1167 if(avctx->intra_quant_bias != FF_DEFAULT_QUANT_BIAS) |
1168 s->intra_quant_bias= avctx->intra_quant_bias; | |
1169 if(avctx->inter_quant_bias != FF_DEFAULT_QUANT_BIAS) | |
1170 s->inter_quant_bias= avctx->inter_quant_bias; | |
2967 | 1171 |
1315
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1288
diff
changeset
|
1172 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
|
1173 |
2653
2515af7d3238
complain about mpeg4 limits only if codec_id == MPEG4
michael
parents:
2639
diff
changeset
|
1174 if(avctx->codec_id == CODEC_ID_MPEG4 && s->avctx->time_base.den > (1<<16)-1){ |
2637 | 1175 av_log(avctx, AV_LOG_ERROR, "timebase not supported by mpeg 4 standard\n"); |
2967 | 1176 return -1; |
2637 | 1177 } |
1178 s->time_increment_bits = av_log2(s->avctx->time_base.den - 1) + 1; | |
1424 | 1179 |
0 | 1180 switch(avctx->codec->id) { |
1181 case CODEC_ID_MPEG1VIDEO: | |
1182 s->out_format = FMT_MPEG1; | |
4189
3c98b0938897
add low delay forcing option for mpeg1/2 encoding
bcoudurier
parents:
4179
diff
changeset
|
1183 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
|
1184 avctx->delay= s->low_delay ? 0 : (s->max_b_frames + 1); |
0 | 1185 break; |
1421 | 1186 case CODEC_ID_MPEG2VIDEO: |
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); |
1421 | 1189 avctx->delay= s->low_delay ? 0 : (s->max_b_frames + 1); |
1661 | 1190 s->rtp_mode= 1; |
1421 | 1191 break; |
1315
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1288
diff
changeset
|
1192 case CODEC_ID_LJPEG: |
2973 | 1193 case CODEC_ID_JPEGLS: |
0 | 1194 case CODEC_ID_MJPEG: |
1195 s->out_format = FMT_MJPEG; | |
1196 s->intra_only = 1; /* force intra only for jpeg */ | |
2973 | 1197 s->mjpeg_write_tables = avctx->codec->id != CODEC_ID_JPEGLS; |
2979 | 1198 s->mjpeg_data_only_frames = 0; /* write all the needed headers */ |
3929 | 1199 s->mjpeg_vsample[0] = 2; |
1200 s->mjpeg_vsample[1] = 2>>chroma_v_shift; | |
1201 s->mjpeg_vsample[2] = 2>>chroma_v_shift; | |
1202 s->mjpeg_hsample[0] = 2; | |
1203 s->mjpeg_hsample[1] = 2>>chroma_h_shift; | |
1204 s->mjpeg_hsample[2] = 2>>chroma_h_shift; | |
0 | 1205 if (mjpeg_init(s) < 0) |
1206 return -1; | |
336 | 1207 avctx->delay=0; |
924 | 1208 s->low_delay=1; |
0 | 1209 break; |
4219 | 1210 #ifdef CONFIG_H261_ENCODER |
2327
5e5cf598a48b
H.261 encoder by (Maarten Daniels <maarten dot daniels at luc dot ac dot be>)
michael
parents:
2298
diff
changeset
|
1211 case CODEC_ID_H261: |
4206
be94e97ecb6e
throw error if unsupported resolution is used with h261
bcoudurier
parents:
4189
diff
changeset
|
1212 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
|
1213 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
|
1214 return -1; |
be94e97ecb6e
throw error if unsupported resolution is used with h261
bcoudurier
parents:
4189
diff
changeset
|
1215 } |
2327
5e5cf598a48b
H.261 encoder by (Maarten Daniels <maarten dot daniels at luc dot ac dot be>)
michael
parents:
2298
diff
changeset
|
1216 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
|
1217 avctx->delay=0; |
5e5cf598a48b
H.261 encoder by (Maarten Daniels <maarten dot daniels at luc dot ac dot be>)
michael
parents:
2298
diff
changeset
|
1218 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
|
1219 break; |
4219 | 1220 #endif |
0 | 1221 case CODEC_ID_H263: |
232
b640ec5948b0
- Now the ME is done for the entire picture when enconding, the
pulento
parents:
231
diff
changeset
|
1222 if (h263_get_picture_format(s->width, s->height) == 7) { |
3011 | 1223 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 | 1224 return -1; |
232
b640ec5948b0
- Now the ME is done for the entire picture when enconding, the
pulento
parents:
231
diff
changeset
|
1225 } |
0 | 1226 s->out_format = FMT_H263; |
2979 | 1227 s->obmc= (avctx->flags & CODEC_FLAG_OBMC) ? 1:0; |
336 | 1228 avctx->delay=0; |
924 | 1229 s->low_delay=1; |
0 | 1230 break; |
1231 case CODEC_ID_H263P: | |
1232 s->out_format = FMT_H263; | |
1233 s->h263_plus = 1; | |
2979 | 1234 /* Fx */ |
1644 | 1235 s->umvplus = (avctx->flags & CODEC_FLAG_H263P_UMV) ? 1:0; |
2979 | 1236 s->h263_aic= (avctx->flags & CODEC_FLAG_H263P_AIC) ? 1:0; |
1237 s->modified_quant= s->h263_aic; | |
1238 s->alt_inter_vlc= (avctx->flags & CODEC_FLAG_H263P_AIV) ? 1:0; | |
1239 s->obmc= (avctx->flags & CODEC_FLAG_OBMC) ? 1:0; | |
1240 s->loop_filter= (avctx->flags & CODEC_FLAG_LOOP_FILTER) ? 1:0; | |
1241 s->unrestricted_mv= s->obmc || s->loop_filter || s->umvplus; | |
1661 | 1242 s->h263_slice_structured= (s->flags & CODEC_FLAG_H263P_SLICE_STRUCT) ? 1:0; |
1644 | 1243 |
2979 | 1244 /* /Fx */ |
79
82e579c37bc3
Moved some H.263+ variables to MpegEncContext to be thread-safe.
pulento
parents:
78
diff
changeset
|
1245 /* These are just to be sure */ |
336 | 1246 avctx->delay=0; |
924 | 1247 s->low_delay=1; |
0 | 1248 break; |
1353
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1344
diff
changeset
|
1249 case CODEC_ID_FLV1: |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1344
diff
changeset
|
1250 s->out_format = FMT_H263; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1344
diff
changeset
|
1251 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
|
1252 s->unrestricted_mv = 1; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1344
diff
changeset
|
1253 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
|
1254 avctx->delay=0; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1344
diff
changeset
|
1255 s->low_delay=1; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1344
diff
changeset
|
1256 break; |
0 | 1257 case CODEC_ID_RV10: |
1258 s->out_format = FMT_H263; | |
336 | 1259 avctx->delay=0; |
924 | 1260 s->low_delay=1; |
0 | 1261 break; |
2380 | 1262 case CODEC_ID_RV20: |
1263 s->out_format = FMT_H263; | |
1264 avctx->delay=0; | |
1265 s->low_delay=1; | |
1266 s->modified_quant=1; | |
1267 s->h263_aic=1; | |
1268 s->h263_plus=1; | |
1269 s->loop_filter=1; | |
1270 s->unrestricted_mv= s->obmc || s->loop_filter || s->umvplus; | |
1271 break; | |
71 | 1272 case CODEC_ID_MPEG4: |
0 | 1273 s->out_format = FMT_H263; |
1274 s->h263_pred = 1; | |
1275 s->unrestricted_mv = 1; | |
924 | 1276 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
|
1277 avctx->delay= s->low_delay ? 0 : (s->max_b_frames + 1); |
0 | 1278 break; |
307 | 1279 case CODEC_ID_MSMPEG4V1: |
0 | 1280 s->out_format = FMT_H263; |
1281 s->h263_msmpeg4 = 1; | |
1282 s->h263_pred = 1; | |
1283 s->unrestricted_mv = 1; | |
307 | 1284 s->msmpeg4_version= 1; |
336 | 1285 avctx->delay=0; |
924 | 1286 s->low_delay=1; |
307 | 1287 break; |
1288 case CODEC_ID_MSMPEG4V2: | |
1289 s->out_format = FMT_H263; | |
1290 s->h263_msmpeg4 = 1; | |
1291 s->h263_pred = 1; | |
1292 s->unrestricted_mv = 1; | |
1293 s->msmpeg4_version= 2; | |
336 | 1294 avctx->delay=0; |
924 | 1295 s->low_delay=1; |
307 | 1296 break; |
1297 case CODEC_ID_MSMPEG4V3: | |
1298 s->out_format = FMT_H263; | |
1299 s->h263_msmpeg4 = 1; | |
1300 s->h263_pred = 1; | |
1301 s->unrestricted_mv = 1; | |
1302 s->msmpeg4_version= 3; | |
1163 | 1303 s->flipflop_rounding=1; |
336 | 1304 avctx->delay=0; |
924 | 1305 s->low_delay=1; |
0 | 1306 break; |
499 | 1307 case CODEC_ID_WMV1: |
1308 s->out_format = FMT_H263; | |
1309 s->h263_msmpeg4 = 1; | |
1310 s->h263_pred = 1; | |
1311 s->unrestricted_mv = 1; | |
1312 s->msmpeg4_version= 4; | |
1163 | 1313 s->flipflop_rounding=1; |
499 | 1314 avctx->delay=0; |
924 | 1315 s->low_delay=1; |
499 | 1316 break; |
1317 case CODEC_ID_WMV2: | |
1318 s->out_format = FMT_H263; | |
1319 s->h263_msmpeg4 = 1; | |
1320 s->h263_pred = 1; | |
1321 s->unrestricted_mv = 1; | |
1322 s->msmpeg4_version= 5; | |
1163 | 1323 s->flipflop_rounding=1; |
499 | 1324 avctx->delay=0; |
924 | 1325 s->low_delay=1; |
499 | 1326 break; |
0 | 1327 default: |
1328 return -1; | |
1329 } | |
2967 | 1330 |
2042 | 1331 avctx->has_b_frames= !s->low_delay; |
1749
7b11032507e2
removing broken framerate conversation hack in mpeg1/2
michael
parents:
1742
diff
changeset
|
1332 |
7
1d3ac9654178
added skip macroblock optimization (big perf win on black regions for example)
glantau
parents:
0
diff
changeset
|
1333 s->encoding = 1; |
1d3ac9654178
added skip macroblock optimization (big perf win on black regions for example)
glantau
parents:
0
diff
changeset
|
1334 |
0 | 1335 /* init */ |
1336 if (MPV_common_init(s) < 0) | |
1337 return -1; | |
1678 | 1338 |
1339 if(s->modified_quant) | |
1340 s->chroma_qscale_table= ff_h263_chroma_qscale_table; | |
2967 | 1341 s->progressive_frame= |
4121 | 1342 s->progressive_sequence= !(avctx->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME|CODEC_FLAG_ALT_SCAN)); |
1799 | 1343 s->quant_precision=5; |
2967 | 1344 |
1729 | 1345 ff_set_cmp(&s->dsp, s->dsp.ildct_cmp, s->avctx->ildct_cmp); |
2382 | 1346 ff_set_cmp(&s->dsp, s->dsp.frame_skip_cmp, s->avctx->frame_skip_cmp); |
2967 | 1347 |
2639 | 1348 #ifdef CONFIG_H261_ENCODER |
2327
5e5cf598a48b
H.261 encoder by (Maarten Daniels <maarten dot daniels at luc dot ac dot be>)
michael
parents:
2298
diff
changeset
|
1349 if (s->out_format == FMT_H261) |
5e5cf598a48b
H.261 encoder by (Maarten Daniels <maarten dot daniels at luc dot ac dot be>)
michael
parents:
2298
diff
changeset
|
1350 ff_h261_encode_init(s); |
2639 | 1351 #endif |
706
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
1352 if (s->out_format == FMT_H263) |
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
1353 h263_encode_init(s); |
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
1354 if(s->msmpeg4_version) |
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
1355 ff_msmpeg4_encode_init(s); |
1042 | 1356 if (s->out_format == FMT_MPEG1) |
1357 ff_mpeg1_encode_init(s); | |
706
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
1358 |
1892 | 1359 /* init q matrix */ |
60 | 1360 for(i=0;i<64;i++) { |
1092 | 1361 int j= s->dsp.idct_permutation[i]; |
599 | 1362 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
|
1363 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
|
1364 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
|
1365 }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
|
1366 s->intra_matrix[j] = |
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
1367 s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i]; |
1042 | 1368 }else |
1421 | 1369 { /* mpeg1/2 */ |
706
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
1370 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
|
1371 s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i]; |
599 | 1372 } |
1411 | 1373 if(s->avctx->intra_matrix) |
1374 s->intra_matrix[j] = s->avctx->intra_matrix[i]; | |
1375 if(s->avctx->inter_matrix) | |
1376 s->inter_matrix[j] = s->avctx->inter_matrix[i]; | |
344 | 1377 } |
1378 | |
1379 /* precompute matrix */ | |
350
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
347
diff
changeset
|
1380 /* for mjpeg, we do include qscale in the matrix */ |
344 | 1381 if (s->out_format != FMT_MJPEG) { |
2967 | 1382 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
|
1383 s->intra_matrix, s->intra_quant_bias, avctx->qmin, 31, 1); |
2967 | 1384 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
|
1385 s->inter_matrix, s->inter_quant_bias, avctx->qmin, 31, 0); |
60 | 1386 } |
1387 | |
329 | 1388 if(ff_rate_control_init(s) < 0) |
1389 return -1; | |
2967 | 1390 |
0 | 1391 return 0; |
1392 } | |
1393 | |
1394 int MPV_encode_end(AVCodecContext *avctx) | |
1395 { | |
1396 MpegEncContext *s = avctx->priv_data; | |
1397 | |
329 | 1398 ff_rate_control_uninit(s); |
1399 | |
0 | 1400 MPV_common_end(s); |
1401 if (s->out_format == FMT_MJPEG) | |
1402 mjpeg_close(s); | |
1458
40b69d238beb
AVI stream header FCC / more reliable detection of old xvid files
michaelni
parents:
1451
diff
changeset
|
1403 |
1424 | 1404 av_freep(&avctx->extradata); |
2967 | 1405 |
0 | 1406 return 0; |
1407 } | |
1408 | |
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
|
1409 #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
|
1410 |
2370
26560d4fdb1f
Memory leak fix patch by (Burkhard Plaum <plaum >at< ipf.uni-stuttgart )dot( de>)
michael
parents:
2364
diff
changeset
|
1411 void init_rl(RLTable *rl, int use_static) |
1042 | 1412 { |
1064 | 1413 int8_t max_level[MAX_RUN+1], max_run[MAX_LEVEL+1]; |
1414 uint8_t index_run[MAX_RUN+1]; | |
1042 | 1415 int last, run, level, start, end, i; |
1416 | |
2370
26560d4fdb1f
Memory leak fix patch by (Burkhard Plaum <plaum >at< ipf.uni-stuttgart )dot( de>)
michael
parents:
2364
diff
changeset
|
1417 /* If table is static, we can quit if rl->max_level[0] is not NULL */ |
26560d4fdb1f
Memory leak fix patch by (Burkhard Plaum <plaum >at< ipf.uni-stuttgart )dot( de>)
michael
parents:
2364
diff
changeset
|
1418 if(use_static && rl->max_level[0]) |
26560d4fdb1f
Memory leak fix patch by (Burkhard Plaum <plaum >at< ipf.uni-stuttgart )dot( de>)
michael
parents:
2364
diff
changeset
|
1419 return; |
26560d4fdb1f
Memory leak fix patch by (Burkhard Plaum <plaum >at< ipf.uni-stuttgart )dot( de>)
michael
parents:
2364
diff
changeset
|
1420 |
1042 | 1421 /* compute max_level[], max_run[] and index_run[] */ |
1422 for(last=0;last<2;last++) { | |
1423 if (last == 0) { | |
1424 start = 0; | |
1425 end = rl->last; | |
1426 } else { | |
1427 start = rl->last; | |
1428 end = rl->n; | |
1429 } | |
1430 | |
1431 memset(max_level, 0, MAX_RUN + 1); | |
1432 memset(max_run, 0, MAX_LEVEL + 1); | |
1433 memset(index_run, rl->n, MAX_RUN + 1); | |
1434 for(i=start;i<end;i++) { | |
1435 run = rl->table_run[i]; | |
1436 level = rl->table_level[i]; | |
1437 if (index_run[run] == rl->n) | |
1438 index_run[run] = i; | |
1439 if (level > max_level[run]) | |
1440 max_level[run] = level; | |
1441 if (run > max_run[level]) | |
1442 max_run[level] = run; | |
1443 } | |
2370
26560d4fdb1f
Memory leak fix patch by (Burkhard Plaum <plaum >at< ipf.uni-stuttgart )dot( de>)
michael
parents:
2364
diff
changeset
|
1444 if(use_static) |
26560d4fdb1f
Memory leak fix patch by (Burkhard Plaum <plaum >at< ipf.uni-stuttgart )dot( de>)
michael
parents:
2364
diff
changeset
|
1445 rl->max_level[last] = av_mallocz_static(MAX_RUN + 1); |
26560d4fdb1f
Memory leak fix patch by (Burkhard Plaum <plaum >at< ipf.uni-stuttgart )dot( de>)
michael
parents:
2364
diff
changeset
|
1446 else |
26560d4fdb1f
Memory leak fix patch by (Burkhard Plaum <plaum >at< ipf.uni-stuttgart )dot( de>)
michael
parents:
2364
diff
changeset
|
1447 rl->max_level[last] = av_malloc(MAX_RUN + 1); |
1042 | 1448 memcpy(rl->max_level[last], max_level, MAX_RUN + 1); |
2370
26560d4fdb1f
Memory leak fix patch by (Burkhard Plaum <plaum >at< ipf.uni-stuttgart )dot( de>)
michael
parents:
2364
diff
changeset
|
1449 if(use_static) |
26560d4fdb1f
Memory leak fix patch by (Burkhard Plaum <plaum >at< ipf.uni-stuttgart )dot( de>)
michael
parents:
2364
diff
changeset
|
1450 rl->max_run[last] = av_mallocz_static(MAX_LEVEL + 1); |
26560d4fdb1f
Memory leak fix patch by (Burkhard Plaum <plaum >at< ipf.uni-stuttgart )dot( de>)
michael
parents:
2364
diff
changeset
|
1451 else |
26560d4fdb1f
Memory leak fix patch by (Burkhard Plaum <plaum >at< ipf.uni-stuttgart )dot( de>)
michael
parents:
2364
diff
changeset
|
1452 rl->max_run[last] = av_malloc(MAX_LEVEL + 1); |
1042 | 1453 memcpy(rl->max_run[last], max_run, MAX_LEVEL + 1); |
2370
26560d4fdb1f
Memory leak fix patch by (Burkhard Plaum <plaum >at< ipf.uni-stuttgart )dot( de>)
michael
parents:
2364
diff
changeset
|
1454 if(use_static) |
26560d4fdb1f
Memory leak fix patch by (Burkhard Plaum <plaum >at< ipf.uni-stuttgart )dot( de>)
michael
parents:
2364
diff
changeset
|
1455 rl->index_run[last] = av_mallocz_static(MAX_RUN + 1); |
26560d4fdb1f
Memory leak fix patch by (Burkhard Plaum <plaum >at< ipf.uni-stuttgart )dot( de>)
michael
parents:
2364
diff
changeset
|
1456 else |
26560d4fdb1f
Memory leak fix patch by (Burkhard Plaum <plaum >at< ipf.uni-stuttgart )dot( de>)
michael
parents:
2364
diff
changeset
|
1457 rl->index_run[last] = av_malloc(MAX_RUN + 1); |
1042 | 1458 memcpy(rl->index_run[last], index_run, MAX_RUN + 1); |
1459 } | |
1460 } | |
1461 | |
0 | 1462 /* 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
|
1463 //FIXME check that this is ok for mpeg4 interlaced |
1064 | 1464 static void draw_edges_c(uint8_t *buf, int wrap, int width, int height, int w) |
0 | 1465 { |
1064 | 1466 uint8_t *ptr, *last_line; |
0 | 1467 int i; |
1468 | |
1469 last_line = buf + (height - 1) * wrap; | |
1470 for(i=0;i<w;i++) { | |
1471 /* top and bottom */ | |
1472 memcpy(buf - (i + 1) * wrap, buf, width); | |
1473 memcpy(last_line + (i + 1) * wrap, last_line, width); | |
1474 } | |
1475 /* left and right */ | |
1476 ptr = buf; | |
1477 for(i=0;i<height;i++) { | |
1478 memset(ptr - w, ptr[0], w); | |
1479 memset(ptr + width, ptr[width-1], w); | |
1480 ptr += wrap; | |
1481 } | |
1482 /* corners */ | |
1483 for(i=0;i<w;i++) { | |
1484 memset(buf - (i + 1) * wrap - w, buf[0], w); /* top left */ | |
1485 memset(buf - (i + 1) * wrap + width, buf[width-1], w); /* top right */ | |
1486 memset(last_line + (i + 1) * wrap - w, last_line[0], w); /* top left */ | |
1487 memset(last_line + (i + 1) * wrap + width, last_line[width-1], w); /* top right */ | |
1488 } | |
1489 } | |
1490 | |
1586 | 1491 int ff_find_unused_picture(MpegEncContext *s, int shared){ |
924 | 1492 int i; |
2967 | 1493 |
924 | 1494 if(shared){ |
1495 for(i=0; i<MAX_PICTURE_COUNT; i++){ | |
1586 | 1496 if(s->picture[i].data[0]==NULL && s->picture[i].type==0) return i; |
924 | 1497 } |
1498 }else{ | |
1499 for(i=0; i<MAX_PICTURE_COUNT; i++){ | |
1586 | 1500 if(s->picture[i].data[0]==NULL && s->picture[i].type!=0) return i; //FIXME |
924 | 1501 } |
1502 for(i=0; i<MAX_PICTURE_COUNT; i++){ | |
1586 | 1503 if(s->picture[i].data[0]==NULL) return i; |
924 | 1504 } |
1505 } | |
1506 | |
1586 | 1507 assert(0); |
1508 return -1; | |
924 | 1509 } |
1510 | |
1597 | 1511 static void update_noise_reduction(MpegEncContext *s){ |
1512 int intra, i; | |
1513 | |
1514 for(intra=0; intra<2; intra++){ | |
1515 if(s->dct_count[intra] > (1<<16)){ | |
1516 for(i=0; i<64; i++){ | |
1517 s->dct_error_sum[intra][i] >>=1; | |
1518 } | |
1519 s->dct_count[intra] >>= 1; | |
1520 } | |
2967 | 1521 |
1597 | 1522 for(i=0; i<64; i++){ |
1523 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); | |
1524 } | |
1525 } | |
1526 } | |
1527 | |
1586 | 1528 /** |
1529 * generic function for encode/decode called after coding/decoding the header and before a frame is coded/decoded | |
1530 */ | |
771
d4cc92144266
handle direct rendering buffer allocation failure
michaelni
parents:
768
diff
changeset
|
1531 int MPV_frame_start(MpegEncContext *s, AVCodecContext *avctx) |
0 | 1532 { |
924 | 1533 int i; |
925 | 1534 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
|
1535 s->mb_skipped = 0; |
1168 | 1536 |
1234 | 1537 assert(s->last_picture_ptr==NULL || s->out_format != FMT_H264 || s->codec_id == CODEC_ID_SVQ3); |
1228 | 1538 |
903 | 1539 /* mark&release old frames */ |
1944 | 1540 if (s->pict_type != B_TYPE && s->last_picture_ptr && s->last_picture_ptr != s->next_picture_ptr && s->last_picture_ptr->data[0]) { |
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 } | |
1553 } | |
910
eb448df811be
fixing files where the first frame isn a keyframe
michaelni
parents:
909
diff
changeset
|
1554 alloc: |
eb448df811be
fixing files where the first frame isn a keyframe
michaelni
parents:
909
diff
changeset
|
1555 if(!s->encoding){ |
2764 | 1556 /* release non reference frames */ |
1228 | 1557 for(i=0; i<MAX_PICTURE_COUNT; i++){ |
1558 if(s->picture[i].data[0] && !s->picture[i].reference /*&& s->picture[i].type!=FF_BUFFER_TYPE_SHARED*/){ | |
1559 s->avctx->release_buffer(s->avctx, (AVFrame*)&s->picture[i]); | |
1560 } | |
1561 } | |
1562 | |
1586 | 1563 if(s->current_picture_ptr && s->current_picture_ptr->data[0]==NULL) |
1564 pic= (AVFrame*)s->current_picture_ptr; //we allready have a unused image (maybe it was set before reading the header) | |
1565 else{ | |
1566 i= ff_find_unused_picture(s, 0); | |
1567 pic= (AVFrame*)&s->picture[i]; | |
1568 } | |
1569 | |
2537
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2534
diff
changeset
|
1570 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
|
1571 && !s->dropable ? 3 : 0; |
1138 | 1572 |
1705 | 1573 pic->coded_picture_number= s->coded_picture_number++; |
2967 | 1574 |
1384 | 1575 if( alloc_picture(s, (Picture*)pic, 0) < 0) |
1576 return -1; | |
903 | 1577 |
1586 | 1578 s->current_picture_ptr= (Picture*)pic; |
1658 | 1579 s->current_picture_ptr->top_field_first= s->top_field_first; //FIXME use only the vars from current_pic |
1659 | 1580 s->current_picture_ptr->interlaced_frame= !s->progressive_frame && !s->progressive_sequence; |
903 | 1581 } |
456 | 1582 |
1173 | 1583 s->current_picture_ptr->pict_type= s->pict_type; |
2967 | 1584 // 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
|
1585 // 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
|
1586 s->current_picture_ptr->key_frame= s->pict_type == I_TYPE; |
1173 | 1587 |
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
|
1588 copy_picture(&s->current_picture, s->current_picture_ptr); |
2967 | 1589 |
1234 | 1590 if(s->out_format != FMT_H264 || s->codec_id == CODEC_ID_SVQ3){ |
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 |
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
|
1605 if(s->pict_type != I_TYPE && (s->last_picture_ptr==NULL || s->last_picture_ptr->data[0]==NULL)){ |
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 } |
1168 | 1624 } |
2967 | 1625 |
910
eb448df811be
fixing files where the first frame isn a keyframe
michaelni
parents:
909
diff
changeset
|
1626 s->hurry_up= s->avctx->hurry_up; |
eb448df811be
fixing files where the first frame isn a keyframe
michaelni
parents:
909
diff
changeset
|
1627 s->error_resilience= avctx->error_resilience; |
eb448df811be
fixing files where the first frame isn a keyframe
michaelni
parents:
909
diff
changeset
|
1628 |
2764 | 1629 /* set dequantizer, we can't do it during init as it might change for mpeg4 |
1630 and we can't do it in the header decode as init isnt called for mpeg4 there yet */ | |
1689 | 1631 if(s->mpeg_quant || s->codec_id == CODEC_ID_MPEG2VIDEO){ |
1632 s->dct_unquantize_intra = s->dct_unquantize_mpeg2_intra; | |
1633 s->dct_unquantize_inter = s->dct_unquantize_mpeg2_inter; | |
2345 | 1634 }else if(s->out_format == FMT_H263 || s->out_format == FMT_H261){ |
1689 | 1635 s->dct_unquantize_intra = s->dct_unquantize_h263_intra; |
1636 s->dct_unquantize_inter = s->dct_unquantize_h263_inter; | |
1637 }else{ | |
1638 s->dct_unquantize_intra = s->dct_unquantize_mpeg1_intra; | |
1639 s->dct_unquantize_inter = s->dct_unquantize_mpeg1_inter; | |
1640 } | |
771
d4cc92144266
handle direct rendering buffer allocation failure
michaelni
parents:
768
diff
changeset
|
1641 |
1597 | 1642 if(s->dct_error_sum){ |
1643 assert(s->avctx->noise_reduction && s->encoding); | |
1644 | |
1645 update_noise_reduction(s); | |
1646 } | |
2967 | 1647 |
1381 | 1648 #ifdef HAVE_XVMC |
1649 if(s->avctx->xvmc_acceleration) | |
1650 return XVMC_field_start(s, avctx); | |
1651 #endif | |
771
d4cc92144266
handle direct rendering buffer allocation failure
michaelni
parents:
768
diff
changeset
|
1652 return 0; |
0 | 1653 } |
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
|
1654 |
0 | 1655 /* generic function for encode/decode called after a frame has been coded/decoded */ |
1656 void MPV_frame_end(MpegEncContext *s) | |
1657 { | |
903 | 1658 int i; |
0 | 1659 /* draw edge for correct motion prediction if outside */ |
1381 | 1660 #ifdef HAVE_XVMC |
1661 //just to make sure that all data is rendered. | |
1662 if(s->avctx->xvmc_acceleration){ | |
1663 XVMC_field_end(s); | |
1664 }else | |
1665 #endif | |
2537
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2534
diff
changeset
|
1666 if(s->unrestricted_mv && s->current_picture.reference && !s->intra_only && !(s->flags&CODEC_FLAG_EMU_EDGE)) { |
903 | 1667 draw_edges(s->current_picture.data[0], s->linesize , s->h_edge_pos , s->v_edge_pos , EDGE_WIDTH ); |
1668 draw_edges(s->current_picture.data[1], s->uvlinesize, s->h_edge_pos>>1, s->v_edge_pos>>1, EDGE_WIDTH/2); | |
1669 draw_edges(s->current_picture.data[2], s->uvlinesize, s->h_edge_pos>>1, s->v_edge_pos>>1, EDGE_WIDTH/2); | |
0 | 1670 } |
207 | 1671 emms_c(); |
2967 | 1672 |
612 | 1673 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
|
1674 s->last_lambda_for[s->pict_type]= s->current_picture_ptr->quality; |
329 | 1675 if(s->pict_type!=B_TYPE){ |
1676 s->last_non_b_pict_type= s->pict_type; | |
1677 } | |
1138 | 1678 #if 0 |
1679 /* copy back current_picture variables */ | |
903 | 1680 for(i=0; i<MAX_PICTURE_COUNT; i++){ |
1681 if(s->picture[i].data[0] == s->current_picture.data[0]){ | |
1682 s->picture[i]= s->current_picture; | |
1683 break; | |
2967 | 1684 } |
903 | 1685 } |
1686 assert(i<MAX_PICTURE_COUNT); | |
2967 | 1687 #endif |
903 | 1688 |
1228 | 1689 if(s->encoding){ |
2764 | 1690 /* release non-reference frames */ |
1228 | 1691 for(i=0; i<MAX_PICTURE_COUNT; i++){ |
1692 if(s->picture[i].data[0] && !s->picture[i].reference /*&& s->picture[i].type!=FF_BUFFER_TYPE_SHARED*/){ | |
1693 s->avctx->release_buffer(s->avctx, (AVFrame*)&s->picture[i]); | |
1694 } | |
1695 } | |
324 | 1696 } |
1138 | 1697 // clear copies, to avoid confusion |
1698 #if 0 | |
1699 memset(&s->last_picture, 0, sizeof(Picture)); | |
1700 memset(&s->next_picture, 0, sizeof(Picture)); | |
1701 memset(&s->current_picture, 0, sizeof(Picture)); | |
1702 #endif | |
2213 | 1703 s->avctx->coded_frame= (AVFrame*)s->current_picture_ptr; |
903 | 1704 } |
1705 | |
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
|
1706 /** |
1285 | 1707 * draws an line from (ex, ey) -> (sx, sy). |
1708 * @param w width of the image | |
1709 * @param h height of the image | |
1710 * @param stride stride/linesize of the image | |
1711 * @param color color of the arrow | |
1712 */ | |
1713 static void draw_line(uint8_t *buf, int sx, int sy, int ex, int ey, int w, int h, int stride, int color){ | |
3595 | 1714 int x, y, fr, f; |
2967 | 1715 |
1285 | 1716 sx= clip(sx, 0, w-1); |
1717 sy= clip(sy, 0, h-1); | |
1718 ex= clip(ex, 0, w-1); | |
1719 ey= clip(ey, 0, h-1); | |
2967 | 1720 |
1285 | 1721 buf[sy*stride + sx]+= color; |
2967 | 1722 |
4001 | 1723 if(FFABS(ex - sx) > FFABS(ey - sy)){ |
1285 | 1724 if(sx > ex){ |
4120 | 1725 FFSWAP(int, sx, ex); |
1726 FFSWAP(int, sy, ey); | |
1285 | 1727 } |
1728 buf+= sx + sy*stride; | |
1729 ex-= sx; | |
1730 f= ((ey-sy)<<16)/ex; | |
1731 for(x= 0; x <= ex; x++){ | |
1918
ea20f38b8d57
nicer looking arrows for the motion vector vissualization
michael
parents:
1916
diff
changeset
|
1732 y = (x*f)>>16; |
ea20f38b8d57
nicer looking arrows for the motion vector vissualization
michael
parents:
1916
diff
changeset
|
1733 fr= (x*f)&0xFFFF; |
ea20f38b8d57
nicer looking arrows for the motion vector vissualization
michael
parents:
1916
diff
changeset
|
1734 buf[ y *stride + x]+= (color*(0x10000-fr))>>16; |
ea20f38b8d57
nicer looking arrows for the motion vector vissualization
michael
parents:
1916
diff
changeset
|
1735 buf[(y+1)*stride + x]+= (color* fr )>>16; |
1285 | 1736 } |
1737 }else{ | |
1738 if(sy > ey){ | |
4120 | 1739 FFSWAP(int, sx, ex); |
1740 FFSWAP(int, sy, ey); | |
1285 | 1741 } |
1742 buf+= sx + sy*stride; | |
1743 ey-= sy; | |
1744 if(ey) f= ((ex-sx)<<16)/ey; | |
1745 else f= 0; | |
1746 for(y= 0; y <= ey; y++){ | |
1918
ea20f38b8d57
nicer looking arrows for the motion vector vissualization
michael
parents:
1916
diff
changeset
|
1747 x = (y*f)>>16; |
ea20f38b8d57
nicer looking arrows for the motion vector vissualization
michael
parents:
1916
diff
changeset
|
1748 fr= (y*f)&0xFFFF; |
ea20f38b8d57
nicer looking arrows for the motion vector vissualization
michael
parents:
1916
diff
changeset
|
1749 buf[y*stride + x ]+= (color*(0x10000-fr))>>16;; |
ea20f38b8d57
nicer looking arrows for the motion vector vissualization
michael
parents:
1916
diff
changeset
|
1750 buf[y*stride + x+1]+= (color* fr )>>16;; |
1285 | 1751 } |
1752 } | |
1753 } | |
1754 | |
1755 /** | |
1756 * draws an arrow from (ex, ey) -> (sx, sy). | |
1757 * @param w width of the image | |
1758 * @param h height of the image | |
1759 * @param stride stride/linesize of the image | |
1760 * @param color color of the arrow | |
1761 */ | |
2967 | 1762 static void draw_arrow(uint8_t *buf, int sx, int sy, int ex, int ey, int w, int h, int stride, int color){ |
1285 | 1763 int dx,dy; |
1764 | |
1765 sx= clip(sx, -100, w+100); | |
1766 sy= clip(sy, -100, h+100); | |
1767 ex= clip(ex, -100, w+100); | |
1768 ey= clip(ey, -100, h+100); | |
2967 | 1769 |
1285 | 1770 dx= ex - sx; |
1771 dy= ey - sy; | |
2967 | 1772 |
1285 | 1773 if(dx*dx + dy*dy > 3*3){ |
1774 int rx= dx + dy; | |
1775 int ry= -dx + dy; | |
1776 int length= ff_sqrt((rx*rx + ry*ry)<<8); | |
2967 | 1777 |
1285 | 1778 //FIXME subpixel accuracy |
1779 rx= ROUNDED_DIV(rx*3<<4, length); | |
1780 ry= ROUNDED_DIV(ry*3<<4, length); | |
2967 | 1781 |
1285 | 1782 draw_line(buf, sx, sy, sx + rx, sy + ry, w, h, stride, color); |
1783 draw_line(buf, sx, sy, sx - ry, sy + rx, w, h, stride, color); | |
1784 } | |
1785 draw_line(buf, sx, sy, ex, ey, w, h, stride, color); | |
1786 } | |
1787 | |
1788 /** | |
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
|
1789 * 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
|
1790 */ |
1706
3ba5c493db6f
motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1705
diff
changeset
|
1791 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
|
1792 |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead 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 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
|
1794 |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead 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 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
|
1796 int x,y; |
2967 | 1797 |
1706
3ba5c493db6f
motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1705
diff
changeset
|
1798 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
|
1799 switch (pict->pict_type) { |
3ba5c493db6f
motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1705
diff
changeset
|
1800 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
|
1801 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
|
1802 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
|
1803 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
|
1804 case FF_SI_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"SI\n"); break; |
2967 | 1805 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
|
1806 } |
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
|
1807 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
|
1808 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
|
1809 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
|
1810 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
|
1811 if(count>9) count=9; |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1597
diff
changeset
|
1812 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
|
1813 } |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1173
diff
changeset
|
1814 if(s->avctx->debug&FF_DEBUG_QP){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1597
diff
changeset
|
1815 av_log(s->avctx, AV_LOG_DEBUG, "%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
|
1816 } |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1173
diff
changeset
|
1817 if(s->avctx->debug&FF_DEBUG_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
|
1818 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
|
1819 //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
|
1820 if(IS_PCM(mb_type)) |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1597
diff
changeset
|
1821 av_log(s->avctx, AV_LOG_DEBUG, "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
|
1822 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
|
1823 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
|
1824 else if(IS_INTRA4x4(mb_type)) |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1597
diff
changeset
|
1825 av_log(s->avctx, AV_LOG_DEBUG, "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
|
1826 else if(IS_INTRA16x16(mb_type)) |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1597
diff
changeset
|
1827 av_log(s->avctx, AV_LOG_DEBUG, "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
|
1828 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
|
1829 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
|
1830 else if(IS_DIRECT(mb_type)) |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1597
diff
changeset
|
1831 av_log(s->avctx, AV_LOG_DEBUG, "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
|
1832 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
|
1833 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
|
1834 else if(IS_GMC(mb_type)) |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1597
diff
changeset
|
1835 av_log(s->avctx, AV_LOG_DEBUG, "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
|
1836 else if(IS_SKIP(mb_type)) |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1597
diff
changeset
|
1837 av_log(s->avctx, AV_LOG_DEBUG, "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
|
1838 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
|
1839 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
|
1840 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
|
1841 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
|
1842 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
|
1843 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
|
1844 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
|
1845 } |
2967 | 1846 |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1173
diff
changeset
|
1847 //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
|
1848 if(IS_8X8(mb_type)) |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1597
diff
changeset
|
1849 av_log(s->avctx, AV_LOG_DEBUG, "+"); |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1173
diff
changeset
|
1850 else if(IS_16X8(mb_type)) |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1597
diff
changeset
|
1851 av_log(s->avctx, AV_LOG_DEBUG, "-"); |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1173
diff
changeset
|
1852 else if(IS_8X16(mb_type)) |
2677 | 1853 av_log(s->avctx, AV_LOG_DEBUG, "|"); |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1173
diff
changeset
|
1854 else if(IS_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
|
1855 av_log(s->avctx, AV_LOG_DEBUG, " "); |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1173
diff
changeset
|
1856 else |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1597
diff
changeset
|
1857 av_log(s->avctx, AV_LOG_DEBUG, "?"); |
2967 | 1858 |
1859 | |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1173
diff
changeset
|
1860 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
|
1861 av_log(s->avctx, AV_LOG_DEBUG, "="); |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1173
diff
changeset
|
1862 else |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1597
diff
changeset
|
1863 av_log(s->avctx, AV_LOG_DEBUG, " "); |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1173
diff
changeset
|
1864 } |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1597
diff
changeset
|
1865 // av_log(s->avctx, AV_LOG_DEBUG, " "); |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1173
diff
changeset
|
1866 } |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1597
diff
changeset
|
1867 av_log(s->avctx, AV_LOG_DEBUG, "\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
|
1868 } |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1173
diff
changeset
|
1869 } |
1668
30746f429df6
move motion_val & mb_type to AVFrame patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1662
diff
changeset
|
1870 |
1706
3ba5c493db6f
motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1705
diff
changeset
|
1871 if((s->avctx->debug&(FF_DEBUG_VIS_QP|FF_DEBUG_VIS_MB_TYPE)) || (s->avctx->debug_mv)){ |
1285 | 1872 const int shift= 1 + s->quarter_sample; |
1873 int mb_y; | |
1706
3ba5c493db6f
motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1705
diff
changeset
|
1874 uint8_t *ptr; |
1707 | 1875 int i; |
1723
033d889d7c2c
non YV12 vissualization fix by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1722
diff
changeset
|
1876 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
|
1877 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
|
1878 const int height= s->avctx->height; |
2395 | 1879 const int mv_sample_log2= 4 - pict->motion_subsample_log2; |
3268 | 1880 const int mv_stride= (s->mb_width << mv_sample_log2) + (s->codec_id == CODEC_ID_H264 ? 0 : 1); |
1285 | 1881 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
|
1882 |
1723
033d889d7c2c
non YV12 vissualization fix by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1722
diff
changeset
|
1883 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
|
1884 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
|
1885 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
|
1886 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
|
1887 } |
3ba5c493db6f
motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1705
diff
changeset
|
1888 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
|
1889 ptr= pict->data[0]; |
1285 | 1890 |
1891 for(mb_y=0; mb_y<s->mb_height; mb_y++){ | |
1892 int mb_x; | |
1893 for(mb_x=0; mb_x<s->mb_width; mb_x++){ | |
1894 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
|
1895 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
|
1896 int type; |
3ba5c493db6f
motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1705
diff
changeset
|
1897 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
|
1898 int direction = 0; |
1706
3ba5c493db6f
motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1705
diff
changeset
|
1899 switch (type) { |
3ba5c493db6f
motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1705
diff
changeset
|
1900 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
|
1901 continue; |
3ba5c493db6f
motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1705
diff
changeset
|
1902 direction = 0; |
3ba5c493db6f
motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1705
diff
changeset
|
1903 break; |
3ba5c493db6f
motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1705
diff
changeset
|
1904 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
|
1905 continue; |
3ba5c493db6f
motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1705
diff
changeset
|
1906 direction = 0; |
3ba5c493db6f
motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1705
diff
changeset
|
1907 break; |
3ba5c493db6f
motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1705
diff
changeset
|
1908 case 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
|
1909 continue; |
3ba5c493db6f
motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1705
diff
changeset
|
1910 direction = 1; |
3ba5c493db6f
motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1705
diff
changeset
|
1911 break; |
3ba5c493db6f
motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1705
diff
changeset
|
1912 } |
1712 | 1913 if(!USES_LIST(pict->mb_type[mb_index], direction)) |
1914 continue; | |
1915 | |
1706
3ba5c493db6f
motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1705
diff
changeset
|
1916 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
|
1917 int i; |
3ba5c493db6f
motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1705
diff
changeset
|
1918 for(i=0; i<4; i++){ |
1285 | 1919 int sx= mb_x*16 + 4 + 8*(i&1); |
1920 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
|
1921 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
|
1922 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
|
1923 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
|
1924 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
|
1925 } |
3ba5c493db6f
motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1705
diff
changeset
|
1926 }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
|
1927 int i; |
3ba5c493db6f
motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1705
diff
changeset
|
1928 for(i=0; i<2; i++){ |
1629
74685a0ec851
16x8 MV vissualization by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1628
diff
changeset
|
1929 int sx=mb_x*16 + 8; |
74685a0ec851
16x8 MV vissualization by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1628
diff
changeset
|
1930 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
|
1931 int xy= (mb_x*2 + (mb_y*2 + i)*mv_stride) << (mv_sample_log2-1); |
2395 | 1932 int mx=(pict->motion_val[direction][xy][0]>>shift); |
1933 int my=(pict->motion_val[direction][xy][1]>>shift); | |
2967 | 1934 |
2395 | 1935 if(IS_INTERLACED(pict->mb_type[mb_index])) |
1936 my*=2; | |
2967 | 1937 |
2395 | 1938 draw_arrow(ptr, sx, sy, mx+sx, my+sy, width, height, s->linesize, 100); |
1939 } | |
1940 }else if(IS_8X16(pict->mb_type[mb_index])){ | |
1941 int i; | |
1942 for(i=0; i<2; i++){ | |
1943 int sx=mb_x*16 + 4 + 8*i; | |
1944 int sy=mb_y*16 + 8; | |
2522
e25782262d7d
kill warnings patch by (M«©ns Rullg«©rd <mru inprovide com>)
michael
parents:
2514
diff
changeset
|
1945 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
|
1946 int mx=(pict->motion_val[direction][xy][0]>>shift); |
b306574523ad
fix y scale of mv vissualization of interlaced MVs
michael
parents:
1945
diff
changeset
|
1947 int my=(pict->motion_val[direction][xy][1]>>shift); |
2967 | 1948 |
1947
b306574523ad
fix y scale of mv vissualization of interlaced MVs
michael
parents:
1945
diff
changeset
|
1949 if(IS_INTERLACED(pict->mb_type[mb_index])) |
b306574523ad
fix y scale of mv vissualization of interlaced MVs
michael
parents:
1945
diff
changeset
|
1950 my*=2; |
2967 | 1951 |
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
|
1952 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
|
1953 } |
3ba5c493db6f
motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1705
diff
changeset
|
1954 }else{ |
3ba5c493db6f
motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1705
diff
changeset
|
1955 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
|
1956 int sy= mb_y*16 + 8; |
2395 | 1957 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
|
1958 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
|
1959 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
|
1960 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
|
1961 } |
2967 | 1962 } |
1685 | 1963 } |
1964 if((s->avctx->debug&FF_DEBUG_VIS_QP) && pict->motion_val){ | |
1965 uint64_t c= (pict->qscale_table[mb_index]*128/31) * 0x0101010101010101ULL; | |
1966 int y; | |
1967 for(y=0; y<8; y++){ | |
1968 *(uint64_t*)(pict->data[1] + 8*mb_x + (8*mb_y + y)*pict->linesize[1])= c; | |
1969 *(uint64_t*)(pict->data[2] + 8*mb_x + (8*mb_y + y)*pict->linesize[2])= c; | |
1970 } | |
1971 } | |
1972 if((s->avctx->debug&FF_DEBUG_VIS_MB_TYPE) && pict->motion_val){ | |
1973 int mb_type= pict->mb_type[mb_index]; | |
1974 uint64_t u,v; | |
1975 int y; | |
1976 #define COLOR(theta, r)\ | |
1977 u= (int)(128 + r*cos(theta*3.141592/180));\ | |
1978 v= (int)(128 + r*sin(theta*3.141592/180)); | |
1979 | |
2967 | 1980 |
1685 | 1981 u=v=128; |
1982 if(IS_PCM(mb_type)){ | |
1983 COLOR(120,48) | |
1984 }else if((IS_INTRA(mb_type) && IS_ACPRED(mb_type)) || IS_INTRA16x16(mb_type)){ | |
1985 COLOR(30,48) | |
1986 }else if(IS_INTRA4x4(mb_type)){ | |
1987 COLOR(90,48) | |
1988 }else if(IS_DIRECT(mb_type) && IS_SKIP(mb_type)){ | |
1989 // COLOR(120,48) | |
1990 }else if(IS_DIRECT(mb_type)){ | |
1991 COLOR(150,48) | |
1992 }else if(IS_GMC(mb_type) && IS_SKIP(mb_type)){ | |
1993 COLOR(170,48) | |
1994 }else if(IS_GMC(mb_type)){ | |
1995 COLOR(190,48) | |
1996 }else if(IS_SKIP(mb_type)){ | |
1997 // COLOR(180,48) | |
1998 }else if(!USES_LIST(mb_type, 1)){ | |
1999 COLOR(240,48) | |
2000 }else if(!USES_LIST(mb_type, 0)){ | |
2001 COLOR(0,48) | |
2002 }else{ | |
2003 assert(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1)); | |
2004 COLOR(300,48) | |
2005 } | |
2006 | |
2007 u*= 0x0101010101010101ULL; | |
2008 v*= 0x0101010101010101ULL; | |
2009 for(y=0; y<8; y++){ | |
2010 *(uint64_t*)(pict->data[1] + 8*mb_x + (8*mb_y + y)*pict->linesize[1])= u; | |
2011 *(uint64_t*)(pict->data[2] + 8*mb_x + (8*mb_y + y)*pict->linesize[2])= v; | |
2012 } | |
2013 | |
2014 //segmentation | |
2015 if(IS_8X8(mb_type) || IS_16X8(mb_type)){ | |
2016 *(uint64_t*)(pict->data[0] + 16*mb_x + 0 + (16*mb_y + 8)*pict->linesize[0])^= 0x8080808080808080ULL; | |
2017 *(uint64_t*)(pict->data[0] + 16*mb_x + 8 + (16*mb_y + 8)*pict->linesize[0])^= 0x8080808080808080ULL; | |
2018 } | |
2019 if(IS_8X8(mb_type) || IS_8X16(mb_type)){ | |
2020 for(y=0; y<16; y++) | |
2021 pict->data[0][16*mb_x + 8 + (16*mb_y + y)*pict->linesize[0]]^= 0x80; | |
2022 } | |
2534 | 2023 if(IS_8X8(mb_type) && mv_sample_log2 >= 2){ |
2024 int dm= 1 << (mv_sample_log2-2); | |
2025 for(i=0; i<4; i++){ | |
2026 int sx= mb_x*16 + 8*(i&1); | |
2027 int sy= mb_y*16 + 8*(i>>1); | |
2028 int xy= (mb_x*2 + (i&1) + (mb_y*2 + (i>>1))*mv_stride) << (mv_sample_log2-1); | |
2029 //FIXME bidir | |
2030 int32_t *mv = (int32_t*)&pict->motion_val[0][xy]; | |
2031 if(mv[0] != mv[dm] || mv[dm*mv_stride] != mv[dm*(mv_stride+1)]) | |
2032 for(y=0; y<8; y++) | |
2033 pict->data[0][sx + 4 + (sy + y)*pict->linesize[0]]^= 0x80; | |
2034 if(mv[0] != mv[dm*mv_stride] || mv[dm] != mv[dm*(mv_stride+1)]) | |
2035 *(uint64_t*)(pict->data[0] + sx + (sy + 4)*pict->linesize[0])^= 0x8080808080808080ULL; | |
2036 } | |
2037 } | |
2967 | 2038 |
1685 | 2039 if(IS_INTERLACED(mb_type) && s->codec_id == CODEC_ID_H264){ |
2040 // hmm | |
2041 } | |
1285 | 2042 } |
2043 s->mbskip_table[mb_index]=0; | |
2044 } | |
2045 } | |
2046 } | |
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
|
2047 } |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1173
diff
changeset
|
2048 |
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
|
2049 #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
|
2050 |
915 | 2051 static int get_sae(uint8_t *src, int ref, int stride){ |
2052 int x,y; | |
2053 int acc=0; | |
2967 | 2054 |
915 | 2055 for(y=0; y<16; y++){ |
2056 for(x=0; x<16; x++){ | |
4001 | 2057 acc+= FFABS(src[x+y*stride] - ref); |
915 | 2058 } |
2059 } | |
2967 | 2060 |
915 | 2061 return acc; |
2062 } | |
2063 | |
2064 static int get_intra_count(MpegEncContext *s, uint8_t *src, uint8_t *ref, int stride){ | |
2065 int x, y, w, h; | |
2066 int acc=0; | |
2967 | 2067 |
915 | 2068 w= s->width &~15; |
2069 h= s->height&~15; | |
2967 | 2070 |
915 | 2071 for(y=0; y<h; y+=16){ |
2072 for(x=0; x<w; x+=16){ | |
2073 int offset= x + y*stride; | |
1708 | 2074 int sad = s->dsp.sad[0](NULL, src + offset, ref + offset, stride, 16); |
915 | 2075 int mean= (s->dsp.pix_sum(src + offset, stride) + 128)>>8; |
2076 int sae = get_sae(src + offset, mean, stride); | |
2967 | 2077 |
915 | 2078 acc+= sae + 500 < sad; |
2079 } | |
2080 } | |
2081 return acc; | |
2082 } | |
2083 | |
924 | 2084 |
925 | 2085 static int load_input_picture(MpegEncContext *s, AVFrame *pic_arg){ |
1373 | 2086 AVFrame *pic=NULL; |
2427 | 2087 int64_t pts; |
924 | 2088 int i; |
903 | 2089 const int encoding_delay= s->max_b_frames; |
924 | 2090 int direct=1; |
2967 | 2091 |
2419 | 2092 if(pic_arg){ |
2427 | 2093 pts= pic_arg->pts; |
2094 pic_arg->display_picture_number= s->input_picture_number++; | |
2095 | |
2967 | 2096 if(pts != AV_NOPTS_VALUE){ |
2419 | 2097 if(s->user_specified_pts != AV_NOPTS_VALUE){ |
2637 | 2098 int64_t time= pts; |
2099 int64_t last= s->user_specified_pts; | |
2967 | 2100 |
2101 if(time <= last){ | |
2962 | 2102 av_log(s->avctx, AV_LOG_ERROR, "Error, Invalid timestamp=%"PRId64", last=%"PRId64"\n", pts, s->user_specified_pts); |
2419 | 2103 return -1; |
2104 } | |
2105 } | |
2427 | 2106 s->user_specified_pts= pts; |
2419 | 2107 }else{ |
2108 if(s->user_specified_pts != AV_NOPTS_VALUE){ | |
2967 | 2109 s->user_specified_pts= |
2637 | 2110 pts= s->user_specified_pts + 1; |
2962 | 2111 av_log(s->avctx, AV_LOG_INFO, "Warning: AVFrame.pts=? trying to guess (%"PRId64")\n", pts); |
2419 | 2112 }else{ |
2637 | 2113 pts= pic_arg->display_picture_number; |
2419 | 2114 } |
2115 } | |
2116 } | |
2117 | |
1373 | 2118 if(pic_arg){ |
924 | 2119 if(encoding_delay && !(s->flags&CODEC_FLAG_INPUT_PRESERVED)) direct=0; |
2120 if(pic_arg->linesize[0] != s->linesize) direct=0; | |
2121 if(pic_arg->linesize[1] != s->uvlinesize) direct=0; | |
2122 if(pic_arg->linesize[2] != s->uvlinesize) direct=0; | |
2967 | 2123 |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1597
diff
changeset
|
2124 // av_log(AV_LOG_DEBUG, "%d %d %d %d\n",pic_arg->linesize[0], pic_arg->linesize[1], s->linesize, s->uvlinesize); |
2967 | 2125 |
924 | 2126 if(direct){ |
1586 | 2127 i= ff_find_unused_picture(s, 1); |
924 | 2128 |
925 | 2129 pic= (AVFrame*)&s->picture[i]; |
1168 | 2130 pic->reference= 3; |
2967 | 2131 |
924 | 2132 for(i=0; i<4; i++){ |
2133 pic->data[i]= pic_arg->data[i]; | |
2134 pic->linesize[i]= pic_arg->linesize[i]; | |
2135 } | |
2136 alloc_picture(s, (Picture*)pic, 1); | |
2137 }else{ | |
1586 | 2138 i= ff_find_unused_picture(s, 0); |
924 | 2139 |
925 | 2140 pic= (AVFrame*)&s->picture[i]; |
1168 | 2141 pic->reference= 3; |
924 | 2142 |
2143 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
|
2144 |
3068 | 2145 if( pic->data[0] + INPLACE_OFFSET == pic_arg->data[0] |
2146 && pic->data[1] + INPLACE_OFFSET == pic_arg->data[1] | |
2147 && pic->data[2] + INPLACE_OFFSET == pic_arg->data[2]){ | |
924 | 2148 // empty |
2149 }else{ | |
2150 int h_chroma_shift, v_chroma_shift; | |
2151 avcodec_get_chroma_sub_sample(s->avctx->pix_fmt, &h_chroma_shift, &v_chroma_shift); | |
2967 | 2152 |
924 | 2153 for(i=0; i<3; i++){ |
2154 int src_stride= pic_arg->linesize[i]; | |
2155 int dst_stride= i ? s->uvlinesize : s->linesize; | |
2156 int h_shift= i ? h_chroma_shift : 0; | |
2157 int v_shift= i ? v_chroma_shift : 0; | |
2158 int w= s->width >>h_shift; | |
2159 int h= s->height>>v_shift; | |
2160 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
|
2161 uint8_t *dst= pic->data[i]; |
16ace038f452
fix buffer underflows by reencoding the current frame with a higher QP
michael
parents:
3929
diff
changeset
|
2162 |
16ace038f452
fix buffer underflows by reencoding the current frame with a higher QP
michael
parents:
3929
diff
changeset
|
2163 if(!s->avctx->rc_buffer_size) |
16ace038f452
fix buffer underflows by reencoding the current frame with a higher QP
michael
parents:
3929
diff
changeset
|
2164 dst +=INPLACE_OFFSET; |
2967 | 2165 |
924 | 2166 if(src_stride==dst_stride) |
2167 memcpy(dst, src, src_stride*h); | |
2168 else{ | |
2169 while(h--){ | |
2170 memcpy(dst, src, w); | |
2171 dst += dst_stride; | |
2172 src += src_stride; | |
2173 } | |
2174 } | |
2175 } | |
2176 } | |
324 | 2177 } |
1938
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1918
diff
changeset
|
2178 copy_picture_attributes(s, pic, pic_arg); |
2427 | 2179 pic->pts= pts; //we set this here to avoid modifiying pic_arg |
1373 | 2180 } |
2967 | 2181 |
903 | 2182 /* shift buffer entries */ |
2183 for(i=1; i<MAX_PICTURE_COUNT /*s->encoding_delay+1*/; i++) | |
2184 s->input_picture[i-1]= s->input_picture[i]; | |
2967 | 2185 |
903 | 2186 s->input_picture[encoding_delay]= (Picture*)pic; |
2187 | |
2188 return 0; | |
2189 } | |
2190 | |
2381 | 2191 static int skip_check(MpegEncContext *s, Picture *p, Picture *ref){ |
2192 int x, y, plane; | |
2193 int score=0; | |
2382 | 2194 int64_t score64=0; |
2381 | 2195 |
2196 for(plane=0; plane<3; plane++){ | |
2197 const int stride= p->linesize[plane]; | |
2198 const int bw= plane ? 1 : 2; | |
2199 for(y=0; y<s->mb_height*bw; y++){ | |
2200 for(x=0; x<s->mb_width*bw; x++){ | |
2931 | 2201 int off= p->type == FF_BUFFER_TYPE_SHARED ? 0: 16; |
2202 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 | 2203 |
2382 | 2204 switch(s->avctx->frame_skip_exp){ |
2205 case 0: score= FFMAX(score, v); break; | |
4001 | 2206 case 1: score+= FFABS(v);break; |
2382 | 2207 case 2: score+= v*v;break; |
4001 | 2208 case 3: score64+= FFABS(v*v*(int64_t)v);break; |
2382 | 2209 case 4: score64+= v*v*(int64_t)(v*v);break; |
2210 } | |
2381 | 2211 } |
2212 } | |
2213 } | |
2967 | 2214 |
2382 | 2215 if(score) score64= score; |
2216 | |
2217 if(score64 < s->avctx->frame_skip_threshold) | |
2381 | 2218 return 1; |
2382 | 2219 if(score64 < ((s->avctx->frame_skip_factor * (int64_t)s->lambda)>>8)) |
2381 | 2220 return 1; |
2221 return 0; | |
2222 } | |
2223 | |
2988 | 2224 static int estimate_best_b_count(MpegEncContext *s){ |
2225 AVCodec *codec= avcodec_find_encoder(s->avctx->codec_id); | |
2226 AVCodecContext *c= avcodec_alloc_context(); | |
2227 AVFrame input[FF_MAX_B_FRAMES+2]; | |
2990
0300c2647bc3
support downscaling frames for dynamic b frame decission
michael
parents:
2988
diff
changeset
|
2228 const int scale= s->avctx->brd_scale; |
3068 | 2229 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
|
2230 int outbuf_size= s->width * s->height; //FIXME |
2988 | 2231 uint8_t *outbuf= av_malloc(outbuf_size); |
2232 int64_t best_rd= INT64_MAX; | |
2233 int best_b_count= -1; | |
3068 | 2234 |
3245 | 2235 assert(scale>=0 && scale <=3); |
2236 | |
3068 | 2237 // emms_c(); |
2238 p_lambda= s->last_lambda_for[P_TYPE]; //s->next_picture_ptr->quality; | |
4001 | 2239 b_lambda= s->last_lambda_for[B_TYPE]; //p_lambda *FFABS(s->avctx->b_quant_factor) + s->avctx->b_quant_offset; |
3068 | 2240 if(!b_lambda) b_lambda= p_lambda; //FIXME we should do this somewhere else |
2241 lambda2= (b_lambda*b_lambda + (1<<FF_LAMBDA_SHIFT)/2 ) >> FF_LAMBDA_SHIFT; | |
2988 | 2242 |
2243 c->width = s->width >> scale; | |
2244 c->height= s->height>> scale; | |
2245 c->flags= CODEC_FLAG_QSCALE | CODEC_FLAG_PSNR | CODEC_FLAG_INPUT_PRESERVED /*| CODEC_FLAG_EMU_EDGE*/; | |
2246 c->flags|= s->avctx->flags & CODEC_FLAG_QPEL; | |
2247 c->mb_decision= s->avctx->mb_decision; | |
2248 c->me_cmp= s->avctx->me_cmp; | |
2249 c->mb_cmp= s->avctx->mb_cmp; | |
2250 c->me_sub_cmp= s->avctx->me_sub_cmp; | |
2251 c->pix_fmt = PIX_FMT_YUV420P; | |
2252 c->time_base= s->avctx->time_base; | |
2253 c->max_b_frames= s->max_b_frames; | |
2254 | |
2255 if (avcodec_open(c, codec) < 0) | |
2256 return -1; | |
2257 | |
2258 for(i=0; i<s->max_b_frames+2; i++){ | |
2259 int ysize= c->width*c->height; | |
2260 int csize= (c->width/2)*(c->height/2); | |
3068 | 2261 Picture pre_input, *pre_input_ptr= i ? s->input_picture[i-1] : s->next_picture_ptr; |
2262 | |
2263 if(pre_input_ptr) | |
2264 pre_input= *pre_input_ptr; | |
2265 | |
2266 if(pre_input.type != FF_BUFFER_TYPE_SHARED && i){ | |
2267 pre_input.data[0]+=INPLACE_OFFSET; | |
2268 pre_input.data[1]+=INPLACE_OFFSET; | |
2269 pre_input.data[2]+=INPLACE_OFFSET; | |
2270 } | |
2988 | 2271 |
2272 avcodec_get_frame_defaults(&input[i]); | |
2273 input[i].data[0]= av_malloc(ysize + 2*csize); | |
2274 input[i].data[1]= input[i].data[0] + ysize; | |
2275 input[i].data[2]= input[i].data[1] + csize; | |
2276 input[i].linesize[0]= c->width; | |
2277 input[i].linesize[1]= | |
2278 input[i].linesize[2]= c->width/2; | |
2279 | |
3245 | 2280 if(!i || s->input_picture[i-1]){ |
2281 s->dsp.shrink[scale](input[i].data[0], input[i].linesize[0], pre_input.data[0], pre_input.linesize[0], c->width, c->height); | |
2282 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); | |
2283 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); | |
2284 } | |
2988 | 2285 } |
2286 | |
2287 for(j=0; j<s->max_b_frames+1; j++){ | |
2288 int64_t rd=0; | |
2289 | |
2290 if(!s->input_picture[j]) | |
2291 break; | |
2292 | |
2293 c->error[0]= c->error[1]= c->error[2]= 0; | |
2294 | |
2295 input[0].pict_type= I_TYPE; | |
3068 | 2296 input[0].quality= 1 * FF_QP2LAMBDA; |
2988 | 2297 out_size = avcodec_encode_video(c, outbuf, outbuf_size, &input[0]); |
3068 | 2298 // rd += (out_size * lambda2) >> FF_LAMBDA_SHIFT; |
2988 | 2299 |
2300 for(i=0; i<s->max_b_frames+1; i++){ | |
2301 int is_p= i % (j+1) == j || i==s->max_b_frames; | |
2302 | |
2303 input[i+1].pict_type= is_p ? P_TYPE : B_TYPE; | |
3068 | 2304 input[i+1].quality= is_p ? p_lambda : b_lambda; |
2988 | 2305 out_size = avcodec_encode_video(c, outbuf, outbuf_size, &input[i+1]); |
3068 | 2306 rd += (out_size * lambda2) >> (FF_LAMBDA_SHIFT - 3); |
2988 | 2307 } |
2308 | |
2309 /* get the delayed frames */ | |
2310 while(out_size){ | |
2311 out_size = avcodec_encode_video(c, outbuf, outbuf_size, NULL); | |
3068 | 2312 rd += (out_size * lambda2) >> (FF_LAMBDA_SHIFT - 3); |
2988 | 2313 } |
2314 | |
2315 rd += c->error[0] + c->error[1] + c->error[2]; | |
2316 | |
2317 if(rd < best_rd){ | |
2318 best_rd= rd; | |
2319 best_b_count= j; | |
2320 } | |
2321 } | |
2322 | |
2323 av_freep(&outbuf); | |
2324 avcodec_close(c); | |
2325 av_freep(&c); | |
2326 | |
2327 for(i=0; i<s->max_b_frames+2; i++){ | |
2328 av_freep(&input[i].data[0]); | |
2329 } | |
2330 | |
2331 return best_b_count; | |
2332 } | |
2333 | |
903 | 2334 static void select_input_picture(MpegEncContext *s){ |
2335 int i; | |
924 | 2336 |
903 | 2337 for(i=1; i<MAX_PICTURE_COUNT; i++) |
2338 s->reordered_input_picture[i-1]= s->reordered_input_picture[i]; | |
2339 s->reordered_input_picture[MAX_PICTURE_COUNT-1]= NULL; | |
2340 | |
2764 | 2341 /* set next picture type & ordering */ |
903 | 2342 if(s->reordered_input_picture[0]==NULL && s->input_picture[0]){ |
1138 | 2343 if(/*s->picture_in_gop_number >= s->gop_size ||*/ s->next_picture_ptr==NULL || s->intra_only){ |
915 | 2344 s->reordered_input_picture[0]= s->input_picture[0]; |
2345 s->reordered_input_picture[0]->pict_type= I_TYPE; | |
1705 | 2346 s->reordered_input_picture[0]->coded_picture_number= s->coded_picture_number++; |
915 | 2347 }else{ |
2348 int b_frames; | |
2381 | 2349 |
2350 if(s->avctx->frame_skip_threshold || s->avctx->frame_skip_factor){ | |
2931 | 2351 if(s->picture_in_gop_number < s->gop_size && skip_check(s, s->input_picture[0], s->next_picture_ptr)){ |
2352 //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
|
2353 //av_log(NULL, AV_LOG_DEBUG, "skip %p %"PRId64"\n", s->input_picture[0]->data[0], s->input_picture[0]->pts); |
2967 | 2354 |
2381 | 2355 if(s->input_picture[0]->type == FF_BUFFER_TYPE_SHARED){ |
2356 for(i=0; i<4; i++) | |
2357 s->input_picture[0]->data[i]= NULL; | |
2967 | 2358 s->input_picture[0]->type= 0; |
2381 | 2359 }else{ |
2967 | 2360 assert( s->input_picture[0]->type==FF_BUFFER_TYPE_USER |
2381 | 2361 || s->input_picture[0]->type==FF_BUFFER_TYPE_INTERNAL); |
2967 | 2362 |
2381 | 2363 s->avctx->release_buffer(s->avctx, (AVFrame*)s->input_picture[0]); |
2364 } | |
2967 | 2365 |
2931 | 2366 emms_c(); |
2367 ff_vbv_update(s, 0); | |
2381 | 2368 |
2369 goto no_output_pic; | |
2370 } | |
2371 } | |
2372 | |
915 | 2373 if(s->flags&CODEC_FLAG_PASS2){ |
2374 for(i=0; i<s->max_b_frames+1; i++){ | |
2375 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
|
2376 |
2967 | 2377 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
|
2378 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
|
2379 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
|
2380 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
|
2381 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
|
2382 } |
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 |
2967 | 2384 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
|
2385 s->rc_context.entry[pict_num].new_pict_type; |
915 | 2386 } |
2387 } | |
924 | 2388 |
2297 | 2389 if(s->avctx->b_frame_strategy==0){ |
915 | 2390 b_frames= s->max_b_frames; |
1373 | 2391 while(b_frames && !s->input_picture[b_frames]) b_frames--; |
1687 | 2392 }else if(s->avctx->b_frame_strategy==1){ |
915 | 2393 for(i=1; i<s->max_b_frames+1; i++){ |
1373 | 2394 if(s->input_picture[i] && s->input_picture[i]->b_frame_score==0){ |
2967 | 2395 s->input_picture[i]->b_frame_score= |
2396 get_intra_count(s, s->input_picture[i ]->data[0], | |
924 | 2397 s->input_picture[i-1]->data[0], s->linesize) + 1; |
915 | 2398 } |
2399 } | |
2728 | 2400 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
|
2401 if(s->input_picture[i]==NULL || s->input_picture[i]->b_frame_score - 1 > s->mb_num/s->avctx->b_sensitivity) break; |
915 | 2402 } |
2967 | 2403 |
915 | 2404 b_frames= FFMAX(0, i-1); |
2967 | 2405 |
915 | 2406 /* reset scores */ |
2407 for(i=0; i<b_frames+1; i++){ | |
2408 s->input_picture[i]->b_frame_score=0; | |
2409 } | |
2988 | 2410 }else if(s->avctx->b_frame_strategy==2){ |
2411 b_frames= estimate_best_b_count(s); | |
915 | 2412 }else{ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1597
diff
changeset
|
2413 av_log(s->avctx, AV_LOG_ERROR, "illegal b frame strategy\n"); |
915 | 2414 b_frames=0; |
909
8ae1e4c24e91
new PSNR code (now works with chroma, b frames, ...)
michaelni
parents:
903
diff
changeset
|
2415 } |
915 | 2416 |
2417 emms_c(); | |
2418 //static int b_count=0; | |
2419 //b_count+= b_frames; | |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1597
diff
changeset
|
2420 //av_log(s->avctx, AV_LOG_DEBUG, "b_frames: %d\n", b_count); |
2297 | 2421 |
2422 for(i= b_frames - 1; i>=0; i--){ | |
2423 int type= s->input_picture[i]->pict_type; | |
2424 if(type && type != B_TYPE) | |
2425 b_frames= i; | |
2426 } | |
2427 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
|
2428 av_log(s->avctx, AV_LOG_ERROR, "warning, too many b frames in a row\n"); |
2297 | 2429 } |
2430 | |
1754
bdf3927bf8c5
closed gop support & flags2 as all bits in flags are used
michael
parents:
1751
diff
changeset
|
2431 if(s->picture_in_gop_number + b_frames >= s->gop_size){ |
2298 | 2432 if((s->flags2 & CODEC_FLAG2_STRICT_GOP) && s->gop_size > s->picture_in_gop_number){ |
2433 b_frames= s->gop_size - s->picture_in_gop_number - 1; | |
2434 }else{ | |
1754
bdf3927bf8c5
closed gop support & flags2 as all bits in flags are used
michael
parents:
1751
diff
changeset
|
2435 if(s->flags & CODEC_FLAG_CLOSED_GOP) |
bdf3927bf8c5
closed gop support & flags2 as all bits in flags are used
michael
parents:
1751
diff
changeset
|
2436 b_frames=0; |
bdf3927bf8c5
closed gop support & flags2 as all bits in flags are used
michael
parents:
1751
diff
changeset
|
2437 s->input_picture[b_frames]->pict_type= I_TYPE; |
2298 | 2438 } |
1754
bdf3927bf8c5
closed gop support & flags2 as all bits in flags are used
michael
parents:
1751
diff
changeset
|
2439 } |
2967 | 2440 |
1754
bdf3927bf8c5
closed gop support & flags2 as all bits in flags are used
michael
parents:
1751
diff
changeset
|
2441 if( (s->flags & CODEC_FLAG_CLOSED_GOP) |
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 && 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
|
2444 b_frames--; |
bdf3927bf8c5
closed gop support & flags2 as all bits in flags are used
michael
parents:
1751
diff
changeset
|
2445 |
915 | 2446 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
|
2447 if(s->reordered_input_picture[0]->pict_type != I_TYPE) |
915 | 2448 s->reordered_input_picture[0]->pict_type= P_TYPE; |
1705 | 2449 s->reordered_input_picture[0]->coded_picture_number= s->coded_picture_number++; |
915 | 2450 for(i=0; i<b_frames; i++){ |
2451 s->reordered_input_picture[i+1]= s->input_picture[i]; | |
2452 s->reordered_input_picture[i+1]->pict_type= B_TYPE; | |
1705 | 2453 s->reordered_input_picture[i+1]->coded_picture_number= s->coded_picture_number++; |
903 | 2454 } |
324 | 2455 } |
2456 } | |
2381 | 2457 no_output_pic: |
903 | 2458 if(s->reordered_input_picture[0]){ |
1168 | 2459 s->reordered_input_picture[0]->reference= s->reordered_input_picture[0]->pict_type!=B_TYPE ? 3 : 0; |
1138 | 2460 |
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
|
2461 copy_picture(&s->new_picture, s->reordered_input_picture[0]); |
924 | 2462 |
3939
16ace038f452
fix buffer underflows by reencoding the current frame with a higher QP
michael
parents:
3929
diff
changeset
|
2463 if(s->reordered_input_picture[0]->type == FF_BUFFER_TYPE_SHARED || s->avctx->rc_buffer_size){ |
2764 | 2464 // input is a shared pix, so we can't modifiy it -> alloc a new one & ensure that the shared one is reuseable |
2967 | 2465 |
1586 | 2466 int i= ff_find_unused_picture(s, 0); |
924 | 2467 Picture *pic= &s->picture[i]; |
2468 | |
3939
16ace038f452
fix buffer underflows by reencoding the current frame with a higher QP
michael
parents:
3929
diff
changeset
|
2469 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
|
2470 alloc_picture(s, pic, 0); |
16ace038f452
fix buffer underflows by reencoding the current frame with a higher QP
michael
parents:
3929
diff
changeset
|
2471 |
924 | 2472 /* 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
|
2473 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
|
2474 s->avctx->release_buffer(s->avctx, (AVFrame*)s->reordered_input_picture[0]); |
924 | 2475 for(i=0; i<4; i++) |
2476 s->reordered_input_picture[0]->data[i]= NULL; | |
2477 s->reordered_input_picture[0]->type= 0; | |
2967 | 2478 |
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
|
2479 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
|
2480 |
1138 | 2481 s->current_picture_ptr= pic; |
924 | 2482 }else{ |
1138 | 2483 // input is not a shared pix -> reuse buffer for current_pix |
2484 | |
2967 | 2485 assert( s->reordered_input_picture[0]->type==FF_BUFFER_TYPE_USER |
924 | 2486 || s->reordered_input_picture[0]->type==FF_BUFFER_TYPE_INTERNAL); |
2967 | 2487 |
1138 | 2488 s->current_picture_ptr= s->reordered_input_picture[0]; |
924 | 2489 for(i=0; i<4; i++){ |
3068 | 2490 s->new_picture.data[i]+= INPLACE_OFFSET; |
924 | 2491 } |
903 | 2492 } |
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
|
2493 copy_picture(&s->current_picture, s->current_picture_ptr); |
2967 | 2494 |
903 | 2495 s->picture_number= s->new_picture.display_picture_number; |
2496 //printf("dpn:%d\n", s->picture_number); | |
2497 }else{ | |
2498 memset(&s->new_picture, 0, sizeof(Picture)); | |
324 | 2499 } |
2500 } | |
2501 | |
0 | 2502 int MPV_encode_picture(AVCodecContext *avctx, |
2503 unsigned char *buf, int buf_size, void *data) | |
2504 { | |
2505 MpegEncContext *s = avctx->priv_data; | |
925 | 2506 AVFrame *pic_arg = data; |
1684 | 2507 int i, stuffing_count; |
0 | 2508 |
1799 | 2509 for(i=0; i<avctx->thread_count; i++){ |
1838 | 2510 int start_y= s->thread_context[i]->start_mb_y; |
2511 int end_y= s->thread_context[i]-> end_mb_y; | |
1799 | 2512 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
|
2513 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
|
2514 uint8_t *end = buf + (size_t)(((int64_t) buf_size)* end_y/h); |
1799 | 2515 |
2516 init_put_bits(&s->thread_context[i]->pb, start, end - start); | |
2517 } | |
0 | 2518 |
903 | 2519 s->picture_in_gop_number++; |
2520 | |
2243
b8bad8bbbc64
check if the user specified timestamps are strictly monotone
michael
parents:
2235
diff
changeset
|
2521 if(load_input_picture(s, pic_arg) < 0) |
b8bad8bbbc64
check if the user specified timestamps are strictly monotone
michael
parents:
2235
diff
changeset
|
2522 return -1; |
2967 | 2523 |
903 | 2524 select_input_picture(s); |
2967 | 2525 |
324 | 2526 /* output? */ |
903 | 2527 if(s->new_picture.data[0]){ |
2528 s->pict_type= s->new_picture.pict_type; | |
2529 //emms_c(); | |
2530 //printf("qs:%f %f %d\n", s->new_picture.quality, s->current_picture.quality, s->qscale); | |
553 | 2531 MPV_frame_start(s, avctx); |
3939
16ace038f452
fix buffer underflows by reencoding the current frame with a higher QP
michael
parents:
3929
diff
changeset
|
2532 vbv_retry: |
3766 | 2533 if (encode_picture(s, s->picture_number) < 0) |
2534 return -1; | |
2967 | 2535 |
376 | 2536 avctx->real_pict_num = s->picture_number; |
324 | 2537 avctx->header_bits = s->header_bits; |
2538 avctx->mv_bits = s->mv_bits; | |
2539 avctx->misc_bits = s->misc_bits; | |
2540 avctx->i_tex_bits = s->i_tex_bits; | |
2541 avctx->p_tex_bits = s->p_tex_bits; | |
2542 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
|
2543 avctx->p_count = s->mb_num - s->i_count - s->skip_count; //FIXME f/b_count in avctx |
324 | 2544 avctx->skip_count = s->skip_count; |
0 | 2545 |
324 | 2546 MPV_frame_end(s); |
2547 | |
2548 if (s->out_format == FMT_MJPEG) | |
2549 mjpeg_picture_trailer(s); | |
2967 | 2550 |
3939
16ace038f452
fix buffer underflows by reencoding the current frame with a higher QP
michael
parents:
3929
diff
changeset
|
2551 if(avctx->rc_buffer_size){ |
16ace038f452
fix buffer underflows by reencoding the current frame with a higher QP
michael
parents:
3929
diff
changeset
|
2552 RateControlContext *rcc= &s->rc_context; |
16ace038f452
fix buffer underflows by reencoding the current frame with a higher QP
michael
parents:
3929
diff
changeset
|
2553 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
|
2554 |
4096
99616a74260a
use lambda/lmax instead of qscale/qmax as end check for vbv retry
michael
parents:
4052
diff
changeset
|
2555 if(put_bits_count(&s->pb) > max_size && s->lambda < s->avctx->lmax){ |
4052 | 2556 s->next_lambda= FFMAX(s->lambda+1, s->lambda*(s->qscale+1) / s->qscale); |
4218 | 2557 if(s->adaptive_quant){ |
2558 int i; | |
4223 | 2559 for(i=0; i<s->mb_height*s->mb_stride; i++) |
4218 | 2560 s->lambda_table[i]= FFMAX(s->lambda_table[i]+1, s->lambda_table[i]*(s->qscale+1) / s->qscale); |
2561 } | |
3939
16ace038f452
fix buffer underflows by reencoding the current frame with a higher QP
michael
parents:
3929
diff
changeset
|
2562 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
|
2563 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
|
2564 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
|
2565 s->no_rounding ^= 1; |
16ace038f452
fix buffer underflows by reencoding the current frame with a higher QP
michael
parents:
3929
diff
changeset
|
2566 } |
4111 | 2567 if(s->pict_type!=B_TYPE){ |
2568 s->time_base= s->last_time_base; | |
2569 s->last_non_b_time= s->time - s->pp_time; | |
2570 } | |
3939
16ace038f452
fix buffer underflows by reencoding the current frame with a higher QP
michael
parents:
3929
diff
changeset
|
2571 // 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
|
2572 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
|
2573 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
|
2574 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
|
2575 } |
16ace038f452
fix buffer underflows by reencoding the current frame with a higher QP
michael
parents:
3929
diff
changeset
|
2576 goto vbv_retry; |
16ace038f452
fix buffer underflows by reencoding the current frame with a higher QP
michael
parents:
3929
diff
changeset
|
2577 } |
16ace038f452
fix buffer underflows by reencoding the current frame with a higher QP
michael
parents:
3929
diff
changeset
|
2578 |
16ace038f452
fix buffer underflows by reencoding the current frame with a higher QP
michael
parents:
3929
diff
changeset
|
2579 assert(s->avctx->rc_max_rate); |
16ace038f452
fix buffer underflows by reencoding the current frame with a higher QP
michael
parents:
3929
diff
changeset
|
2580 } |
16ace038f452
fix buffer underflows by reencoding the current frame with a higher QP
michael
parents:
3929
diff
changeset
|
2581 |
329 | 2582 if(s->flags&CODEC_FLAG_PASS1) |
2583 ff_write_pass1_stats(s); | |
1138 | 2584 |
2585 for(i=0; i<4; i++){ | |
2955 | 2586 s->current_picture_ptr->error[i]= s->current_picture.error[i]; |
1138 | 2587 avctx->error[i] += s->current_picture_ptr->error[i]; |
2588 } | |
1766 | 2589 |
2428
548c87c06dbb
assertion about bits statistic and minor bits stat fix
michael
parents:
2427
diff
changeset
|
2590 if(s->flags&CODEC_FLAG_PASS1) |
548c87c06dbb
assertion about bits statistic and minor bits stat fix
michael
parents:
2427
diff
changeset
|
2591 assert(avctx->header_bits + avctx->mv_bits + avctx->misc_bits + avctx->i_tex_bits + avctx->p_tex_bits == put_bits_count(&s->pb)); |
1684 | 2592 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
|
2593 s->frame_bits = put_bits_count(&s->pb); |
1766 | 2594 |
2595 stuffing_count= ff_vbv_update(s, s->frame_bits); | |
2596 if(stuffing_count){ | |
2422 | 2597 if(s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb)>>3) < stuffing_count + 50){ |
2598 av_log(s->avctx, AV_LOG_ERROR, "stuffing too large\n"); | |
2599 return -1; | |
2600 } | |
2601 | |
1766 | 2602 switch(s->codec_id){ |
2603 case CODEC_ID_MPEG1VIDEO: | |
2604 case CODEC_ID_MPEG2VIDEO: | |
2605 while(stuffing_count--){ | |
2606 put_bits(&s->pb, 8, 0); | |
2607 } | |
2608 break; | |
2609 case CODEC_ID_MPEG4: | |
2610 put_bits(&s->pb, 16, 0); | |
2611 put_bits(&s->pb, 16, 0x1C3); | |
2612 stuffing_count -= 4; | |
2613 while(stuffing_count--){ | |
2614 put_bits(&s->pb, 8, 0xFF); | |
2615 } | |
2616 break; | |
2617 default: | |
2618 av_log(s->avctx, AV_LOG_ERROR, "vbv buffer overflow\n"); | |
2619 } | |
2620 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
|
2621 s->frame_bits = put_bits_count(&s->pb); |
1766 | 2622 } |
2623 | |
2967 | 2624 /* update mpeg1/2 vbv_delay for CBR */ |
1907 | 2625 if(s->avctx->rc_max_rate && s->avctx->rc_min_rate == s->avctx->rc_max_rate && s->out_format == FMT_MPEG1 |
2626 && 90000LL * (avctx->rc_buffer_size-1) <= s->avctx->rc_max_rate*0xFFFFLL){ | |
1766 | 2627 int vbv_delay; |
2628 | |
2629 assert(s->repeat_first_field==0); | |
2967 | 2630 |
1766 | 2631 vbv_delay= lrintf(90000 * s->rc_context.buffer_index / s->avctx->rc_max_rate); |
2632 assert(vbv_delay < 0xFFFF); | |
2633 | |
2634 s->vbv_delay_ptr[0] &= 0xF8; | |
2635 s->vbv_delay_ptr[0] |= vbv_delay>>13; | |
2636 s->vbv_delay_ptr[1] = vbv_delay>>5; | |
2637 s->vbv_delay_ptr[2] &= 0x07; | |
2638 s->vbv_delay_ptr[2] |= vbv_delay<<3; | |
2639 } | |
2640 s->total_bits += s->frame_bits; | |
2641 avctx->frame_bits = s->frame_bits; | |
2642 }else{ | |
2643 assert((pbBufPtr(&s->pb) == s->pb.buf)); | |
2644 s->frame_bits=0; | |
1684 | 2645 } |
1766 | 2646 assert((s->frame_bits&7)==0); |
2967 | 2647 |
1684 | 2648 return s->frame_bits/8; |
0 | 2649 } |
2650 | |
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
|
2651 #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
|
2652 |
255 | 2653 static inline void gmc1_motion(MpegEncContext *s, |
1064 | 2654 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
|
2655 uint8_t **ref_picture) |
255 | 2656 { |
1064 | 2657 uint8_t *ptr; |
556 | 2658 int offset, src_x, src_y, linesize, uvlinesize; |
255 | 2659 int motion_x, motion_y; |
566 | 2660 int emu=0; |
255 | 2661 |
2662 motion_x= s->sprite_offset[0][0]; | |
2663 motion_y= s->sprite_offset[0][1]; | |
2664 src_x = s->mb_x * 16 + (motion_x >> (s->sprite_warping_accuracy+1)); | |
2665 src_y = s->mb_y * 16 + (motion_y >> (s->sprite_warping_accuracy+1)); | |
2666 motion_x<<=(3-s->sprite_warping_accuracy); | |
2667 motion_y<<=(3-s->sprite_warping_accuracy); | |
2668 src_x = clip(src_x, -16, s->width); | |
2669 if (src_x == s->width) | |
2670 motion_x =0; | |
2671 src_y = clip(src_y, -16, s->height); | |
2672 if (src_y == s->height) | |
2673 motion_y =0; | |
753 | 2674 |
255 | 2675 linesize = s->linesize; |
556 | 2676 uvlinesize = s->uvlinesize; |
2967 | 2677 |
1842
0d82db458a3c
interlaced mpeg4 + edge emu fix (fixes decoding of mermaid.avi)
michael
parents:
1838
diff
changeset
|
2678 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
|
2679 |
566 | 2680 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
|
2681 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
|
2682 || (unsigned)src_y >= s->v_edge_pos - 17){ |
1317
26c44d2433c1
make ff_emulated_edge_mc() independant of MpegEncContext
michaelni
parents:
1315
diff
changeset
|
2683 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 | 2684 ptr= s->edge_emu_buffer; |
2685 } | |
2686 } | |
2967 | 2687 |
753 | 2688 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
|
2689 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
|
2690 s->dsp.gmc1(dest_y+8, ptr+8, linesize, 16, motion_x&15, motion_y&15, 128 - s->no_rounding); |
753 | 2691 }else{ |
2692 int dxy; | |
2967 | 2693 |
753 | 2694 dxy= ((motion_x>>3)&1) | ((motion_y>>2)&2); |
2695 if (s->no_rounding){ | |
2979 | 2696 s->dsp.put_no_rnd_pixels_tab[0][dxy](dest_y, ptr, linesize, 16); |
753 | 2697 }else{ |
853
eacc2dd8fd9d
* using DSPContext - so each codec could use its local (sub)set of CPU extension
kabi
parents:
847
diff
changeset
|
2698 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
|
2699 } |
753 | 2700 } |
2967 | 2701 |
753 | 2702 if(s->flags&CODEC_FLAG_GRAY) return; |
255 | 2703 |
2704 motion_x= s->sprite_offset[1][0]; | |
2705 motion_y= s->sprite_offset[1][1]; | |
2706 src_x = s->mb_x * 8 + (motion_x >> (s->sprite_warping_accuracy+1)); | |
2707 src_y = s->mb_y * 8 + (motion_y >> (s->sprite_warping_accuracy+1)); | |
2708 motion_x<<=(3-s->sprite_warping_accuracy); | |
2709 motion_y<<=(3-s->sprite_warping_accuracy); | |
2710 src_x = clip(src_x, -8, s->width>>1); | |
2711 if (src_x == s->width>>1) | |
2712 motion_x =0; | |
2713 src_y = clip(src_y, -8, s->height>>1); | |
2714 if (src_y == s->height>>1) | |
2715 motion_y =0; | |
2716 | |
1842
0d82db458a3c
interlaced mpeg4 + edge emu fix (fixes decoding of mermaid.avi)
michael
parents:
1838
diff
changeset
|
2717 offset = (src_y * uvlinesize) + src_x; |
255 | 2718 ptr = ref_picture[1] + offset; |
1002 | 2719 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
|
2720 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
|
2721 || (unsigned)src_y >= (s->v_edge_pos>>1) - 9){ |
1317
26c44d2433c1
make ff_emulated_edge_mc() independant of MpegEncContext
michaelni
parents:
1315
diff
changeset
|
2722 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 | 2723 ptr= s->edge_emu_buffer; |
2724 emu=1; | |
2725 } | |
566 | 2726 } |
1842
0d82db458a3c
interlaced mpeg4 + edge emu fix (fixes decoding of mermaid.avi)
michael
parents:
1838
diff
changeset
|
2727 s->dsp.gmc1(dest_cb, ptr, uvlinesize, 8, motion_x&15, motion_y&15, 128 - s->no_rounding); |
2967 | 2728 |
255 | 2729 ptr = ref_picture[2] + offset; |
566 | 2730 if(emu){ |
1317
26c44d2433c1
make ff_emulated_edge_mc() independant of MpegEncContext
michaelni
parents:
1315
diff
changeset
|
2731 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 | 2732 ptr= s->edge_emu_buffer; |
2733 } | |
1842
0d82db458a3c
interlaced mpeg4 + edge emu fix (fixes decoding of mermaid.avi)
michael
parents:
1838
diff
changeset
|
2734 s->dsp.gmc1(dest_cr, ptr, uvlinesize, 8, motion_x&15, motion_y&15, 128 - s->no_rounding); |
2967 | 2735 |
255 | 2736 return; |
2737 } | |
2738 | |
753 | 2739 static inline void gmc_motion(MpegEncContext *s, |
1064 | 2740 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
|
2741 uint8_t **ref_picture) |
753 | 2742 { |
1064 | 2743 uint8_t *ptr; |
753 | 2744 int linesize, uvlinesize; |
2745 const int a= s->sprite_warping_accuracy; | |
2746 int ox, oy; | |
2747 | |
2748 linesize = s->linesize; | |
2749 uvlinesize = s->uvlinesize; | |
2750 | |
1842
0d82db458a3c
interlaced mpeg4 + edge emu fix (fixes decoding of mermaid.avi)
michael
parents:
1838
diff
changeset
|
2751 ptr = ref_picture[0]; |
0d82db458a3c
interlaced mpeg4 + edge emu fix (fixes decoding of mermaid.avi)
michael
parents:
1838
diff
changeset
|
2752 |
753 | 2753 ox= s->sprite_offset[0][0] + s->sprite_delta[0][0]*s->mb_x*16 + s->sprite_delta[0][1]*s->mb_y*16; |
2754 oy= s->sprite_offset[0][1] + s->sprite_delta[1][0]*s->mb_x*16 + s->sprite_delta[1][1]*s->mb_y*16; | |
2755 | |
853
eacc2dd8fd9d
* using DSPContext - so each codec could use its local (sub)set of CPU extension
kabi
parents:
847
diff
changeset
|
2756 s->dsp.gmc(dest_y, ptr, linesize, 16, |
2967 | 2757 ox, |
2758 oy, | |
753 | 2759 s->sprite_delta[0][0], s->sprite_delta[0][1], |
2967 | 2760 s->sprite_delta[1][0], s->sprite_delta[1][1], |
753 | 2761 a+1, (1<<(2*a+1)) - s->no_rounding, |
2762 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
|
2763 s->dsp.gmc(dest_y+8, ptr, linesize, 16, |
2967 | 2764 ox + s->sprite_delta[0][0]*8, |
2765 oy + s->sprite_delta[1][0]*8, | |
753 | 2766 s->sprite_delta[0][0], s->sprite_delta[0][1], |
2967 | 2767 s->sprite_delta[1][0], s->sprite_delta[1][1], |
753 | 2768 a+1, (1<<(2*a+1)) - s->no_rounding, |
2769 s->h_edge_pos, s->v_edge_pos); | |
2770 | |
2771 if(s->flags&CODEC_FLAG_GRAY) return; | |
2772 | |
2773 ox= s->sprite_offset[1][0] + s->sprite_delta[0][0]*s->mb_x*8 + s->sprite_delta[0][1]*s->mb_y*8; | |
2774 oy= s->sprite_offset[1][1] + s->sprite_delta[1][0]*s->mb_x*8 + s->sprite_delta[1][1]*s->mb_y*8; | |
2775 | |
1842
0d82db458a3c
interlaced mpeg4 + edge emu fix (fixes decoding of mermaid.avi)
michael
parents:
1838
diff
changeset
|
2776 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
|
2777 s->dsp.gmc(dest_cb, ptr, uvlinesize, 8, |
2967 | 2778 ox, |
2779 oy, | |
753 | 2780 s->sprite_delta[0][0], s->sprite_delta[0][1], |
2967 | 2781 s->sprite_delta[1][0], s->sprite_delta[1][1], |
753 | 2782 a+1, (1<<(2*a+1)) - s->no_rounding, |
2783 s->h_edge_pos>>1, s->v_edge_pos>>1); | |
2967 | 2784 |
1842
0d82db458a3c
interlaced mpeg4 + edge emu fix (fixes decoding of mermaid.avi)
michael
parents:
1838
diff
changeset
|
2785 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
|
2786 s->dsp.gmc(dest_cr, ptr, uvlinesize, 8, |
2967 | 2787 ox, |
2788 oy, | |
753 | 2789 s->sprite_delta[0][0], s->sprite_delta[0][1], |
2967 | 2790 s->sprite_delta[1][0], s->sprite_delta[1][1], |
753 | 2791 a+1, (1<<(2*a+1)) - s->no_rounding, |
2792 s->h_edge_pos>>1, s->v_edge_pos>>1); | |
2793 } | |
2794 | |
1317
26c44d2433c1
make ff_emulated_edge_mc() independant of MpegEncContext
michaelni
parents:
1315
diff
changeset
|
2795 /** |
26c44d2433c1
make ff_emulated_edge_mc() independant of MpegEncContext
michaelni
parents:
1315
diff
changeset
|
2796 * 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
|
2797 * @param buf destination buffer |
26c44d2433c1
make ff_emulated_edge_mc() independant of MpegEncContext
michaelni
parents:
1315
diff
changeset
|
2798 * @param src source buffer |
26c44d2433c1
make ff_emulated_edge_mc() independant of MpegEncContext
michaelni
parents:
1315
diff
changeset
|
2799 * @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
|
2800 * @param block_w width of block |
26c44d2433c1
make ff_emulated_edge_mc() independant of MpegEncContext
michaelni
parents:
1315
diff
changeset
|
2801 * @param block_h height of block |
26c44d2433c1
make ff_emulated_edge_mc() independant of MpegEncContext
michaelni
parents:
1315
diff
changeset
|
2802 * @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
|
2803 * @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
|
2804 * @param w width of the source buffer |
26c44d2433c1
make ff_emulated_edge_mc() independant of MpegEncContext
michaelni
parents:
1315
diff
changeset
|
2805 * @param h height of the source buffer |
26c44d2433c1
make ff_emulated_edge_mc() independant of MpegEncContext
michaelni
parents:
1315
diff
changeset
|
2806 */ |
2967 | 2807 void ff_emulated_edge_mc(uint8_t *buf, uint8_t *src, int linesize, int block_w, int block_h, |
553 | 2808 int src_x, int src_y, int w, int h){ |
2809 int x, y; | |
2810 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
|
2811 |
553 | 2812 if(src_y>= h){ |
2813 src+= (h-1-src_y)*linesize; | |
2814 src_y=h-1; | |
554 | 2815 }else if(src_y<=-block_h){ |
2816 src+= (1-block_h-src_y)*linesize; | |
2817 src_y=1-block_h; | |
553 | 2818 } |
2819 if(src_x>= w){ | |
2820 src+= (w-1-src_x); | |
2821 src_x=w-1; | |
554 | 2822 }else if(src_x<=-block_w){ |
2823 src+= (1-block_w-src_x); | |
2824 src_x=1-block_w; | |
553 | 2825 } |
2826 | |
847 | 2827 start_y= FFMAX(0, -src_y); |
2828 start_x= FFMAX(0, -src_x); | |
2829 end_y= FFMIN(block_h, h-src_y); | |
2830 end_x= FFMIN(block_w, w-src_x); | |
566 | 2831 |
553 | 2832 // copy existing part |
2833 for(y=start_y; y<end_y; y++){ | |
2834 for(x=start_x; x<end_x; x++){ | |
2835 buf[x + y*linesize]= src[x + y*linesize]; | |
2836 } | |
2837 } | |
2838 | |
2839 //top | |
2840 for(y=0; y<start_y; y++){ | |
2841 for(x=start_x; x<end_x; x++){ | |
2842 buf[x + y*linesize]= buf[x + start_y*linesize]; | |
2843 } | |
2844 } | |
2845 | |
2846 //bottom | |
2847 for(y=end_y; y<block_h; y++){ | |
2848 for(x=start_x; x<end_x; x++){ | |
2849 buf[x + y*linesize]= buf[x + (end_y-1)*linesize]; | |
2850 } | |
2851 } | |
2967 | 2852 |
553 | 2853 for(y=0; y<block_h; y++){ |
2854 //left | |
2855 for(x=0; x<start_x; x++){ | |
2856 buf[x + y*linesize]= buf[start_x + y*linesize]; | |
2857 } | |
2967 | 2858 |
553 | 2859 //right |
2860 for(x=end_x; x<block_w; x++){ | |
2861 buf[x + y*linesize]= buf[end_x - 1 + y*linesize]; | |
2862 } | |
2863 } | |
2864 } | |
2865 | |
2967 | 2866 static inline int hpel_motion(MpegEncContext *s, |
1842
0d82db458a3c
interlaced mpeg4 + edge emu fix (fixes decoding of mermaid.avi)
michael
parents:
1838
diff
changeset
|
2867 uint8_t *dest, uint8_t *src, |
0d82db458a3c
interlaced mpeg4 + edge emu fix (fixes decoding of mermaid.avi)
michael
parents:
1838
diff
changeset
|
2868 int field_based, int field_select, |
1633 | 2869 int src_x, int src_y, |
2870 int width, int height, int stride, | |
2871 int h_edge_pos, int v_edge_pos, | |
2872 int w, int h, op_pixels_func *pix_op, | |
2873 int motion_x, int motion_y) | |
2874 { | |
2875 int dxy; | |
2876 int emu=0; | |
2877 | |
2878 dxy = ((motion_y & 1) << 1) | (motion_x & 1); | |
2879 src_x += motion_x >> 1; | |
2880 src_y += motion_y >> 1; | |
2967 | 2881 |
1633 | 2882 /* WARNING: do no forget half pels */ |
2883 src_x = clip(src_x, -16, width); //FIXME unneeded for emu? | |
2884 if (src_x == width) | |
2885 dxy &= ~1; | |
2886 src_y = clip(src_y, -16, height); | |
2887 if (src_y == height) | |
2888 dxy &= ~2; | |
2889 src += src_y * stride + src_x; | |
2890 | |
2891 if(s->unrestricted_mv && (s->flags&CODEC_FLAG_EMU_EDGE)){ | |
2892 if( (unsigned)src_x > h_edge_pos - (motion_x&1) - w | |
2893 || (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
|
2894 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
|
2895 src_x, src_y<<field_based, h_edge_pos, s->v_edge_pos); |
1633 | 2896 src= s->edge_emu_buffer; |
2897 emu=1; | |
2898 } | |
2899 } | |
1842
0d82db458a3c
interlaced mpeg4 + edge emu fix (fixes decoding of mermaid.avi)
michael
parents:
1838
diff
changeset
|
2900 if(field_select) |
0d82db458a3c
interlaced mpeg4 + edge emu fix (fixes decoding of mermaid.avi)
michael
parents:
1838
diff
changeset
|
2901 src += s->linesize; |
1633 | 2902 pix_op[dxy](dest, src, stride, h); |
2903 return emu; | |
2904 } | |
553 | 2905 |
2967 | 2906 static inline int hpel_motion_lowres(MpegEncContext *s, |
2292 | 2907 uint8_t *dest, uint8_t *src, |
2908 int field_based, int field_select, | |
2909 int src_x, int src_y, | |
2910 int width, int height, int stride, | |
2911 int h_edge_pos, int v_edge_pos, | |
2912 int w, int h, h264_chroma_mc_func *pix_op, | |
2913 int motion_x, int motion_y) | |
2914 { | |
2915 const int lowres= s->avctx->lowres; | |
2916 const int s_mask= (2<<lowres)-1; | |
2917 int emu=0; | |
2918 int sx, sy; | |
2919 | |
2920 if(s->quarter_sample){ | |
2921 motion_x/=2; | |
2922 motion_y/=2; | |
2923 } | |
2924 | |
2925 sx= motion_x & s_mask; | |
2926 sy= motion_y & s_mask; | |
2927 src_x += motion_x >> (lowres+1); | |
2928 src_y += motion_y >> (lowres+1); | |
2967 | 2929 |
2292 | 2930 src += src_y * stride + src_x; |
2931 | |
2932 if( (unsigned)src_x > h_edge_pos - (!!sx) - w | |
2933 || (unsigned)src_y >(v_edge_pos >> field_based) - (!!sy) - h){ | |
2934 ff_emulated_edge_mc(s->edge_emu_buffer, src, s->linesize, w+1, (h+1)<<field_based, | |
2935 src_x, src_y<<field_based, h_edge_pos, v_edge_pos); | |
2936 src= s->edge_emu_buffer; | |
2937 emu=1; | |
2938 } | |
2939 | |
2940 sx <<= 2 - lowres; | |
2941 sy <<= 2 - lowres; | |
2942 if(field_select) | |
2943 src += s->linesize; | |
2944 pix_op[lowres](dest, src, stride, h, sx, sy); | |
2945 return emu; | |
2946 } | |
2947 | |
0 | 2948 /* 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
|
2949 static av_always_inline void mpeg_motion(MpegEncContext *s, |
1064 | 2950 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
|
2951 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
|
2952 uint8_t **ref_picture, op_pixels_func (*pix_op)[4], |
0 | 2953 int motion_x, int motion_y, int h) |
2954 { | |
1846 | 2955 uint8_t *ptr_y, *ptr_cb, *ptr_cr; |
2956 int dxy, uvdxy, mx, my, src_x, src_y, uvsrc_x, uvsrc_y, v_edge_pos, uvlinesize, linesize; | |
2967 | 2957 |
2958 #if 0 | |
255 | 2959 if(s->quarter_sample) |
2960 { | |
2961 motion_x>>=1; | |
2962 motion_y>>=1; | |
2963 } | |
651 | 2964 #endif |
1633 | 2965 |
582
5132a4ee50cd
different edge positions fixed with edge emu / dr1
michaelni
parents:
575
diff
changeset
|
2966 v_edge_pos = s->v_edge_pos >> field_based; |
1846 | 2967 linesize = s->current_picture.linesize[0] << field_based; |
1138 | 2968 uvlinesize = s->current_picture.linesize[1] << field_based; |
1633 | 2969 |
1846 | 2970 dxy = ((motion_y & 1) << 1) | (motion_x & 1); |
2971 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
|
2972 src_y =(s->mb_y<<(4-field_based)) + (motion_y >> 1); |
485 | 2973 |
0 | 2974 if (s->out_format == FMT_H263) { |
1916 | 2975 if((s->workaround_bugs & FF_BUG_HPEL_CHROMA) && field_based){ |
2976 mx = (motion_x>>1)|(motion_x&1); | |
2977 my = motion_y >>1; | |
2978 uvdxy = ((my & 1) << 1) | (mx & 1); | |
2979 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
|
2980 uvsrc_y = (s->mb_y<<(3-field_based)) + (my >> 1); |
1916 | 2981 }else{ |
2982 uvdxy = dxy | (motion_y & 2) | ((motion_x & 2) >> 1); | |
2983 uvsrc_x = src_x>>1; | |
2984 uvsrc_y = src_y>>1; | |
2985 } | |
2044
b6f2add2511e
h261 decoder by (Maarten Daniels <maarten.daniels at student dot luc dot ac dot be>)
michael
parents:
2042
diff
changeset
|
2986 }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
|
2987 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
|
2988 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
|
2989 uvdxy = 0; |
b6f2add2511e
h261 decoder by (Maarten Daniels <maarten.daniels at student dot luc dot ac dot be>)
michael
parents:
2042
diff
changeset
|
2990 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
|
2991 uvsrc_y = s->mb_y*8 + my; |
0 | 2992 } else { |
2074
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
2993 if(s->chroma_y_shift){ |
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
2994 mx = motion_x / 2; |
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
2995 my = motion_y / 2; |
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
2996 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
|
2997 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
|
2998 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
|
2999 } else { |
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
3000 if(s->chroma_x_shift){ |
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
3001 //Chroma422 |
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
3002 mx = motion_x / 2; |
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
3003 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
|
3004 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
|
3005 uvsrc_y = src_y; |
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
3006 } else { |
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
3007 //Chroma444 |
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
3008 uvdxy = dxy; |
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
3009 uvsrc_x = src_x; |
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
3010 uvsrc_y = src_y; |
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
3011 } |
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
3012 } |
1846 | 3013 } |
3014 | |
3015 ptr_y = ref_picture[0] + src_y * linesize + src_x; | |
3016 ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x; | |
3017 ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x; | |
3018 | |
3019 if( (unsigned)src_x > s->h_edge_pos - (motion_x&1) - 16 | |
3020 || (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
|
3021 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
|
3022 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
|
3023 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
|
3024 return ; |
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
3025 } |
1846 | 3026 ff_emulated_edge_mc(s->edge_emu_buffer, ptr_y, s->linesize, 17, 17+field_based, |
3027 src_x, src_y<<field_based, s->h_edge_pos, s->v_edge_pos); | |
3028 ptr_y = s->edge_emu_buffer; | |
3029 if(!(s->flags&CODEC_FLAG_GRAY)){ | |
1874 | 3030 uint8_t *uvbuf= s->edge_emu_buffer+18*s->linesize; |
2967 | 3031 ff_emulated_edge_mc(uvbuf , ptr_cb, s->uvlinesize, 9, 9+field_based, |
1846 | 3032 uvsrc_x, uvsrc_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1); |
2967 | 3033 ff_emulated_edge_mc(uvbuf+16, ptr_cr, s->uvlinesize, 9, 9+field_based, |
1846 | 3034 uvsrc_x, uvsrc_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1); |
3035 ptr_cb= uvbuf; | |
3036 ptr_cr= uvbuf+16; | |
3037 } | |
3038 } | |
3039 | |
3040 if(bottom_field){ //FIXME use this for field pix too instead of the obnoxious hack which changes picture.data | |
3041 dest_y += s->linesize; | |
3042 dest_cb+= s->uvlinesize; | |
3043 dest_cr+= s->uvlinesize; | |
3044 } | |
3045 | |
3046 if(field_select){ | |
3047 ptr_y += s->linesize; | |
3048 ptr_cb+= s->uvlinesize; | |
3049 ptr_cr+= s->uvlinesize; | |
3050 } | |
3051 | |
3052 pix_op[0][dxy](dest_y, ptr_y, linesize, h); | |
2967 | 3053 |
1846 | 3054 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
|
3055 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
|
3056 pix_op[s->chroma_x_shift][uvdxy](dest_cr, ptr_cr, uvlinesize, h >> s->chroma_y_shift); |
1846 | 3057 } |
2639 | 3058 #if defined(CONFIG_H261_ENCODER) || defined(CONFIG_H261_DECODER) |
2291 | 3059 if(s->out_format == FMT_H261){ |
3060 ff_h261_loop_filter(s); | |
3061 } | |
2639 | 3062 #endif |
0 | 3063 } |
2256 | 3064 |
3065 /* 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
|
3066 static av_always_inline void mpeg_motion_lowres(MpegEncContext *s, |
2256 | 3067 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr, |
3068 int field_based, int bottom_field, int field_select, | |
3069 uint8_t **ref_picture, h264_chroma_mc_func *pix_op, | |
3070 int motion_x, int motion_y, int h) | |
3071 { | |
3072 uint8_t *ptr_y, *ptr_cb, *ptr_cr; | |
3073 int mx, my, src_x, src_y, uvsrc_x, uvsrc_y, uvlinesize, linesize, sx, sy, uvsx, uvsy; | |
3074 const int lowres= s->avctx->lowres; | |
3075 const int block_s= 8>>lowres; | |
3076 const int s_mask= (2<<lowres)-1; | |
3077 const int h_edge_pos = s->h_edge_pos >> lowres; | |
3078 const int v_edge_pos = s->v_edge_pos >> lowres; | |
3079 linesize = s->current_picture.linesize[0] << field_based; | |
3080 uvlinesize = s->current_picture.linesize[1] << field_based; | |
3081 | |
2260 | 3082 if(s->quarter_sample){ //FIXME obviously not perfect but qpel wont work in lowres anyway |
3083 motion_x/=2; | |
3084 motion_y/=2; | |
3085 } | |
2967 | 3086 |
2260 | 3087 if(field_based){ |
3088 motion_y += (bottom_field - field_select)*((1<<lowres)-1); | |
3089 } | |
3090 | |
2256 | 3091 sx= motion_x & s_mask; |
3092 sy= motion_y & s_mask; | |
3093 src_x = s->mb_x*2*block_s + (motion_x >> (lowres+1)); | |
2260 | 3094 src_y =(s->mb_y*2*block_s>>field_based) + (motion_y >> (lowres+1)); |
2967 | 3095 |
2256 | 3096 if (s->out_format == FMT_H263) { |
2265 | 3097 uvsx = ((motion_x>>1) & s_mask) | (sx&1); |
3098 uvsy = ((motion_y>>1) & s_mask) | (sy&1); | |
2256 | 3099 uvsrc_x = src_x>>1; |
3100 uvsrc_y = src_y>>1; | |
3101 }else if(s->out_format == FMT_H261){//even chroma mv's are full pel in H261 | |
3102 mx = motion_x / 4; | |
3103 my = motion_y / 4; | |
3104 uvsx = (2*mx) & s_mask; | |
3105 uvsy = (2*my) & s_mask; | |
3106 uvsrc_x = s->mb_x*block_s + (mx >> lowres); | |
3107 uvsrc_y = s->mb_y*block_s + (my >> lowres); | |
3108 } else { | |
3109 mx = motion_x / 2; | |
3110 my = motion_y / 2; | |
3111 uvsx = mx & s_mask; | |
3112 uvsy = my & s_mask; | |
3113 uvsrc_x = s->mb_x*block_s + (mx >> (lowres+1)); | |
2260 | 3114 uvsrc_y =(s->mb_y*block_s>>field_based) + (my >> (lowres+1)); |
2256 | 3115 } |
3116 | |
3117 ptr_y = ref_picture[0] + src_y * linesize + src_x; | |
3118 ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x; | |
3119 ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x; | |
3120 | |
3121 if( (unsigned)src_x > h_edge_pos - (!!sx) - 2*block_s | |
3122 || (unsigned)src_y >(v_edge_pos >> field_based) - (!!sy) - h){ | |
3123 ff_emulated_edge_mc(s->edge_emu_buffer, ptr_y, s->linesize, 17, 17+field_based, | |
3124 src_x, src_y<<field_based, h_edge_pos, v_edge_pos); | |
3125 ptr_y = s->edge_emu_buffer; | |
3126 if(!(s->flags&CODEC_FLAG_GRAY)){ | |
3127 uint8_t *uvbuf= s->edge_emu_buffer+18*s->linesize; | |
2967 | 3128 ff_emulated_edge_mc(uvbuf , ptr_cb, s->uvlinesize, 9, 9+field_based, |
2256 | 3129 uvsrc_x, uvsrc_y<<field_based, h_edge_pos>>1, v_edge_pos>>1); |
2967 | 3130 ff_emulated_edge_mc(uvbuf+16, ptr_cr, s->uvlinesize, 9, 9+field_based, |
2256 | 3131 uvsrc_x, uvsrc_y<<field_based, h_edge_pos>>1, v_edge_pos>>1); |
3132 ptr_cb= uvbuf; | |
3133 ptr_cr= uvbuf+16; | |
3134 } | |
3135 } | |
3136 | |
2260 | 3137 if(bottom_field){ //FIXME use this for field pix too instead of the obnoxious hack which changes picture.data |
3138 dest_y += s->linesize; | |
3139 dest_cb+= s->uvlinesize; | |
3140 dest_cr+= s->uvlinesize; | |
3141 } | |
3142 | |
3143 if(field_select){ | |
3144 ptr_y += s->linesize; | |
3145 ptr_cb+= s->uvlinesize; | |
3146 ptr_cr+= s->uvlinesize; | |
3147 } | |
3148 | |
2256 | 3149 sx <<= 2 - lowres; |
3150 sy <<= 2 - lowres; | |
3151 pix_op[lowres-1](dest_y, ptr_y, linesize, h, sx, sy); | |
2967 | 3152 |
2256 | 3153 if(!(s->flags&CODEC_FLAG_GRAY)){ |
3154 uvsx <<= 2 - lowres; | |
3155 uvsy <<= 2 - lowres; | |
3156 pix_op[lowres](dest_cb, ptr_cb, uvlinesize, h >> s->chroma_y_shift, uvsx, uvsy); | |
3157 pix_op[lowres](dest_cr, ptr_cr, uvlinesize, h >> s->chroma_y_shift, uvsx, uvsy); | |
3158 } | |
2291 | 3159 //FIXME h261 lowres loop filter |
2256 | 3160 } |
3161 | |
1633 | 3162 //FIXME move to dsputil, avg variant, 16x16 version |
3163 static inline void put_obmc(uint8_t *dst, uint8_t *src[5], int stride){ | |
3164 int x; | |
3165 uint8_t * const top = src[1]; | |
3166 uint8_t * const left = src[2]; | |
3167 uint8_t * const mid = src[0]; | |
3168 uint8_t * const right = src[3]; | |
3169 uint8_t * const bottom= src[4]; | |
3170 #define OBMC_FILTER(x, t, l, m, r, b)\ | |
3171 dst[x]= (t*top[x] + l*left[x] + m*mid[x] + r*right[x] + b*bottom[x] + 4)>>3 | |
3172 #define OBMC_FILTER4(x, t, l, m, r, b)\ | |
3173 OBMC_FILTER(x , t, l, m, r, b);\ | |
3174 OBMC_FILTER(x+1 , t, l, m, r, b);\ | |
3175 OBMC_FILTER(x +stride, t, l, m, r, b);\ | |
3176 OBMC_FILTER(x+1+stride, t, l, m, r, b); | |
2967 | 3177 |
1633 | 3178 x=0; |
3179 OBMC_FILTER (x , 2, 2, 4, 0, 0); | |
3180 OBMC_FILTER (x+1, 2, 1, 5, 0, 0); | |
3181 OBMC_FILTER4(x+2, 2, 1, 5, 0, 0); | |
3182 OBMC_FILTER4(x+4, 2, 0, 5, 1, 0); | |
3183 OBMC_FILTER (x+6, 2, 0, 5, 1, 0); | |
3184 OBMC_FILTER (x+7, 2, 0, 4, 2, 0); | |
3185 x+= stride; | |
3186 OBMC_FILTER (x , 1, 2, 5, 0, 0); | |
3187 OBMC_FILTER (x+1, 1, 2, 5, 0, 0); | |
3188 OBMC_FILTER (x+6, 1, 0, 5, 2, 0); | |
3189 OBMC_FILTER (x+7, 1, 0, 5, 2, 0); | |
3190 x+= stride; | |
3191 OBMC_FILTER4(x , 1, 2, 5, 0, 0); | |
3192 OBMC_FILTER4(x+2, 1, 1, 6, 0, 0); | |
3193 OBMC_FILTER4(x+4, 1, 0, 6, 1, 0); | |
3194 OBMC_FILTER4(x+6, 1, 0, 5, 2, 0); | |
3195 x+= 2*stride; | |
3196 OBMC_FILTER4(x , 0, 2, 5, 0, 1); | |
3197 OBMC_FILTER4(x+2, 0, 1, 6, 0, 1); | |
3198 OBMC_FILTER4(x+4, 0, 0, 6, 1, 1); | |
3199 OBMC_FILTER4(x+6, 0, 0, 5, 2, 1); | |
3200 x+= 2*stride; | |
3201 OBMC_FILTER (x , 0, 2, 5, 0, 1); | |
3202 OBMC_FILTER (x+1, 0, 2, 5, 0, 1); | |
3203 OBMC_FILTER4(x+2, 0, 1, 5, 0, 2); | |
3204 OBMC_FILTER4(x+4, 0, 0, 5, 1, 2); | |
3205 OBMC_FILTER (x+6, 0, 0, 5, 2, 1); | |
3206 OBMC_FILTER (x+7, 0, 0, 5, 2, 1); | |
3207 x+= stride; | |
3208 OBMC_FILTER (x , 0, 2, 4, 0, 2); | |
3209 OBMC_FILTER (x+1, 0, 1, 5, 0, 2); | |
3210 OBMC_FILTER (x+6, 0, 0, 5, 1, 2); | |
3211 OBMC_FILTER (x+7, 0, 0, 4, 2, 2); | |
3212 } | |
3213 | |
3214 /* obmc for 1 8x8 luma block */ | |
3215 static inline void obmc_motion(MpegEncContext *s, | |
3216 uint8_t *dest, uint8_t *src, | |
3217 int src_x, int src_y, | |
3218 op_pixels_func *pix_op, | |
3219 int16_t mv[5][2]/* mid top left right bottom*/) | |
3220 #define MID 0 | |
3221 { | |
3222 int i; | |
3223 uint8_t *ptr[5]; | |
2967 | 3224 |
1633 | 3225 assert(s->quarter_sample==0); |
2967 | 3226 |
1633 | 3227 for(i=0; i<5; i++){ |
3228 if(i && mv[i][0]==mv[MID][0] && mv[i][1]==mv[MID][1]){ | |
3229 ptr[i]= ptr[MID]; | |
3230 }else{ | |
1799 | 3231 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
|
3232 hpel_motion(s, ptr[i], src, 0, 0, |
1633 | 3233 src_x, src_y, |
3234 s->width, s->height, s->linesize, | |
3235 s->h_edge_pos, s->v_edge_pos, | |
3236 8, 8, pix_op, | |
3237 mv[i][0], mv[i][1]); | |
3238 } | |
3239 } | |
3240 | |
2967 | 3241 put_obmc(dest, ptr, s->linesize); |
1633 | 3242 } |
0 | 3243 |
255 | 3244 static inline void qpel_motion(MpegEncContext *s, |
1064 | 3245 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
|
3246 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
|
3247 uint8_t **ref_picture, op_pixels_func (*pix_op)[4], |
651 | 3248 qpel_mc_func (*qpix_op)[16], |
255 | 3249 int motion_x, int motion_y, int h) |
3250 { | |
1846 | 3251 uint8_t *ptr_y, *ptr_cb, *ptr_cr; |
3252 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
|
3253 |
255 | 3254 dxy = ((motion_y & 3) << 2) | (motion_x & 3); |
1846 | 3255 src_x = s->mb_x * 16 + (motion_x >> 2); |
255 | 3256 src_y = s->mb_y * (16 >> field_based) + (motion_y >> 2); |
3257 | |
582
5132a4ee50cd
different edge positions fixed with edge emu / dr1
michaelni
parents:
575
diff
changeset
|
3258 v_edge_pos = s->v_edge_pos >> field_based; |
255 | 3259 linesize = s->linesize << field_based; |
671 | 3260 uvlinesize = s->uvlinesize << field_based; |
2967 | 3261 |
671 | 3262 if(field_based){ |
3263 mx= motion_x/2; | |
3264 my= motion_y>>1; | |
1048 | 3265 }else if(s->workaround_bugs&FF_BUG_QPEL_CHROMA2){ |
3266 static const int rtab[8]= {0,0,1,1,0,0,0,1}; | |
3267 mx= (motion_x>>1) + rtab[motion_x&7]; | |
3268 my= (motion_y>>1) + rtab[motion_y&7]; | |
760 | 3269 }else if(s->workaround_bugs&FF_BUG_QPEL_CHROMA){ |
671 | 3270 mx= (motion_x>>1)|(motion_x&1); |
3271 my= (motion_y>>1)|(motion_y&1); | |
3272 }else{ | |
3273 mx= motion_x/2; | |
3274 my= motion_y/2; | |
3275 } | |
3276 mx= (mx>>1)|(mx&1); | |
3277 my= (my>>1)|(my&1); | |
1048 | 3278 |
1846 | 3279 uvdxy= (mx&1) | ((my&1)<<1); |
671 | 3280 mx>>=1; |
3281 my>>=1; | |
255 | 3282 |
1846 | 3283 uvsrc_x = s->mb_x * 8 + mx; |
3284 uvsrc_y = s->mb_y * (8 >> field_based) + my; | |
3285 | |
3286 ptr_y = ref_picture[0] + src_y * linesize + src_x; | |
3287 ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x; | |
3288 ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x; | |
3289 | |
2967 | 3290 if( (unsigned)src_x > s->h_edge_pos - (motion_x&3) - 16 |
1846 | 3291 || (unsigned)src_y > v_edge_pos - (motion_y&3) - h ){ |
2967 | 3292 ff_emulated_edge_mc(s->edge_emu_buffer, ptr_y, s->linesize, 17, 17+field_based, |
1846 | 3293 src_x, src_y<<field_based, s->h_edge_pos, s->v_edge_pos); |
3294 ptr_y= s->edge_emu_buffer; | |
3295 if(!(s->flags&CODEC_FLAG_GRAY)){ | |
1874 | 3296 uint8_t *uvbuf= s->edge_emu_buffer + 18*s->linesize; |
2967 | 3297 ff_emulated_edge_mc(uvbuf, ptr_cb, s->uvlinesize, 9, 9 + field_based, |
1846 | 3298 uvsrc_x, uvsrc_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1); |
2967 | 3299 ff_emulated_edge_mc(uvbuf + 16, ptr_cr, s->uvlinesize, 9, 9 + field_based, |
1846 | 3300 uvsrc_x, uvsrc_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1); |
3301 ptr_cb= uvbuf; | |
3302 ptr_cr= uvbuf + 16; | |
3303 } | |
3304 } | |
3305 | |
3306 if(!field_based) | |
3307 qpix_op[0][dxy](dest_y, ptr_y, linesize); | |
3308 else{ | |
3309 if(bottom_field){ | |
3310 dest_y += s->linesize; | |
3311 dest_cb+= s->uvlinesize; | |
3312 dest_cr+= s->uvlinesize; | |
3313 } | |
3314 | |
3315 if(field_select){ | |
3316 ptr_y += s->linesize; | |
3317 ptr_cb += s->uvlinesize; | |
3318 ptr_cr += s->uvlinesize; | |
3319 } | |
3320 //damn interlaced mode | |
3321 //FIXME boundary mirroring is not exactly correct here | |
3322 qpix_op[1][dxy](dest_y , ptr_y , linesize); | |
3323 qpix_op[1][dxy](dest_y+8, ptr_y+8, linesize); | |
3324 } | |
3325 if(!(s->flags&CODEC_FLAG_GRAY)){ | |
3326 pix_op[1][uvdxy](dest_cr, ptr_cr, uvlinesize, h >> 1); | |
3327 pix_op[1][uvdxy](dest_cb, ptr_cb, uvlinesize, h >> 1); | |
3328 } | |
255 | 3329 } |
3330 | |
1013 | 3331 inline int ff_h263_round_chroma(int x){ |
3332 if (x >= 0) | |
3333 return (h263_chroma_roundtab[x & 0xf] + ((x >> 3) & ~1)); | |
3334 else { | |
3335 x = -x; | |
3336 return -(h263_chroma_roundtab[x & 0xf] + ((x >> 3) & ~1)); | |
3337 } | |
3338 } | |
255 | 3339 |
1225 | 3340 /** |
1633 | 3341 * h263 chorma 4mv motion compensation. |
3342 */ | |
3343 static inline void chroma_4mv_motion(MpegEncContext *s, | |
3344 uint8_t *dest_cb, uint8_t *dest_cr, | |
3345 uint8_t **ref_picture, | |
3346 op_pixels_func *pix_op, | |
3347 int mx, int my){ | |
3348 int dxy, emu=0, src_x, src_y, offset; | |
3349 uint8_t *ptr; | |
2967 | 3350 |
1633 | 3351 /* In case of 8X8, we construct a single chroma motion vector |
3352 with a special rounding */ | |
3353 mx= ff_h263_round_chroma(mx); | |
3354 my= ff_h263_round_chroma(my); | |
2967 | 3355 |
1633 | 3356 dxy = ((my & 1) << 1) | (mx & 1); |
3357 mx >>= 1; | |
3358 my >>= 1; | |
3359 | |
3360 src_x = s->mb_x * 8 + mx; | |
3361 src_y = s->mb_y * 8 + my; | |
3362 src_x = clip(src_x, -8, s->width/2); | |
3363 if (src_x == s->width/2) | |
3364 dxy &= ~1; | |
3365 src_y = clip(src_y, -8, s->height/2); | |
3366 if (src_y == s->height/2) | |
3367 dxy &= ~2; | |
2967 | 3368 |
1633 | 3369 offset = (src_y * (s->uvlinesize)) + src_x; |
3370 ptr = ref_picture[1] + offset; | |
3371 if(s->flags&CODEC_FLAG_EMU_EDGE){ | |
3372 if( (unsigned)src_x > (s->h_edge_pos>>1) - (dxy &1) - 8 | |
3373 || (unsigned)src_y > (s->v_edge_pos>>1) - (dxy>>1) - 8){ | |
3374 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); | |
3375 ptr= s->edge_emu_buffer; | |
3376 emu=1; | |
3377 } | |
3378 } | |
3379 pix_op[dxy](dest_cb, ptr, s->uvlinesize, 8); | |
3380 | |
3381 ptr = ref_picture[2] + offset; | |
3382 if(emu){ | |
3383 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); | |
3384 ptr= s->edge_emu_buffer; | |
3385 } | |
3386 pix_op[dxy](dest_cr, ptr, s->uvlinesize, 8); | |
3387 } | |
3388 | |
2292 | 3389 static inline void chroma_4mv_motion_lowres(MpegEncContext *s, |
3390 uint8_t *dest_cb, uint8_t *dest_cr, | |
3391 uint8_t **ref_picture, | |
3392 h264_chroma_mc_func *pix_op, | |
3393 int mx, int my){ | |
3394 const int lowres= s->avctx->lowres; | |
3395 const int block_s= 8>>lowres; | |
3396 const int s_mask= (2<<lowres)-1; | |
3397 const int h_edge_pos = s->h_edge_pos >> (lowres+1); | |
3398 const int v_edge_pos = s->v_edge_pos >> (lowres+1); | |
3399 int emu=0, src_x, src_y, offset, sx, sy; | |
3400 uint8_t *ptr; | |
2967 | 3401 |
2292 | 3402 if(s->quarter_sample){ |
3403 mx/=2; | |
3404 my/=2; | |
3405 } | |
3406 | |
3407 /* In case of 8X8, we construct a single chroma motion vector | |
3408 with a special rounding */ | |
3409 mx= ff_h263_round_chroma(mx); | |
3410 my= ff_h263_round_chroma(my); | |
2967 | 3411 |
2292 | 3412 sx= mx & s_mask; |
3413 sy= my & s_mask; | |
3414 src_x = s->mb_x*block_s + (mx >> (lowres+1)); | |
3415 src_y = s->mb_y*block_s + (my >> (lowres+1)); | |
2967 | 3416 |
2292 | 3417 offset = src_y * s->uvlinesize + src_x; |
3418 ptr = ref_picture[1] + offset; | |
3419 if(s->flags&CODEC_FLAG_EMU_EDGE){ | |
3420 if( (unsigned)src_x > h_edge_pos - (!!sx) - block_s | |
3421 || (unsigned)src_y > v_edge_pos - (!!sy) - block_s){ | |
3422 ff_emulated_edge_mc(s->edge_emu_buffer, ptr, s->uvlinesize, 9, 9, src_x, src_y, h_edge_pos, v_edge_pos); | |
3423 ptr= s->edge_emu_buffer; | |
3424 emu=1; | |
3425 } | |
2967 | 3426 } |
2292 | 3427 sx <<= 2 - lowres; |
3428 sy <<= 2 - lowres; | |
3429 pix_op[lowres](dest_cb, ptr, s->uvlinesize, block_s, sx, sy); | |
2967 | 3430 |
2292 | 3431 ptr = ref_picture[2] + offset; |
3432 if(emu){ | |
3433 ff_emulated_edge_mc(s->edge_emu_buffer, ptr, s->uvlinesize, 9, 9, src_x, src_y, h_edge_pos, v_edge_pos); | |
3434 ptr= s->edge_emu_buffer; | |
3435 } | |
3436 pix_op[lowres](dest_cr, ptr, s->uvlinesize, block_s, sx, sy); | |
3437 } | |
3438 | |
3216
4186eb8d29a1
prefetch pixels for future motion compensation. 4-10% faster mpeg1/2/4 decoding (on an athlon-xp).
lorenm
parents:
3145
diff
changeset
|
3439 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
|
3440 /* 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
|
3441 * 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
|
3442 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
|
3443 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
|
3444 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
|
3445 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
|
3446 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
|
3447 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
|
3448 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
|
3449 } |
4186eb8d29a1
prefetch pixels for future motion compensation. 4-10% faster mpeg1/2/4 decoding (on an athlon-xp).
lorenm
parents:
3145
diff
changeset
|
3450 |
1633 | 3451 /** |
2764 | 3452 * motion compensation of a single macroblock |
1225 | 3453 * @param s context |
3454 * @param dest_y luma destination pointer | |
3455 * @param dest_cb chroma cb/u destination pointer | |
3456 * @param dest_cr chroma cr/v destination pointer | |
3457 * @param dir direction (0->forward, 1->backward) | |
3458 * @param ref_picture array[3] of pointers to the 3 planes of the reference picture | |
3459 * @param pic_op halfpel motion compensation function (average or put normally) | |
3460 * @param pic_op qpel motion compensation function (average or put normally) | |
3461 * the motion vectors are taken from s->mv and the MV type from s->mv_type | |
3462 */ | |
2967 | 3463 static inline void MPV_motion(MpegEncContext *s, |
1064 | 3464 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr, |
2967 | 3465 int dir, uint8_t **ref_picture, |
651 | 3466 op_pixels_func (*pix_op)[4], qpel_mc_func (*qpix_op)[16]) |
0 | 3467 { |
1633 | 3468 int dxy, mx, my, src_x, src_y, motion_x, motion_y; |
0 | 3469 int mb_x, mb_y, i; |
1064 | 3470 uint8_t *ptr, *dest; |
0 | 3471 |
3472 mb_x = s->mb_x; | |
3473 mb_y = s->mb_y; | |
3474 | |
3216
4186eb8d29a1
prefetch pixels for future motion compensation. 4-10% faster mpeg1/2/4 decoding (on an athlon-xp).
lorenm
parents:
3145
diff
changeset
|
3475 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
|
3476 |
1655 | 3477 if(s->obmc && s->pict_type != B_TYPE){ |
1633 | 3478 int16_t mv_cache[4][4][2]; |
3479 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
|
3480 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
|
3481 const int mot_xy= mb_x*2 + mb_y*2*mot_stride; |
1633 | 3482 |
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
|
3483 assert(!s->mb_skipped); |
2967 | 3484 |
1668
30746f429df6
move motion_val & mb_type to AVFrame patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1662
diff
changeset
|
3485 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
|
3486 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
|
3487 memcpy(mv_cache[3][1], s->current_picture.motion_val[0][mot_xy+mot_stride], sizeof(int16_t)*4); |
1633 | 3488 |
3489 if(mb_y==0 || IS_INTRA(s->current_picture.mb_type[xy-s->mb_stride])){ | |
3490 memcpy(mv_cache[0][1], mv_cache[1][1], sizeof(int16_t)*4); | |
3491 }else{ | |
1668
30746f429df6
move motion_val & mb_type to AVFrame patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1662
diff
changeset
|
3492 memcpy(mv_cache[0][1], s->current_picture.motion_val[0][mot_xy-mot_stride], sizeof(int16_t)*4); |
1633 | 3493 } |
3494 | |
3495 if(mb_x==0 || IS_INTRA(s->current_picture.mb_type[xy-1])){ | |
3496 *(int32_t*)mv_cache[1][0]= *(int32_t*)mv_cache[1][1]; | |
3497 *(int32_t*)mv_cache[2][0]= *(int32_t*)mv_cache[2][1]; | |
3498 }else{ | |
1668
30746f429df6
move motion_val & mb_type to AVFrame patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1662
diff
changeset
|
3499 *(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
|
3500 *(int32_t*)mv_cache[2][0]= *(int32_t*)s->current_picture.motion_val[0][mot_xy-1+mot_stride]; |
1633 | 3501 } |
3502 | |
3503 if(mb_x+1>=s->mb_width || IS_INTRA(s->current_picture.mb_type[xy+1])){ | |
3504 *(int32_t*)mv_cache[1][3]= *(int32_t*)mv_cache[1][2]; | |
3505 *(int32_t*)mv_cache[2][3]= *(int32_t*)mv_cache[2][2]; | |
3506 }else{ | |
1668
30746f429df6
move motion_val & mb_type to AVFrame patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1662
diff
changeset
|
3507 *(int32_t*)mv_cache[1][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
|
3508 *(int32_t*)mv_cache[2][3]= *(int32_t*)s->current_picture.motion_val[0][mot_xy+2+mot_stride]; |
1633 | 3509 } |
2967 | 3510 |
1633 | 3511 mx = 0; |
3512 my = 0; | |
3513 for(i=0;i<4;i++) { | |
3514 const int x= (i&1)+1; | |
3515 const int y= (i>>1)+1; | |
3516 int16_t mv[5][2]= { | |
3517 {mv_cache[y][x ][0], mv_cache[y][x ][1]}, | |
3518 {mv_cache[y-1][x][0], mv_cache[y-1][x][1]}, | |
3519 {mv_cache[y][x-1][0], mv_cache[y][x-1][1]}, | |
3520 {mv_cache[y][x+1][0], mv_cache[y][x+1][1]}, | |
3521 {mv_cache[y+1][x][0], mv_cache[y+1][x][1]}}; | |
3522 //FIXME cleanup | |
3523 obmc_motion(s, dest_y + ((i & 1) * 8) + (i >> 1) * 8 * s->linesize, | |
3524 ref_picture[0], | |
3525 mb_x * 16 + (i & 1) * 8, mb_y * 16 + (i >>1) * 8, | |
3526 pix_op[1], | |
3527 mv); | |
3528 | |
3529 mx += mv[0][0]; | |
3530 my += mv[0][1]; | |
3531 } | |
3532 if(!(s->flags&CODEC_FLAG_GRAY)) | |
3533 chroma_4mv_motion(s, dest_cb, dest_cr, ref_picture, pix_op[1], mx, my); | |
3534 | |
3535 return; | |
3536 } | |
2967 | 3537 |
0 | 3538 switch(s->mv_type) { |
3539 case MV_TYPE_16X16: | |
255 | 3540 if(s->mcsel){ |
753 | 3541 if(s->real_sprite_warping_points==1){ |
1842
0d82db458a3c
interlaced mpeg4 + edge emu fix (fixes decoding of mermaid.avi)
michael
parents:
1838
diff
changeset
|
3542 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
|
3543 ref_picture); |
753 | 3544 }else{ |
1842
0d82db458a3c
interlaced mpeg4 + edge emu fix (fixes decoding of mermaid.avi)
michael
parents:
1838
diff
changeset
|
3545 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
|
3546 ref_picture); |
753 | 3547 } |
651 | 3548 }else if(s->quarter_sample){ |
2967 | 3549 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
|
3550 0, 0, 0, |
0d82db458a3c
interlaced mpeg4 + edge emu fix (fixes decoding of mermaid.avi)
michael
parents:
1838
diff
changeset
|
3551 ref_picture, pix_op, qpix_op, |
255 | 3552 s->mv[dir][0][0], s->mv[dir][0][1], 16); |
936 | 3553 }else if(s->mspel){ |
3554 ff_mspel_motion(s, dest_y, dest_cb, dest_cr, | |
3555 ref_picture, pix_op, | |
3556 s->mv[dir][0][0], s->mv[dir][0][1], 16); | |
1042 | 3557 }else |
3558 { | |
2967 | 3559 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
|
3560 0, 0, 0, |
0d82db458a3c
interlaced mpeg4 + edge emu fix (fixes decoding of mermaid.avi)
michael
parents:
1838
diff
changeset
|
3561 ref_picture, pix_op, |
255 | 3562 s->mv[dir][0][0], s->mv[dir][0][1], 16); |
2967 | 3563 } |
0 | 3564 break; |
3565 case MV_TYPE_8X8: | |
673 | 3566 mx = 0; |
3567 my = 0; | |
3568 if(s->quarter_sample){ | |
3569 for(i=0;i<4;i++) { | |
3570 motion_x = s->mv[dir][i][0]; | |
3571 motion_y = s->mv[dir][i][1]; | |
0 | 3572 |
673 | 3573 dxy = ((motion_y & 3) << 2) | (motion_x & 3); |
3574 src_x = mb_x * 16 + (motion_x >> 2) + (i & 1) * 8; | |
3575 src_y = mb_y * 16 + (motion_y >> 2) + (i >>1) * 8; | |
2967 | 3576 |
673 | 3577 /* WARNING: do no forget half pels */ |
3578 src_x = clip(src_x, -16, s->width); | |
3579 if (src_x == s->width) | |
3580 dxy &= ~3; | |
3581 src_y = clip(src_y, -16, s->height); | |
3582 if (src_y == s->height) | |
3583 dxy &= ~12; | |
2967 | 3584 |
673 | 3585 ptr = ref_picture[0] + (src_y * s->linesize) + (src_x); |
3586 if(s->flags&CODEC_FLAG_EMU_EDGE){ | |
2967 | 3587 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
|
3588 || (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
|
3589 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 | 3590 ptr= s->edge_emu_buffer; |
3591 } | |
3592 } | |
3593 dest = dest_y + ((i & 1) * 8) + (i >> 1) * 8 * s->linesize; | |
3594 qpix_op[1][dxy](dest, ptr, s->linesize); | |
3595 | |
3596 mx += s->mv[dir][i][0]/2; | |
3597 my += s->mv[dir][i][1]/2; | |
3598 } | |
3599 }else{ | |
3600 for(i=0;i<4;i++) { | |
1633 | 3601 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
|
3602 ref_picture[0], 0, 0, |
1633 | 3603 mb_x * 16 + (i & 1) * 8, mb_y * 16 + (i >>1) * 8, |
3604 s->width, s->height, s->linesize, | |
3605 s->h_edge_pos, s->v_edge_pos, | |
3606 8, 8, pix_op[1], | |
3607 s->mv[dir][i][0], s->mv[dir][i][1]); | |
673 | 3608 |
3609 mx += s->mv[dir][i][0]; | |
3610 my += s->mv[dir][i][1]; | |
554 | 3611 } |
0 | 3612 } |
673 | 3613 |
1633 | 3614 if(!(s->flags&CODEC_FLAG_GRAY)) |
3615 chroma_4mv_motion(s, dest_cb, dest_cr, ref_picture, pix_op[1], mx, my); | |
0 | 3616 break; |
3617 case MV_TYPE_FIELD: | |
3618 if (s->picture_structure == PICT_FRAME) { | |
671 | 3619 if(s->quarter_sample){ |
1843 | 3620 for(i=0; i<2; i++){ |
3621 qpel_motion(s, dest_y, dest_cb, dest_cr, | |
3622 1, i, s->field_select[dir][i], | |
3623 ref_picture, pix_op, qpix_op, | |
3624 s->mv[dir][i][0], s->mv[dir][i][1], 8); | |
3625 } | |
671 | 3626 }else{ |
2967 | 3627 /* top field */ |
1842
0d82db458a3c
interlaced mpeg4 + edge emu fix (fixes decoding of mermaid.avi)
michael
parents:
1838
diff
changeset
|
3628 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
|
3629 1, 0, s->field_select[dir][0], |
0d82db458a3c
interlaced mpeg4 + edge emu fix (fixes decoding of mermaid.avi)
michael
parents:
1838
diff
changeset
|
3630 ref_picture, pix_op, |
671 | 3631 s->mv[dir][0][0], s->mv[dir][0][1], 8); |
3632 /* bottom field */ | |
1842
0d82db458a3c
interlaced mpeg4 + edge emu fix (fixes decoding of mermaid.avi)
michael
parents:
1838
diff
changeset
|
3633 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
|
3634 1, 1, s->field_select[dir][1], |
0d82db458a3c
interlaced mpeg4 + edge emu fix (fixes decoding of mermaid.avi)
michael
parents:
1838
diff
changeset
|
3635 ref_picture, pix_op, |
671 | 3636 s->mv[dir][1][0], s->mv[dir][1][1], 8); |
3637 } | |
0 | 3638 } else { |
1842
0d82db458a3c
interlaced mpeg4 + edge emu fix (fixes decoding of mermaid.avi)
michael
parents:
1838
diff
changeset
|
3639 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
|
3640 ref_picture= s->current_picture_ptr->data; |
2967 | 3641 } |
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 |
1842
0d82db458a3c
interlaced mpeg4 + edge emu fix (fixes decoding of mermaid.avi)
michael
parents:
1838
diff
changeset
|
3643 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
|
3644 0, 0, s->field_select[dir][0], |
0d82db458a3c
interlaced mpeg4 + edge emu fix (fixes decoding of mermaid.avi)
michael
parents:
1838
diff
changeset
|
3645 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
|
3646 s->mv[dir][0][0], s->mv[dir][0][1], 16); |
0 | 3647 } |
3648 break; | |
1843 | 3649 case MV_TYPE_16X8: |
3650 for(i=0; i<2; i++){ | |
3651 uint8_t ** ref2picture; | |
3652 | |
3653 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
|
3654 ref2picture= ref_picture; |
338a2f6e6402
Mpeg2 16x8 Patch by ("Ivan Kalvachev" <ivan at cacad dot com>)
michaelni
parents:
1328
diff
changeset
|
3655 }else{ |
1842
0d82db458a3c
interlaced mpeg4 + edge emu fix (fixes decoding of mermaid.avi)
michael
parents:
1838
diff
changeset
|
3656 ref2picture= s->current_picture_ptr->data; |
2967 | 3657 } |
3658 | |
3659 mpeg_motion(s, dest_y, dest_cb, dest_cr, | |
1843 | 3660 0, 0, s->field_select[dir][i], |
1842
0d82db458a3c
interlaced mpeg4 + edge emu fix (fixes decoding of mermaid.avi)
michael
parents:
1838
diff
changeset
|
3661 ref2picture, pix_op, |
1843 | 3662 s->mv[dir][i][0], s->mv[dir][i][1] + 16*i, 8); |
2967 | 3663 |
1843 | 3664 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
|
3665 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
|
3666 dest_cr+= (16>>s->chroma_y_shift)*s->uvlinesize; |
2967 | 3667 } |
1339
338a2f6e6402
Mpeg2 16x8 Patch by ("Ivan Kalvachev" <ivan at cacad dot com>)
michaelni
parents:
1328
diff
changeset
|
3668 break; |
1326
6cdd3b8f4fd3
DMV support patch by ("Ivan Kalvachev" <ivan at cacad dot com>)
michaelni
parents:
1317
diff
changeset
|
3669 case MV_TYPE_DMV: |
6cdd3b8f4fd3
DMV support patch by ("Ivan Kalvachev" <ivan at cacad dot com>)
michaelni
parents:
1317
diff
changeset
|
3670 if(s->picture_structure == PICT_FRAME){ |
1843 | 3671 for(i=0; i<2; i++){ |
3672 int j; | |
3673 for(j=0; j<2; j++){ | |
3674 mpeg_motion(s, dest_y, dest_cb, dest_cr, | |
3675 1, j, j^i, | |
3676 ref_picture, pix_op, | |
3677 s->mv[dir][2*i + j][0], s->mv[dir][2*i + j][1], 8); | |
3678 } | |
2967 | 3679 pix_op = s->dsp.avg_pixels_tab; |
1843 | 3680 } |
1326
6cdd3b8f4fd3
DMV support patch by ("Ivan Kalvachev" <ivan at cacad dot com>)
michaelni
parents:
1317
diff
changeset
|
3681 }else{ |
1843 | 3682 for(i=0; i<2; i++){ |
2967 | 3683 mpeg_motion(s, dest_y, dest_cb, dest_cr, |
1843 | 3684 0, 0, s->picture_structure != i+1, |
3685 ref_picture, pix_op, | |
3686 s->mv[dir][2*i][0],s->mv[dir][2*i][1],16); | |
3687 | |
3688 // after put we make avg of the same block | |
2967 | 3689 pix_op=s->dsp.avg_pixels_tab; |
1843 | 3690 |
3691 //opposite parity is always in the same frame if this is second field | |
3692 if(!s->first_field){ | |
2967 | 3693 ref_picture = s->current_picture_ptr->data; |
1843 | 3694 } |
1842
0d82db458a3c
interlaced mpeg4 + edge emu fix (fixes decoding of mermaid.avi)
michael
parents:
1838
diff
changeset
|
3695 } |
1326
6cdd3b8f4fd3
DMV support patch by ("Ivan Kalvachev" <ivan at cacad dot com>)
michaelni
parents:
1317
diff
changeset
|
3696 } |
6cdd3b8f4fd3
DMV support patch by ("Ivan Kalvachev" <ivan at cacad dot com>)
michaelni
parents:
1317
diff
changeset
|
3697 break; |
1633 | 3698 default: assert(0); |
0 | 3699 } |
3700 } | |
3701 | |
2256 | 3702 /** |
2764 | 3703 * motion compensation of a single macroblock |
2256 | 3704 * @param s context |
3705 * @param dest_y luma destination pointer | |
3706 * @param dest_cb chroma cb/u destination pointer | |
3707 * @param dest_cr chroma cr/v destination pointer | |
3708 * @param dir direction (0->forward, 1->backward) | |
3709 * @param ref_picture array[3] of pointers to the 3 planes of the reference picture | |
3710 * @param pic_op halfpel motion compensation function (average or put normally) | |
3711 * the motion vectors are taken from s->mv and the MV type from s->mv_type | |
3712 */ | |
2967 | 3713 static inline void MPV_motion_lowres(MpegEncContext *s, |
2256 | 3714 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr, |
2967 | 3715 int dir, uint8_t **ref_picture, |
2256 | 3716 h264_chroma_mc_func *pix_op) |
3717 { | |
2292 | 3718 int mx, my; |
2260 | 3719 int mb_x, mb_y, i; |
3720 const int lowres= s->avctx->lowres; | |
2967 | 3721 const int block_s= 8>>lowres; |
2260 | 3722 |
3723 mb_x = s->mb_x; | |
3724 mb_y = s->mb_y; | |
3725 | |
3726 switch(s->mv_type) { | |
3727 case MV_TYPE_16X16: | |
2967 | 3728 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr, |
2260 | 3729 0, 0, 0, |
3730 ref_picture, pix_op, | |
3731 s->mv[dir][0][0], s->mv[dir][0][1], 2*block_s); | |
3732 break; | |
2292 | 3733 case MV_TYPE_8X8: |
2260 | 3734 mx = 0; |
3735 my = 0; | |
3736 for(i=0;i<4;i++) { | |
2292 | 3737 hpel_motion_lowres(s, dest_y + ((i & 1) + (i >> 1) * s->linesize)*block_s, |
2260 | 3738 ref_picture[0], 0, 0, |
2292 | 3739 (2*mb_x + (i & 1))*block_s, (2*mb_y + (i >>1))*block_s, |
2260 | 3740 s->width, s->height, s->linesize, |
2292 | 3741 s->h_edge_pos >> lowres, s->v_edge_pos >> lowres, |
3742 block_s, block_s, pix_op, | |
2260 | 3743 s->mv[dir][i][0], s->mv[dir][i][1]); |
3744 | |
3745 mx += s->mv[dir][i][0]; | |
3746 my += s->mv[dir][i][1]; | |
3747 } | |
3748 | |
3749 if(!(s->flags&CODEC_FLAG_GRAY)) | |
2292 | 3750 chroma_4mv_motion_lowres(s, dest_cb, dest_cr, ref_picture, pix_op, mx, my); |
3751 break; | |
2260 | 3752 case MV_TYPE_FIELD: |
3753 if (s->picture_structure == PICT_FRAME) { | |
2967 | 3754 /* top field */ |
2260 | 3755 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr, |
3756 1, 0, s->field_select[dir][0], | |
3757 ref_picture, pix_op, | |
3758 s->mv[dir][0][0], s->mv[dir][0][1], block_s); | |
3759 /* bottom field */ | |
3760 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr, | |
3761 1, 1, s->field_select[dir][1], | |
3762 ref_picture, pix_op, | |
3763 s->mv[dir][1][0], s->mv[dir][1][1], block_s); | |
3764 } else { | |
3765 if(s->picture_structure != s->field_select[dir][0] + 1 && s->pict_type != B_TYPE && !s->first_field){ | |
3766 ref_picture= s->current_picture_ptr->data; | |
2967 | 3767 } |
2260 | 3768 |
3769 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr, | |
3770 0, 0, s->field_select[dir][0], | |
3771 ref_picture, pix_op, | |
3772 s->mv[dir][0][0], s->mv[dir][0][1], 2*block_s); | |
3773 } | |
3774 break; | |
3775 case MV_TYPE_16X8: | |
3776 for(i=0; i<2; i++){ | |
3777 uint8_t ** ref2picture; | |
3778 | |
3779 if(s->picture_structure == s->field_select[dir][i] + 1 || s->pict_type == B_TYPE || s->first_field){ | |
3780 ref2picture= ref_picture; | |
3781 }else{ | |
3782 ref2picture= s->current_picture_ptr->data; | |
2967 | 3783 } |
3784 | |
3785 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr, | |
2260 | 3786 0, 0, s->field_select[dir][i], |
3787 ref2picture, pix_op, | |
3788 s->mv[dir][i][0], s->mv[dir][i][1] + 2*block_s*i, block_s); | |
2967 | 3789 |
2260 | 3790 dest_y += 2*block_s*s->linesize; |
3791 dest_cb+= (2*block_s>>s->chroma_y_shift)*s->uvlinesize; | |
3792 dest_cr+= (2*block_s>>s->chroma_y_shift)*s->uvlinesize; | |
2967 | 3793 } |
2260 | 3794 break; |
3795 case MV_TYPE_DMV: | |
3796 if(s->picture_structure == PICT_FRAME){ | |
3797 for(i=0; i<2; i++){ | |
3798 int j; | |
3799 for(j=0; j<2; j++){ | |
3800 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr, | |
3801 1, j, j^i, | |
3802 ref_picture, pix_op, | |
3803 s->mv[dir][2*i + j][0], s->mv[dir][2*i + j][1], block_s); | |
3804 } | |
3805 pix_op = s->dsp.avg_h264_chroma_pixels_tab; | |
3806 } | |
3807 }else{ | |
3808 for(i=0; i<2; i++){ | |
2967 | 3809 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr, |
2260 | 3810 0, 0, s->picture_structure != i+1, |
3811 ref_picture, pix_op, | |
3812 s->mv[dir][2*i][0],s->mv[dir][2*i][1],2*block_s); | |
3813 | |
3814 // after put we make avg of the same block | |
3815 pix_op = s->dsp.avg_h264_chroma_pixels_tab; | |
3816 | |
3817 //opposite parity is always in the same frame if this is second field | |
3818 if(!s->first_field){ | |
2967 | 3819 ref_picture = s->current_picture_ptr->data; |
2260 | 3820 } |
3821 } | |
3822 } | |
3823 break; | |
3824 default: assert(0); | |
3825 } | |
2256 | 3826 } |
0 | 3827 |
3828 /* put block[] to dest[] */ | |
2967 | 3829 static inline void put_dct(MpegEncContext *s, |
1651 | 3830 DCTELEM *block, int i, uint8_t *dest, int line_size, int qscale) |
0 | 3831 { |
1689 | 3832 s->dct_unquantize_intra(s, block, i, qscale); |
1092 | 3833 s->dsp.idct_put (dest, line_size, block); |
0 | 3834 } |
3835 | |
3836 /* add block[] to dest[] */ | |
2967 | 3837 static inline void add_dct(MpegEncContext *s, |
1064 | 3838 DCTELEM *block, int i, uint8_t *dest, int line_size) |
0 | 3839 { |
3840 if (s->block_last_index[i] >= 0) { | |
1092 | 3841 s->dsp.idct_add (dest, line_size, block); |
481 | 3842 } |
3843 } | |
3844 | |
2967 | 3845 static inline void add_dequant_dct(MpegEncContext *s, |
1644 | 3846 DCTELEM *block, int i, uint8_t *dest, int line_size, int qscale) |
481 | 3847 { |
3848 if (s->block_last_index[i] >= 0) { | |
1689 | 3849 s->dct_unquantize_inter(s, block, i, qscale); |
324 | 3850 |
1092 | 3851 s->dsp.idct_add (dest, line_size, block); |
0 | 3852 } |
3853 } | |
3854 | |
456 | 3855 /** |
3856 * cleans dc, ac, coded_block for the current non intra MB | |
3857 */ | |
3858 void ff_clean_intra_table_entries(MpegEncContext *s) | |
3859 { | |
1938
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1918
diff
changeset
|
3860 int wrap = s->b8_stride; |
456 | 3861 int xy = s->block_index[0]; |
2967 | 3862 |
3863 s->dc_val[0][xy ] = | |
3864 s->dc_val[0][xy + 1 ] = | |
456 | 3865 s->dc_val[0][xy + wrap] = |
3866 s->dc_val[0][xy + 1 + wrap] = 1024; | |
3867 /* ac pred */ | |
1064 | 3868 memset(s->ac_val[0][xy ], 0, 32 * sizeof(int16_t)); |
3869 memset(s->ac_val[0][xy + wrap], 0, 32 * sizeof(int16_t)); | |
456 | 3870 if (s->msmpeg4_version>=3) { |
3871 s->coded_block[xy ] = | |
3872 s->coded_block[xy + 1 ] = | |
3873 s->coded_block[xy + wrap] = | |
3874 s->coded_block[xy + 1 + wrap] = 0; | |
3875 } | |
3876 /* chroma */ | |
1938
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1918
diff
changeset
|
3877 wrap = s->mb_stride; |
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1918
diff
changeset
|
3878 xy = s->mb_x + s->mb_y * wrap; |
456 | 3879 s->dc_val[1][xy] = |
3880 s->dc_val[2][xy] = 1024; | |
3881 /* ac pred */ | |
1064 | 3882 memset(s->ac_val[1][xy], 0, 16 * sizeof(int16_t)); |
3883 memset(s->ac_val[2][xy], 0, 16 * sizeof(int16_t)); | |
2967 | 3884 |
1938
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1918
diff
changeset
|
3885 s->mbintra_table[xy]= 0; |
456 | 3886 } |
3887 | |
0 | 3888 /* generic function called after a macroblock has been parsed by the |
3889 decoder or after it has been encoded by the encoder. | |
3890 | |
3891 Important variables used: | |
3892 s->mb_intra : true if intra macroblock | |
3893 s->mv_dir : motion vector direction | |
3894 s->mv_type : motion vector type | |
3895 s->mv : motion vector | |
3896 s->interlaced_dct : true if interlaced dct used (mpeg2) | |
3897 */ | |
4283
d6f83e2f8804
rename always_inline to av_always_inline and move to common.h
mru
parents:
4281
diff
changeset
|
3898 static av_always_inline void MPV_decode_mb_internal(MpegEncContext *s, DCTELEM block[12][64], int lowres_flag) |
0 | 3899 { |
244 | 3900 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
|
3901 const int mb_xy = s->mb_y * s->mb_stride + s->mb_x; |
1381 | 3902 #ifdef HAVE_XVMC |
3903 if(s->avctx->xvmc_acceleration){ | |
1580
628bf341e099
XvMC speedup by removing one memcpy and doing MB packing
iive
parents:
1579
diff
changeset
|
3904 XVMC_decode_mb(s);//xvmc uses pblocks |
1381 | 3905 return; |
3906 } | |
3907 #endif | |
0 | 3908 |
3909 mb_x = s->mb_x; | |
3910 mb_y = s->mb_y; | |
3911 | |
1833
ba27ce284d07
export DCT coefficients patch by (Wolfgang Hesseler <wolfgang.hesseler at imk dot fraunhofer dot de>)
michael
parents:
1831
diff
changeset
|
3912 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
|
3913 /* save DCT coefficients */ |
ba27ce284d07
export DCT coefficients patch by (Wolfgang Hesseler <wolfgang.hesseler at imk dot fraunhofer dot de>)
michael
parents:
1831
diff
changeset
|
3914 int i,j; |
ba27ce284d07
export DCT coefficients patch by (Wolfgang Hesseler <wolfgang.hesseler at imk dot fraunhofer dot de>)
michael
parents:
1831
diff
changeset
|
3915 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
|
3916 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
|
3917 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
|
3918 *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
|
3919 } |
ba27ce284d07
export DCT coefficients patch by (Wolfgang Hesseler <wolfgang.hesseler at imk dot fraunhofer dot de>)
michael
parents:
1831
diff
changeset
|
3920 |
903 | 3921 s->current_picture.qscale_table[mb_xy]= s->qscale; |
108
1e4a4af694d1
exporting qscale data for postprocessing (for MPlayer)
arpi_esp
parents:
79
diff
changeset
|
3922 |
0 | 3923 /* update DC predictors for P macroblocks */ |
3924 if (!s->mb_intra) { | |
249
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
3925 if (s->h263_pred || s->h263_aic) { |
481 | 3926 if(s->mbintra_table[mb_xy]) |
456 | 3927 ff_clean_intra_table_entries(s); |
0 | 3928 } else { |
456 | 3929 s->last_dc[0] = |
3930 s->last_dc[1] = | |
0 | 3931 s->last_dc[2] = 128 << s->intra_dc_precision; |
3932 } | |
3933 } | |
249
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
3934 else if (s->h263_pred || s->h263_aic) |
481 | 3935 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
|
3936 |
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
|
3937 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 | 3938 uint8_t *dest_y, *dest_cb, *dest_cr; |
481 | 3939 int dct_linesize, dct_offset; |
651 | 3940 op_pixels_func (*op_pix)[4]; |
3941 qpel_mc_func (*op_qpix)[16]; | |
2627
bf158d23bbcc
Spelling errors patch by (Kevin Baragona | kevinmb500 gawab com)
michael
parents:
2620
diff
changeset
|
3942 const int linesize= s->current_picture.linesize[0]; //not s->linesize as this would be wrong for field pics |
1138 | 3943 const int uvlinesize= s->current_picture.linesize[1]; |
2256 | 3944 const int readable= s->pict_type != B_TYPE || s->encoding || s->avctx->draw_horiz_band || lowres_flag; |
3945 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
|
3946 |
903 | 3947 /* avoid copy if macroblock skipped in last frame too */ |
3948 /* skip only during decoding as we might trash the buffers during encoding a bit */ | |
3949 if(!s->encoding){ | |
1064 | 3950 uint8_t *mbskip_ptr = &s->mbskip_table[mb_xy]; |
903 | 3951 const int age= s->current_picture.age; |
3952 | |
3953 assert(age); | |
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 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
|
3956 s->mb_skipped= 0; |
903 | 3957 assert(s->pict_type!=I_TYPE); |
2967 | 3958 |
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
|
3959 (*mbskip_ptr) ++; /* indicate that this time we skipped it */ |
556 | 3960 if(*mbskip_ptr >99) *mbskip_ptr= 99; |
3961 | |
903 | 3962 /* 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
|
3963 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
|
3964 return; |
903 | 3965 } |
1021
2d7c9f5738de
trying to fix mb skip bug in mpeg1/2 if slices are not used
michaelni
parents:
1014
diff
changeset
|
3966 } 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
|
3967 (*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
|
3968 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
|
3969 } else{ |
7
1d3ac9654178
added skip macroblock optimization (big perf win on black regions for example)
glantau
parents:
0
diff
changeset
|
3970 *mbskip_ptr = 0; /* not skipped */ |
1d3ac9654178
added skip macroblock optimization (big perf win on black regions for example)
glantau
parents:
0
diff
changeset
|
3971 } |
717 | 3972 } |
2967 | 3973 |
2074
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
3974 dct_linesize = linesize << s->interlaced_dct; |
2256 | 3975 dct_offset =(s->interlaced_dct)? linesize : linesize*block_size; |
2967 | 3976 |
1632 | 3977 if(readable){ |
3978 dest_y= s->dest[0]; | |
3979 dest_cb= s->dest[1]; | |
3980 dest_cr= s->dest[2]; | |
3981 }else{ | |
1799 | 3982 dest_y = s->b_scratchpad; |
1834 | 3983 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
|
3984 dest_cr= s->b_scratchpad+32*linesize; |
1632 | 3985 } |
2256 | 3986 |
0 | 3987 if (!s->mb_intra) { |
3988 /* motion handling */ | |
2627
bf158d23bbcc
Spelling errors patch by (Kevin Baragona | kevinmb500 gawab com)
michael
parents:
2620
diff
changeset
|
3989 /* decoding or more than one mb_type (MC was already done otherwise) */ |
1389 | 3990 if(!s->encoding){ |
2256 | 3991 if(lowres_flag){ |
3992 h264_chroma_mc_func *op_pix = s->dsp.put_h264_chroma_pixels_tab; | |
3993 | |
3994 if (s->mv_dir & MV_DIR_FORWARD) { | |
3995 MPV_motion_lowres(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.data, op_pix); | |
3996 op_pix = s->dsp.avg_h264_chroma_pixels_tab; | |
3997 } | |
3998 if (s->mv_dir & MV_DIR_BACKWARD) { | |
3999 MPV_motion_lowres(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.data, op_pix); | |
4000 } | |
324 | 4001 }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
|
4002 op_qpix= s->me.qpel_put; |
2967 | 4003 if ((!s->no_rounding) || s->pict_type==B_TYPE){ |
2256 | 4004 op_pix = s->dsp.put_pixels_tab; |
4005 }else{ | |
4006 op_pix = s->dsp.put_no_rnd_pixels_tab; | |
4007 } | |
4008 if (s->mv_dir & MV_DIR_FORWARD) { | |
4009 MPV_motion(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.data, op_pix, op_qpix); | |
4010 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
|
4011 op_qpix= s->me.qpel_avg; |
2256 | 4012 } |
4013 if (s->mv_dir & MV_DIR_BACKWARD) { | |
4014 MPV_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.data, op_pix, op_qpix); | |
4015 } | |
324 | 4016 } |
0 | 4017 } |
4018 | |
481 | 4019 /* skip dequant / idct if we are really late ;) */ |
2792 | 4020 if(s->hurry_up>1) goto skip_idct; |
4021 if(s->avctx->skip_idct){ | |
4022 if( (s->avctx->skip_idct >= AVDISCARD_NONREF && s->pict_type == B_TYPE) | |
4023 ||(s->avctx->skip_idct >= AVDISCARD_NONKEY && s->pict_type != I_TYPE) | |
4024 || s->avctx->skip_idct >= AVDISCARD_ALL) | |
4025 goto skip_idct; | |
4026 } | |
481 | 4027 |
0 | 4028 /* add dct residue */ |
1421 | 4029 if(s->encoding || !( s->h263_msmpeg4 || s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO |
711 | 4030 || (s->codec_id==CODEC_ID_MPEG4 && !s->mpeg_quant))){ |
2256 | 4031 add_dequant_dct(s, block[0], 0, dest_y , dct_linesize, s->qscale); |
4032 add_dequant_dct(s, block[1], 1, dest_y + block_size, dct_linesize, s->qscale); | |
4033 add_dequant_dct(s, block[2], 2, dest_y + dct_offset , dct_linesize, s->qscale); | |
4034 add_dequant_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize, s->qscale); | |
0 | 4035 |
485 | 4036 if(!(s->flags&CODEC_FLAG_GRAY)){ |
3309 | 4037 if (s->chroma_y_shift){ |
4038 add_dequant_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale); | |
4039 add_dequant_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale); | |
4040 }else{ | |
4041 dct_linesize >>= 1; | |
4042 dct_offset >>=1; | |
4043 add_dequant_dct(s, block[4], 4, dest_cb, dct_linesize, s->chroma_qscale); | |
4044 add_dequant_dct(s, block[5], 5, dest_cr, dct_linesize, s->chroma_qscale); | |
4045 add_dequant_dct(s, block[6], 6, dest_cb + dct_offset, dct_linesize, s->chroma_qscale); | |
4046 add_dequant_dct(s, block[7], 7, dest_cr + dct_offset, dct_linesize, s->chroma_qscale); | |
4047 } | |
485 | 4048 } |
936 | 4049 } else if(s->codec_id != CODEC_ID_WMV2){ |
2256 | 4050 add_dct(s, block[0], 0, dest_y , dct_linesize); |
4051 add_dct(s, block[1], 1, dest_y + block_size, dct_linesize); | |
4052 add_dct(s, block[2], 2, dest_y + dct_offset , dct_linesize); | |
4053 add_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize); | |
481 | 4054 |
485 | 4055 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
|
4056 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
|
4057 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
|
4058 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
|
4059 }else{ |
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
4060 //chroma422 |
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
4061 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
|
4062 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
|
4063 |
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
4064 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
|
4065 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
|
4066 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
|
4067 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
|
4068 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
|
4069 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
|
4070 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
|
4071 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
|
4072 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
|
4073 } |
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
4074 } |
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
4075 }//fi gray |
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
4076 } |
1042 | 4077 else{ |
936 | 4078 ff_wmv2_add_mb(s, block, dest_y, dest_cb, dest_cr); |
481 | 4079 } |
0 | 4080 } else { |
4081 /* dct only in intra block */ | |
1421 | 4082 if(s->encoding || !(s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO)){ |
2256 | 4083 put_dct(s, block[0], 0, dest_y , dct_linesize, s->qscale); |
4084 put_dct(s, block[1], 1, dest_y + block_size, dct_linesize, s->qscale); | |
4085 put_dct(s, block[2], 2, dest_y + dct_offset , dct_linesize, s->qscale); | |
4086 put_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize, s->qscale); | |
0 | 4087 |
711 | 4088 if(!(s->flags&CODEC_FLAG_GRAY)){ |
3309 | 4089 if(s->chroma_y_shift){ |
4090 put_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale); | |
4091 put_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale); | |
4092 }else{ | |
4093 dct_offset >>=1; | |
4094 dct_linesize >>=1; | |
4095 put_dct(s, block[4], 4, dest_cb, dct_linesize, s->chroma_qscale); | |
4096 put_dct(s, block[5], 5, dest_cr, dct_linesize, s->chroma_qscale); | |
4097 put_dct(s, block[6], 6, dest_cb + dct_offset, dct_linesize, s->chroma_qscale); | |
4098 put_dct(s, block[7], 7, dest_cr + dct_offset, dct_linesize, s->chroma_qscale); | |
4099 } | |
711 | 4100 } |
4101 }else{ | |
2256 | 4102 s->dsp.idct_put(dest_y , dct_linesize, block[0]); |
4103 s->dsp.idct_put(dest_y + block_size, dct_linesize, block[1]); | |
4104 s->dsp.idct_put(dest_y + dct_offset , dct_linesize, block[2]); | |
4105 s->dsp.idct_put(dest_y + dct_offset + block_size, dct_linesize, block[3]); | |
711 | 4106 |
4107 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
|
4108 if(s->chroma_y_shift){ |
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
4109 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
|
4110 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
|
4111 }else{ |
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
4112 |
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
4113 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
|
4114 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
|
4115 |
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
4116 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
|
4117 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
|
4118 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
|
4119 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
|
4120 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
|
4121 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
|
4122 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
|
4123 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
|
4124 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
|
4125 } |
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
4126 } |
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
4127 }//gray |
485 | 4128 } |
0 | 4129 } |
2792 | 4130 skip_idct: |
1632 | 4131 if(!readable){ |
4132 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
|
4133 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
|
4134 s->dsp.put_pixels_tab[s->chroma_x_shift][0](s->dest[2], dest_cr, uvlinesize,16 >> s->chroma_y_shift); |
1632 | 4135 } |
0 | 4136 } |
294 | 4137 } |
4138 | |
2256 | 4139 void MPV_decode_mb(MpegEncContext *s, DCTELEM block[12][64]){ |
4140 if(s->avctx->lowres) MPV_decode_mb_internal(s, block, 1); | |
4141 else MPV_decode_mb_internal(s, block, 0); | |
4142 } | |
4143 | |
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
|
4144 #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
|
4145 |
605
40874804a5af
same dc skip behavior for chroma & luma elimination, its confusing otherwise imho
michaelni
parents:
604
diff
changeset
|
4146 static inline void dct_single_coeff_elimination(MpegEncContext *s, int n, int threshold) |
456 | 4147 { |
4148 static const char tab[64]= | |
4149 {3,2,2,1,1,1,1,1, | |
4150 1,1,1,1,1,1,1,1, | |
4151 1,1,1,1,1,1,1,1, | |
4152 0,0,0,0,0,0,0,0, | |
4153 0,0,0,0,0,0,0,0, | |
4154 0,0,0,0,0,0,0,0, | |
4155 0,0,0,0,0,0,0,0, | |
4156 0,0,0,0,0,0,0,0}; | |
4157 int score=0; | |
4158 int run=0; | |
4159 int i; | |
4160 DCTELEM *block= s->block[n]; | |
4161 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
|
4162 int skip_dc; |
456 | 4163 |
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
|
4164 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
|
4165 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
|
4166 threshold= -threshold; |
605
40874804a5af
same dc skip behavior for chroma & luma elimination, its confusing otherwise imho
michaelni
parents:
604
diff
changeset
|
4167 }else |
40874804a5af
same dc skip behavior for chroma & luma elimination, its confusing otherwise imho
michaelni
parents:
604
diff
changeset
|
4168 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
|
4169 |
456 | 4170 /* are all which we could set to zero are allready zero? */ |
4171 if(last_index<=skip_dc - 1) return; | |
4172 | |
4173 for(i=0; i<=last_index; i++){ | |
706
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
4174 const int j = s->intra_scantable.permutated[i]; |
4001 | 4175 const int level = FFABS(block[j]); |
456 | 4176 if(level==1){ |
4177 if(skip_dc && i==0) continue; | |
4178 score+= tab[run]; | |
4179 run=0; | |
4180 }else if(level>1){ | |
4181 return; | |
4182 }else{ | |
4183 run++; | |
4184 } | |
4185 } | |
4186 if(score >= threshold) return; | |
4187 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
|
4188 const int j = s->intra_scantable.permutated[i]; |
456 | 4189 block[j]=0; |
4190 } | |
4191 if(block[0]) s->block_last_index[n]= 0; | |
4192 else s->block_last_index[n]= -1; | |
4193 } | |
4194 | |
344 | 4195 static inline void clip_coeffs(MpegEncContext *s, DCTELEM *block, int last_index) |
4196 { | |
4197 int i; | |
4198 const int maxlevel= s->max_qcoeff; | |
4199 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
|
4200 int overflow=0; |
2967 | 4201 |
706
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
4202 if(s->mb_intra){ |
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
4203 i=1; //skip clipping of intra dc |
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
4204 }else |
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
4205 i=0; |
2967 | 4206 |
706
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
4207 for(;i<=last_index; i++){ |
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
4208 const int j= s->intra_scantable.permutated[i]; |
344 | 4209 int level = block[j]; |
2967 | 4210 |
1722
7e040c2a86e4
warn the user if we had to clip some dct coefficient due to a crappy format which doenst support the whole needed range (msmpeg4/wmv mostly but mpeg1 too to a lesser extend)
michael
parents:
1719
diff
changeset
|
4211 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
|
4212 level=maxlevel; |
7e040c2a86e4
warn the user if we had to clip some dct coefficient due to a crappy format which doenst support the whole needed range (msmpeg4/wmv mostly but mpeg1 too to a lesser extend)
michael
parents:
1719
diff
changeset
|
4213 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
|
4214 }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
|
4215 level=minlevel; |
7e040c2a86e4
warn the user if we had to clip some dct coefficient due to a crappy format which doenst support the whole needed range (msmpeg4/wmv mostly but mpeg1 too to a lesser extend)
michael
parents:
1719
diff
changeset
|
4216 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
|
4217 } |
2967 | 4218 |
344 | 4219 block[j]= level; |
4220 } | |
2967 | 4221 |
1722
7e040c2a86e4
warn the user if we had to clip some dct coefficient due to a crappy format which doenst support the whole needed range (msmpeg4/wmv mostly but mpeg1 too to a lesser extend)
michael
parents:
1719
diff
changeset
|
4222 if(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
|
4223 av_log(s->avctx, AV_LOG_INFO, "warning, clipping %d dct coefficients to %d..%d\n", overflow, minlevel, maxlevel); |
344 | 4224 } |
324 | 4225 |
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
|
4226 #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
|
4227 |
1098
b7f267d168b7
mpeg2 field pictures + sliced mode (doesnt work with mplayer though, dunno why)
michaelni
parents:
1096
diff
changeset
|
4228 /** |
b7f267d168b7
mpeg2 field pictures + sliced mode (doesnt work with mplayer though, dunno why)
michaelni
parents:
1096
diff
changeset
|
4229 * |
b7f267d168b7
mpeg2 field pictures + sliced mode (doesnt work with mplayer though, dunno why)
michaelni
parents:
1096
diff
changeset
|
4230 * @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
|
4231 */ |
b7f267d168b7
mpeg2 field pictures + sliced mode (doesnt work with mplayer though, dunno why)
michaelni
parents:
1096
diff
changeset
|
4232 void ff_draw_horiz_band(MpegEncContext *s, int y, int h){ |
1368 | 4233 if (s->avctx->draw_horiz_band) { |
1370 | 4234 AVFrame *src; |
1368 | 4235 int offset[4]; |
2967 | 4236 |
1370 | 4237 if(s->picture_structure != PICT_FRAME){ |
4238 h <<= 1; | |
4239 y <<= 1; | |
4240 if(s->first_field && !(s->avctx->slice_flags&SLICE_FLAG_ALLOW_FIELD)) return; | |
4241 } | |
4242 | |
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
|
4243 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
|
4244 |
2967 | 4245 if(s->pict_type==B_TYPE || s->low_delay || (s->avctx->slice_flags&SLICE_FLAG_CODED_ORDER)) |
1370 | 4246 src= (AVFrame*)s->current_picture_ptr; |
4247 else if(s->last_picture_ptr) | |
4248 src= (AVFrame*)s->last_picture_ptr; | |
4249 else | |
4250 return; | |
2967 | 4251 |
1369 | 4252 if(s->pict_type==B_TYPE && s->picture_structure == PICT_FRAME && s->out_format != FMT_H264){ |
1368 | 4253 offset[0]= |
4254 offset[1]= | |
4255 offset[2]= | |
4256 offset[3]= 0; | |
4257 }else{ | |
4258 offset[0]= y * s->linesize;; | |
2967 | 4259 offset[1]= |
2074
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
4260 offset[2]= (y >> s->chroma_y_shift) * s->uvlinesize; |
1368 | 4261 offset[3]= 0; |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
731
diff
changeset
|
4262 } |
1368 | 4263 |
813 | 4264 emms_c(); |
4265 | |
1370 | 4266 s->avctx->draw_horiz_band(s->avctx, src, offset, |
4267 y, s->picture_structure, h); | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
731
diff
changeset
|
4268 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
731
diff
changeset
|
4269 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
731
diff
changeset
|
4270 |
1389 | 4271 void ff_init_block_index(MpegEncContext *s){ //FIXME maybe rename |
2764 | 4272 const int linesize= s->current_picture.linesize[0]; //not s->linesize as this would be wrong for field pics |
1389 | 4273 const int uvlinesize= s->current_picture.linesize[1]; |
2256 | 4274 const int mb_size= 4 - s->avctx->lowres; |
2967 | 4275 |
1938
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1918
diff
changeset
|
4276 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
|
4277 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
|
4278 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
|
4279 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
|
4280 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
|
4281 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
|
4282 //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
|
4283 |
2256 | 4284 s->dest[0] = s->current_picture.data[0] + ((s->mb_x - 1) << mb_size); |
4285 s->dest[1] = s->current_picture.data[1] + ((s->mb_x - 1) << (mb_size - s->chroma_x_shift)); | |
4286 s->dest[2] = s->current_picture.data[2] + ((s->mb_x - 1) << (mb_size - s->chroma_x_shift)); | |
2168 | 4287 |
2074
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
4288 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
|
4289 { |
2256 | 4290 s->dest[0] += s->mb_y * linesize << mb_size; |
4291 s->dest[1] += s->mb_y * uvlinesize << (mb_size - s->chroma_y_shift); | |
4292 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
|
4293 } |
1389 | 4294 } |
4295 | |
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
|
4296 #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
|
4297 |
1777 | 4298 static void get_vissual_weight(int16_t *weight, uint8_t *ptr, int stride){ |
4299 int x, y; | |
4300 //FIXME optimize | |
4301 for(y=0; y<8; y++){ | |
4302 for(x=0; x<8; x++){ | |
4303 int x2, y2; | |
4304 int sum=0; | |
4305 int sqr=0; | |
4306 int count=0; | |
4307 | |
4308 for(y2= FFMAX(y-1, 0); y2 < FFMIN(8, y+2); y2++){ | |
4309 for(x2= FFMAX(x-1, 0); x2 < FFMIN(8, x+2); x2++){ | |
4310 int v= ptr[x2 + y2*stride]; | |
4311 sum += v; | |
4312 sqr += v*v; | |
4313 count++; | |
4314 } | |
4315 } | |
4316 weight[x + 8*y]= (36*ff_sqrt(count*sqr - sum*sum)) / count; | |
4317 } | |
4318 } | |
4319 } | |
4320 | |
4283
d6f83e2f8804
rename always_inline to av_always_inline and move to common.h
mru
parents:
4281
diff
changeset
|
4321 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 | 4322 { |
3309 | 4323 int16_t weight[8][64]; |
4324 DCTELEM orig[8][64]; | |
294 | 4325 const int mb_x= s->mb_x; |
4326 const int mb_y= s->mb_y; | |
4327 int i; | |
3309 | 4328 int skip_dct[8]; |
697 | 4329 int dct_offset = s->linesize*8; //default for progressive frames |
1778 | 4330 uint8_t *ptr_y, *ptr_cb, *ptr_cr; |
4331 int wrap_y, wrap_c; | |
2967 | 4332 |
3309 | 4333 for(i=0; i<mb_block_count; i++) skip_dct[i]=0; |
2967 | 4334 |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
673
diff
changeset
|
4335 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
|
4336 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
|
4337 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
|
4338 |
010f76d07a27
use lagrange multipler instead of qp for ratecontrol, this may break some things, tell me ASAP if u notice anything broken
michaelni
parents:
1497
diff
changeset
|
4339 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
|
4340 update_qscale(s); |
2967 | 4341 |
1616 | 4342 if(!(s->flags&CODEC_FLAG_QP_RD)){ |
4343 s->dquant= s->qscale - last_qp; | |
4344 | |
1805
5dd5b2052f5b
mpeg4 b frame + adaptive quantization assertion failure fix
michael
parents:
1804
diff
changeset
|
4345 if(s->out_format==FMT_H263){ |
1616 | 4346 s->dquant= clip(s->dquant, -2, 2); //FIXME RD |
2967 | 4347 |
4348 if(s->codec_id==CODEC_ID_MPEG4){ | |
1805
5dd5b2052f5b
mpeg4 b frame + adaptive quantization assertion failure fix
michael
parents:
1804
diff
changeset
|
4349 if(!s->mb_intra){ |
5dd5b2052f5b
mpeg4 b frame + adaptive quantization assertion failure fix
michael
parents:
1804
diff
changeset
|
4350 if(s->pict_type == B_TYPE){ |
2967 | 4351 if(s->dquant&1) |
1805
5dd5b2052f5b
mpeg4 b frame + adaptive quantization assertion failure fix
michael
parents:
1804
diff
changeset
|
4352 s->dquant= (s->dquant/2)*2; |
5dd5b2052f5b
mpeg4 b frame + adaptive quantization assertion failure fix
michael
parents:
1804
diff
changeset
|
4353 if(s->mv_dir&MV_DIRECT) |
5dd5b2052f5b
mpeg4 b frame + adaptive quantization assertion failure fix
michael
parents:
1804
diff
changeset
|
4354 s->dquant= 0; |
5dd5b2052f5b
mpeg4 b frame + adaptive quantization assertion failure fix
michael
parents:
1804
diff
changeset
|
4355 } |
5dd5b2052f5b
mpeg4 b frame + adaptive quantization assertion failure fix
michael
parents:
1804
diff
changeset
|
4356 if(s->mv_type==MV_TYPE_8X8) |
5dd5b2052f5b
mpeg4 b frame + adaptive quantization assertion failure fix
michael
parents:
1804
diff
changeset
|
4357 s->dquant=0; |
5dd5b2052f5b
mpeg4 b frame + adaptive quantization assertion failure fix
michael
parents:
1804
diff
changeset
|
4358 } |
1616 | 4359 } |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
673
diff
changeset
|
4360 } |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
673
diff
changeset
|
4361 } |
1652 | 4362 ff_set_qscale(s, last_qp + s->dquant); |
2054 | 4363 }else if(s->flags&CODEC_FLAG_QP_RD) |
4364 ff_set_qscale(s, s->qscale + s->dquant); | |
294 | 4365 |
1778 | 4366 wrap_y = s->linesize; |
4367 wrap_c = s->uvlinesize; | |
4368 ptr_y = s->new_picture.data[0] + (mb_y * 16 * wrap_y) + mb_x * 16; | |
3309 | 4369 ptr_cb = s->new_picture.data[1] + (mb_y * mb_block_height * wrap_c) + mb_x * 8; |
4370 ptr_cr = s->new_picture.data[2] + (mb_y * mb_block_height * wrap_c) + mb_x * 8; | |
1778 | 4371 |
4372 if(mb_x*16+16 > s->width || mb_y*16+16 > s->height){ | |
2165
5ca07515a309
10l (dont store 2 different things at the same place ...)
michael
parents:
2132
diff
changeset
|
4373 uint8_t *ebuf= s->edge_emu_buffer + 32; |
5ca07515a309
10l (dont store 2 different things at the same place ...)
michael
parents:
2132
diff
changeset
|
4374 ff_emulated_edge_mc(ebuf , ptr_y , wrap_y,16,16,mb_x*16,mb_y*16, s->width , s->height); |
5ca07515a309
10l (dont store 2 different things at the same place ...)
michael
parents:
2132
diff
changeset
|
4375 ptr_y= ebuf; |
3309 | 4376 ff_emulated_edge_mc(ebuf+18*wrap_y , ptr_cb, wrap_c, 8, mb_block_height, mb_x*8, mb_y*8, s->width>>1, s->height>>1); |
2165
5ca07515a309
10l (dont store 2 different things at the same place ...)
michael
parents:
2132
diff
changeset
|
4377 ptr_cb= ebuf+18*wrap_y; |
3309 | 4378 ff_emulated_edge_mc(ebuf+18*wrap_y+8, ptr_cr, wrap_c, 8, mb_block_height, mb_x*8, mb_y*8, s->width>>1, s->height>>1); |
2165
5ca07515a309
10l (dont store 2 different things at the same place ...)
michael
parents:
2132
diff
changeset
|
4379 ptr_cr= ebuf+18*wrap_y+8; |
1778 | 4380 } |
4381 | |
324 | 4382 if (s->mb_intra) { |
697 | 4383 if(s->flags&CODEC_FLAG_INTERLACED_DCT){ |
4384 int progressive_score, interlaced_score; | |
1708 | 4385 |
1729 | 4386 s->interlaced_dct=0; |
2967 | 4387 progressive_score= s->dsp.ildct_cmp[4](s, ptr_y , NULL, wrap_y, 8) |
1777 | 4388 +s->dsp.ildct_cmp[4](s, ptr_y + wrap_y*8, NULL, wrap_y, 8) - 400; |
1729 | 4389 |
4390 if(progressive_score > 0){ | |
2967 | 4391 interlaced_score = s->dsp.ildct_cmp[4](s, ptr_y , NULL, wrap_y*2, 8) |
1777 | 4392 +s->dsp.ildct_cmp[4](s, ptr_y + wrap_y , NULL, wrap_y*2, 8); |
1729 | 4393 if(progressive_score > interlaced_score){ |
4394 s->interlaced_dct=1; | |
2967 | 4395 |
1729 | 4396 dct_offset= wrap_y; |
4397 wrap_y<<=1; | |
3309 | 4398 if (s->chroma_format == CHROMA_422) |
4399 wrap_c<<=1; | |
1729 | 4400 } |
4401 } | |
697 | 4402 } |
2967 | 4403 |
2979 | 4404 s->dsp.get_pixels(s->block[0], ptr_y , wrap_y); |
1777 | 4405 s->dsp.get_pixels(s->block[1], ptr_y + 8, wrap_y); |
4406 s->dsp.get_pixels(s->block[2], ptr_y + dct_offset , wrap_y); | |
4407 s->dsp.get_pixels(s->block[3], ptr_y + dct_offset + 8, wrap_y); | |
294 | 4408 |
487 | 4409 if(s->flags&CODEC_FLAG_GRAY){ |
4410 skip_dct[4]= 1; | |
4411 skip_dct[5]= 1; | |
4412 }else{ | |
2979 | 4413 s->dsp.get_pixels(s->block[4], ptr_cb, wrap_c); |
1777 | 4414 s->dsp.get_pixels(s->block[5], ptr_cr, wrap_c); |
3309 | 4415 if(!s->chroma_y_shift){ /* 422 */ |
4416 s->dsp.get_pixels(s->block[6], ptr_cb + (dct_offset>>1), wrap_c); | |
4417 s->dsp.get_pixels(s->block[7], ptr_cr + (dct_offset>>1), wrap_c); | |
4418 } | |
1777 | 4419 } |
324 | 4420 }else{ |
651 | 4421 op_pixels_func (*op_pix)[4]; |
4422 qpel_mc_func (*op_qpix)[16]; | |
1064 | 4423 uint8_t *dest_y, *dest_cb, *dest_cr; |
294 | 4424 |
1389 | 4425 dest_y = s->dest[0]; |
4426 dest_cb = s->dest[1]; | |
4427 dest_cr = s->dest[2]; | |
324 | 4428 |
327 | 4429 if ((!s->no_rounding) || s->pict_type==B_TYPE){ |
2979 | 4430 op_pix = s->dsp.put_pixels_tab; |
853
eacc2dd8fd9d
* using DSPContext - so each codec could use its local (sub)set of CPU extension
kabi
parents:
847
diff
changeset
|
4431 op_qpix= s->dsp.put_qpel_pixels_tab; |
295 | 4432 }else{ |
853
eacc2dd8fd9d
* using DSPContext - so each codec could use its local (sub)set of CPU extension
kabi
parents:
847
diff
changeset
|
4433 op_pix = s->dsp.put_no_rnd_pixels_tab; |
eacc2dd8fd9d
* using DSPContext - so each codec could use its local (sub)set of CPU extension
kabi
parents:
847
diff
changeset
|
4434 op_qpix= s->dsp.put_no_rnd_qpel_pixels_tab; |
324 | 4435 } |
295 | 4436 |
324 | 4437 if (s->mv_dir & MV_DIR_FORWARD) { |
903 | 4438 MPV_motion(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.data, op_pix, op_qpix); |
853
eacc2dd8fd9d
* using DSPContext - so each codec could use its local (sub)set of CPU extension
kabi
parents:
847
diff
changeset
|
4439 op_pix = s->dsp.avg_pixels_tab; |
eacc2dd8fd9d
* using DSPContext - so each codec could use its local (sub)set of CPU extension
kabi
parents:
847
diff
changeset
|
4440 op_qpix= s->dsp.avg_qpel_pixels_tab; |
324 | 4441 } |
4442 if (s->mv_dir & MV_DIR_BACKWARD) { | |
903 | 4443 MPV_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.data, op_pix, op_qpix); |
324 | 4444 } |
295 | 4445 |
697 | 4446 if(s->flags&CODEC_FLAG_INTERLACED_DCT){ |
4447 int progressive_score, interlaced_score; | |
1729 | 4448 |
4449 s->interlaced_dct=0; | |
2967 | 4450 progressive_score= s->dsp.ildct_cmp[0](s, dest_y , ptr_y , wrap_y, 8) |
1729 | 4451 +s->dsp.ildct_cmp[0](s, dest_y + wrap_y*8, ptr_y + wrap_y*8, wrap_y, 8) - 400; |
2967 | 4452 |
1729 | 4453 if(s->avctx->ildct_cmp == FF_CMP_VSSE) progressive_score -= 400; |
4454 | |
4455 if(progressive_score>0){ | |
2967 | 4456 interlaced_score = s->dsp.ildct_cmp[0](s, dest_y , ptr_y , wrap_y*2, 8) |
1729 | 4457 +s->dsp.ildct_cmp[0](s, dest_y + wrap_y , ptr_y + wrap_y , wrap_y*2, 8); |
2967 | 4458 |
1729 | 4459 if(progressive_score > interlaced_score){ |
4460 s->interlaced_dct=1; | |
2967 | 4461 |
1729 | 4462 dct_offset= wrap_y; |
4463 wrap_y<<=1; | |
3309 | 4464 if (s->chroma_format == CHROMA_422) |
4465 wrap_c<<=1; | |
1729 | 4466 } |
4467 } | |
697 | 4468 } |
2967 | 4469 |
2979 | 4470 s->dsp.diff_pixels(s->block[0], ptr_y , dest_y , wrap_y); |
853
eacc2dd8fd9d
* using DSPContext - so each codec could use its local (sub)set of CPU extension
kabi
parents:
847
diff
changeset
|
4471 s->dsp.diff_pixels(s->block[1], ptr_y + 8, dest_y + 8, wrap_y); |
eacc2dd8fd9d
* using DSPContext - so each codec could use its local (sub)set of CPU extension
kabi
parents:
847
diff
changeset
|
4472 s->dsp.diff_pixels(s->block[2], ptr_y + dct_offset , dest_y + dct_offset , wrap_y); |
eacc2dd8fd9d
* using DSPContext - so each codec could use its local (sub)set of CPU extension
kabi
parents:
847
diff
changeset
|
4473 s->dsp.diff_pixels(s->block[3], ptr_y + dct_offset + 8, dest_y + dct_offset + 8, wrap_y); |
2967 | 4474 |
487 | 4475 if(s->flags&CODEC_FLAG_GRAY){ |
4476 skip_dct[4]= 1; | |
4477 skip_dct[5]= 1; | |
4478 }else{ | |
853
eacc2dd8fd9d
* using DSPContext - so each codec could use its local (sub)set of CPU extension
kabi
parents:
847
diff
changeset
|
4479 s->dsp.diff_pixels(s->block[4], ptr_cb, dest_cb, wrap_c); |
eacc2dd8fd9d
* using DSPContext - so each codec could use its local (sub)set of CPU extension
kabi
parents:
847
diff
changeset
|
4480 s->dsp.diff_pixels(s->block[5], ptr_cr, dest_cr, wrap_c); |
3309 | 4481 if(!s->chroma_y_shift){ /* 422 */ |
4482 s->dsp.diff_pixels(s->block[6], ptr_cb + (dct_offset>>1), dest_cb + (dct_offset>>1), wrap_c); | |
4483 s->dsp.diff_pixels(s->block[7], ptr_cr + (dct_offset>>1), dest_cr + (dct_offset>>1), wrap_c); | |
4484 } | |
487 | 4485 } |
2967 | 4486 /* pre quantization */ |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1173
diff
changeset
|
4487 if(s->current_picture.mc_mb_var[s->mb_stride*mb_y+ mb_x]<2*s->qscale*s->qscale){ |
697 | 4488 //FIXME optimize |
2979 | 4489 if(s->dsp.sad[1](NULL, ptr_y , dest_y , wrap_y, 8) < 20*s->qscale) skip_dct[0]= 1; |
1708 | 4490 if(s->dsp.sad[1](NULL, ptr_y + 8, dest_y + 8, wrap_y, 8) < 20*s->qscale) skip_dct[1]= 1; |
4491 if(s->dsp.sad[1](NULL, ptr_y +dct_offset , dest_y +dct_offset , wrap_y, 8) < 20*s->qscale) skip_dct[2]= 1; | |
4492 if(s->dsp.sad[1](NULL, ptr_y +dct_offset+ 8, dest_y +dct_offset+ 8, wrap_y, 8) < 20*s->qscale) skip_dct[3]= 1; | |
4493 if(s->dsp.sad[1](NULL, ptr_cb , dest_cb , wrap_c, 8) < 20*s->qscale) skip_dct[4]= 1; | |
4494 if(s->dsp.sad[1](NULL, ptr_cr , dest_cr , wrap_c, 8) < 20*s->qscale) skip_dct[5]= 1; | |
3309 | 4495 if(!s->chroma_y_shift){ /* 422 */ |
4496 if(s->dsp.sad[1](NULL, ptr_cb +(dct_offset>>1), dest_cb +(dct_offset>>1), wrap_c, 8) < 20*s->qscale) skip_dct[6]= 1; | |
4497 if(s->dsp.sad[1](NULL, ptr_cr +(dct_offset>>1), dest_cr +(dct_offset>>1), wrap_c, 8) < 20*s->qscale) skip_dct[7]= 1; | |
4498 } | |
456 | 4499 } |
1778 | 4500 } |
4501 | |
4502 if(s->avctx->quantizer_noise_shaping){ | |
4503 if(!skip_dct[0]) get_vissual_weight(weight[0], ptr_y , wrap_y); | |
4504 if(!skip_dct[1]) get_vissual_weight(weight[1], ptr_y + 8, wrap_y); | |
4505 if(!skip_dct[2]) get_vissual_weight(weight[2], ptr_y + dct_offset , wrap_y); | |
4506 if(!skip_dct[3]) get_vissual_weight(weight[3], ptr_y + dct_offset + 8, wrap_y); | |
4507 if(!skip_dct[4]) get_vissual_weight(weight[4], ptr_cb , wrap_c); | |
4508 if(!skip_dct[5]) get_vissual_weight(weight[5], ptr_cr , wrap_c); | |
3309 | 4509 if(!s->chroma_y_shift){ /* 422 */ |
4510 if(!skip_dct[6]) get_vissual_weight(weight[6], ptr_cb + (dct_offset>>1), wrap_c); | |
4511 if(!skip_dct[7]) get_vissual_weight(weight[7], ptr_cr + (dct_offset>>1), wrap_c); | |
4512 } | |
4513 memcpy(orig[0], s->block[0], sizeof(DCTELEM)*64*mb_block_count); | |
294 | 4514 } |
2967 | 4515 |
294 | 4516 /* DCT & quantize */ |
1778 | 4517 assert(s->out_format!=FMT_MJPEG || s->qscale==8); |
4518 { | |
3309 | 4519 for(i=0;i<mb_block_count;i++) { |
456 | 4520 if(!skip_dct[i]){ |
4521 int overflow; | |
625
bb6a69f9d409
slow but accurate integer dct from IJG (should be ok with the LGPL as the old DCT is the fast integer DCT from IJG)
michaelni
parents:
619
diff
changeset
|
4522 s->block_last_index[i] = s->dct_quantize(s, s->block[i], i, s->qscale, &overflow); |
344 | 4523 // FIXME we could decide to change to quantizer instead of clipping |
350
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
347
diff
changeset
|
4524 // JS: I don't think that would be a good idea it could lower quality instead |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
347
diff
changeset
|
4525 // of improve it. Just INTRADC clipping deserves changes in quantizer |
456 | 4526 if (overflow) clip_coeffs(s, s->block[i], s->block_last_index[i]); |
4527 }else | |
4528 s->block_last_index[i]= -1; | |
344 | 4529 } |
1777 | 4530 if(s->avctx->quantizer_noise_shaping){ |
3309 | 4531 for(i=0;i<mb_block_count;i++) { |
1777 | 4532 if(!skip_dct[i]){ |
4533 s->block_last_index[i] = dct_quantize_refine(s, s->block[i], weight[i], orig[i], i, s->qscale); | |
4534 } | |
4535 } | |
4536 } | |
2967 | 4537 |
456 | 4538 if(s->luma_elim_threshold && !s->mb_intra) |
4539 for(i=0; i<4; i++) | |
605
40874804a5af
same dc skip behavior for chroma & luma elimination, its confusing otherwise imho
michaelni
parents:
604
diff
changeset
|
4540 dct_single_coeff_elimination(s, i, s->luma_elim_threshold); |
456 | 4541 if(s->chroma_elim_threshold && !s->mb_intra) |
3309 | 4542 for(i=4; i<mb_block_count; i++) |
605
40874804a5af
same dc skip behavior for chroma & luma elimination, its confusing otherwise imho
michaelni
parents:
604
diff
changeset
|
4543 dct_single_coeff_elimination(s, i, s->chroma_elim_threshold); |
1497 | 4544 |
4545 if(s->flags & CODEC_FLAG_CBP_RD){ | |
3309 | 4546 for(i=0;i<mb_block_count;i++) { |
1497 | 4547 if(s->block_last_index[i] == -1) |
4548 s->coded_score[i]= INT_MAX/256; | |
4549 } | |
4550 } | |
294 | 4551 } |
4552 | |
487 | 4553 if((s->flags&CODEC_FLAG_GRAY) && s->mb_intra){ |
4554 s->block_last_index[4]= | |
4555 s->block_last_index[5]= 0; | |
4556 s->block[4][0]= | |
1011 | 4557 s->block[5][0]= (1024 + s->c_dc_scale/2)/ s->c_dc_scale; |
487 | 4558 } |
4559 | |
1708 | 4560 //non c quantize code returns incorrect block_last_index FIXME |
4561 if(s->alternate_scan && s->dct_quantize != dct_quantize_c){ | |
3309 | 4562 for(i=0; i<mb_block_count; i++){ |
1708 | 4563 int j; |
4564 if(s->block_last_index[i]>0){ | |
4565 for(j=63; j>0; j--){ | |
4566 if(s->block[i][ s->intra_scantable.permutated[j] ]) break; | |
4567 } | |
4568 s->block_last_index[i]= j; | |
4569 } | |
4570 } | |
4571 } | |
4572 | |
294 | 4573 /* huffman encode */ |
936 | 4574 switch(s->codec_id){ //FIXME funct ptr could be slightly faster |
4575 case CODEC_ID_MPEG1VIDEO: | |
1421 | 4576 case CODEC_ID_MPEG2VIDEO: |
936 | 4577 mpeg1_encode_mb(s, s->block, motion_x, motion_y); break; |
4578 case CODEC_ID_MPEG4: | |
4579 mpeg4_encode_mb(s, s->block, motion_x, motion_y); break; | |
4580 case CODEC_ID_MSMPEG4V2: | |
4581 case CODEC_ID_MSMPEG4V3: | |
4582 case CODEC_ID_WMV1: | |
4583 msmpeg4_encode_mb(s, s->block, motion_x, motion_y); break; | |
4584 case CODEC_ID_WMV2: | |
4585 ff_wmv2_encode_mb(s, s->block, motion_x, motion_y); break; | |
2639 | 4586 #ifdef CONFIG_H261_ENCODER |
2327
5e5cf598a48b
H.261 encoder by (Maarten Daniels <maarten dot daniels at luc dot ac dot be>)
michael
parents:
2298
diff
changeset
|
4587 case CODEC_ID_H261: |
5e5cf598a48b
H.261 encoder by (Maarten Daniels <maarten dot daniels at luc dot ac dot be>)
michael
parents:
2298
diff
changeset
|
4588 ff_h261_encode_mb(s, s->block, motion_x, motion_y); break; |
2639 | 4589 #endif |
936 | 4590 case CODEC_ID_H263: |
4591 case CODEC_ID_H263P: | |
1353
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1344
diff
changeset
|
4592 case CODEC_ID_FLV1: |
936 | 4593 case CODEC_ID_RV10: |
2380 | 4594 case CODEC_ID_RV20: |
936 | 4595 h263_encode_mb(s, s->block, motion_x, motion_y); break; |
1042 | 4596 case CODEC_ID_MJPEG: |
4597 mjpeg_encode_mb(s, s->block); break; | |
936 | 4598 default: |
4599 assert(0); | |
294 | 4600 } |
4601 } | |
4602 | |
4283
d6f83e2f8804
rename always_inline to av_always_inline and move to common.h
mru
parents:
4281
diff
changeset
|
4603 static av_always_inline void encode_mb(MpegEncContext *s, int motion_x, int motion_y) |
3309 | 4604 { |
4605 if (s->chroma_format == CHROMA_420) encode_mb_internal(s, motion_x, motion_y, 8, 6); | |
4606 else encode_mb_internal(s, motion_x, motion_y, 16, 8); | |
4607 } | |
4608 | |
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
|
4609 #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
|
4610 |
1368 | 4611 void ff_mpeg_flush(AVCodecContext *avctx){ |
4612 int i; | |
4613 MpegEncContext *s = avctx->priv_data; | |
2967 | 4614 |
4615 if(s==NULL || s->picture==NULL) | |
1751 | 4616 return; |
2967 | 4617 |
1368 | 4618 for(i=0; i<MAX_PICTURE_COUNT; i++){ |
4619 if(s->picture[i].data[0] && ( s->picture[i].type == FF_BUFFER_TYPE_INTERNAL | |
4620 || s->picture[i].type == FF_BUFFER_TYPE_USER)) | |
4621 avctx->release_buffer(avctx, (AVFrame*)&s->picture[i]); | |
4622 } | |
1601 | 4623 s->current_picture_ptr = s->last_picture_ptr = s->next_picture_ptr = NULL; |
2967 | 4624 |
2380 | 4625 s->mb_x= s->mb_y= 0; |
2967 | 4626 |
1395 | 4627 s->parse_context.state= -1; |
4628 s->parse_context.frame_start_found= 0; | |
4629 s->parse_context.overread= 0; | |
4630 s->parse_context.overread_index= 0; | |
4631 s->parse_context.index= 0; | |
4632 s->parse_context.last_index= 0; | |
1851 | 4633 s->bitstream_buffer_size=0; |
1368 | 4634 } |
4635 | |
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
|
4636 #ifdef CONFIG_ENCODERS |
1064 | 4637 void ff_copy_bits(PutBitContext *pb, uint8_t *src, int length) |
294 | 4638 { |
1810 | 4639 const uint16_t *srcw= (uint16_t*)src; |
1799 | 4640 int words= length>>4; |
326 | 4641 int bits= length&15; |
4642 int i; | |
4643 | |
456 | 4644 if(length==0) return; |
2967 | 4645 |
1803 | 4646 if(words < 16){ |
4647 for(i=0; i<words; i++) put_bits(pb, 16, be2me_16(srcw[i])); | |
4648 }else if(put_bits_count(pb)&7){ | |
4649 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
|
4650 }else{ |
1803 | 4651 for(i=0; put_bits_count(pb)&31; i++) |
4652 put_bits(pb, 8, src[i]); | |
1799 | 4653 flush_put_bits(pb); |
1803 | 4654 memcpy(pbBufPtr(pb), src+i, 2*words-i); |
4655 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
|
4656 } |
2967 | 4657 |
1803 | 4658 put_bits(pb, bits, be2me_16(srcw[words])>>(16-bits)); |
0 | 4659 } |
4660 | |
456 | 4661 static inline void copy_context_before_encode(MpegEncContext *d, MpegEncContext *s, int type){ |
326 | 4662 int i; |
4663 | |
4664 memcpy(d->last_mv, s->last_mv, 2*2*2*sizeof(int)); //FIXME is memcpy faster then a loop? | |
4665 | |
4666 /* mpeg1 */ | |
1160 | 4667 d->mb_skip_run= s->mb_skip_run; |
326 | 4668 for(i=0; i<3; i++) |
4669 d->last_dc[i]= s->last_dc[i]; | |
2967 | 4670 |
326 | 4671 /* statistics */ |
4672 d->mv_bits= s->mv_bits; | |
4673 d->i_tex_bits= s->i_tex_bits; | |
4674 d->p_tex_bits= s->p_tex_bits; | |
4675 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
|
4676 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
|
4677 d->b_count= s->b_count; |
326 | 4678 d->skip_count= s->skip_count; |
4679 d->misc_bits= s->misc_bits; | |
329 | 4680 d->last_bits= 0; |
327 | 4681 |
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
|
4682 d->mb_skipped= 0; |
912 | 4683 d->qscale= s->qscale; |
1616 | 4684 d->dquant= s->dquant; |
326 | 4685 } |
4686 | |
456 | 4687 static inline void copy_context_after_encode(MpegEncContext *d, MpegEncContext *s, int type){ |
326 | 4688 int i; |
4689 | |
2967 | 4690 memcpy(d->mv, s->mv, 2*4*2*sizeof(int)); |
326 | 4691 memcpy(d->last_mv, s->last_mv, 2*2*2*sizeof(int)); //FIXME is memcpy faster then a loop? |
2967 | 4692 |
326 | 4693 /* mpeg1 */ |
1160 | 4694 d->mb_skip_run= s->mb_skip_run; |
326 | 4695 for(i=0; i<3; i++) |
4696 d->last_dc[i]= s->last_dc[i]; | |
2967 | 4697 |
326 | 4698 /* statistics */ |
4699 d->mv_bits= s->mv_bits; | |
4700 d->i_tex_bits= s->i_tex_bits; | |
4701 d->p_tex_bits= s->p_tex_bits; | |
4702 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
|
4703 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
|
4704 d->b_count= s->b_count; |
326 | 4705 d->skip_count= s->skip_count; |
4706 d->misc_bits= s->misc_bits; | |
4707 | |
4708 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
|
4709 d->mb_skipped= s->mb_skipped; |
326 | 4710 d->mv_type= s->mv_type; |
4711 d->mv_dir= s->mv_dir; | |
4712 d->pb= s->pb; | |
456 | 4713 if(s->data_partitioning){ |
4714 d->pb2= s->pb2; | |
4715 d->tex_pb= s->tex_pb; | |
4716 } | |
326 | 4717 d->block= s->block; |
3309 | 4718 for(i=0; i<8; i++) |
326 | 4719 d->block_last_index[i]= s->block_last_index[i]; |
755 | 4720 d->interlaced_dct= s->interlaced_dct; |
912 | 4721 d->qscale= s->qscale; |
326 | 4722 } |
4723 | |
2967 | 4724 static inline void encode_mb_hq(MpegEncContext *s, MpegEncContext *backup, MpegEncContext *best, int type, |
456 | 4725 PutBitContext pb[2], PutBitContext pb2[2], PutBitContext tex_pb[2], |
4726 int *dmin, int *next_block, int motion_x, int motion_y) | |
4727 { | |
1389 | 4728 int score; |
4729 uint8_t *dest_backup[3]; | |
2967 | 4730 |
456 | 4731 copy_context_before_encode(s, backup, type); |
4732 | |
4733 s->block= s->blocks[*next_block]; | |
4734 s->pb= pb[*next_block]; | |
4735 if(s->data_partitioning){ | |
4736 s->pb2 = pb2 [*next_block]; | |
4737 s->tex_pb= tex_pb[*next_block]; | |
4738 } | |
2967 | 4739 |
1389 | 4740 if(*next_block){ |
4741 memcpy(dest_backup, s->dest, sizeof(s->dest)); | |
1799 | 4742 s->dest[0] = s->rd_scratchpad; |
4743 s->dest[1] = s->rd_scratchpad + 16*s->linesize; | |
4744 s->dest[2] = s->rd_scratchpad + 16*s->linesize + 8; | |
4745 assert(s->linesize >= 32); //FIXME | |
1389 | 4746 } |
456 | 4747 |
4748 encode_mb(s, motion_x, motion_y); | |
2967 | 4749 |
1786 | 4750 score= put_bits_count(&s->pb); |
456 | 4751 if(s->data_partitioning){ |
1786 | 4752 score+= put_bits_count(&s->pb2); |
4753 score+= put_bits_count(&s->tex_pb); | |
456 | 4754 } |
2967 | 4755 |
1389 | 4756 if(s->avctx->mb_decision == FF_MB_DECISION_RD){ |
4757 MPV_decode_mb(s, s->block); | |
4758 | |
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
|
4759 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
|
4760 score += sse_mb(s) << FF_LAMBDA_SHIFT; |
1389 | 4761 } |
2967 | 4762 |
1389 | 4763 if(*next_block){ |
4764 memcpy(s->dest, dest_backup, sizeof(s->dest)); | |
4765 } | |
4766 | |
4767 if(score<*dmin){ | |
4768 *dmin= score; | |
456 | 4769 *next_block^=1; |
4770 | |
4771 copy_context_after_encode(best, s, type); | |
4772 } | |
4773 } | |
2967 | 4774 |
1389 | 4775 static int sse(MpegEncContext *s, uint8_t *src1, uint8_t *src2, int w, int h, int stride){ |
4179 | 4776 uint32_t *sq = ff_squareTbl + 256; |
909
8ae1e4c24e91
new PSNR code (now works with chroma, b frames, ...)
michaelni
parents:
903
diff
changeset
|
4777 int acc=0; |
8ae1e4c24e91
new PSNR code (now works with chroma, b frames, ...)
michaelni
parents:
903
diff
changeset
|
4778 int x,y; |
2967 | 4779 |
4780 if(w==16 && h==16) | |
1708 | 4781 return s->dsp.sse[0](NULL, src1, src2, stride, 16); |
936 | 4782 else if(w==8 && h==8) |
1708 | 4783 return s->dsp.sse[1](NULL, src1, src2, stride, 8); |
2967 | 4784 |
909
8ae1e4c24e91
new PSNR code (now works with chroma, b frames, ...)
michaelni
parents:
903
diff
changeset
|
4785 for(y=0; y<h; y++){ |
8ae1e4c24e91
new PSNR code (now works with chroma, b frames, ...)
michaelni
parents:
903
diff
changeset
|
4786 for(x=0; x<w; x++){ |
8ae1e4c24e91
new PSNR code (now works with chroma, b frames, ...)
michaelni
parents:
903
diff
changeset
|
4787 acc+= sq[src1[x + y*stride] - src2[x + y*stride]]; |
2967 | 4788 } |
4789 } | |
4790 | |
936 | 4791 assert(acc>=0); |
2967 | 4792 |
909
8ae1e4c24e91
new PSNR code (now works with chroma, b frames, ...)
michaelni
parents:
903
diff
changeset
|
4793 return acc; |
8ae1e4c24e91
new PSNR code (now works with chroma, b frames, ...)
michaelni
parents:
903
diff
changeset
|
4794 } |
326 | 4795 |
1389 | 4796 static int sse_mb(MpegEncContext *s){ |
4797 int w= 16; | |
4798 int h= 16; | |
4799 | |
4800 if(s->mb_x*16 + 16 > s->width ) w= s->width - s->mb_x*16; | |
4801 if(s->mb_y*16 + 16 > s->height) h= s->height- s->mb_y*16; | |
4802 | |
4803 if(w==16 && h==16) | |
2065
9e4bebc39ade
noise preserving sum of squares comparission function
michael
parents:
2063
diff
changeset
|
4804 if(s->avctx->mb_cmp == FF_CMP_NSSE){ |
2066 | 4805 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) |
4806 +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) | |
4807 +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
|
4808 }else{ |
1708 | 4809 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) |
4810 +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) | |
4811 +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
|
4812 } |
1389 | 4813 else |
4814 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) | |
4815 +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) | |
4816 +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); | |
4817 } | |
4818 | |
1799 | 4819 static int pre_estimate_motion_thread(AVCodecContext *c, void *arg){ |
4820 MpegEncContext *s= arg; | |
4821 | |
2967 | 4822 |
1799 | 4823 s->me.pre_pass=1; |
4824 s->me.dia_size= s->avctx->pre_dia_size; | |
4825 s->first_slice_line=1; | |
4826 for(s->mb_y= s->end_mb_y-1; s->mb_y >= s->start_mb_y; s->mb_y--) { | |
4827 for(s->mb_x=s->mb_width-1; s->mb_x >=0 ;s->mb_x--) { | |
4828 ff_pre_estimate_p_frame_motion(s, s->mb_x, s->mb_y); | |
4829 } | |
4830 s->first_slice_line=0; | |
4831 } | |
2967 | 4832 |
1799 | 4833 s->me.pre_pass=0; |
2967 | 4834 |
1799 | 4835 return 0; |
4836 } | |
4837 | |
4838 static int estimate_motion_thread(AVCodecContext *c, void *arg){ | |
4839 MpegEncContext *s= arg; | |
4840 | |
4281
de525a2b41db
ff_check_alignment to warn the user about a missaligned stack
michael
parents:
4274
diff
changeset
|
4841 ff_check_alignment(); |
de525a2b41db
ff_check_alignment to warn the user about a missaligned stack
michael
parents:
4274
diff
changeset
|
4842 |
1799 | 4843 s->me.dia_size= s->avctx->dia_size; |
4844 s->first_slice_line=1; | |
4845 for(s->mb_y= s->start_mb_y; s->mb_y < s->end_mb_y; s->mb_y++) { | |
4846 s->mb_x=0; //for block init below | |
4847 ff_init_block_index(s); | |
4848 for(s->mb_x=0; s->mb_x < s->mb_width; s->mb_x++) { | |
4849 s->block_index[0]+=2; | |
4850 s->block_index[1]+=2; | |
4851 s->block_index[2]+=2; | |
4852 s->block_index[3]+=2; | |
2967 | 4853 |
1799 | 4854 /* compute motion vector & mb_type and store in context */ |
4855 if(s->pict_type==B_TYPE) | |
4856 ff_estimate_b_frame_motion(s, s->mb_x, s->mb_y); | |
4857 else | |
4858 ff_estimate_p_frame_motion(s, s->mb_x, s->mb_y); | |
4859 } | |
4860 s->first_slice_line=0; | |
4861 } | |
4862 return 0; | |
4863 } | |
4864 | |
1804
cc0a15943a87
multithreaded spatial complexity calculation for i frames
michael
parents:
1803
diff
changeset
|
4865 static int mb_var_thread(AVCodecContext *c, void *arg){ |
cc0a15943a87
multithreaded spatial complexity calculation for i frames
michael
parents:
1803
diff
changeset
|
4866 MpegEncContext *s= arg; |
cc0a15943a87
multithreaded spatial complexity calculation for i frames
michael
parents:
1803
diff
changeset
|
4867 int mb_x, mb_y; |
cc0a15943a87
multithreaded spatial complexity calculation for i frames
michael
parents:
1803
diff
changeset
|
4868 |
4281
de525a2b41db
ff_check_alignment to warn the user about a missaligned stack
michael
parents:
4274
diff
changeset
|
4869 ff_check_alignment(); |
de525a2b41db
ff_check_alignment to warn the user about a missaligned stack
michael
parents:
4274
diff
changeset
|
4870 |
1804
cc0a15943a87
multithreaded spatial complexity calculation for i frames
michael
parents:
1803
diff
changeset
|
4871 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
|
4872 for(mb_x=0; mb_x < s->mb_width; mb_x++) { |
cc0a15943a87
multithreaded spatial complexity calculation for i frames
michael
parents:
1803
diff
changeset
|
4873 int xx = mb_x * 16; |
cc0a15943a87
multithreaded spatial complexity calculation for i frames
michael
parents:
1803
diff
changeset
|
4874 int yy = mb_y * 16; |
cc0a15943a87
multithreaded spatial complexity calculation for i frames
michael
parents:
1803
diff
changeset
|
4875 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
|
4876 int varc; |
cc0a15943a87
multithreaded spatial complexity calculation for i frames
michael
parents:
1803
diff
changeset
|
4877 int sum = s->dsp.pix_sum(pix, s->linesize); |
2967 | 4878 |
1804
cc0a15943a87
multithreaded spatial complexity calculation for i frames
michael
parents:
1803
diff
changeset
|
4879 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
|
4880 |
cc0a15943a87
multithreaded spatial complexity calculation for i frames
michael
parents:
1803
diff
changeset
|
4881 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
|
4882 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
|
4883 s->me.mb_var_sum_temp += varc; |
1804
cc0a15943a87
multithreaded spatial complexity calculation for i frames
michael
parents:
1803
diff
changeset
|
4884 } |
cc0a15943a87
multithreaded spatial complexity calculation for i frames
michael
parents:
1803
diff
changeset
|
4885 } |
1805
5dd5b2052f5b
mpeg4 b frame + adaptive quantization assertion failure fix
michael
parents:
1804
diff
changeset
|
4886 return 0; |
1804
cc0a15943a87
multithreaded spatial complexity calculation for i frames
michael
parents:
1803
diff
changeset
|
4887 } |
cc0a15943a87
multithreaded spatial complexity calculation for i frames
michael
parents:
1803
diff
changeset
|
4888 |
1799 | 4889 static void write_slice_end(MpegEncContext *s){ |
4890 if(s->codec_id==CODEC_ID_MPEG4){ | |
4891 if(s->partitioned_frame){ | |
4892 ff_mpeg4_merge_partitions(s); | |
4893 } | |
2967 | 4894 |
1799 | 4895 ff_mpeg4_stuffing(&s->pb); |
4896 }else if(s->out_format == FMT_MJPEG){ | |
4897 ff_mjpeg_stuffing(&s->pb); | |
4898 } | |
4899 | |
4900 align_put_bits(&s->pb); | |
4901 flush_put_bits(&s->pb); | |
2967 | 4902 |
2428
548c87c06dbb
assertion about bits statistic and minor bits stat fix
michael
parents:
2427
diff
changeset
|
4903 if((s->flags&CODEC_FLAG_PASS1) && !s->partitioned_frame) |
548c87c06dbb
assertion about bits statistic and minor bits stat fix
michael
parents:
2427
diff
changeset
|
4904 s->misc_bits+= get_bits_diff(s); |
1799 | 4905 } |
4906 | |
4907 static int encode_thread(AVCodecContext *c, void *arg){ | |
4908 MpegEncContext *s= arg; | |
766 | 4909 int mb_x, mb_y, pdif = 0; |
1708 | 4910 int i, j; |
326 | 4911 MpegEncContext best_s, backup_s; |
2422 | 4912 uint8_t bit_buf[2][MAX_MB_BYTES]; |
4913 uint8_t bit_buf2[2][MAX_MB_BYTES]; | |
4914 uint8_t bit_buf_tex[2][MAX_MB_BYTES]; | |
456 | 4915 PutBitContext pb[2], pb2[2], tex_pb[2]; |
1799 | 4916 //printf("%d->%d\n", s->resync_mb_y, s->end_mb_y); |
456 | 4917 |
4281
de525a2b41db
ff_check_alignment to warn the user about a missaligned stack
michael
parents:
4274
diff
changeset
|
4918 ff_check_alignment(); |
de525a2b41db
ff_check_alignment to warn the user about a missaligned stack
michael
parents:
4274
diff
changeset
|
4919 |
456 | 4920 for(i=0; i<2; i++){ |
2422 | 4921 init_put_bits(&pb [i], bit_buf [i], MAX_MB_BYTES); |
4922 init_put_bits(&pb2 [i], bit_buf2 [i], MAX_MB_BYTES); | |
4923 init_put_bits(&tex_pb[i], bit_buf_tex[i], MAX_MB_BYTES); | |
456 | 4924 } |
0 | 4925 |
1786 | 4926 s->last_bits= put_bits_count(&s->pb); |
286 | 4927 s->mv_bits=0; |
4928 s->misc_bits=0; | |
4929 s->i_tex_bits=0; | |
4930 s->p_tex_bits=0; | |
4931 s->i_count=0; | |
656
e47fa3e3f2d5
statistics for forw & back p-MBs instead of just one counter for both
michaelni
parents:
652
diff
changeset
|
4932 s->f_count=0; |
e47fa3e3f2d5
statistics for forw & back p-MBs instead of just one counter for both
michaelni
parents:
652
diff
changeset
|
4933 s->b_count=0; |
286 | 4934 s->skip_count=0; |
4935 | |
909
8ae1e4c24e91
new PSNR code (now works with chroma, b frames, ...)
michaelni
parents:
903
diff
changeset
|
4936 for(i=0; i<3; i++){ |
8ae1e4c24e91
new PSNR code (now works with chroma, b frames, ...)
michaelni
parents:
903
diff
changeset
|
4937 /* init last dc values */ |
8ae1e4c24e91
new PSNR code (now works with chroma, b frames, ...)
michaelni
parents:
903
diff
changeset
|
4938 /* note: quant matrix value (8) is implied here */ |
1992 | 4939 s->last_dc[i] = 128 << s->intra_dc_precision; |
2967 | 4940 |
2955 | 4941 s->current_picture.error[i] = 0; |
909
8ae1e4c24e91
new PSNR code (now works with chroma, b frames, ...)
michaelni
parents:
903
diff
changeset
|
4942 } |
1160 | 4943 s->mb_skip_run = 0; |
1708 | 4944 memset(s->last_mv, 0, sizeof(s->last_mv)); |
2967 | 4945 |
1051
e5a9dbf597d4
mpeg1 bframe encoding patch by (Rapha«³l LEGRAND) with some modifications by me
michaelni
parents:
1048
diff
changeset
|
4946 s->last_mv_dir = 0; |
0 | 4947 |
1353
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1344
diff
changeset
|
4948 switch(s->codec_id){ |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1344
diff
changeset
|
4949 case CODEC_ID_H263: |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1344
diff
changeset
|
4950 case CODEC_ID_H263P: |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1344
diff
changeset
|
4951 case CODEC_ID_FLV1: |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
731
diff
changeset
|
4952 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
|
4953 break; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1344
diff
changeset
|
4954 case CODEC_ID_MPEG4: |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1344
diff
changeset
|
4955 if(s->partitioned_frame) |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1344
diff
changeset
|
4956 ff_mpeg4_init_partitions(s); |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1344
diff
changeset
|
4957 break; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1344
diff
changeset
|
4958 } |
456 | 4959 |
4960 s->resync_mb_x=0; | |
2967 | 4961 s->resync_mb_y=0; |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
731
diff
changeset
|
4962 s->first_slice_line = 1; |
766 | 4963 s->ptr_lastgob = s->pb.buf; |
1799 | 4964 for(mb_y= s->start_mb_y; mb_y < s->end_mb_y; mb_y++) { |
4965 // printf("row %d at %X\n", s->mb_y, (int)s); | |
1389 | 4966 s->mb_x=0; |
4967 s->mb_y= mb_y; | |
4968 | |
1652 | 4969 ff_set_qscale(s, s->qscale); |
1389 | 4970 ff_init_block_index(s); |
2967 | 4971 |
232
b640ec5948b0
- Now the ME is done for the entire picture when enconding, the
pulento
parents:
231
diff
changeset
|
4972 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
|
4973 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
|
4974 int mb_type= s->mb_type[xy]; |
456 | 4975 // int d; |
1389 | 4976 int dmin= INT_MAX; |
1708 | 4977 int dir; |
0 | 4978 |
2422 | 4979 if(s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb)>>3) < MAX_MB_BYTES){ |
4980 av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n"); | |
4981 return -1; | |
4982 } | |
4983 if(s->data_partitioning){ | |
4984 if( s->pb2 .buf_end - s->pb2 .buf - (put_bits_count(&s-> pb2)>>3) < MAX_MB_BYTES | |
4985 || s->tex_pb.buf_end - s->tex_pb.buf - (put_bits_count(&s->tex_pb )>>3) < MAX_MB_BYTES){ | |
4986 av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n"); | |
4987 return -1; | |
4988 } | |
4989 } | |
4990 | |
232
b640ec5948b0
- Now the ME is done for the entire picture when enconding, the
pulento
parents:
231
diff
changeset
|
4991 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
|
4992 s->mb_y = mb_y; // moved into loop, can get changed by H.261 |
1389 | 4993 ff_update_block_index(s); |
456 | 4994 |
2639 | 4995 #ifdef CONFIG_H261_ENCODER |
2327
5e5cf598a48b
H.261 encoder by (Maarten Daniels <maarten dot daniels at luc dot ac dot be>)
michael
parents:
2298
diff
changeset
|
4996 if(s->codec_id == CODEC_ID_H261){ |
5e5cf598a48b
H.261 encoder by (Maarten Daniels <maarten dot daniels at luc dot ac dot be>)
michael
parents:
2298
diff
changeset
|
4997 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
|
4998 xy= s->mb_y*s->mb_stride + s->mb_x; |
2345 | 4999 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
|
5000 } |
2639 | 5001 #endif |
2327
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 } |
4314
5ed8f8fd71e9
try direct mode MB after QPRD, slight PSNR/bitrate gain if b frames + QPRD
michael
parents:
4283
diff
changeset
|
5294 s->current_picture.qscale_table[xy]= best_s.qscale; |
1616 | 5295 |
326 | 5296 copy_context_after_encode(s, &best_s, -1); |
2967 | 5297 |
1786 | 5298 pb_bits_count= put_bits_count(&s->pb); |
456 | 5299 flush_put_bits(&s->pb); |
5300 ff_copy_bits(&backup_s.pb, bit_buf[next_block^1], pb_bits_count); | |
5301 s->pb= backup_s.pb; | |
2967 | 5302 |
456 | 5303 if(s->data_partitioning){ |
1786 | 5304 pb2_bits_count= put_bits_count(&s->pb2); |
456 | 5305 flush_put_bits(&s->pb2); |
5306 ff_copy_bits(&backup_s.pb2, bit_buf2[next_block^1], pb2_bits_count); | |
5307 s->pb2= backup_s.pb2; | |
2967 | 5308 |
1786 | 5309 tex_pb_bits_count= put_bits_count(&s->tex_pb); |
456 | 5310 flush_put_bits(&s->tex_pb); |
5311 ff_copy_bits(&backup_s.tex_pb, bit_buf_tex[next_block^1], tex_pb_bits_count); | |
5312 s->tex_pb= backup_s.tex_pb; | |
5313 } | |
1786 | 5314 s->last_bits= put_bits_count(&s->pb); |
2967 | 5315 |
1389 | 5316 if (s->out_format == FMT_H263 && s->pict_type!=B_TYPE) |
5317 ff_h263_update_motion_val(s); | |
2967 | 5318 |
1799 | 5319 if(next_block==0){ //FIXME 16 vs linesize16 |
5320 s->dsp.put_pixels_tab[0][0](s->dest[0], s->rd_scratchpad , s->linesize ,16); | |
5321 s->dsp.put_pixels_tab[1][0](s->dest[1], s->rd_scratchpad + 16*s->linesize , s->uvlinesize, 8); | |
5322 s->dsp.put_pixels_tab[1][0](s->dest[2], s->rd_scratchpad + 16*s->linesize + 8, s->uvlinesize, 8); | |
1389 | 5323 } |
5324 | |
5325 if(s->avctx->mb_decision == FF_MB_DECISION_BITS) | |
5326 MPV_decode_mb(s, s->block); | |
294 | 5327 } else { |
324 | 5328 int motion_x, motion_y; |
5329 s->mv_type=MV_TYPE_16X16; | |
294 | 5330 // only one MB-Type possible |
2967 | 5331 |
327 | 5332 switch(mb_type){ |
1708 | 5333 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
|
5334 s->mv_dir = 0; |
294 | 5335 s->mb_intra= 1; |
324 | 5336 motion_x= s->mv[0][0][0] = 0; |
5337 motion_y= s->mv[0][0][1] = 0; | |
327 | 5338 break; |
1708 | 5339 case CANDIDATE_MB_TYPE_INTER: |
324 | 5340 s->mv_dir = MV_DIR_FORWARD; |
5341 s->mb_intra= 0; | |
5342 motion_x= s->mv[0][0][0] = s->p_mv_table[xy][0]; | |
5343 motion_y= s->mv[0][0][1] = s->p_mv_table[xy][1]; | |
327 | 5344 break; |
1708 | 5345 case CANDIDATE_MB_TYPE_INTER_I: |
5346 s->mv_dir = MV_DIR_FORWARD; | |
5347 s->mv_type = MV_TYPE_FIELD; | |
5348 s->mb_intra= 0; | |
5349 for(i=0; i<2; i++){ | |
5350 j= s->field_select[0][i] = s->p_field_select_table[i][xy]; | |
5351 s->mv[0][i][0] = s->p_field_mv_table[i][j][xy][0]; | |
5352 s->mv[0][i][1] = s->p_field_mv_table[i][j][xy][1]; | |
5353 } | |
5354 motion_x = motion_y = 0; | |
5355 break; | |
5356 case CANDIDATE_MB_TYPE_INTER4V: | |
456 | 5357 s->mv_dir = MV_DIR_FORWARD; |
5358 s->mv_type = MV_TYPE_8X8; | |
5359 s->mb_intra= 0; | |
5360 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
|
5361 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
|
5362 s->mv[0][i][1] = s->current_picture.motion_val[0][s->block_index[i]][1]; |
456 | 5363 } |
5364 motion_x= motion_y= 0; | |
5365 break; | |
1708 | 5366 case CANDIDATE_MB_TYPE_DIRECT: |
324 | 5367 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT; |
5368 s->mb_intra= 0; | |
327 | 5369 motion_x=s->b_direct_mv_table[xy][0]; |
5370 motion_y=s->b_direct_mv_table[xy][1]; | |
936 | 5371 ff_mpeg4_set_direct_mv(s, motion_x, motion_y); |
327 | 5372 break; |
1708 | 5373 case CANDIDATE_MB_TYPE_BIDIR: |
324 | 5374 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD; |
294 | 5375 s->mb_intra= 0; |
324 | 5376 motion_x=0; |
5377 motion_y=0; | |
5378 s->mv[0][0][0] = s->b_bidir_forw_mv_table[xy][0]; | |
5379 s->mv[0][0][1] = s->b_bidir_forw_mv_table[xy][1]; | |
5380 s->mv[1][0][0] = s->b_bidir_back_mv_table[xy][0]; | |
5381 s->mv[1][0][1] = s->b_bidir_back_mv_table[xy][1]; | |
327 | 5382 break; |
1708 | 5383 case CANDIDATE_MB_TYPE_BACKWARD: |
324 | 5384 s->mv_dir = MV_DIR_BACKWARD; |
5385 s->mb_intra= 0; | |
5386 motion_x= s->mv[1][0][0] = s->b_back_mv_table[xy][0]; | |
5387 motion_y= s->mv[1][0][1] = s->b_back_mv_table[xy][1]; | |
327 | 5388 break; |
1708 | 5389 case CANDIDATE_MB_TYPE_FORWARD: |
324 | 5390 s->mv_dir = MV_DIR_FORWARD; |
5391 s->mb_intra= 0; | |
5392 motion_x= s->mv[0][0][0] = s->b_forw_mv_table[xy][0]; | |
5393 motion_y= s->mv[0][0][1] = s->b_forw_mv_table[xy][1]; | |
5394 // printf(" %d %d ", motion_x, motion_y); | |
327 | 5395 break; |
1708 | 5396 case CANDIDATE_MB_TYPE_FORWARD_I: |
5397 s->mv_dir = MV_DIR_FORWARD; | |
5398 s->mv_type = MV_TYPE_FIELD; | |
5399 s->mb_intra= 0; | |
5400 for(i=0; i<2; i++){ | |
5401 j= s->field_select[0][i] = s->b_field_select_table[0][i][xy]; | |
5402 s->mv[0][i][0] = s->b_field_mv_table[0][i][j][xy][0]; | |
5403 s->mv[0][i][1] = s->b_field_mv_table[0][i][j][xy][1]; | |
5404 } | |
5405 motion_x=motion_y=0; | |
5406 break; | |
5407 case CANDIDATE_MB_TYPE_BACKWARD_I: | |
5408 s->mv_dir = MV_DIR_BACKWARD; | |
5409 s->mv_type = MV_TYPE_FIELD; | |
5410 s->mb_intra= 0; | |
5411 for(i=0; i<2; i++){ | |
5412 j= s->field_select[1][i] = s->b_field_select_table[1][i][xy]; | |
5413 s->mv[1][i][0] = s->b_field_mv_table[1][i][j][xy][0]; | |
5414 s->mv[1][i][1] = s->b_field_mv_table[1][i][j][xy][1]; | |
5415 } | |
5416 motion_x=motion_y=0; | |
5417 break; | |
5418 case CANDIDATE_MB_TYPE_BIDIR_I: | |
5419 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD; | |
5420 s->mv_type = MV_TYPE_FIELD; | |
5421 s->mb_intra= 0; | |
5422 for(dir=0; dir<2; dir++){ | |
5423 for(i=0; i<2; i++){ | |
5424 j= s->field_select[dir][i] = s->b_field_select_table[dir][i][xy]; | |
5425 s->mv[dir][i][0] = s->b_field_mv_table[dir][i][j][xy][0]; | |
5426 s->mv[dir][i][1] = s->b_field_mv_table[dir][i][j][xy][1]; | |
5427 } | |
5428 } | |
5429 motion_x=motion_y=0; | |
5430 break; | |
327 | 5431 default: |
324 | 5432 motion_x=motion_y=0; //gcc warning fix |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1597
diff
changeset
|
5433 av_log(s->avctx, AV_LOG_ERROR, "illegal MB type\n"); |
294 | 5434 } |
1051
e5a9dbf597d4
mpeg1 bframe encoding patch by (Rapha«³l LEGRAND) with some modifications by me
michaelni
parents:
1048
diff
changeset
|
5435 |
324 | 5436 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
|
5437 |
2627
bf158d23bbcc
Spelling errors patch by (Kevin Baragona | kevinmb500 gawab com)
michael
parents:
2620
diff
changeset
|
5438 // 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
|
5439 s->last_mv_dir = s->mv_dir; |
2967 | 5440 |
1389 | 5441 if (s->out_format == FMT_H263 && s->pict_type!=B_TYPE) |
5442 ff_h263_update_motion_val(s); | |
2967 | 5443 |
1389 | 5444 MPV_decode_mb(s, s->block); |
248
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
244
diff
changeset
|
5445 } |
1051
e5a9dbf597d4
mpeg1 bframe encoding patch by (Rapha«³l LEGRAND) with some modifications by me
michaelni
parents:
1048
diff
changeset
|
5446 |
327 | 5447 /* clean the MV table in IPS frames for direct mode in B frames */ |
5448 if(s->mb_intra /* && I,P,S_TYPE */){ | |
5449 s->p_mv_table[xy][0]=0; | |
5450 s->p_mv_table[xy][1]=0; | |
5451 } | |
2967 | 5452 |
909
8ae1e4c24e91
new PSNR code (now works with chroma, b frames, ...)
michaelni
parents:
903
diff
changeset
|
5453 if(s->flags&CODEC_FLAG_PSNR){ |
8ae1e4c24e91
new PSNR code (now works with chroma, b frames, ...)
michaelni
parents:
903
diff
changeset
|
5454 int w= 16; |
8ae1e4c24e91
new PSNR code (now works with chroma, b frames, ...)
michaelni
parents:
903
diff
changeset
|
5455 int h= 16; |
8ae1e4c24e91
new PSNR code (now works with chroma, b frames, ...)
michaelni
parents:
903
diff
changeset
|
5456 |
8ae1e4c24e91
new PSNR code (now works with chroma, b frames, ...)
michaelni
parents:
903
diff
changeset
|
5457 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
|
5458 if(s->mb_y*16 + 16 > s->height) h= s->height- s->mb_y*16; |
936 | 5459 |
2955 | 5460 s->current_picture.error[0] += sse( |
1389 | 5461 s, s->new_picture.data[0] + s->mb_x*16 + s->mb_y*s->linesize*16, |
5462 s->dest[0], w, h, s->linesize); | |
2955 | 5463 s->current_picture.error[1] += sse( |
1389 | 5464 s, s->new_picture.data[1] + s->mb_x*8 + s->mb_y*s->uvlinesize*8, |
5465 s->dest[1], w>>1, h>>1, s->uvlinesize); | |
2955 | 5466 s->current_picture.error[2] += sse( |
1389 | 5467 s, s->new_picture .data[2] + s->mb_x*8 + s->mb_y*s->uvlinesize*8, |
5468 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
|
5469 } |
2345 | 5470 if(s->loop_filter){ |
5471 if(s->out_format == FMT_H263) | |
5472 ff_h263_loop_filter(s); | |
5473 } | |
1786 | 5474 //printf("MB %d %d bits\n", s->mb_x+s->mb_y*s->mb_stride, put_bits_count(&s->pb)); |
0 | 5475 } |
5476 } | |
286 | 5477 |
2627
bf158d23bbcc
Spelling errors patch by (Kevin Baragona | kevinmb500 gawab com)
michael
parents:
2620
diff
changeset
|
5478 //not beautiful here but we must write it before flushing so it has to be here |
456 | 5479 if (s->msmpeg4_version && s->msmpeg4_version<4 && s->pict_type == I_TYPE) |
208 | 5480 msmpeg4_encode_ext_header(s); |
456 | 5481 |
1799 | 5482 write_slice_end(s); |
5483 | |
2967 | 5484 /* Send the last GOB if RTP */ |
1661 | 5485 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
|
5486 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
|
5487 pdif = pbBufPtr(&s->pb) - s->ptr_lastgob; |
231 | 5488 /* Call the RTP callback to send the last GOB */ |
1799 | 5489 emms_c(); |
2492
57ba17bd3924
rtp_callback: send number of mb patch by (Johan Bilien {jobi via.ecp fr)
michael
parents:
2450
diff
changeset
|
5490 s->avctx->rtp_callback(s->avctx, s->ptr_lastgob, pdif, number_mb); |
231 | 5491 } |
1799 | 5492 |
5493 return 0; | |
5494 } | |
5495 | |
5496 #define MERGE(field) dst->field += src->field; src->field=0 | |
5497 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
|
5498 MERGE(me.scene_change_score); |
3ab8f3e2ae6a
moving motion estimation specific variables from MpegEncContext -> MotionEstContext
michael
parents:
1994
diff
changeset
|
5499 MERGE(me.mc_mb_var_sum_temp); |
3ab8f3e2ae6a
moving motion estimation specific variables from MpegEncContext -> MotionEstContext
michael
parents:
1994
diff
changeset
|
5500 MERGE(me.mb_var_sum_temp); |
1799 | 5501 } |
5502 | |
5503 static void merge_context_after_encode(MpegEncContext *dst, MpegEncContext *src){ | |
5504 int i; | |
5505 | |
5506 MERGE(dct_count[0]); //note, the other dct vars are not part of the context | |
5507 MERGE(dct_count[1]); | |
5508 MERGE(mv_bits); | |
5509 MERGE(i_tex_bits); | |
5510 MERGE(p_tex_bits); | |
5511 MERGE(i_count); | |
5512 MERGE(f_count); | |
5513 MERGE(b_count); | |
5514 MERGE(skip_count); | |
5515 MERGE(misc_bits); | |
5516 MERGE(error_count); | |
5517 MERGE(padding_bug_score); | |
2955 | 5518 MERGE(current_picture.error[0]); |
5519 MERGE(current_picture.error[1]); | |
5520 MERGE(current_picture.error[2]); | |
1799 | 5521 |
5522 if(dst->avctx->noise_reduction){ | |
5523 for(i=0; i<64; i++){ | |
5524 MERGE(dct_error_sum[0][i]); | |
5525 MERGE(dct_error_sum[1][i]); | |
5526 } | |
5527 } | |
2967 | 5528 |
1799 | 5529 assert(put_bits_count(&src->pb) % 8 ==0); |
5530 assert(put_bits_count(&dst->pb) % 8 ==0); | |
5531 ff_copy_bits(&dst->pb, src->pb.buf, put_bits_count(&src->pb)); | |
5532 flush_put_bits(&dst->pb); | |
5533 } | |
5534 | |
3766 | 5535 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
|
5536 if (s->next_lambda){ |
16ace038f452
fix buffer underflows by reencoding the current frame with a higher QP
michael
parents:
3929
diff
changeset
|
5537 s->current_picture_ptr->quality= |
16ace038f452
fix buffer underflows by reencoding the current frame with a higher QP
michael
parents:
3929
diff
changeset
|
5538 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
|
5539 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
|
5540 } else if (!s->fixed_qscale) { |
2974 | 5541 s->current_picture_ptr->quality= |
5542 s->current_picture.quality = ff_rate_estimate_qscale(s, dry_run); | |
3766 | 5543 if (s->current_picture.quality < 0) |
5544 return -1; | |
5545 } | |
2974 | 5546 |
5547 if(s->adaptive_quant){ | |
5548 switch(s->codec_id){ | |
5549 case CODEC_ID_MPEG4: | |
5550 ff_clean_mpeg4_qscales(s); | |
5551 break; | |
5552 case CODEC_ID_H263: | |
5553 case CODEC_ID_H263P: | |
5554 case CODEC_ID_FLV1: | |
5555 ff_clean_h263_qscales(s); | |
5556 break; | |
5557 } | |
5558 | |
5559 s->lambda= s->lambda_table[0]; | |
5560 //FIXME broken | |
5561 }else | |
5562 s->lambda= s->current_picture.quality; | |
5563 //printf("%d %d\n", s->avctx->global_quality, s->current_picture.quality); | |
5564 update_qscale(s); | |
3780
6741c0e88310
return 0 from encode_picture() and estimate_qp() on success
mru
parents:
3777
diff
changeset
|
5565 return 0; |
2974 | 5566 } |
5567 | |
3766 | 5568 static int encode_picture(MpegEncContext *s, int picture_number) |
1799 | 5569 { |
2024
f65d87bfdd5a
some of the warning fixes by (Michael Roitzsch <mroi at users dot sourceforge dot net>)
michael
parents:
2015
diff
changeset
|
5570 int i; |
1799 | 5571 int bits; |
5572 | |
5573 s->picture_number = picture_number; | |
2967 | 5574 |
1799 | 5575 /* Reset the average MB variance */ |
2015
3ab8f3e2ae6a
moving motion estimation specific variables from MpegEncContext -> MotionEstContext
michael
parents:
1994
diff
changeset
|
5576 s->me.mb_var_sum_temp = |
3ab8f3e2ae6a
moving motion estimation specific variables from MpegEncContext -> MotionEstContext
michael
parents:
1994
diff
changeset
|
5577 s->me.mc_mb_var_sum_temp = 0; |
1799 | 5578 |
5579 /* we need to initialize some time vars before we can encode b-frames */ | |
5580 // RAL: Condition added for MPEG1VIDEO | |
5581 if (s->codec_id == CODEC_ID_MPEG1VIDEO || s->codec_id == CODEC_ID_MPEG2VIDEO || (s->h263_pred && !s->h263_msmpeg4)) | |
1834 | 5582 ff_set_mpeg4_time(s, s->picture_number); //FIXME rename and use has_b_frames or similar |
2967 | 5583 |
2015
3ab8f3e2ae6a
moving motion estimation specific variables from MpegEncContext -> MotionEstContext
michael
parents:
1994
diff
changeset
|
5584 s->me.scene_change_score=0; |
2967 | 5585 |
2053 | 5586 // s->lambda= s->current_picture_ptr->quality; //FIXME qscale / ... stuff for ME ratedistoration |
2967 | 5587 |
1799 | 5588 if(s->pict_type==I_TYPE){ |
5589 if(s->msmpeg4_version >= 3) s->no_rounding=1; | |
5590 else s->no_rounding=0; | |
5591 }else if(s->pict_type!=B_TYPE){ | |
5592 if(s->flipflop_rounding || s->codec_id == CODEC_ID_H263P || s->codec_id == CODEC_ID_MPEG4) | |
2967 | 5593 s->no_rounding ^= 1; |
5594 } | |
5595 | |
2981 | 5596 if(s->flags & CODEC_FLAG_PASS2){ |
3766 | 5597 if (estimate_qp(s,1) < 0) |
5598 return -1; | |
2981 | 5599 ff_get_2pass_fcode(s); |
5600 }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
|
5601 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
|
5602 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
|
5603 else |
2997
188f4ef688f2
second try of improved lambda/qp guessing for motion estimation RD in first pass
michael
parents:
2990
diff
changeset
|
5604 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
|
5605 update_qscale(s); |
529163f99474
improved lambda/qp guessing for motion estimation RD in first pass
michael
parents:
2979
diff
changeset
|
5606 } |
2974 | 5607 |
2627
bf158d23bbcc
Spelling errors patch by (Kevin Baragona | kevinmb500 gawab com)
michael
parents:
2620
diff
changeset
|
5608 s->mb_intra=0; //for the rate distortion & bit compare functions |
1799 | 5609 for(i=1; i<s->avctx->thread_count; i++){ |
1827 | 5610 ff_update_duplicate_context(s->thread_context[i], s); |
1799 | 5611 } |
1962 | 5612 |
5613 ff_init_me(s); | |
5614 | |
1799 | 5615 /* Estimate motion for every MB */ |
5616 if(s->pict_type != I_TYPE){ | |
2584 | 5617 s->lambda = (s->lambda * s->avctx->me_penalty_compensation + 128)>>8; |
4097 | 5618 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
|
5619 if(s->pict_type != B_TYPE && s->avctx->me_threshold==0){ |
1799 | 5620 if((s->avctx->pre_me && s->last_non_b_pict_type==I_TYPE) || s->avctx->pre_me==2){ |
5621 s->avctx->execute(s->avctx, pre_estimate_motion_thread, (void**)&(s->thread_context[0]), NULL, s->avctx->thread_count); | |
5622 } | |
5623 } | |
5624 | |
5625 s->avctx->execute(s->avctx, estimate_motion_thread, (void**)&(s->thread_context[0]), NULL, s->avctx->thread_count); | |
5626 }else /* if(s->pict_type == I_TYPE) */{ | |
5627 /* I-Frame */ | |
5628 for(i=0; i<s->mb_stride*s->mb_height; i++) | |
5629 s->mb_type[i]= CANDIDATE_MB_TYPE_INTRA; | |
2967 | 5630 |
1799 | 5631 if(!s->fixed_qscale){ |
5632 /* finding spatial complexity for I-frame rate control */ | |
1804
cc0a15943a87
multithreaded spatial complexity calculation for i frames
michael
parents:
1803
diff
changeset
|
5633 s->avctx->execute(s->avctx, mb_var_thread, (void**)&(s->thread_context[0]), NULL, s->avctx->thread_count); |
1799 | 5634 } |
5635 } | |
1804
cc0a15943a87
multithreaded spatial complexity calculation for i frames
michael
parents:
1803
diff
changeset
|
5636 for(i=1; i<s->avctx->thread_count; i++){ |
cc0a15943a87
multithreaded spatial complexity calculation for i frames
michael
parents:
1803
diff
changeset
|
5637 merge_context_after_me(s, s->thread_context[i]); |
cc0a15943a87
multithreaded spatial complexity calculation for i frames
michael
parents:
1803
diff
changeset
|
5638 } |
2015
3ab8f3e2ae6a
moving motion estimation specific variables from MpegEncContext -> MotionEstContext
michael
parents:
1994
diff
changeset
|
5639 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
|
5640 s->current_picture. mb_var_sum= s->current_picture_ptr-> mb_var_sum= s->me. mb_var_sum_temp; |
1799 | 5641 emms_c(); |
5642 | |
2015
3ab8f3e2ae6a
moving motion estimation specific variables from MpegEncContext -> MotionEstContext
michael
parents:
1994
diff
changeset
|
5643 if(s->me.scene_change_score > s->avctx->scenechange_threshold && s->pict_type == P_TYPE){ |
1799 | 5644 s->pict_type= I_TYPE; |
5645 for(i=0; i<s->mb_stride*s->mb_height; i++) | |
5646 s->mb_type[i]= CANDIDATE_MB_TYPE_INTRA; | |
5647 //printf("Scene change detected, encoding as I Frame %d %d\n", s->current_picture.mb_var_sum, s->current_picture.mc_mb_var_sum); | |
5648 } | |
5649 | |
5650 if(!s->umvplus){ | |
5651 if(s->pict_type==P_TYPE || s->pict_type==S_TYPE) { | |
5652 s->f_code= ff_get_best_fcode(s, s->p_mv_table, CANDIDATE_MB_TYPE_INTER); | |
5653 | |
5654 if(s->flags & CODEC_FLAG_INTERLACED_ME){ | |
5655 int a,b; | |
5656 a= ff_get_best_fcode(s, s->p_field_mv_table[0][0], CANDIDATE_MB_TYPE_INTER_I); //FIXME field_select | |
5657 b= ff_get_best_fcode(s, s->p_field_mv_table[1][1], CANDIDATE_MB_TYPE_INTER_I); | |
5658 s->f_code= FFMAX(s->f_code, FFMAX(a,b)); | |
5659 } | |
2967 | 5660 |
1799 | 5661 ff_fix_long_p_mvs(s); |
5662 ff_fix_long_mvs(s, NULL, 0, s->p_mv_table, s->f_code, CANDIDATE_MB_TYPE_INTER, 0); | |
5663 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
|
5664 int j; |
1799 | 5665 for(i=0; i<2; i++){ |
5666 for(j=0; j<2; j++) | |
2967 | 5667 ff_fix_long_mvs(s, s->p_field_select_table[i], j, |
1799 | 5668 s->p_field_mv_table[i][j], s->f_code, CANDIDATE_MB_TYPE_INTER_I, 0); |
5669 } | |
5670 } | |
5671 } | |
5672 | |
5673 if(s->pict_type==B_TYPE){ | |
5674 int a, b; | |
5675 | |
5676 a = ff_get_best_fcode(s, s->b_forw_mv_table, CANDIDATE_MB_TYPE_FORWARD); | |
5677 b = ff_get_best_fcode(s, s->b_bidir_forw_mv_table, CANDIDATE_MB_TYPE_BIDIR); | |
5678 s->f_code = FFMAX(a, b); | |
5679 | |
5680 a = ff_get_best_fcode(s, s->b_back_mv_table, CANDIDATE_MB_TYPE_BACKWARD); | |
5681 b = ff_get_best_fcode(s, s->b_bidir_back_mv_table, CANDIDATE_MB_TYPE_BIDIR); | |
5682 s->b_code = FFMAX(a, b); | |
5683 | |
5684 ff_fix_long_mvs(s, NULL, 0, s->b_forw_mv_table, s->f_code, CANDIDATE_MB_TYPE_FORWARD, 1); | |
5685 ff_fix_long_mvs(s, NULL, 0, s->b_back_mv_table, s->b_code, CANDIDATE_MB_TYPE_BACKWARD, 1); | |
5686 ff_fix_long_mvs(s, NULL, 0, s->b_bidir_forw_mv_table, s->f_code, CANDIDATE_MB_TYPE_BIDIR, 1); | |
5687 ff_fix_long_mvs(s, NULL, 0, s->b_bidir_back_mv_table, s->b_code, CANDIDATE_MB_TYPE_BIDIR, 1); | |
5688 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
|
5689 int dir, j; |
1799 | 5690 for(dir=0; dir<2; dir++){ |
5691 for(i=0; i<2; i++){ | |
5692 for(j=0; j<2; j++){ | |
2967 | 5693 int type= dir ? (CANDIDATE_MB_TYPE_BACKWARD_I|CANDIDATE_MB_TYPE_BIDIR_I) |
1799 | 5694 : (CANDIDATE_MB_TYPE_FORWARD_I |CANDIDATE_MB_TYPE_BIDIR_I); |
2967 | 5695 ff_fix_long_mvs(s, s->b_field_select_table[dir][i], j, |
1799 | 5696 s->b_field_mv_table[dir][i][j], dir ? s->b_code : s->f_code, type, 1); |
5697 } | |
5698 } | |
5699 } | |
5700 } | |
5701 } | |
5702 } | |
5703 | |
3766 | 5704 if (estimate_qp(s, 0) < 0) |
5705 return -1; | |
2967 | 5706 |
5707 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
|
5708 s->qscale= 3; //reduce clipping problems |
2967 | 5709 |
1799 | 5710 if (s->out_format == FMT_MJPEG) { |
5711 /* for mjpeg, we do include qscale in the matrix */ | |
5712 s->intra_matrix[0] = ff_mpeg1_default_intra_matrix[0]; | |
5713 for(i=1;i<64;i++){ | |
5714 int j= s->dsp.idct_permutation[i]; | |
5715 | |
3286
30d412952107
clip_uint8 now return an uint8_t so no need to &0xFF
aurel
parents:
3281
diff
changeset
|
5716 s->intra_matrix[j] = clip_uint8((ff_mpeg1_default_intra_matrix[i] * s->qscale) >> 3); |
1799 | 5717 } |
2967 | 5718 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
|
5719 s->intra_matrix, s->intra_quant_bias, 8, 8, 1); |
1799 | 5720 s->qscale= 8; |
5721 } | |
2967 | 5722 |
1799 | 5723 //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
|
5724 s->current_picture_ptr->key_frame= |
1799 | 5725 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
|
5726 s->current_picture_ptr->pict_type= |
1799 | 5727 s->current_picture.pict_type= s->pict_type; |
5728 | |
5729 if(s->current_picture.key_frame) | |
5730 s->picture_in_gop_number=0; | |
5731 | |
5732 s->last_bits= put_bits_count(&s->pb); | |
5733 switch(s->out_format) { | |
5734 case FMT_MJPEG: | |
5735 mjpeg_picture_header(s); | |
5736 break; | |
2639 | 5737 #ifdef CONFIG_H261_ENCODER |
2327
5e5cf598a48b
H.261 encoder by (Maarten Daniels <maarten dot daniels at luc dot ac dot be>)
michael
parents:
2298
diff
changeset
|
5738 case FMT_H261: |
5e5cf598a48b
H.261 encoder by (Maarten Daniels <maarten dot daniels at luc dot ac dot be>)
michael
parents:
2298
diff
changeset
|
5739 ff_h261_encode_picture_header(s, picture_number); |
5e5cf598a48b
H.261 encoder by (Maarten Daniels <maarten dot daniels at luc dot ac dot be>)
michael
parents:
2298
diff
changeset
|
5740 break; |
2639 | 5741 #endif |
1799 | 5742 case FMT_H263: |
2967 | 5743 if (s->codec_id == CODEC_ID_WMV2) |
1799 | 5744 ff_wmv2_encode_picture_header(s, picture_number); |
2967 | 5745 else if (s->h263_msmpeg4) |
1799 | 5746 msmpeg4_encode_picture_header(s, picture_number); |
5747 else if (s->h263_pred) | |
5748 mpeg4_encode_picture_header(s, picture_number); | |
2639 | 5749 #ifdef CONFIG_RV10_ENCODER |
2967 | 5750 else if (s->codec_id == CODEC_ID_RV10) |
1799 | 5751 rv10_encode_picture_header(s, picture_number); |
2639 | 5752 #endif |
5753 #ifdef CONFIG_RV20_ENCODER | |
2967 | 5754 else if (s->codec_id == CODEC_ID_RV20) |
2380 | 5755 rv20_encode_picture_header(s, picture_number); |
2639 | 5756 #endif |
1799 | 5757 else if (s->codec_id == CODEC_ID_FLV1) |
5758 ff_flv_encode_picture_header(s, picture_number); | |
5759 else | |
5760 h263_encode_picture_header(s, picture_number); | |
5761 break; | |
5762 case FMT_MPEG1: | |
5763 mpeg1_encode_picture_header(s, picture_number); | |
5764 break; | |
5765 case FMT_H264: | |
5766 break; | |
5767 default: | |
5768 assert(0); | |
5769 } | |
5770 bits= put_bits_count(&s->pb); | |
5771 s->header_bits= bits - s->last_bits; | |
2967 | 5772 |
1799 | 5773 for(i=1; i<s->avctx->thread_count; i++){ |
5774 update_duplicate_context_after_me(s->thread_context[i], s); | |
5775 } | |
5776 s->avctx->execute(s->avctx, encode_thread, (void**)&(s->thread_context[0]), NULL, s->avctx->thread_count); | |
5777 for(i=1; i<s->avctx->thread_count; i++){ | |
5778 merge_context_after_encode(s, s->thread_context[i]); | |
5779 } | |
5780 emms_c(); | |
3780
6741c0e88310
return 0 from encode_picture() and estimate_qp() on success
mru
parents:
3777
diff
changeset
|
5781 return 0; |
0 | 5782 } |
5783 | |
1719 | 5784 static void denoise_dct_c(MpegEncContext *s, DCTELEM *block){ |
1597 | 5785 const int intra= s->mb_intra; |
5786 int i; | |
5787 | |
1599 | 5788 s->dct_count[intra]++; |
5789 | |
1597 | 5790 for(i=0; i<64; i++){ |
5791 int level= block[i]; | |
5792 | |
5793 if(level){ | |
5794 if(level>0){ | |
5795 s->dct_error_sum[intra][i] += level; | |
5796 level -= s->dct_offset[intra][i]; | |
5797 if(level<0) level=0; | |
5798 }else{ | |
5799 s->dct_error_sum[intra][i] -= level; | |
5800 level += s->dct_offset[intra][i]; | |
5801 if(level>0) level=0; | |
5802 } | |
5803 block[i]= level; | |
5804 } | |
5805 } | |
5806 } | |
5807 | |
2967 | 5808 static int dct_quantize_trellis_c(MpegEncContext *s, |
945 | 5809 DCTELEM *block, int n, |
5810 int qscale, int *overflow){ | |
5811 const int *qmat; | |
1064 | 5812 const uint8_t *scantable= s->intra_scantable.scantable; |
1718 | 5813 const uint8_t *perm_scantable= s->intra_scantable.permutated; |
945 | 5814 int max=0; |
5815 unsigned int threshold1, threshold2; | |
5816 int bias=0; | |
5817 int run_tab[65]; | |
5818 int level_tab[65]; | |
5819 int score_tab[65]; | |
1718 | 5820 int survivor[65]; |
5821 int survivor_count; | |
946 | 5822 int last_run=0; |
5823 int last_level=0; | |
5824 int last_score= 0; | |
1718 | 5825 int last_i; |
1715 | 5826 int coeff[2][64]; |
945 | 5827 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
|
5828 int qmul, qadd, start_i, last_non_zero, i, dc; |
945 | 5829 const int esc_length= s->ac_esc_length; |
5830 uint8_t * length; | |
5831 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
|
5832 const int lambda= s->lambda2 >> (FF_LAMBDA_SHIFT - 6); |
2967 | 5833 |
1092 | 5834 s->dsp.fdct (block); |
2967 | 5835 |
1597 | 5836 if(s->dct_error_sum) |
1719 | 5837 s->denoise_dct(s, block); |
945 | 5838 qmul= qscale*16; |
5839 qadd= ((qscale-1)|1)*8; | |
946 | 5840 |
945 | 5841 if (s->mb_intra) { |
5842 int q; | |
5843 if (!s->h263_aic) { | |
5844 if (n < 4) | |
5845 q = s->y_dc_scale; | |
5846 else | |
5847 q = s->c_dc_scale; | |
5848 q = q << 3; | |
5849 } else{ | |
5850 /* For AIC we skip quant/dequant of INTRADC */ | |
5851 q = 1 << 3; | |
5852 qadd=0; | |
5853 } | |
2967 | 5854 |
945 | 5855 /* note: block[0] is assumed to be positive */ |
5856 block[0] = (block[0] + (q >> 1)) / q; | |
5857 start_i = 1; | |
5858 last_non_zero = 0; | |
5859 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
|
5860 if(s->mpeg_quant || s->out_format == FMT_MPEG1) |
945 | 5861 bias= 1<<(QMAT_SHIFT-1); |
5862 length = s->intra_ac_vlc_length; | |
5863 last_length= s->intra_ac_vlc_last_length; | |
5864 } else { | |
5865 start_i = 0; | |
5866 last_non_zero = -1; | |
5867 qmat = s->q_inter_matrix[qscale]; | |
5868 length = s->inter_ac_vlc_length; | |
5869 last_length= s->inter_ac_vlc_last_length; | |
5870 } | |
1718 | 5871 last_i= start_i; |
945 | 5872 |
5873 threshold1= (1<<QMAT_SHIFT) - bias - 1; | |
5874 threshold2= (threshold1<<1); | |
946 | 5875 |
1715 | 5876 for(i=63; i>=start_i; i--) { |
5877 const int j = scantable[i]; | |
5878 int level = block[j] * qmat[j]; | |
5879 | |
5880 if(((unsigned)(level+threshold1))>threshold2){ | |
5881 last_non_zero = i; | |
5882 break; | |
5883 } | |
5884 } | |
5885 | |
5886 for(i=start_i; i<=last_non_zero; i++) { | |
945 | 5887 const int j = scantable[i]; |
1715 | 5888 int level = block[j] * qmat[j]; |
945 | 5889 |
5890 // if( bias+level >= (1<<(QMAT_SHIFT - 3)) | |
5891 // || bias-level >= (1<<(QMAT_SHIFT - 3))){ | |
5892 if(((unsigned)(level+threshold1))>threshold2){ | |
5893 if(level>0){ | |
5894 level= (bias + level)>>QMAT_SHIFT; | |
1718 | 5895 coeff[0][i]= level; |
5896 coeff[1][i]= level-1; | |
946 | 5897 // coeff[2][k]= level-2; |
945 | 5898 }else{ |
5899 level= (bias - level)>>QMAT_SHIFT; | |
1718 | 5900 coeff[0][i]= -level; |
5901 coeff[1][i]= -level+1; | |
946 | 5902 // coeff[2][k]= -level+2; |
945 | 5903 } |
1718 | 5904 coeff_count[i]= FFMIN(level, 2); |
5905 assert(coeff_count[i]); | |
945 | 5906 max |=level; |
5907 }else{ | |
1718 | 5908 coeff[0][i]= (level>>31)|1; |
5909 coeff_count[i]= 1; | |
945 | 5910 } |
5911 } | |
2967 | 5912 |
2627
bf158d23bbcc
Spelling errors patch by (Kevin Baragona | kevinmb500 gawab com)
michael
parents:
2620
diff
changeset
|
5913 *overflow= s->max_qcoeff < max; //overflow might have happened |
2967 | 5914 |
945 | 5915 if(last_non_zero < start_i){ |
5916 memset(block + start_i, 0, (64-start_i)*sizeof(DCTELEM)); | |
5917 return last_non_zero; | |
5918 } | |
5919 | |
1718 | 5920 score_tab[start_i]= 0; |
5921 survivor[0]= start_i; | |
5922 survivor_count= 1; | |
2967 | 5923 |
1718 | 5924 for(i=start_i; i<=last_non_zero; i++){ |
5925 int level_index, j; | |
4001 | 5926 const int dct_coeff= FFABS(block[ scantable[i] ]); |
945 | 5927 const int zero_distoration= dct_coeff*dct_coeff; |
946 | 5928 int best_score=256*256*256*120; |
945 | 5929 for(level_index=0; level_index < coeff_count[i]; level_index++){ |
5930 int distoration; | |
5931 int level= coeff[level_index][i]; | |
4001 | 5932 const int alevel= FFABS(level); |
945 | 5933 int unquant_coeff; |
2967 | 5934 |
945 | 5935 assert(level); |
5936 | |
5937 if(s->out_format == FMT_H263){ | |
1716 | 5938 unquant_coeff= alevel*qmul + qadd; |
947 | 5939 }else{ //MPEG1 |
1718 | 5940 j= s->dsp.idct_permutation[ scantable[i] ]; //FIXME optimize |
947 | 5941 if(s->mb_intra){ |
1716 | 5942 unquant_coeff = (int)( alevel * qscale * s->intra_matrix[j]) >> 3; |
947 | 5943 unquant_coeff = (unquant_coeff - 1) | 1; |
5944 }else{ | |
1716 | 5945 unquant_coeff = ((( alevel << 1) + 1) * qscale * ((int) s->inter_matrix[j])) >> 4; |
947 | 5946 unquant_coeff = (unquant_coeff - 1) | 1; |
5947 } | |
5948 unquant_coeff<<= 3; | |
5949 } | |
946 | 5950 |
1715 | 5951 distoration= (unquant_coeff - dct_coeff) * (unquant_coeff - dct_coeff) - zero_distoration; |
945 | 5952 level+=64; |
5953 if((level&(~127)) == 0){ | |
1718 | 5954 for(j=survivor_count-1; j>=0; j--){ |
5955 int run= i - survivor[j]; | |
947 | 5956 int score= distoration + length[UNI_AC_ENC_INDEX(run, level)]*lambda; |
945 | 5957 score += score_tab[i-run]; |
2967 | 5958 |
945 | 5959 if(score < best_score){ |
1718 | 5960 best_score= score; |
945 | 5961 run_tab[i+1]= run; |
5962 level_tab[i+1]= level-64; | |
5963 } | |
5964 } | |
5965 | |
5966 if(s->out_format == FMT_H263){ | |
1718 | 5967 for(j=survivor_count-1; j>=0; j--){ |
5968 int run= i - survivor[j]; | |
947 | 5969 int score= distoration + last_length[UNI_AC_ENC_INDEX(run, level)]*lambda; |
945 | 5970 score += score_tab[i-run]; |
946 | 5971 if(score < last_score){ |
5972 last_score= score; | |
5973 last_run= run; | |
5974 last_level= level-64; | |
5975 last_i= i+1; | |
945 | 5976 } |
5977 } | |
5978 } | |
5979 }else{ | |
5980 distoration += esc_length*lambda; | |
1718 | 5981 for(j=survivor_count-1; j>=0; j--){ |
5982 int run= i - survivor[j]; | |
945 | 5983 int score= distoration + 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]; | |
945 | 5995 int score= distoration + score_tab[i-run]; |
946 | 5996 if(score < last_score){ |
5997 last_score= score; | |
5998 last_run= run; | |
5999 last_level= level-64; | |
6000 last_i= i+1; | |
945 | 6001 } |
6002 } | |
6003 } | |
6004 } | |
6005 } | |
2967 | 6006 |
1718 | 6007 score_tab[i+1]= best_score; |
6008 | |
946 | 6009 //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 | 6010 if(last_non_zero <= 27){ |
6011 for(; survivor_count; survivor_count--){ | |
6012 if(score_tab[ survivor[survivor_count-1] ] <= best_score) | |
6013 break; | |
6014 } | |
6015 }else{ | |
6016 for(; survivor_count; survivor_count--){ | |
6017 if(score_tab[ survivor[survivor_count-1] ] <= best_score + lambda) | |
6018 break; | |
6019 } | |
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
|
6020 } |
1718 | 6021 |
6022 survivor[ survivor_count++ ]= i+1; | |
945 | 6023 } |
946 | 6024 |
945 | 6025 if(s->out_format != FMT_H263){ |
946 | 6026 last_score= 256*256*256*120; |
1718 | 6027 for(i= survivor[0]; i<=last_non_zero + 1; i++){ |
946 | 6028 int score= score_tab[i]; |
947 | 6029 if(i) score += lambda*2; //FIXME exacter? |
6030 | |
946 | 6031 if(score < last_score){ |
6032 last_score= score; | |
6033 last_i= i; | |
6034 last_level= level_tab[i]; | |
6035 last_run= run_tab[i]; | |
6036 } | |
945 | 6037 } |
6038 } | |
1490
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1480
diff
changeset
|
6039 |
1715 | 6040 s->coded_score[n] = last_score; |
2967 | 6041 |
4001 | 6042 dc= FFABS(block[0]); |
1718 | 6043 last_non_zero= last_i - 1; |
945 | 6044 memset(block + start_i, 0, (64-start_i)*sizeof(DCTELEM)); |
2967 | 6045 |
945 | 6046 if(last_non_zero < start_i) |
6047 return last_non_zero; | |
1490
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1480
diff
changeset
|
6048 |
1480
8657d6800d15
slight quality improvement ( < +0.04 PSNR) for high bitrate videos with trellis quantization
michaelni
parents:
1471
diff
changeset
|
6049 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
|
6050 int best_level= 0; |
8657d6800d15
slight quality improvement ( < +0.04 PSNR) for high bitrate videos with trellis quantization
michaelni
parents:
1471
diff
changeset
|
6051 int best_score= dc * dc; |
2967 | 6052 |
1480
8657d6800d15
slight quality improvement ( < +0.04 PSNR) for high bitrate videos with trellis quantization
michaelni
parents:
1471
diff
changeset
|
6053 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
|
6054 int level= coeff[i][0]; |
4001 | 6055 int alevel= FFABS(level); |
1716 | 6056 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
|
6057 |
8657d6800d15
slight quality improvement ( < +0.04 PSNR) for high bitrate videos with trellis quantization
michaelni
parents:
1471
diff
changeset
|
6058 if(s->out_format == FMT_H263){ |
1716 | 6059 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
|
6060 }else{ //MPEG1 |
1716 | 6061 unquant_coeff = ((( alevel << 1) + 1) * qscale * ((int) s->inter_matrix[0])) >> 4; |
6062 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
|
6063 } |
8657d6800d15
slight quality improvement ( < +0.04 PSNR) for high bitrate videos with trellis quantization
michaelni
parents:
1471
diff
changeset
|
6064 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
|
6065 unquant_coeff<<= 3 + 3; |
8657d6800d15
slight quality improvement ( < +0.04 PSNR) for high bitrate videos with trellis quantization
michaelni
parents:
1471
diff
changeset
|
6066 |
1716 | 6067 distortion= (unquant_coeff - dc) * (unquant_coeff - dc); |
1490
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1480
diff
changeset
|
6068 level+=64; |
1716 | 6069 if((level&(~127)) == 0) score= distortion + last_length[UNI_AC_ENC_INDEX(0, level)]*lambda; |
6070 else score= distortion + esc_length*lambda; | |
1490
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1480
diff
changeset
|
6071 |
1480
8657d6800d15
slight quality improvement ( < +0.04 PSNR) for high bitrate videos with trellis quantization
michaelni
parents:
1471
diff
changeset
|
6072 if(score < best_score){ |
8657d6800d15
slight quality improvement ( < +0.04 PSNR) for high bitrate videos with trellis quantization
michaelni
parents:
1471
diff
changeset
|
6073 best_score= score; |
1490
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1480
diff
changeset
|
6074 best_level= level - 64; |
1480
8657d6800d15
slight quality improvement ( < +0.04 PSNR) for high bitrate videos with trellis quantization
michaelni
parents:
1471
diff
changeset
|
6075 } |
8657d6800d15
slight quality improvement ( < +0.04 PSNR) for high bitrate videos with trellis quantization
michaelni
parents:
1471
diff
changeset
|
6076 } |
8657d6800d15
slight quality improvement ( < +0.04 PSNR) for high bitrate videos with trellis quantization
michaelni
parents:
1471
diff
changeset
|
6077 block[0]= best_level; |
1490
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1480
diff
changeset
|
6078 s->coded_score[n] = best_score - dc*dc; |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1480
diff
changeset
|
6079 if(best_level == 0) return -1; |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1480
diff
changeset
|
6080 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
|
6081 } |
1490
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1480
diff
changeset
|
6082 |
946 | 6083 i= last_i; |
6084 assert(last_level); | |
1718 | 6085 |
6086 block[ perm_scantable[last_non_zero] ]= last_level; | |
946 | 6087 i -= last_run + 1; |
2967 | 6088 |
1718 | 6089 for(; i>start_i; i -= run_tab[i] + 1){ |
6090 block[ perm_scantable[i-1] ]= level_tab[i]; | |
945 | 6091 } |
6092 | |
6093 return last_non_zero; | |
6094 } | |
6095 | |
1777 | 6096 //#define REFINE_STATS 1 |
6097 static int16_t basis[64][64]; | |
6098 | |
6099 static void build_basis(uint8_t *perm){ | |
6100 int i, j, x, y; | |
6101 emms_c(); | |
6102 for(i=0; i<8; i++){ | |
6103 for(j=0; j<8; j++){ | |
6104 for(y=0; y<8; y++){ | |
6105 for(x=0; x<8; x++){ | |
6106 double s= 0.25*(1<<BASIS_SHIFT); | |
6107 int index= 8*i + j; | |
6108 int perm_index= perm[index]; | |
6109 if(i==0) s*= sqrt(0.5); | |
6110 if(j==0) s*= sqrt(0.5); | |
6111 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))); | |
6112 } | |
6113 } | |
6114 } | |
6115 } | |
6116 } | |
6117 | |
6118 static int dct_quantize_refine(MpegEncContext *s, //FIXME breaks denoise? | |
6119 DCTELEM *block, int16_t *weight, DCTELEM *orig, | |
6120 int n, int qscale){ | |
6121 int16_t rem[64]; | |
3089 | 6122 DECLARE_ALIGNED_16(DCTELEM, d1[64]); |
1777 | 6123 const int *qmat; |
6124 const uint8_t *scantable= s->intra_scantable.scantable; | |
6125 const uint8_t *perm_scantable= s->intra_scantable.permutated; | |
6126 // unsigned int threshold1, threshold2; | |
6127 // int bias=0; | |
6128 int run_tab[65]; | |
6129 int prev_run=0; | |
6130 int prev_level=0; | |
6131 int qmul, qadd, start_i, last_non_zero, i, dc; | |
6132 uint8_t * length; | |
6133 uint8_t * last_length; | |
6134 int lambda; | |
6135 int rle_index, run, q, sum; | |
6136 #ifdef REFINE_STATS | |
6137 static int count=0; | |
6138 static int after_last=0; | |
6139 static int to_zero=0; | |
6140 static int from_zero=0; | |
6141 static int raise=0; | |
6142 static int lower=0; | |
6143 static int messed_sign=0; | |
6144 #endif | |
6145 | |
6146 if(basis[0][0] == 0) | |
6147 build_basis(s->dsp.idct_permutation); | |
2967 | 6148 |
1777 | 6149 qmul= qscale*2; |
6150 qadd= (qscale-1)|1; | |
6151 if (s->mb_intra) { | |
6152 if (!s->h263_aic) { | |
6153 if (n < 4) | |
6154 q = s->y_dc_scale; | |
6155 else | |
6156 q = s->c_dc_scale; | |
6157 } else{ | |
6158 /* For AIC we skip quant/dequant of INTRADC */ | |
6159 q = 1; | |
6160 qadd=0; | |
6161 } | |
6162 q <<= RECON_SHIFT-3; | |
6163 /* note: block[0] is assumed to be positive */ | |
6164 dc= block[0]*q; | |
6165 // block[0] = (block[0] + (q >> 1)) / q; | |
6166 start_i = 1; | |
6167 qmat = s->q_intra_matrix[qscale]; | |
6168 // if(s->mpeg_quant || s->out_format == FMT_MPEG1) | |
6169 // bias= 1<<(QMAT_SHIFT-1); | |
6170 length = s->intra_ac_vlc_length; | |
6171 last_length= s->intra_ac_vlc_last_length; | |
6172 } else { | |
6173 dc= 0; | |
6174 start_i = 0; | |
6175 qmat = s->q_inter_matrix[qscale]; | |
6176 length = s->inter_ac_vlc_length; | |
6177 last_length= s->inter_ac_vlc_last_length; | |
6178 } | |
6179 last_non_zero = s->block_last_index[n]; | |
6180 | |
6181 #ifdef REFINE_STATS | |
6182 {START_TIMER | |
6183 #endif | |
1784 | 6184 dc += (1<<(RECON_SHIFT-1)); |
6185 for(i=0; i<64; i++){ | |
2627
bf158d23bbcc
Spelling errors patch by (Kevin Baragona | kevinmb500 gawab com)
michael
parents:
2620
diff
changeset
|
6186 rem[i]= dc - (orig[i]<<RECON_SHIFT); //FIXME use orig dirrectly instead of copying to rem[] |
1777 | 6187 } |
6188 #ifdef REFINE_STATS | |
6189 STOP_TIMER("memset rem[]")} | |
6190 #endif | |
6191 sum=0; | |
6192 for(i=0; i<64; i++){ | |
6193 int one= 36; | |
6194 int qns=4; | |
6195 int w; | |
6196 | |
4001 | 6197 w= FFABS(weight[i]) + qns*one; |
1777 | 6198 w= 15 + (48*qns*one + w/2)/w; // 16 .. 63 |
6199 | |
6200 weight[i] = w; | |
6201 // w=weight[i] = (63*qns + (w/2)) / w; | |
2967 | 6202 |
1777 | 6203 assert(w>0); |
6204 assert(w<(1<<6)); | |
6205 sum += w*w; | |
6206 } | |
6207 lambda= sum*(uint64_t)s->lambda2 >> (FF_LAMBDA_SHIFT - 6 + 6 + 6 + 6); | |
6208 #ifdef REFINE_STATS | |
6209 {START_TIMER | |
6210 #endif | |
6211 run=0; | |
6212 rle_index=0; | |
6213 for(i=start_i; i<=last_non_zero; i++){ | |
6214 int j= perm_scantable[i]; | |
6215 const int level= block[j]; | |
6216 int coeff; | |
2967 | 6217 |
1777 | 6218 if(level){ |
6219 if(level<0) coeff= qmul*level - qadd; | |
6220 else coeff= qmul*level + qadd; | |
6221 run_tab[rle_index++]=run; | |
6222 run=0; | |
6223 | |
1784 | 6224 s->dsp.add_8x8basis(rem, basis[j], coeff); |
1777 | 6225 }else{ |
6226 run++; | |
6227 } | |
6228 } | |
6229 #ifdef REFINE_STATS | |
6230 if(last_non_zero>0){ | |
6231 STOP_TIMER("init rem[]") | |
6232 } | |
6233 } | |
6234 | |
6235 {START_TIMER | |
6236 #endif | |
6237 for(;;){ | |
1784 | 6238 int best_score=s->dsp.try_8x8basis(rem, weight, basis[0], 0); |
1777 | 6239 int best_coeff=0; |
6240 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
|
6241 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
|
6242 #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
|
6243 {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
|
6244 #endif |
14d918d0ef42
analyze the gradient of the error surface to avoid a few checks in the quantizing noise shaper
michael
parents:
1784
diff
changeset
|
6245 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
|
6246 |
14d918d0ef42
analyze the gradient of the error surface to avoid a few checks in the quantizing noise shaper
michael
parents:
1784
diff
changeset
|
6247 if(analyze_gradient){ |
1777 | 6248 #ifdef REFINE_STATS |
6249 {START_TIMER | |
6250 #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
|
6251 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
|
6252 int w= weight[i]; |
2967 | 6253 |
1785
14d918d0ef42
analyze the gradient of the error surface to avoid a few checks in the quantizing noise shaper
michael
parents:
1784
diff
changeset
|
6254 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
|
6255 } |
14d918d0ef42
analyze the gradient of the error surface to avoid a few checks in the quantizing noise shaper
michael
parents:
1784
diff
changeset
|
6256 #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
|
6257 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
|
6258 {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
|
6259 #endif |
14d918d0ef42
analyze the gradient of the error surface to avoid a few checks in the quantizing noise shaper
michael
parents:
1784
diff
changeset
|
6260 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
|
6261 #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
|
6262 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
|
6263 #endif |
14d918d0ef42
analyze the gradient of the error surface to avoid a few checks in the quantizing noise shaper
michael
parents:
1784
diff
changeset
|
6264 } |
14d918d0ef42
analyze the gradient of the error surface to avoid a few checks in the quantizing noise shaper
michael
parents:
1784
diff
changeset
|
6265 |
1777 | 6266 if(start_i){ |
6267 const int level= block[0]; | |
6268 int change, old_coeff; | |
6269 | |
6270 assert(s->mb_intra); | |
2967 | 6271 |
1777 | 6272 old_coeff= q*level; |
2967 | 6273 |
1777 | 6274 for(change=-1; change<=1; change+=2){ |
6275 int new_level= level + change; | |
6276 int score, new_coeff; | |
2967 | 6277 |
1777 | 6278 new_coeff= q*new_level; |
6279 if(new_coeff >= 2048 || new_coeff < 0) | |
6280 continue; | |
6281 | |
1784 | 6282 score= s->dsp.try_8x8basis(rem, weight, basis[0], new_coeff - old_coeff); |
1777 | 6283 if(score<best_score){ |
6284 best_score= score; | |
6285 best_coeff= 0; | |
6286 best_change= change; | |
6287 best_unquant_change= new_coeff - old_coeff; | |
6288 } | |
6289 } | |
6290 } | |
2967 | 6291 |
1777 | 6292 run=0; |
6293 rle_index=0; | |
6294 run2= run_tab[rle_index++]; | |
6295 prev_level=0; | |
6296 prev_run=0; | |
6297 | |
6298 for(i=start_i; i<64; i++){ | |
6299 int j= perm_scantable[i]; | |
6300 const int level= block[j]; | |
6301 int change, old_coeff; | |
6302 | |
6303 if(s->avctx->quantizer_noise_shaping < 3 && i > last_non_zero + 1) | |
6304 break; | |
6305 | |
6306 if(level){ | |
6307 if(level<0) old_coeff= qmul*level - qadd; | |
6308 else old_coeff= qmul*level + qadd; | |
6309 run2= run_tab[rle_index++]; //FIXME ! maybe after last | |
6310 }else{ | |
6311 old_coeff=0; | |
6312 run2--; | |
6313 assert(run2>=0 || i >= last_non_zero ); | |
6314 } | |
2967 | 6315 |
1777 | 6316 for(change=-1; change<=1; change+=2){ |
6317 int new_level= level + change; | |
6318 int score, new_coeff, unquant_change; | |
2967 | 6319 |
1777 | 6320 score=0; |
4001 | 6321 if(s->avctx->quantizer_noise_shaping < 2 && FFABS(new_level) > FFABS(level)) |
1777 | 6322 continue; |
6323 | |
6324 if(new_level){ | |
6325 if(new_level<0) new_coeff= qmul*new_level - qadd; | |
6326 else new_coeff= qmul*new_level + qadd; | |
6327 if(new_coeff >= 2048 || new_coeff <= -2048) | |
6328 continue; | |
6329 //FIXME check for overflow | |
2967 | 6330 |
1777 | 6331 if(level){ |
6332 if(level < 63 && level > -63){ | |
6333 if(i < last_non_zero) | |
6334 score += length[UNI_AC_ENC_INDEX(run, new_level+64)] | |
6335 - length[UNI_AC_ENC_INDEX(run, level+64)]; | |
6336 else | |
6337 score += last_length[UNI_AC_ENC_INDEX(run, new_level+64)] | |
6338 - last_length[UNI_AC_ENC_INDEX(run, level+64)]; | |
6339 } | |
6340 }else{ | |
4001 | 6341 assert(FFABS(new_level)==1); |
2967 | 6342 |
1785
14d918d0ef42
analyze the gradient of the error surface to avoid a few checks in the quantizing noise shaper
michael
parents:
1784
diff
changeset
|
6343 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
|
6344 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
|
6345 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
|
6346 continue; |
14d918d0ef42
analyze the gradient of the error surface to avoid a few checks in the quantizing noise shaper
michael
parents:
1784
diff
changeset
|
6347 } |
14d918d0ef42
analyze the gradient of the error surface to avoid a few checks in the quantizing noise shaper
michael
parents:
1784
diff
changeset
|
6348 |
1777 | 6349 if(i < last_non_zero){ |
6350 int next_i= i + run2 + 1; | |
6351 int next_level= block[ perm_scantable[next_i] ] + 64; | |
2967 | 6352 |
1777 | 6353 if(next_level&(~127)) |
6354 next_level= 0; | |
6355 | |
6356 if(next_i < last_non_zero) | |
6357 score += length[UNI_AC_ENC_INDEX(run, 65)] | |
6358 + length[UNI_AC_ENC_INDEX(run2, next_level)] | |
6359 - length[UNI_AC_ENC_INDEX(run + run2 + 1, next_level)]; | |
6360 else | |
6361 score += length[UNI_AC_ENC_INDEX(run, 65)] | |
6362 + last_length[UNI_AC_ENC_INDEX(run2, next_level)] | |
6363 - last_length[UNI_AC_ENC_INDEX(run + run2 + 1, next_level)]; | |
6364 }else{ | |
6365 score += last_length[UNI_AC_ENC_INDEX(run, 65)]; | |
6366 if(prev_level){ | |
6367 score += length[UNI_AC_ENC_INDEX(prev_run, prev_level)] | |
6368 - last_length[UNI_AC_ENC_INDEX(prev_run, prev_level)]; | |
6369 } | |
6370 } | |
6371 } | |
6372 }else{ | |
6373 new_coeff=0; | |
4001 | 6374 assert(FFABS(level)==1); |
1777 | 6375 |
6376 if(i < last_non_zero){ | |
6377 int next_i= i + run2 + 1; | |
6378 int next_level= block[ perm_scantable[next_i] ] + 64; | |
2967 | 6379 |
1777 | 6380 if(next_level&(~127)) |
6381 next_level= 0; | |
6382 | |
6383 if(next_i < last_non_zero) | |
6384 score += length[UNI_AC_ENC_INDEX(run + run2 + 1, next_level)] | |
6385 - length[UNI_AC_ENC_INDEX(run2, next_level)] | |
6386 - length[UNI_AC_ENC_INDEX(run, 65)]; | |
6387 else | |
6388 score += last_length[UNI_AC_ENC_INDEX(run + run2 + 1, next_level)] | |
6389 - last_length[UNI_AC_ENC_INDEX(run2, next_level)] | |
6390 - length[UNI_AC_ENC_INDEX(run, 65)]; | |
6391 }else{ | |
6392 score += -last_length[UNI_AC_ENC_INDEX(run, 65)]; | |
6393 if(prev_level){ | |
6394 score += last_length[UNI_AC_ENC_INDEX(prev_run, prev_level)] | |
6395 - length[UNI_AC_ENC_INDEX(prev_run, prev_level)]; | |
6396 } | |
6397 } | |
6398 } | |
2967 | 6399 |
1777 | 6400 score *= lambda; |
6401 | |
6402 unquant_change= new_coeff - old_coeff; | |
6403 assert((score < 100*lambda && score > -100*lambda) || lambda==0); | |
2967 | 6404 |
1784 | 6405 score+= s->dsp.try_8x8basis(rem, weight, basis[j], unquant_change); |
1777 | 6406 if(score<best_score){ |
6407 best_score= score; | |
6408 best_coeff= i; | |
6409 best_change= change; | |
6410 best_unquant_change= unquant_change; | |
6411 } | |
6412 } | |
6413 if(level){ | |
6414 prev_level= level + 64; | |
6415 if(prev_level&(~127)) | |
6416 prev_level= 0; | |
6417 prev_run= run; | |
6418 run=0; | |
6419 }else{ | |
6420 run++; | |
6421 } | |
6422 } | |
6423 #ifdef REFINE_STATS | |
6424 STOP_TIMER("iterative step")} | |
6425 #endif | |
6426 | |
6427 if(best_change){ | |
6428 int j= perm_scantable[ best_coeff ]; | |
2967 | 6429 |
1777 | 6430 block[j] += best_change; |
2967 | 6431 |
1777 | 6432 if(best_coeff > last_non_zero){ |
6433 last_non_zero= best_coeff; | |
6434 assert(block[j]); | |
6435 #ifdef REFINE_STATS | |
6436 after_last++; | |
6437 #endif | |
6438 }else{ | |
6439 #ifdef REFINE_STATS | |
6440 if(block[j]){ | |
6441 if(block[j] - best_change){ | |
4001 | 6442 if(FFABS(block[j]) > FFABS(block[j] - best_change)){ |
1777 | 6443 raise++; |
6444 }else{ | |
6445 lower++; | |
6446 } | |
6447 }else{ | |
6448 from_zero++; | |
6449 } | |
6450 }else{ | |
6451 to_zero++; | |
6452 } | |
6453 #endif | |
6454 for(; last_non_zero>=start_i; last_non_zero--){ | |
6455 if(block[perm_scantable[last_non_zero]]) | |
6456 break; | |
6457 } | |
6458 } | |
6459 #ifdef REFINE_STATS | |
6460 count++; | |
6461 if(256*256*256*64 % count == 0){ | |
6462 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); | |
6463 } | |
6464 #endif | |
6465 run=0; | |
6466 rle_index=0; | |
6467 for(i=start_i; i<=last_non_zero; i++){ | |
6468 int j= perm_scantable[i]; | |
6469 const int level= block[j]; | |
2967 | 6470 |
1777 | 6471 if(level){ |
6472 run_tab[rle_index++]=run; | |
6473 run=0; | |
6474 }else{ | |
6475 run++; | |
6476 } | |
6477 } | |
2967 | 6478 |
1784 | 6479 s->dsp.add_8x8basis(rem, basis[j], best_unquant_change); |
1777 | 6480 }else{ |
6481 break; | |
6482 } | |
6483 } | |
6484 #ifdef REFINE_STATS | |
6485 if(last_non_zero>0){ | |
6486 STOP_TIMER("iterative search") | |
6487 } | |
6488 } | |
6489 #endif | |
6490 | |
6491 return last_non_zero; | |
6492 } | |
6493 | |
2967 | 6494 static int dct_quantize_c(MpegEncContext *s, |
0 | 6495 DCTELEM *block, int n, |
344 | 6496 int qscale, int *overflow) |
0 | 6497 { |
1715 | 6498 int i, j, level, last_non_zero, q, start_i; |
0 | 6499 const int *qmat; |
1064 | 6500 const uint8_t *scantable= s->intra_scantable.scantable; |
344 | 6501 int bias; |
6502 int max=0; | |
6503 unsigned int threshold1, threshold2; | |
828
ace3ccd18dd2
Altivec Patch (Mark III) by (Dieter Shirley <dieters at schemasoft dot com>)
michaelni
parents:
815
diff
changeset
|
6504 |
1092 | 6505 s->dsp.fdct (block); |
0 | 6506 |
1597 | 6507 if(s->dct_error_sum) |
1719 | 6508 s->denoise_dct(s, block); |
1597 | 6509 |
0 | 6510 if (s->mb_intra) { |
350
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
347
diff
changeset
|
6511 if (!s->h263_aic) { |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
347
diff
changeset
|
6512 if (n < 4) |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
347
diff
changeset
|
6513 q = s->y_dc_scale; |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
347
diff
changeset
|
6514 else |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
347
diff
changeset
|
6515 q = s->c_dc_scale; |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
347
diff
changeset
|
6516 q = q << 3; |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
347
diff
changeset
|
6517 } else |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
347
diff
changeset
|
6518 /* 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
|
6519 q = 1 << 3; |
2967 | 6520 |
0 | 6521 /* note: block[0] is assumed to be positive */ |
6522 block[0] = (block[0] + (q >> 1)) / q; | |
1715 | 6523 start_i = 1; |
0 | 6524 last_non_zero = 0; |
344 | 6525 qmat = s->q_intra_matrix[qscale]; |
635 | 6526 bias= s->intra_quant_bias<<(QMAT_SHIFT - QUANT_BIAS_SHIFT); |
0 | 6527 } else { |
1715 | 6528 start_i = 0; |
0 | 6529 last_non_zero = -1; |
344 | 6530 qmat = s->q_inter_matrix[qscale]; |
635 | 6531 bias= s->inter_quant_bias<<(QMAT_SHIFT - QUANT_BIAS_SHIFT); |
0 | 6532 } |
635 | 6533 threshold1= (1<<QMAT_SHIFT) - bias - 1; |
6534 threshold2= (threshold1<<1); | |
1715 | 6535 for(i=63;i>=start_i;i--) { |
764 | 6536 j = scantable[i]; |
1715 | 6537 level = block[j] * qmat[j]; |
6538 | |
6539 if(((unsigned)(level+threshold1))>threshold2){ | |
6540 last_non_zero = i; | |
6541 break; | |
6542 }else{ | |
6543 block[j]=0; | |
6544 } | |
6545 } | |
6546 for(i=start_i; i<=last_non_zero; i++) { | |
6547 j = scantable[i]; | |
6548 level = block[j] * qmat[j]; | |
344 | 6549 |
1215 | 6550 // if( bias+level >= (1<<QMAT_SHIFT) |
6551 // || bias-level >= (1<<QMAT_SHIFT)){ | |
344 | 6552 if(((unsigned)(level+threshold1))>threshold2){ |
6553 if(level>0){ | |
635 | 6554 level= (bias + level)>>QMAT_SHIFT; |
344 | 6555 block[j]= level; |
6556 }else{ | |
635 | 6557 level= (bias - level)>>QMAT_SHIFT; |
344 | 6558 block[j]= -level; |
0 | 6559 } |
344 | 6560 max |=level; |
6561 }else{ | |
6562 block[j]=0; | |
0 | 6563 } |
6564 } | |
2627
bf158d23bbcc
Spelling errors patch by (Kevin Baragona | kevinmb500 gawab com)
michael
parents:
2620
diff
changeset
|
6565 *overflow= s->max_qcoeff < max; //overflow might have happened |
2967 | 6566 |
764 | 6567 /* we need this permutation so that we correct the IDCT, we only permute the !=0 elements */ |
1092 | 6568 if (s->dsp.idct_permutation_type != FF_NO_IDCT_PERM) |
2979 | 6569 ff_block_permute(block, s->dsp.idct_permutation, scantable, last_non_zero); |
764 | 6570 |
0 | 6571 return last_non_zero; |
6572 } | |
6573 | |
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
|
6574 #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
|
6575 |
2967 | 6576 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
|
6577 DCTELEM *block, int n, int qscale) |
0 | 6578 { |
200 | 6579 int i, level, nCoeffs; |
1064 | 6580 const uint16_t *quant_matrix; |
0 | 6581 |
706
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
6582 nCoeffs= s->block_last_index[n]; |
2967 | 6583 |
6584 if (n < 4) | |
1689 | 6585 block[0] = block[0] * s->y_dc_scale; |
6586 else | |
6587 block[0] = block[0] * s->c_dc_scale; | |
6588 /* XXX: only mpeg1 */ | |
6589 quant_matrix = s->intra_matrix; | |
6590 for(i=1;i<=nCoeffs;i++) { | |
6591 int j= s->intra_scantable.permutated[i]; | |
6592 level = block[j]; | |
6593 if (level) { | |
6594 if (level < 0) { | |
6595 level = -level; | |
6596 level = (int)(level * qscale * quant_matrix[j]) >> 3; | |
6597 level = (level - 1) | 1; | |
6598 level = -level; | |
6599 } else { | |
6600 level = (int)(level * qscale * quant_matrix[j]) >> 3; | |
6601 level = (level - 1) | 1; | |
0 | 6602 } |
1689 | 6603 block[j] = level; |
0 | 6604 } |
6605 } | |
6606 } | |
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
|
6607 |
2967 | 6608 static void dct_unquantize_mpeg1_inter_c(MpegEncContext *s, |
1689 | 6609 DCTELEM *block, int n, int qscale) |
6610 { | |
6611 int i, level, nCoeffs; | |
6612 const uint16_t *quant_matrix; | |
6613 | |
6614 nCoeffs= s->block_last_index[n]; | |
2967 | 6615 |
1689 | 6616 quant_matrix = s->inter_matrix; |
6617 for(i=0; i<=nCoeffs; i++) { | |
6618 int j= s->intra_scantable.permutated[i]; | |
6619 level = block[j]; | |
6620 if (level) { | |
6621 if (level < 0) { | |
6622 level = -level; | |
6623 level = (((level << 1) + 1) * qscale * | |
6624 ((int) (quant_matrix[j]))) >> 4; | |
6625 level = (level - 1) | 1; | |
6626 level = -level; | |
6627 } else { | |
6628 level = (((level << 1) + 1) * qscale * | |
6629 ((int) (quant_matrix[j]))) >> 4; | |
6630 level = (level - 1) | 1; | |
6631 } | |
6632 block[j] = level; | |
6633 } | |
6634 } | |
6635 } | |
6636 | |
2967 | 6637 static void dct_unquantize_mpeg2_intra_c(MpegEncContext *s, |
325 | 6638 DCTELEM *block, int n, int qscale) |
6639 { | |
6640 int i, level, nCoeffs; | |
1064 | 6641 const uint16_t *quant_matrix; |
325 | 6642 |
706
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
6643 if(s->alternate_scan) nCoeffs= 63; |
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
6644 else nCoeffs= s->block_last_index[n]; |
2967 | 6645 |
6646 if (n < 4) | |
1689 | 6647 block[0] = block[0] * s->y_dc_scale; |
6648 else | |
6649 block[0] = block[0] * s->c_dc_scale; | |
6650 quant_matrix = s->intra_matrix; | |
6651 for(i=1;i<=nCoeffs;i++) { | |
6652 int j= s->intra_scantable.permutated[i]; | |
6653 level = block[j]; | |
6654 if (level) { | |
6655 if (level < 0) { | |
6656 level = -level; | |
6657 level = (int)(level * qscale * quant_matrix[j]) >> 3; | |
6658 level = -level; | |
6659 } else { | |
6660 level = (int)(level * qscale * quant_matrix[j]) >> 3; | |
6661 } | |
6662 block[j] = level; | |
6663 } | |
6664 } | |
6665 } | |
6666 | |
3281
7fac25904a8b
missmatch control for mpeg2 intra dequantization if bitexact=1
michael
parents:
3268
diff
changeset
|
6667 static void dct_unquantize_mpeg2_intra_bitexact(MpegEncContext *s, |
7fac25904a8b
missmatch control for mpeg2 intra dequantization if bitexact=1
michael
parents:
3268
diff
changeset
|
6668 DCTELEM *block, int n, int qscale) |
7fac25904a8b
missmatch control for mpeg2 intra dequantization if bitexact=1
michael
parents:
3268
diff
changeset
|
6669 { |
7fac25904a8b
missmatch control for mpeg2 intra dequantization if bitexact=1
michael
parents:
3268
diff
changeset
|
6670 int i, level, nCoeffs; |
7fac25904a8b
missmatch control for mpeg2 intra dequantization if bitexact=1
michael
parents:
3268
diff
changeset
|
6671 const uint16_t *quant_matrix; |
7fac25904a8b
missmatch control for mpeg2 intra dequantization if bitexact=1
michael
parents:
3268
diff
changeset
|
6672 int sum=-1; |
7fac25904a8b
missmatch control for mpeg2 intra dequantization if bitexact=1
michael
parents:
3268
diff
changeset
|
6673 |
7fac25904a8b
missmatch control for mpeg2 intra dequantization if bitexact=1
michael
parents:
3268
diff
changeset
|
6674 if(s->alternate_scan) nCoeffs= 63; |
7fac25904a8b
missmatch control for mpeg2 intra dequantization if bitexact=1
michael
parents:
3268
diff
changeset
|
6675 else nCoeffs= s->block_last_index[n]; |
7fac25904a8b
missmatch control for mpeg2 intra dequantization if bitexact=1
michael
parents:
3268
diff
changeset
|
6676 |
7fac25904a8b
missmatch control for mpeg2 intra dequantization if bitexact=1
michael
parents:
3268
diff
changeset
|
6677 if (n < 4) |
7fac25904a8b
missmatch control for mpeg2 intra dequantization if bitexact=1
michael
parents:
3268
diff
changeset
|
6678 block[0] = block[0] * s->y_dc_scale; |
7fac25904a8b
missmatch control for mpeg2 intra dequantization if bitexact=1
michael
parents:
3268
diff
changeset
|
6679 else |
7fac25904a8b
missmatch control for mpeg2 intra dequantization if bitexact=1
michael
parents:
3268
diff
changeset
|
6680 block[0] = block[0] * s->c_dc_scale; |
7fac25904a8b
missmatch control for mpeg2 intra dequantization if bitexact=1
michael
parents:
3268
diff
changeset
|
6681 quant_matrix = s->intra_matrix; |
7fac25904a8b
missmatch control for mpeg2 intra dequantization if bitexact=1
michael
parents:
3268
diff
changeset
|
6682 for(i=1;i<=nCoeffs;i++) { |
7fac25904a8b
missmatch control for mpeg2 intra dequantization if bitexact=1
michael
parents:
3268
diff
changeset
|
6683 int j= s->intra_scantable.permutated[i]; |
7fac25904a8b
missmatch control for mpeg2 intra dequantization if bitexact=1
michael
parents:
3268
diff
changeset
|
6684 level = block[j]; |
7fac25904a8b
missmatch control for mpeg2 intra dequantization if bitexact=1
michael
parents:
3268
diff
changeset
|
6685 if (level) { |
7fac25904a8b
missmatch control for mpeg2 intra dequantization if bitexact=1
michael
parents:
3268
diff
changeset
|
6686 if (level < 0) { |
7fac25904a8b
missmatch control for mpeg2 intra dequantization if bitexact=1
michael
parents:
3268
diff
changeset
|
6687 level = -level; |
7fac25904a8b
missmatch control for mpeg2 intra dequantization if bitexact=1
michael
parents:
3268
diff
changeset
|
6688 level = (int)(level * qscale * quant_matrix[j]) >> 3; |
7fac25904a8b
missmatch control for mpeg2 intra dequantization if bitexact=1
michael
parents:
3268
diff
changeset
|
6689 level = -level; |
7fac25904a8b
missmatch control for mpeg2 intra dequantization if bitexact=1
michael
parents:
3268
diff
changeset
|
6690 } else { |
7fac25904a8b
missmatch control for mpeg2 intra dequantization if bitexact=1
michael
parents:
3268
diff
changeset
|
6691 level = (int)(level * qscale * quant_matrix[j]) >> 3; |
7fac25904a8b
missmatch control for mpeg2 intra dequantization if bitexact=1
michael
parents:
3268
diff
changeset
|
6692 } |
7fac25904a8b
missmatch control for mpeg2 intra dequantization if bitexact=1
michael
parents:
3268
diff
changeset
|
6693 block[j] = level; |
7fac25904a8b
missmatch control for mpeg2 intra dequantization if bitexact=1
michael
parents:
3268
diff
changeset
|
6694 sum+=level; |
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 } |
7fac25904a8b
missmatch control for mpeg2 intra dequantization if bitexact=1
michael
parents:
3268
diff
changeset
|
6697 block[63]^=sum&1; |
7fac25904a8b
missmatch control for mpeg2 intra dequantization if bitexact=1
michael
parents:
3268
diff
changeset
|
6698 } |
7fac25904a8b
missmatch control for mpeg2 intra dequantization if bitexact=1
michael
parents:
3268
diff
changeset
|
6699 |
2967 | 6700 static void dct_unquantize_mpeg2_inter_c(MpegEncContext *s, |
1689 | 6701 DCTELEM *block, int n, int qscale) |
6702 { | |
6703 int i, level, nCoeffs; | |
6704 const uint16_t *quant_matrix; | |
6705 int sum=-1; | |
6706 | |
6707 if(s->alternate_scan) nCoeffs= 63; | |
6708 else nCoeffs= s->block_last_index[n]; | |
2967 | 6709 |
1689 | 6710 quant_matrix = s->inter_matrix; |
6711 for(i=0; i<=nCoeffs; i++) { | |
6712 int j= s->intra_scantable.permutated[i]; | |
6713 level = block[j]; | |
6714 if (level) { | |
6715 if (level < 0) { | |
6716 level = -level; | |
6717 level = (((level << 1) + 1) * qscale * | |
6718 ((int) (quant_matrix[j]))) >> 4; | |
6719 level = -level; | |
6720 } else { | |
6721 level = (((level << 1) + 1) * qscale * | |
6722 ((int) (quant_matrix[j]))) >> 4; | |
6723 } | |
6724 block[j] = level; | |
6725 sum+=level; | |
6726 } | |
6727 } | |
6728 block[63]^=sum&1; | |
6729 } | |
6730 | |
2967 | 6731 static void dct_unquantize_h263_intra_c(MpegEncContext *s, |
1689 | 6732 DCTELEM *block, int n, int qscale) |
6733 { | |
6734 int i, level, qmul, qadd; | |
6735 int nCoeffs; | |
2967 | 6736 |
1689 | 6737 assert(s->block_last_index[n]>=0); |
2967 | 6738 |
1689 | 6739 qmul = qscale << 1; |
2967 | 6740 |
1689 | 6741 if (!s->h263_aic) { |
2967 | 6742 if (n < 4) |
325 | 6743 block[0] = block[0] * s->y_dc_scale; |
6744 else | |
6745 block[0] = block[0] * s->c_dc_scale; | |
1689 | 6746 qadd = (qscale - 1) | 1; |
6747 }else{ | |
6748 qadd = 0; | |
6749 } | |
6750 if(s->ac_pred) | |
6751 nCoeffs=63; | |
6752 else | |
6753 nCoeffs= s->inter_scantable.raster_end[ s->block_last_index[n] ]; | |
6754 | |
6755 for(i=1; i<=nCoeffs; i++) { | |
6756 level = block[i]; | |
6757 if (level) { | |
6758 if (level < 0) { | |
6759 level = level * qmul - qadd; | |
6760 } else { | |
6761 level = level * qmul + qadd; | |
325 | 6762 } |
1689 | 6763 block[i] = level; |
325 | 6764 } |
6765 } | |
6766 } | |
6767 | |
2967 | 6768 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
|
6769 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
|
6770 { |
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
|
6771 int i, level, qmul, qadd; |
200 | 6772 int nCoeffs; |
2967 | 6773 |
706
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
6774 assert(s->block_last_index[n]>=0); |
2967 | 6775 |
706
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
6776 qadd = (qscale - 1) | 1; |
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
6777 qmul = qscale << 1; |
2967 | 6778 |
1689 | 6779 nCoeffs= s->inter_scantable.raster_end[ s->block_last_index[n] ]; |
6780 | |
6781 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
|
6782 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
|
6783 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
|
6784 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
|
6785 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
|
6786 } 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
|
6787 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
|
6788 } |
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
|
6789 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
|
6790 } |
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
|
6791 } |
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
|
6792 } |
0 | 6793 |
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
|
6794 #ifdef CONFIG_ENCODERS |
0 | 6795 AVCodec h263_encoder = { |
6796 "h263", | |
6797 CODEC_TYPE_VIDEO, | |
6798 CODEC_ID_H263, | |
6799 sizeof(MpegEncContext), | |
6800 MPV_encode_init, | |
6801 MPV_encode_picture, | |
6802 MPV_encode_end, | |
2524 | 6803 .pix_fmts= (enum PixelFormat[]){PIX_FMT_YUV420P, -1}, |
0 | 6804 }; |
6805 | |
6806 AVCodec h263p_encoder = { | |
6807 "h263p", | |
6808 CODEC_TYPE_VIDEO, | |
6809 CODEC_ID_H263P, | |
6810 sizeof(MpegEncContext), | |
6811 MPV_encode_init, | |
6812 MPV_encode_picture, | |
6813 MPV_encode_end, | |
2524 | 6814 .pix_fmts= (enum PixelFormat[]){PIX_FMT_YUV420P, -1}, |
0 | 6815 }; |
6816 | |
1353
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1344
diff
changeset
|
6817 AVCodec flv_encoder = { |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1344
diff
changeset
|
6818 "flv", |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1344
diff
changeset
|
6819 CODEC_TYPE_VIDEO, |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1344
diff
changeset
|
6820 CODEC_ID_FLV1, |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1344
diff
changeset
|
6821 sizeof(MpegEncContext), |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1344
diff
changeset
|
6822 MPV_encode_init, |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1344
diff
changeset
|
6823 MPV_encode_picture, |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1344
diff
changeset
|
6824 MPV_encode_end, |
2524 | 6825 .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
|
6826 }; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1344
diff
changeset
|
6827 |
0 | 6828 AVCodec rv10_encoder = { |
6829 "rv10", | |
6830 CODEC_TYPE_VIDEO, | |
6831 CODEC_ID_RV10, | |
6832 sizeof(MpegEncContext), | |
6833 MPV_encode_init, | |
6834 MPV_encode_picture, | |
6835 MPV_encode_end, | |
2524 | 6836 .pix_fmts= (enum PixelFormat[]){PIX_FMT_YUV420P, -1}, |
0 | 6837 }; |
6838 | |
2380 | 6839 AVCodec rv20_encoder = { |
6840 "rv20", | |
6841 CODEC_TYPE_VIDEO, | |
6842 CODEC_ID_RV20, | |
6843 sizeof(MpegEncContext), | |
6844 MPV_encode_init, | |
6845 MPV_encode_picture, | |
6846 MPV_encode_end, | |
2524 | 6847 .pix_fmts= (enum PixelFormat[]){PIX_FMT_YUV420P, -1}, |
2380 | 6848 }; |
6849 | |
71 | 6850 AVCodec mpeg4_encoder = { |
6851 "mpeg4", | |
0 | 6852 CODEC_TYPE_VIDEO, |
71 | 6853 CODEC_ID_MPEG4, |
0 | 6854 sizeof(MpegEncContext), |
6855 MPV_encode_init, | |
6856 MPV_encode_picture, | |
6857 MPV_encode_end, | |
2524 | 6858 .pix_fmts= (enum PixelFormat[]){PIX_FMT_YUV420P, -1}, |
2111 | 6859 .capabilities= CODEC_CAP_DELAY, |
0 | 6860 }; |
6861 | |
307 | 6862 AVCodec msmpeg4v1_encoder = { |
6863 "msmpeg4v1", | |
0 | 6864 CODEC_TYPE_VIDEO, |
307 | 6865 CODEC_ID_MSMPEG4V1, |
0 | 6866 sizeof(MpegEncContext), |
6867 MPV_encode_init, | |
6868 MPV_encode_picture, | |
6869 MPV_encode_end, | |
2524 | 6870 .pix_fmts= (enum PixelFormat[]){PIX_FMT_YUV420P, -1}, |
0 | 6871 }; |
307 | 6872 |
6873 AVCodec msmpeg4v2_encoder = { | |
6874 "msmpeg4v2", | |
6875 CODEC_TYPE_VIDEO, | |
6876 CODEC_ID_MSMPEG4V2, | |
6877 sizeof(MpegEncContext), | |
6878 MPV_encode_init, | |
6879 MPV_encode_picture, | |
6880 MPV_encode_end, | |
2524 | 6881 .pix_fmts= (enum PixelFormat[]){PIX_FMT_YUV420P, -1}, |
307 | 6882 }; |
6883 | |
6884 AVCodec msmpeg4v3_encoder = { | |
6885 "msmpeg4", | |
6886 CODEC_TYPE_VIDEO, | |
6887 CODEC_ID_MSMPEG4V3, | |
6888 sizeof(MpegEncContext), | |
6889 MPV_encode_init, | |
6890 MPV_encode_picture, | |
6891 MPV_encode_end, | |
2524 | 6892 .pix_fmts= (enum PixelFormat[]){PIX_FMT_YUV420P, -1}, |
307 | 6893 }; |
499 | 6894 |
6895 AVCodec wmv1_encoder = { | |
6896 "wmv1", | |
6897 CODEC_TYPE_VIDEO, | |
6898 CODEC_ID_WMV1, | |
6899 sizeof(MpegEncContext), | |
6900 MPV_encode_init, | |
6901 MPV_encode_picture, | |
6902 MPV_encode_end, | |
2524 | 6903 .pix_fmts= (enum PixelFormat[]){PIX_FMT_YUV420P, -1}, |
499 | 6904 }; |
6905 | |
1042 | 6906 AVCodec mjpeg_encoder = { |
6907 "mjpeg", | |
6908 CODEC_TYPE_VIDEO, | |
6909 CODEC_ID_MJPEG, | |
6910 sizeof(MpegEncContext), | |
6911 MPV_encode_init, | |
6912 MPV_encode_picture, | |
6913 MPV_encode_end, | |
3929 | 6914 .pix_fmts= (enum PixelFormat[]){PIX_FMT_YUVJ420P, PIX_FMT_YUVJ422P, -1}, |
1042 | 6915 }; |
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
|
6916 |
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
|
6917 #endif //CONFIG_ENCODERS |