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