Mercurial > libavcodec.hg
annotate mpegvideo.c @ 1757:3906ddbaffec libavcodec
optimization & bugfix extracted from the 4k line diff between ffmpeg 0.4.7 and http://www.alicestreet.com/ffh263.html
the other parts of the diff where
1. spelling fixes (rejected as only a small part of it could be applied automatically)
2. cosmetics (reindention, function reordering, var renaming, ...) with bugs (rejected)
3. rtp related stuff (rejetced as it breaks several codecs)
4. some changes to the intra/inter decission & scene change detection (quality tests needed first)
author | michael |
---|---|
date | Sat, 24 Jan 2004 23:47:33 +0000 |
parents | bdf3927bf8c5 |
children | ebe7fa49ddcc |
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 | |
1021
2d7c9f5738de
trying to fix mb skip bug in mpeg1/2 if slices are not used
michaelni
parents:
1014
diff
changeset
|
28 #include <limits.h> |
0 | 29 #include "avcodec.h" |
30 #include "dsputil.h" | |
31 #include "mpegvideo.h" | |
1557 | 32 #include "faandct.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); |
1389 | 60 static int sse_mb(MpegEncContext *s); |
1719 | 61 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
|
62 #endif //CONFIG_ENCODERS |
206 | 63 |
1381 | 64 #ifdef HAVE_XVMC |
65 extern int XVMC_field_start(MpegEncContext*s, AVCodecContext *avctx); | |
66 extern void XVMC_field_end(MpegEncContext *s); | |
1580
628bf341e099
XvMC speedup by removing one memcpy and doing MB packing
iive
parents:
1579
diff
changeset
|
67 extern void XVMC_decode_mb(MpegEncContext *s); |
1381 | 68 #endif |
69 | |
1064 | 70 void (*draw_edges)(uint8_t *buf, int wrap, int width, int height, int w)= draw_edges_c; |
206 | 71 |
0 | 72 |
73 /* enable all paranoid tests for rounding, overflows, etc... */ | |
74 //#define PARANOID | |
75 | |
76 //#define DEBUG | |
77 | |
321 | 78 |
0 | 79 /* for jpeg fast DCT */ |
80 #define CONST_BITS 14 | |
81 | |
853
eacc2dd8fd9d
* using DSPContext - so each codec could use its local (sub)set of CPU extension
kabi
parents:
847
diff
changeset
|
82 static const uint16_t aanscales[64] = { |
0 | 83 /* precomputed values scaled up by 14 bits */ |
84 16384, 22725, 21407, 19266, 16384, 12873, 8867, 4520, | |
85 22725, 31521, 29692, 26722, 22725, 17855, 12299, 6270, | |
86 21407, 29692, 27969, 25172, 21407, 16819, 11585, 5906, | |
87 19266, 26722, 25172, 22654, 19266, 15137, 10426, 5315, | |
88 16384, 22725, 21407, 19266, 16384, 12873, 8867, 4520, | |
89 12873, 17855, 16819, 15137, 12873, 10114, 6967, 3552, | |
936 | 90 8867 , 12299, 11585, 10426, 8867, 6967, 4799, 2446, |
91 4520 , 6270, 5906, 5315, 4520, 3552, 2446, 1247 | |
0 | 92 }; |
93 | |
853
eacc2dd8fd9d
* using DSPContext - so each codec could use its local (sub)set of CPU extension
kabi
parents:
847
diff
changeset
|
94 static const uint8_t h263_chroma_roundtab[16] = { |
1013 | 95 // 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
0 | 96 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, |
97 }; | |
98 | |
1644 | 99 static const uint8_t ff_default_chroma_qscale_table[32]={ |
100 // 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 | |
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 }; | |
103 | |
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
|
104 #ifdef CONFIG_ENCODERS |
1162 | 105 static uint8_t (*default_mv_penalty)[MAX_MV*2+1]=NULL; |
1064 | 106 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
|
107 |
998 | 108 enum PixelFormat ff_yuv420p_list[2]= {PIX_FMT_YUV420P, -1}; |
109 | |
1579
039cb2296de2
make convert_matrix() independant of MpegEncContext
michael
parents:
1573
diff
changeset
|
110 static void convert_matrix(DSPContext *dsp, int (*qmat)[64], uint16_t (*qmat16)[2][64], |
1064 | 111 const uint16_t *quant_matrix, int bias, int qmin, int qmax) |
0 | 112 { |
344 | 113 int qscale; |
0 | 114 |
709
afeff6ccb7f5
convert only needed matrixes in convert_matrix() (mjpeg calls it for every frame)
michaelni
parents:
706
diff
changeset
|
115 for(qscale=qmin; qscale<=qmax; qscale++){ |
344 | 116 int i; |
1579
039cb2296de2
make convert_matrix() independant of MpegEncContext
michael
parents:
1573
diff
changeset
|
117 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
|
118 #ifdef FAAN_POSTSCALE |
1579
039cb2296de2
make convert_matrix() independant of MpegEncContext
michael
parents:
1573
diff
changeset
|
119 || dsp->fdct == ff_faandct |
1562
bf452704100f
optionally merge postscale into quantization table for the float aan dct
michael
parents:
1557
diff
changeset
|
120 #endif |
bf452704100f
optionally merge postscale into quantization table for the float aan dct
michael
parents:
1557
diff
changeset
|
121 ) { |
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
|
122 for(i=0;i<64;i++) { |
1579
039cb2296de2
make convert_matrix() independant of MpegEncContext
michael
parents:
1573
diff
changeset
|
123 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
|
124 /* 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
|
125 /* 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
|
126 /* (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
|
127 /* 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
|
128 |
1064 | 129 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
|
130 (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
|
131 } |
1579
039cb2296de2
make convert_matrix() independant of MpegEncContext
michael
parents:
1573
diff
changeset
|
132 } else if (dsp->fdct == fdct_ifast |
1562
bf452704100f
optionally merge postscale into quantization table for the float aan dct
michael
parents:
1557
diff
changeset
|
133 #ifndef FAAN_POSTSCALE |
1579
039cb2296de2
make convert_matrix() independant of MpegEncContext
michael
parents:
1573
diff
changeset
|
134 || dsp->fdct == ff_faandct |
1562
bf452704100f
optionally merge postscale into quantization table for the float aan dct
michael
parents:
1557
diff
changeset
|
135 #endif |
bf452704100f
optionally merge postscale into quantization table for the float aan dct
michael
parents:
1557
diff
changeset
|
136 ) { |
344 | 137 for(i=0;i<64;i++) { |
1579
039cb2296de2
make convert_matrix() independant of MpegEncContext
michael
parents:
1573
diff
changeset
|
138 const int j= dsp->idct_permutation[i]; |
344 | 139 /* 16 <= qscale * quant_matrix[i] <= 7905 */ |
140 /* 19952 <= aanscales[i] * qscale * quant_matrix[i] <= 249205026 */ | |
141 /* (1<<36)/19952 >= (1<<36)/(aanscales[i] * qscale * quant_matrix[i]) >= (1<<36)/249205026 */ | |
142 /* 3444240 >= (1<<36)/(aanscales[i] * qscale * quant_matrix[i]) >= 275 */ | |
143 | |
1064 | 144 qmat[qscale][i] = (int)((uint64_t_C(1) << (QMAT_SHIFT + 14)) / |
344 | 145 (aanscales[i] * qscale * quant_matrix[j])); |
146 } | |
147 } else { | |
148 for(i=0;i<64;i++) { | |
1579
039cb2296de2
make convert_matrix() independant of MpegEncContext
michael
parents:
1573
diff
changeset
|
149 const int j= dsp->idct_permutation[i]; |
344 | 150 /* We can safely suppose that 16 <= quant_matrix[i] <= 255 |
151 So 16 <= qscale * quant_matrix[i] <= 7905 | |
152 so (1<<19) / 16 >= (1<<19) / (qscale * quant_matrix[i]) >= (1<<19) / 7905 | |
153 so 32768 >= (1<<19) / (qscale * quant_matrix[i]) >= 67 | |
154 */ | |
1064 | 155 qmat[qscale][i] = (int)((uint64_t_C(1) << QMAT_SHIFT) / (qscale * quant_matrix[j])); |
945 | 156 // 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
|
157 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
|
158 |
d736e24bf303
move mmx quantizer matrixes out of MpegEncContext (23k -> 7k) (no meassureable slowdown)
michael
parents:
1553
diff
changeset
|
159 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
|
160 qmat16[qscale][1][i]= ROUNDED_DIV(bias<<(16-QUANT_BIAS_SHIFT), qmat16[qscale][0][i]); |
344 | 161 } |
0 | 162 } |
163 } | |
164 } | |
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
|
165 |
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
|
166 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
|
167 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
|
168 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
|
169 |
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
|
170 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
|
171 } |
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
|
172 #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
|
173 |
1273 | 174 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
|
175 int i; |
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
176 int end; |
764 | 177 |
178 st->scantable= src_scantable; | |
706
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
179 |
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
180 for(i=0; i<64; i++){ |
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
181 int j; |
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
182 j = src_scantable[i]; |
1273 | 183 st->permutated[i] = permutation[j]; |
828
ace3ccd18dd2
Altivec Patch (Mark III) by (Dieter Shirley <dieters at schemasoft dot com>)
michaelni
parents:
815
diff
changeset
|
184 #ifdef ARCH_POWERPC |
ace3ccd18dd2
Altivec Patch (Mark III) by (Dieter Shirley <dieters at schemasoft dot com>)
michaelni
parents:
815
diff
changeset
|
185 st->inverse[j] = i; |
ace3ccd18dd2
Altivec Patch (Mark III) by (Dieter Shirley <dieters at schemasoft dot com>)
michaelni
parents:
815
diff
changeset
|
186 #endif |
706
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
187 } |
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
188 |
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
189 end=-1; |
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
190 for(i=0; i<64; i++){ |
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
191 int j; |
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
192 j = st->permutated[i]; |
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
193 if(j>end) end=j; |
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
194 st->raster_end[i]= end; |
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
195 } |
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
196 } |
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
197 |
1530
3b31998fe22f
disable encoders where appropriate (patch courtesy of BERO
melanson
parents:
1523
diff
changeset
|
198 #ifdef CONFIG_ENCODERS |
1411 | 199 void ff_write_quant_matrix(PutBitContext *pb, int16_t *matrix){ |
200 int i; | |
201 | |
202 if(matrix){ | |
203 put_bits(pb, 1, 1); | |
204 for(i=0;i<64;i++) { | |
205 put_bits(pb, 8, matrix[ ff_zigzag_direct[i] ]); | |
206 } | |
207 }else | |
208 put_bits(pb, 1, 0); | |
209 } | |
1530
3b31998fe22f
disable encoders where appropriate (patch courtesy of BERO
melanson
parents:
1523
diff
changeset
|
210 #endif //CONFIG_ENCODERS |
1411 | 211 |
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
|
212 /* 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
|
213 int DCT_common_init(MpegEncContext *s) |
0 | 214 { |
1689 | 215 s->dct_unquantize_h263_intra = dct_unquantize_h263_intra_c; |
216 s->dct_unquantize_h263_inter = dct_unquantize_h263_inter_c; | |
217 s->dct_unquantize_mpeg1_intra = dct_unquantize_mpeg1_intra_c; | |
218 s->dct_unquantize_mpeg1_inter = dct_unquantize_mpeg1_inter_c; | |
219 s->dct_unquantize_mpeg2_intra = dct_unquantize_mpeg2_intra_c; | |
220 s->dct_unquantize_mpeg2_inter = dct_unquantize_mpeg2_inter_c; | |
1092 | 221 |
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
|
222 #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
|
223 s->dct_quantize= dct_quantize_c; |
1719 | 224 s->denoise_dct= denoise_dct_c; |
1092 | 225 #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
|
226 |
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
|
227 #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
|
228 MPV_common_init_mmx(s); |
8 | 229 #endif |
514
c9f724e3a797
Update and activate dct_unquantize_h263_mvi. Thanks to M«©ns Rullg«©rd
mellum
parents:
506
diff
changeset
|
230 #ifdef ARCH_ALPHA |
c9f724e3a797
Update and activate dct_unquantize_h263_mvi. Thanks to M«©ns Rullg«©rd
mellum
parents:
506
diff
changeset
|
231 MPV_common_init_axp(s); |
c9f724e3a797
Update and activate dct_unquantize_h263_mvi. Thanks to M«©ns Rullg«©rd
mellum
parents:
506
diff
changeset
|
232 #endif |
628
f596db4aa871
sun solaris compilation bugfix, patch by (Martin Olschewski <olschewski at zpr dot uni-koeln dot de>)
michaelni
parents:
625
diff
changeset
|
233 #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
|
234 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
|
235 #endif |
721
71f669e9f633
ps2 optimizations update patch by (Leon van Stuivenberg <leonvs at iae dot nl>)
michaelni
parents:
717
diff
changeset
|
236 #ifdef HAVE_MMI |
71f669e9f633
ps2 optimizations update patch by (Leon van Stuivenberg <leonvs at iae dot nl>)
michaelni
parents:
717
diff
changeset
|
237 MPV_common_init_mmi(s); |
71f669e9f633
ps2 optimizations update patch by (Leon van Stuivenberg <leonvs at iae dot nl>)
michaelni
parents:
717
diff
changeset
|
238 #endif |
730 | 239 #ifdef ARCH_ARMV4L |
874 | 240 MPV_common_init_armv4l(s); |
730 | 241 #endif |
828
ace3ccd18dd2
Altivec Patch (Mark III) by (Dieter Shirley <dieters at schemasoft dot com>)
michaelni
parents:
815
diff
changeset
|
242 #ifdef ARCH_POWERPC |
ace3ccd18dd2
Altivec Patch (Mark III) by (Dieter Shirley <dieters at schemasoft dot com>)
michaelni
parents:
815
diff
changeset
|
243 MPV_common_init_ppc(s); |
ace3ccd18dd2
Altivec Patch (Mark III) by (Dieter Shirley <dieters at schemasoft dot com>)
michaelni
parents:
815
diff
changeset
|
244 #endif |
730 | 245 |
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
|
246 #ifdef CONFIG_ENCODERS |
1007 | 247 s->fast_dct_quantize= s->dct_quantize; |
248 | |
945 | 249 if(s->flags&CODEC_FLAG_TRELLIS_QUANT){ |
250 s->dct_quantize= dct_quantize_trellis_c; //move before MPV_common_init_* | |
251 } | |
252 | |
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
|
253 #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
|
254 |
706
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
255 /* load & permutate scantables |
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
256 note: only wmv uses differnt ones |
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
257 */ |
1708 | 258 if(s->alternate_scan){ |
259 ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable , ff_alternate_vertical_scan); | |
260 ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable , ff_alternate_vertical_scan); | |
261 }else{ | |
262 ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable , ff_zigzag_direct); | |
263 ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable , ff_zigzag_direct); | |
264 } | |
1273 | 265 ff_init_scantable(s->dsp.idct_permutation, &s->intra_h_scantable, ff_alternate_horizontal_scan); |
266 ff_init_scantable(s->dsp.idct_permutation, &s->intra_v_scantable, ff_alternate_vertical_scan); | |
591 | 267 |
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
|
268 s->picture_structure= PICT_FRAME; |
5e6e505d8997
field picture decoding support (16x16 MC blocks only as i dont have any samples which use other modes ...)
michaelni
parents:
1095
diff
changeset
|
269 |
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
|
270 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
|
271 } |
a91203b34e71
moved dct init out from mpv_common_init to dct_common_init (for less-uglier way for dv)
al3x
parents:
721
diff
changeset
|
272 |
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
|
273 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
|
274 *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
|
275 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
|
276 } |
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
|
277 |
1702 | 278 static void copy_picture_attributes(AVFrame *dst, AVFrame *src){ |
279 dst->pict_type = src->pict_type; | |
280 dst->quality = src->quality; | |
281 dst->coded_picture_number = src->coded_picture_number; | |
282 dst->display_picture_number = src->display_picture_number; | |
283 // dst->reference = src->reference; | |
284 dst->pts = src->pts; | |
285 dst->interlaced_frame = src->interlaced_frame; | |
286 dst->top_field_first = src->top_field_first; | |
287 } | |
288 | |
903 | 289 /** |
924 | 290 * allocates a Picture |
291 * The pixels are allocated/set by calling get_buffer() if shared=0 | |
903 | 292 */ |
924 | 293 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
|
294 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
|
295 const int mb_array_size= s->mb_stride*s->mb_height; |
1655 | 296 const int b8_array_size= s->b8_stride*s->mb_height*2; |
297 const int b4_array_size= s->b4_stride*s->mb_height*4; | |
1168 | 298 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
|
299 |
924 | 300 if(shared){ |
301 assert(pic->data[0]); | |
302 assert(pic->type == 0 || pic->type == FF_BUFFER_TYPE_SHARED); | |
303 pic->type= FF_BUFFER_TYPE_SHARED; | |
304 }else{ | |
305 int r; | |
306 | |
307 assert(!pic->data[0]); | |
308 | |
925 | 309 r= s->avctx->get_buffer(s->avctx, (AVFrame*)pic); |
924 | 310 |
311 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
|
312 av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed (%d %d %d %p)\n", r, pic->age, pic->type, pic->data[0]); |
924 | 313 return -1; |
314 } | |
315 | |
316 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
|
317 av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed (stride changed)\n"); |
924 | 318 return -1; |
319 } | |
320 | |
321 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
|
322 av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed (uv stride missmatch)\n"); |
924 | 323 return -1; |
324 } | |
325 | |
326 s->linesize = pic->linesize[0]; | |
327 s->uvlinesize= pic->linesize[1]; | |
903 | 328 } |
924 | 329 |
330 if(pic->qscale_table==NULL){ | |
331 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
|
332 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
|
333 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
|
334 CHECKED_ALLOCZ(pic->mb_mean , mb_array_size * sizeof(int8_t)) |
924 | 335 } |
336 | |
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
|
337 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
|
338 CHECKED_ALLOCZ(pic->qscale_table , mb_array_size * sizeof(uint8_t)) |
1742 | 339 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
|
340 pic->mb_type= pic->mb_type_base + s->mb_stride+1; |
1168 | 341 if(s->out_format == FMT_H264){ |
342 for(i=0; i<2; i++){ | |
1742 | 343 CHECKED_ALLOCZ(pic->motion_val_base[i], 2 * (b4_array_size+1) * sizeof(int16_t)) |
1655 | 344 pic->motion_val[i]= pic->motion_val_base[i]+1; |
345 CHECKED_ALLOCZ(pic->ref_index[i] , b8_array_size * sizeof(uint8_t)) | |
346 } | |
1669 | 347 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
|
348 }else if(s->out_format == FMT_H263 || s->encoding || (s->avctx->debug&FF_DEBUG_MV) || (s->avctx->debug_mv)){ |
1655 | 349 for(i=0; i<2; i++){ |
1742 | 350 CHECKED_ALLOCZ(pic->motion_val_base[i], 2 * (b8_array_size+1) * sizeof(int16_t)*2) //FIXME |
1655 | 351 pic->motion_val[i]= pic->motion_val_base[i]+1; |
1168 | 352 } |
1669 | 353 pic->motion_subsample_log2= 3; |
1168 | 354 } |
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
|
355 pic->qstride= s->mb_stride; |
1546 | 356 CHECKED_ALLOCZ(pic->pan_scan , 1 * sizeof(AVPanScan)) |
924 | 357 } |
1168 | 358 |
1021
2d7c9f5738de
trying to fix mb skip bug in mpeg1/2 if slices are not used
michaelni
parents:
1014
diff
changeset
|
359 //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
|
360 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
|
361 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
|
362 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
|
363 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
|
364 |
903 | 365 return 0; |
366 fail: //for the CHECKED_ALLOCZ macro | |
367 return -1; | |
368 } | |
369 | |
924 | 370 /** |
371 * deallocates a picture | |
372 */ | |
903 | 373 static void free_picture(MpegEncContext *s, Picture *pic){ |
374 int i; | |
924 | 375 |
376 if(pic->data[0] && pic->type!=FF_BUFFER_TYPE_SHARED){ | |
925 | 377 s->avctx->release_buffer(s->avctx, (AVFrame*)pic); |
924 | 378 } |
379 | |
903 | 380 av_freep(&pic->mb_var); |
381 av_freep(&pic->mc_mb_var); | |
382 av_freep(&pic->mb_mean); | |
383 av_freep(&pic->mbskip_table); | |
384 av_freep(&pic->qscale_table); | |
1168 | 385 av_freep(&pic->mb_type_base); |
1546 | 386 av_freep(&pic->pan_scan); |
1168 | 387 pic->mb_type= NULL; |
388 for(i=0; i<2; i++){ | |
1655 | 389 av_freep(&pic->motion_val_base[i]); |
1168 | 390 av_freep(&pic->ref_index[i]); |
391 } | |
1214 | 392 |
393 if(pic->type == FF_BUFFER_TYPE_SHARED){ | |
924 | 394 for(i=0; i<4; i++){ |
395 pic->base[i]= | |
396 pic->data[i]= NULL; | |
397 } | |
398 pic->type= 0; | |
903 | 399 } |
400 } | |
401 | |
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
|
402 /* init common structure 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
|
403 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
|
404 { |
1708 | 405 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
|
406 |
1092 | 407 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
|
408 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
|
409 |
754 | 410 s->flags= s->avctx->flags; |
1754
bdf3927bf8c5
closed gop support & flags2 as all bits in flags are used
michael
parents:
1751
diff
changeset
|
411 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
|
412 |
903 | 413 s->mb_width = (s->width + 15) / 16; |
0 | 414 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
|
415 s->mb_stride = s->mb_width + 1; |
1655 | 416 s->b8_stride = s->mb_width*2 + 1; |
417 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
|
418 mb_array_size= s->mb_height * s->mb_stride; |
1708 | 419 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
|
420 |
eacc2dd8fd9d
* using DSPContext - so each codec could use its local (sub)set of CPU extension
kabi
parents:
847
diff
changeset
|
421 /* 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
|
422 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
|
423 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
|
424 |
eacc2dd8fd9d
* using DSPContext - so each codec could use its local (sub)set of CPU extension
kabi
parents:
847
diff
changeset
|
425 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
|
426 |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1173
diff
changeset
|
427 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
|
428 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
|
429 s->block_wrap[2]= |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1173
diff
changeset
|
430 s->block_wrap[3]= s->mb_width*2 + 2; |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1173
diff
changeset
|
431 s->block_wrap[4]= |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1173
diff
changeset
|
432 s->block_wrap[5]= s->mb_width + 2; |
853
eacc2dd8fd9d
* using DSPContext - so each codec could use its local (sub)set of CPU extension
kabi
parents:
847
diff
changeset
|
433 |
1644 | 434 s->y_dc_scale_table= |
435 s->c_dc_scale_table= ff_mpeg1_dc_scale_table; | |
1659 | 436 s->chroma_qscale_table= ff_default_chroma_qscale_table; |
1676 | 437 if (!s->encoding) |
438 s->progressive_sequence= 1; | |
1659 | 439 s->progressive_frame= 1; |
1705 | 440 s->coded_picture_number = 0; |
1676 | 441 |
756 | 442 y_size = (2 * s->mb_width + 2) * (2 * s->mb_height + 2); |
443 c_size = (s->mb_width + 2) * (s->mb_height + 2); | |
444 yc_size = y_size + 2 * c_size; | |
853
eacc2dd8fd9d
* using DSPContext - so each codec could use its local (sub)set of CPU extension
kabi
parents:
847
diff
changeset
|
445 |
701 | 446 /* convert fourcc to upper case */ |
1116 | 447 s->avctx->codec_tag= toupper( s->avctx->codec_tag &0xFF) |
448 + (toupper((s->avctx->codec_tag>>8 )&0xFF)<<8 ) | |
449 + (toupper((s->avctx->codec_tag>>16)&0xFF)<<16) | |
450 + (toupper((s->avctx->codec_tag>>24)&0xFF)<<24); | |
582
5132a4ee50cd
different edge positions fixed with edge emu / dr1
michaelni
parents:
575
diff
changeset
|
451 |
1458
40b69d238beb
AVI stream header FCC / more reliable detection of old xvid files
michaelni
parents:
1451
diff
changeset
|
452 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
|
453 + (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
|
454 + (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
|
455 + (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
|
456 |
956
45bd748e305f
negative linesize support (so mplayer -flip works)
michaelni
parents:
955
diff
changeset
|
457 CHECKED_ALLOCZ(s->allocated_edge_emu_buffer, (s->width+64)*2*17*2); //(width + edge + align)*interlaced*MBsize*tolerance |
45bd748e305f
negative linesize support (so mplayer -flip works)
michaelni
parents:
955
diff
changeset
|
458 s->edge_emu_buffer= s->allocated_edge_emu_buffer + (s->width+64)*2*17; |
903 | 459 |
925 | 460 s->avctx->coded_frame= (AVFrame*)&s->current_picture; |
903 | 461 |
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
|
462 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
|
463 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
|
464 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
|
465 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
|
466 } |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1173
diff
changeset
|
467 } |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1173
diff
changeset
|
468 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
|
469 |
232
b640ec5948b0
- Now the ME is done for the entire picture when enconding, the
pulento
parents:
231
diff
changeset
|
470 if (s->encoding) { |
324 | 471 /* 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
|
472 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
|
473 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
|
474 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
|
475 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
|
476 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
|
477 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
|
478 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
|
479 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
|
480 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
|
481 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
|
482 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
|
483 s->b_direct_mv_table = s->b_direct_mv_table_base + s->mb_stride + 1; |
324 | 484 |
903 | 485 //FIXME should be linesize instead of s->width*2 but that isnt known before get_buffer() |
936 | 486 CHECKED_ALLOCZ(s->me.scratchpad, s->width*2*16*3*sizeof(uint8_t)) |
456 | 487 |
936 | 488 CHECKED_ALLOCZ(s->me.map , ME_MAP_SIZE*sizeof(uint32_t)) |
489 CHECKED_ALLOCZ(s->me.score_map, ME_MAP_SIZE*sizeof(uint32_t)) | |
327 | 490 |
456 | 491 if(s->codec_id==CODEC_ID_MPEG4){ |
492 CHECKED_ALLOCZ(s->tex_pb_buffer, PB_BUFFER_SIZE); | |
493 CHECKED_ALLOCZ( s->pb2_buffer, PB_BUFFER_SIZE); | |
494 } | |
612 | 495 |
650
ef4a33aad86e
reducing sizeof MpegEncContext to avoid stack overflow on crap M$ windo$
michaelni
parents:
635
diff
changeset
|
496 if(s->msmpeg4_version){ |
ef4a33aad86e
reducing sizeof MpegEncContext to avoid stack overflow on crap M$ windo$
michaelni
parents:
635
diff
changeset
|
497 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
|
498 } |
612 | 499 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
|
500 |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1173
diff
changeset
|
501 /* Allocate MB type table */ |
1708 | 502 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
|
503 |
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
|
504 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
|
505 |
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
|
506 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
|
507 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
|
508 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
|
509 CHECKED_ALLOCZ(s->q_inter_matrix16, 64*32*2 * sizeof(uint16_t)) |
1556 | 510 CHECKED_ALLOCZ(s->input_picture, MAX_PICTURE_COUNT * sizeof(Picture*)) |
511 CHECKED_ALLOCZ(s->reordered_input_picture, MAX_PICTURE_COUNT * sizeof(Picture*)) | |
1597 | 512 |
513 if(s->avctx->noise_reduction){ | |
514 CHECKED_ALLOCZ(s->dct_error_sum, 2 * 64 * sizeof(int)) | |
515 CHECKED_ALLOCZ(s->dct_offset, 2 * 64 * sizeof(uint16_t)) | |
516 } | |
232
b640ec5948b0
- Now the ME is done for the entire picture when enconding, the
pulento
parents:
231
diff
changeset
|
517 } |
1555 | 518 CHECKED_ALLOCZ(s->blocks, 64*6*2 * sizeof(DCTELEM)) |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
731
diff
changeset
|
519 |
1552
26c6ecba99a1
dynamic alloc of picture structs instead of putting them in MpegEncContext
michael
parents:
1546
diff
changeset
|
520 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
|
521 |
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
|
522 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
|
523 |
1708 | 524 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
|
525 /* interlaced direct mode decoding tables */ |
1708 | 526 for(i=0; i<2; i++){ |
527 int j, k; | |
528 for(j=0; j<2; j++){ | |
529 for(k=0; k<2; k++){ | |
530 CHECKED_ALLOCZ(s->b_field_mv_table_base[i][j][k] , mv_table_size * 2 * sizeof(int16_t)) | |
531 s->b_field_mv_table[i][j][k] = s->b_field_mv_table_base[i][j][k] + s->mb_stride + 1; | |
532 } | |
533 CHECKED_ALLOCZ(s->b_field_select_table[i][j] , mb_array_size * 2 * sizeof(uint8_t)) | |
534 CHECKED_ALLOCZ(s->p_field_mv_table_base[i][j] , mv_table_size * 2 * sizeof(int16_t)) | |
535 s->p_field_mv_table[i][j] = s->p_field_mv_table_base[i][j] + s->mb_stride + 1; | |
536 } | |
537 CHECKED_ALLOCZ(s->p_field_select_table[i] , mb_array_size * 2 * sizeof(uint8_t)) | |
538 } | |
0 | 539 } |
767 | 540 if (s->out_format == FMT_H263) { |
0 | 541 /* ac values */ |
1064 | 542 CHECKED_ALLOCZ(s->ac_val[0], yc_size * sizeof(int16_t) * 16); |
0 | 543 s->ac_val[1] = s->ac_val[0] + y_size; |
544 s->ac_val[2] = s->ac_val[1] + c_size; | |
545 | |
546 /* cbp values */ | |
456 | 547 CHECKED_ALLOCZ(s->coded_block, y_size); |
333 | 548 |
549 /* divx501 bitstream reorder buffer */ | |
456 | 550 CHECKED_ALLOCZ(s->bitstream_buffer, BITSTREAM_BUFFER_SIZE); |
843 | 551 |
456 | 552 /* 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
|
553 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
|
554 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
|
555 } |
756 | 556 |
557 if (s->h263_pred || s->h263_plus || !s->encoding) { | |
558 /* dc values */ | |
559 //MN: we need these for error resilience of intra-frames | |
1064 | 560 CHECKED_ALLOCZ(s->dc_val[0], yc_size * sizeof(int16_t)); |
756 | 561 s->dc_val[1] = s->dc_val[0] + y_size; |
562 s->dc_val[2] = s->dc_val[1] + c_size; | |
563 for(i=0;i<yc_size;i++) | |
564 s->dc_val[0][i] = 1024; | |
565 } | |
566 | |
611
3214d3f4519e
error concealment needs the mbintra_table so it should allways be allocated
michaelni
parents:
608
diff
changeset
|
567 /* 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
|
568 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
|
569 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
|
570 |
0 | 571 /* default structure is frame */ |
572 s->picture_structure = PICT_FRAME; | |
553 | 573 |
7
1d3ac9654178
added skip macroblock optimization (big perf win on black regions for example)
glantau
parents:
0
diff
changeset
|
574 /* 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
|
575 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
|
576 //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
|
577 CHECKED_ALLOCZ(s->prev_pict_types, PREV_PICT_TYPES_BUFFER_SIZE); |
294 | 578 |
327 | 579 s->block= s->blocks[0]; |
7
1d3ac9654178
added skip macroblock optimization (big perf win on black regions for example)
glantau
parents:
0
diff
changeset
|
580 |
1580
628bf341e099
XvMC speedup by removing one memcpy and doing MB packing
iive
parents:
1579
diff
changeset
|
581 for(i=0;i<12;i++){ |
628bf341e099
XvMC speedup by removing one memcpy and doing MB packing
iive
parents:
1579
diff
changeset
|
582 s->pblocks[i] = (short *)(&s->block[i]); |
628bf341e099
XvMC speedup by removing one memcpy and doing MB packing
iive
parents:
1579
diff
changeset
|
583 } |
628bf341e099
XvMC speedup by removing one memcpy and doing MB packing
iive
parents:
1579
diff
changeset
|
584 |
842
e460775adb38
cleanup (breaks compatibility, requested by fabrice)
michaelni
parents:
828
diff
changeset
|
585 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
|
586 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
|
587 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
|
588 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
|
589 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
|
590 } |
842
e460775adb38
cleanup (breaks compatibility, requested by fabrice)
michaelni
parents:
828
diff
changeset
|
591 |
0 | 592 s->context_initialized = 1; |
593 return 0; | |
594 fail: | |
244 | 595 MPV_common_end(s); |
596 return -1; | |
597 } | |
598 | |
456 | 599 |
600 //extern int sads; | |
601 | |
244 | 602 /* init common structure for both encoder and decoder */ |
603 void MPV_common_end(MpegEncContext *s) | |
604 { | |
1708 | 605 int i, j, k; |
244 | 606 |
1344
447b88b784ee
memleak fix by (Jake Page <jake at CS dot Stanford dot EDU>)
michaelni
parents:
1339
diff
changeset
|
607 av_freep(&s->parse_context.buffer); |
447b88b784ee
memleak fix by (Jake Page <jake at CS dot Stanford dot EDU>)
michaelni
parents:
1339
diff
changeset
|
608 s->parse_context.buffer_size=0; |
447b88b784ee
memleak fix by (Jake Page <jake at CS dot Stanford dot EDU>)
michaelni
parents:
1339
diff
changeset
|
609 |
396
fce0a2520551
removed useless header includes - use av memory functions
glantau
parents:
376
diff
changeset
|
610 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
|
611 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
|
612 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
|
613 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
|
614 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
|
615 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
|
616 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
|
617 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
|
618 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
|
619 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
|
620 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
|
621 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
|
622 s->b_direct_mv_table= NULL; |
1708 | 623 for(i=0; i<2; i++){ |
624 for(j=0; j<2; j++){ | |
625 for(k=0; k<2; k++){ | |
626 av_freep(&s->b_field_mv_table_base[i][j][k]); | |
627 s->b_field_mv_table[i][j][k]=NULL; | |
628 } | |
629 av_freep(&s->b_field_select_table[i][j]); | |
630 av_freep(&s->p_field_mv_table_base[i][j]); | |
631 s->p_field_mv_table[i][j]=NULL; | |
632 } | |
633 av_freep(&s->p_field_select_table[i]); | |
634 } | |
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 |
396
fce0a2520551
removed useless header includes - use av memory functions
glantau
parents:
376
diff
changeset
|
636 av_freep(&s->dc_val[0]); |
fce0a2520551
removed useless header includes - use av memory functions
glantau
parents:
376
diff
changeset
|
637 av_freep(&s->ac_val[0]); |
fce0a2520551
removed useless header includes - use av memory functions
glantau
parents:
376
diff
changeset
|
638 av_freep(&s->coded_block); |
fce0a2520551
removed useless header includes - use av memory functions
glantau
parents:
376
diff
changeset
|
639 av_freep(&s->mbintra_table); |
456 | 640 av_freep(&s->cbp_table); |
641 av_freep(&s->pred_dir_table); | |
936 | 642 av_freep(&s->me.scratchpad); |
643 av_freep(&s->me.map); | |
644 av_freep(&s->me.score_map); | |
456 | 645 |
396
fce0a2520551
removed useless header includes - use av memory functions
glantau
parents:
376
diff
changeset
|
646 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
|
647 av_freep(&s->prev_pict_types); |
396
fce0a2520551
removed useless header includes - use av memory functions
glantau
parents:
376
diff
changeset
|
648 av_freep(&s->bitstream_buffer); |
456 | 649 av_freep(&s->tex_pb_buffer); |
650 av_freep(&s->pb2_buffer); | |
956
45bd748e305f
negative linesize support (so mplayer -flip works)
michaelni
parents:
955
diff
changeset
|
651 av_freep(&s->allocated_edge_emu_buffer); s->edge_emu_buffer= NULL; |
612 | 652 av_freep(&s->avctx->stats_out); |
650
ef4a33aad86e
reducing sizeof MpegEncContext to avoid stack overflow on crap M$ windo$
michaelni
parents:
635
diff
changeset
|
653 av_freep(&s->ac_stats); |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
731
diff
changeset
|
654 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
|
655 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
|
656 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
|
657 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
|
658 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
|
659 av_freep(&s->q_intra_matrix16); |
d736e24bf303
move mmx quantizer matrixes out of MpegEncContext (23k -> 7k) (no meassureable slowdown)
michael
parents:
1553
diff
changeset
|
660 av_freep(&s->q_inter_matrix16); |
1555 | 661 av_freep(&s->blocks); |
1556 | 662 av_freep(&s->input_picture); |
663 av_freep(&s->reordered_input_picture); | |
1597 | 664 av_freep(&s->dct_error_sum); |
665 av_freep(&s->dct_offset); | |
903 | 666 |
1573 | 667 if(s->picture){ |
668 for(i=0; i<MAX_PICTURE_COUNT; i++){ | |
669 free_picture(s, &s->picture[i]); | |
670 } | |
0 | 671 } |
1552
26c6ecba99a1
dynamic alloc of picture structs instead of putting them in MpegEncContext
michael
parents:
1546
diff
changeset
|
672 av_freep(&s->picture); |
1214 | 673 avcodec_default_free_buffers(s->avctx); |
0 | 674 s->context_initialized = 0; |
1523 | 675 s->last_picture_ptr= |
676 s->next_picture_ptr= | |
677 s->current_picture_ptr= NULL; | |
1706
3ba5c493db6f
motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1705
diff
changeset
|
678 for(i=0; i<3; i++) |
3ba5c493db6f
motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1705
diff
changeset
|
679 if (s->visualization_buffer[i]) |
3ba5c493db6f
motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1705
diff
changeset
|
680 av_free(s->visualization_buffer[i]); |
0 | 681 } |
682 | |
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
|
683 #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
|
684 |
0 | 685 /* init video encoder */ |
686 int MPV_encode_init(AVCodecContext *avctx) | |
687 { | |
688 MpegEncContext *s = avctx->priv_data; | |
1424 | 689 int i, dummy; |
1315
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1288
diff
changeset
|
690 int chroma_h_shift, chroma_v_shift; |
315 | 691 |
1402
f662e9c86cf2
* fixing a regression in mpeg encoder (not setting pix_fmt),
romansh
parents:
1397
diff
changeset
|
692 avctx->pix_fmt = PIX_FMT_YUV420P; // FIXME |
f662e9c86cf2
* fixing a regression in mpeg encoder (not setting pix_fmt),
romansh
parents:
1397
diff
changeset
|
693 |
0 | 694 s->bit_rate = avctx->bit_rate; |
695 s->width = avctx->width; | |
696 s->height = avctx->height; | |
456 | 697 if(avctx->gop_size > 600){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1597
diff
changeset
|
698 av_log(avctx, AV_LOG_ERROR, "Warning keyframe interval too large! reducing it ...\n"); |
456 | 699 avctx->gop_size=600; |
700 } | |
0 | 701 s->gop_size = avctx->gop_size; |
194
27d1773552c9
mpeg4 encoder fix by Michael Niedermayer <michaelni@gmx.at>
arpi_esp
parents:
191
diff
changeset
|
702 s->avctx = avctx; |
294 | 703 s->flags= avctx->flags; |
1754
bdf3927bf8c5
closed gop support & flags2 as all bits in flags are used
michael
parents:
1751
diff
changeset
|
704 s->flags2= avctx->flags2; |
324 | 705 s->max_b_frames= avctx->max_b_frames; |
344 | 706 s->codec_id= avctx->codec->id; |
456 | 707 s->luma_elim_threshold = avctx->luma_elim_threshold; |
708 s->chroma_elim_threshold= avctx->chroma_elim_threshold; | |
709 s->strict_std_compliance= avctx->strict_std_compliance; | |
710 s->data_partitioning= avctx->flags & CODEC_FLAG_PART; | |
936 | 711 s->quarter_sample= (avctx->flags & CODEC_FLAG_QPEL)!=0; |
599 | 712 s->mpeg_quant= avctx->mpeg_quant; |
1661 | 713 s->rtp_mode= !!avctx->rtp_payload_size; |
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
|
714 |
0 | 715 if (s->gop_size <= 1) { |
716 s->intra_only = 1; | |
717 s->gop_size = 12; | |
718 } else { | |
719 s->intra_only = 0; | |
720 } | |
693
b6a7ff92df57
darkness masking (lumi masking does only bright stuff now)
michaelni
parents:
690
diff
changeset
|
721 |
936 | 722 s->me_method = avctx->me_method; |
693
b6a7ff92df57
darkness masking (lumi masking does only bright stuff now)
michaelni
parents:
690
diff
changeset
|
723 |
320
cda7d0857baf
- ME setting moved to AVCodecContext/MpegEncContext, no longer a global.
pulento
parents:
315
diff
changeset
|
724 /* Fixed QSCALE */ |
1708 | 725 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
|
726 |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
673
diff
changeset
|
727 s->adaptive_quant= ( s->avctx->lumi_masking |
693
b6a7ff92df57
darkness masking (lumi masking does only bright stuff now)
michaelni
parents:
690
diff
changeset
|
728 || s->avctx->dark_masking |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
673
diff
changeset
|
729 || s->avctx->temporal_cplx_masking |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
673
diff
changeset
|
730 || s->avctx->spatial_cplx_masking |
1616 | 731 || s->avctx->p_masking |
732 || (s->flags&CODEC_FLAG_QP_RD)) | |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
673
diff
changeset
|
733 && !s->fixed_qscale; |
697 | 734 |
1708 | 735 s->obmc= !!(s->flags & CODEC_FLAG_OBMC); |
736 s->loop_filter= !!(s->flags & CODEC_FLAG_LOOP_FILTER); | |
737 s->alternate_scan= !!(s->flags & CODEC_FLAG_ALT_SCAN); | |
1633 | 738 |
1711 | 739 if(avctx->rc_max_rate && !avctx->rc_buffer_size){ |
740 av_log(avctx, AV_LOG_ERROR, "a vbv buffer size is needed, for encoding with a maximum bitrate\n"); | |
741 return -1; | |
742 } | |
743 | |
744 if(avctx->rc_min_rate && avctx->rc_max_rate != avctx->rc_min_rate){ | |
745 av_log(avctx, AV_LOG_INFO, "Warning min_rate > 0 but min_rate != max_rate isnt recommanded!\n"); | |
746 } | |
747 | |
1633 | 748 if((s->flags & CODEC_FLAG_4MV) && s->codec_id != CODEC_ID_MPEG4 |
749 && s->codec_id != CODEC_ID_H263 && s->codec_id != CODEC_ID_H263P){ | |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1597
diff
changeset
|
750 av_log(avctx, AV_LOG_ERROR, "4MV not supported by codec\n"); |
1188 | 751 return -1; |
752 } | |
1711 | 753 |
1633 | 754 if(s->obmc && s->avctx->mb_decision != FF_MB_DECISION_SIMPLE){ |
755 av_log(avctx, AV_LOG_ERROR, "OBMC is only supported with simple mb decission\n"); | |
756 return -1; | |
757 } | |
758 | |
1644 | 759 if(s->obmc && s->codec_id != CODEC_ID_H263 && s->codec_id != CODEC_ID_H263P){ |
760 av_log(avctx, AV_LOG_ERROR, "OBMC is only supported with H263(+)\n"); | |
761 return -1; | |
762 } | |
763 | |
1188 | 764 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
|
765 av_log(avctx, AV_LOG_ERROR, "qpel not supported by codec\n"); |
1188 | 766 return -1; |
767 } | |
768 | |
769 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
|
770 av_log(avctx, AV_LOG_ERROR, "data partitioning not supported by codec\n"); |
1188 | 771 return -1; |
772 } | |
773 | |
1421 | 774 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
|
775 av_log(avctx, AV_LOG_ERROR, "b frames not supported by codec\n"); |
1188 | 776 return -1; |
777 } | |
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
|
778 |
1188 | 779 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
|
780 av_log(avctx, AV_LOG_ERROR, "mpeg2 style quantization not supporetd by codec\n"); |
1188 | 781 return -1; |
782 } | |
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
|
783 |
1490
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1480
diff
changeset
|
784 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
|
785 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
|
786 return -1; |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1480
diff
changeset
|
787 } |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1480
diff
changeset
|
788 |
1622 | 789 if((s->flags & CODEC_FLAG_QP_RD) && s->avctx->mb_decision != FF_MB_DECISION_RD){ |
790 av_log(avctx, AV_LOG_ERROR, "QP RD needs mbd=2\n"); | |
791 return -1; | |
792 } | |
793 | |
1754
bdf3927bf8c5
closed gop support & flags2 as all bits in flags are used
michael
parents:
1751
diff
changeset
|
794 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
|
795 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
|
796 return -1; |
bdf3927bf8c5
closed gop support & flags2 as all bits in flags are used
michael
parents:
1751
diff
changeset
|
797 } |
bdf3927bf8c5
closed gop support & flags2 as all bits in flags are used
michael
parents:
1751
diff
changeset
|
798 |
1150 | 799 if(s->codec_id==CODEC_ID_MJPEG){ |
800 s->intra_quant_bias= 1<<(QUANT_BIAS_SHIFT-1); //(a + x/2)/x | |
801 s->inter_quant_bias= 0; | |
1421 | 802 }else if(s->mpeg_quant || s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO){ |
1150 | 803 s->intra_quant_bias= 3<<(QUANT_BIAS_SHIFT-3); //(a + x*3/8)/x |
804 s->inter_quant_bias= 0; | |
805 }else{ | |
806 s->intra_quant_bias=0; | |
807 s->inter_quant_bias=-(1<<(QUANT_BIAS_SHIFT-2)); //(a - x/4)/x | |
808 } | |
809 | |
810 if(avctx->intra_quant_bias != FF_DEFAULT_QUANT_BIAS) | |
811 s->intra_quant_bias= avctx->intra_quant_bias; | |
812 if(avctx->inter_quant_bias != FF_DEFAULT_QUANT_BIAS) | |
813 s->inter_quant_bias= avctx->inter_quant_bias; | |
1315
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1288
diff
changeset
|
814 |
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1288
diff
changeset
|
815 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
|
816 |
1424 | 817 av_reduce(&s->time_increment_resolution, &dummy, s->avctx->frame_rate, s->avctx->frame_rate_base, (1<<16)-1); |
818 s->time_increment_bits = av_log2(s->time_increment_resolution - 1) + 1; | |
819 | |
0 | 820 switch(avctx->codec->id) { |
821 case CODEC_ID_MPEG1VIDEO: | |
822 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
|
823 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
|
824 avctx->delay= s->low_delay ? 0 : (s->max_b_frames + 1); |
0 | 825 break; |
1421 | 826 case CODEC_ID_MPEG2VIDEO: |
827 s->out_format = FMT_MPEG1; | |
828 s->low_delay= 0; //s->max_b_frames ? 0 : 1; | |
829 avctx->delay= s->low_delay ? 0 : (s->max_b_frames + 1); | |
1661 | 830 s->rtp_mode= 1; |
1421 | 831 break; |
1315
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1288
diff
changeset
|
832 case CODEC_ID_LJPEG: |
0 | 833 case CODEC_ID_MJPEG: |
834 s->out_format = FMT_MJPEG; | |
835 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
|
836 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
|
837 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
|
838 s->mjpeg_vsample[0] = 1<<chroma_v_shift; |
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1288
diff
changeset
|
839 s->mjpeg_vsample[1] = 1; |
232
b640ec5948b0
- Now the ME is done for the entire picture when enconding, the
pulento
parents:
231
diff
changeset
|
840 s->mjpeg_vsample[2] = 1; |
1315
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1288
diff
changeset
|
841 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
|
842 s->mjpeg_hsample[1] = 1; |
b640ec5948b0
- Now the ME is done for the entire picture when enconding, the
pulento
parents:
231
diff
changeset
|
843 s->mjpeg_hsample[2] = 1; |
0 | 844 if (mjpeg_init(s) < 0) |
845 return -1; | |
336 | 846 avctx->delay=0; |
924 | 847 s->low_delay=1; |
0 | 848 break; |
1042 | 849 #ifdef CONFIG_RISKY |
0 | 850 case CODEC_ID_H263: |
232
b640ec5948b0
- Now the ME is done for the entire picture when enconding, the
pulento
parents:
231
diff
changeset
|
851 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
|
852 av_log(avctx, AV_LOG_INFO, "Input picture size isn't suitable for h263 codec! try h263+\n"); |
0 | 853 return -1; |
232
b640ec5948b0
- Now the ME is done for the entire picture when enconding, the
pulento
parents:
231
diff
changeset
|
854 } |
0 | 855 s->out_format = FMT_H263; |
1644 | 856 s->obmc= (avctx->flags & CODEC_FLAG_OBMC) ? 1:0; |
336 | 857 avctx->delay=0; |
924 | 858 s->low_delay=1; |
0 | 859 break; |
860 case CODEC_ID_H263P: | |
861 s->out_format = FMT_H263; | |
862 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
|
863 /* Fx */ |
1644 | 864 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
|
865 s->h263_aic= (avctx->flags & CODEC_FLAG_H263P_AIC) ? 1:0; |
1644 | 866 s->modified_quant= s->h263_aic; |
1637 | 867 s->alt_inter_vlc= (avctx->flags & CODEC_FLAG_H263P_AIV) ? 1:0; |
1644 | 868 s->obmc= (avctx->flags & CODEC_FLAG_OBMC) ? 1:0; |
869 s->loop_filter= (avctx->flags & CODEC_FLAG_LOOP_FILTER) ? 1:0; | |
870 s->unrestricted_mv= s->obmc || s->loop_filter || s->umvplus; | |
1661 | 871 s->h263_slice_structured= (s->flags & CODEC_FLAG_H263P_SLICE_STRUCT) ? 1:0; |
1644 | 872 |
1095
c7604e6291c5
extended option for h263+ patch by (fixounet at free dot fr) with some minor modifications
michaelni
parents:
1094
diff
changeset
|
873 /* /Fx */ |
79
82e579c37bc3
Moved some H.263+ variables to MpegEncContext to be thread-safe.
pulento
parents:
78
diff
changeset
|
874 /* These are just to be sure */ |
336 | 875 avctx->delay=0; |
924 | 876 s->low_delay=1; |
0 | 877 break; |
1353
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1344
diff
changeset
|
878 case CODEC_ID_FLV1: |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1344
diff
changeset
|
879 s->out_format = FMT_H263; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1344
diff
changeset
|
880 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
|
881 s->unrestricted_mv = 1; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1344
diff
changeset
|
882 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
|
883 avctx->delay=0; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1344
diff
changeset
|
884 s->low_delay=1; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1344
diff
changeset
|
885 break; |
0 | 886 case CODEC_ID_RV10: |
887 s->out_format = FMT_H263; | |
336 | 888 avctx->delay=0; |
924 | 889 s->low_delay=1; |
0 | 890 break; |
71 | 891 case CODEC_ID_MPEG4: |
0 | 892 s->out_format = FMT_H263; |
893 s->h263_pred = 1; | |
894 s->unrestricted_mv = 1; | |
924 | 895 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
|
896 avctx->delay= s->low_delay ? 0 : (s->max_b_frames + 1); |
0 | 897 break; |
307 | 898 case CODEC_ID_MSMPEG4V1: |
0 | 899 s->out_format = FMT_H263; |
900 s->h263_msmpeg4 = 1; | |
901 s->h263_pred = 1; | |
902 s->unrestricted_mv = 1; | |
307 | 903 s->msmpeg4_version= 1; |
336 | 904 avctx->delay=0; |
924 | 905 s->low_delay=1; |
307 | 906 break; |
907 case CODEC_ID_MSMPEG4V2: | |
908 s->out_format = FMT_H263; | |
909 s->h263_msmpeg4 = 1; | |
910 s->h263_pred = 1; | |
911 s->unrestricted_mv = 1; | |
912 s->msmpeg4_version= 2; | |
336 | 913 avctx->delay=0; |
924 | 914 s->low_delay=1; |
307 | 915 break; |
916 case CODEC_ID_MSMPEG4V3: | |
917 s->out_format = FMT_H263; | |
918 s->h263_msmpeg4 = 1; | |
919 s->h263_pred = 1; | |
920 s->unrestricted_mv = 1; | |
921 s->msmpeg4_version= 3; | |
1163 | 922 s->flipflop_rounding=1; |
336 | 923 avctx->delay=0; |
924 | 924 s->low_delay=1; |
0 | 925 break; |
499 | 926 case CODEC_ID_WMV1: |
927 s->out_format = FMT_H263; | |
928 s->h263_msmpeg4 = 1; | |
929 s->h263_pred = 1; | |
930 s->unrestricted_mv = 1; | |
931 s->msmpeg4_version= 4; | |
1163 | 932 s->flipflop_rounding=1; |
499 | 933 avctx->delay=0; |
924 | 934 s->low_delay=1; |
499 | 935 break; |
936 case CODEC_ID_WMV2: | |
937 s->out_format = FMT_H263; | |
938 s->h263_msmpeg4 = 1; | |
939 s->h263_pred = 1; | |
940 s->unrestricted_mv = 1; | |
941 s->msmpeg4_version= 5; | |
1163 | 942 s->flipflop_rounding=1; |
499 | 943 avctx->delay=0; |
924 | 944 s->low_delay=1; |
499 | 945 break; |
1042 | 946 #endif |
0 | 947 default: |
948 return -1; | |
949 } | |
1749
7b11032507e2
removing broken framerate conversation hack in mpeg1/2
michael
parents:
1742
diff
changeset
|
950 |
277
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
271
diff
changeset
|
951 { /* set up some save defaults, some codecs might override them later */ |
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
271
diff
changeset
|
952 static int done=0; |
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
271
diff
changeset
|
953 if(!done){ |
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
271
diff
changeset
|
954 int i; |
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
271
diff
changeset
|
955 done=1; |
815
78accc54493b
put a few large tables under #ifdef CONFIG_ENCODERS or dynamically allocate them
michaelni
parents:
814
diff
changeset
|
956 |
1162 | 957 default_mv_penalty= av_mallocz( sizeof(uint8_t)*(MAX_FCODE+1)*(2*MAX_MV+1) ); |
958 memset(default_mv_penalty, 0, sizeof(uint8_t)*(MAX_FCODE+1)*(2*MAX_MV+1)); | |
1064 | 959 memset(default_fcode_tab , 0, sizeof(uint8_t)*(2*MAX_MV+1)); |
277
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
271
diff
changeset
|
960 |
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
271
diff
changeset
|
961 for(i=-16; i<16; i++){ |
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
271
diff
changeset
|
962 default_fcode_tab[i + MAX_MV]= 1; |
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
271
diff
changeset
|
963 } |
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
271
diff
changeset
|
964 } |
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
271
diff
changeset
|
965 } |
936 | 966 s->me.mv_penalty= default_mv_penalty; |
277
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
271
diff
changeset
|
967 s->fcode_tab= default_fcode_tab; |
506
b9ed0ae72d51
init dc_scale tables to defaults (fixes mjpeg sig11)
michaelni
parents:
499
diff
changeset
|
968 |
287 | 969 /* dont use mv_penalty table for crap MV as it would be confused */ |
936 | 970 //FIXME remove after fixing / removing old ME |
971 if (s->me_method < ME_EPZS) s->me.mv_penalty = default_mv_penalty; | |
287 | 972 |
7
1d3ac9654178
added skip macroblock optimization (big perf win on black regions for example)
glantau
parents:
0
diff
changeset
|
973 s->encoding = 1; |
1d3ac9654178
added skip macroblock optimization (big perf win on black regions for example)
glantau
parents:
0
diff
changeset
|
974 |
0 | 975 /* init */ |
976 if (MPV_common_init(s) < 0) | |
977 return -1; | |
1678 | 978 |
979 if(s->modified_quant) | |
980 s->chroma_qscale_table= ff_h263_chroma_qscale_table; | |
981 s->progressive_frame= | |
1708 | 982 s->progressive_sequence= !(avctx->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)); |
0 | 983 |
1729 | 984 ff_set_cmp(&s->dsp, s->dsp.ildct_cmp, s->avctx->ildct_cmp); |
985 | |
936 | 986 ff_init_me(s); |
987 | |
815
78accc54493b
put a few large tables under #ifdef CONFIG_ENCODERS or dynamically allocate them
michaelni
parents:
814
diff
changeset
|
988 #ifdef CONFIG_ENCODERS |
1042 | 989 #ifdef CONFIG_RISKY |
706
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
990 if (s->out_format == FMT_H263) |
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
991 h263_encode_init(s); |
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
992 if(s->msmpeg4_version) |
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
993 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
|
994 #endif |
1042 | 995 if (s->out_format == FMT_MPEG1) |
996 ff_mpeg1_encode_init(s); | |
997 #endif | |
706
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
998 |
60 | 999 /* init default q matrix */ |
1000 for(i=0;i<64;i++) { | |
1092 | 1001 int j= s->dsp.idct_permutation[i]; |
1042 | 1002 #ifdef CONFIG_RISKY |
599 | 1003 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
|
1004 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
|
1005 s->inter_matrix[j] = ff_mpeg4_default_non_intra_matrix[i]; |
599 | 1006 }else if(s->out_format == FMT_H263){ |
706
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
1007 s->intra_matrix[j] = |
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
1008 s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i]; |
1042 | 1009 }else |
1010 #endif | |
1421 | 1011 { /* mpeg1/2 */ |
706
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
1012 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
|
1013 s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i]; |
599 | 1014 } |
1411 | 1015 if(s->avctx->intra_matrix) |
1016 s->intra_matrix[j] = s->avctx->intra_matrix[i]; | |
1017 if(s->avctx->inter_matrix) | |
1018 s->inter_matrix[j] = s->avctx->inter_matrix[i]; | |
344 | 1019 } |
1020 | |
1021 /* precompute matrix */ | |
350
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
347
diff
changeset
|
1022 /* for mjpeg, we do include qscale in the matrix */ |
344 | 1023 if (s->out_format != FMT_MJPEG) { |
1579
039cb2296de2
make convert_matrix() independant of MpegEncContext
michael
parents:
1573
diff
changeset
|
1024 convert_matrix(&s->dsp, s->q_intra_matrix, s->q_intra_matrix16, |
709
afeff6ccb7f5
convert only needed matrixes in convert_matrix() (mjpeg calls it for every frame)
michaelni
parents:
706
diff
changeset
|
1025 s->intra_matrix, s->intra_quant_bias, 1, 31); |
1579
039cb2296de2
make convert_matrix() independant of MpegEncContext
michael
parents:
1573
diff
changeset
|
1026 convert_matrix(&s->dsp, s->q_inter_matrix, s->q_inter_matrix16, |
709
afeff6ccb7f5
convert only needed matrixes in convert_matrix() (mjpeg calls it for every frame)
michaelni
parents:
706
diff
changeset
|
1027 s->inter_matrix, s->inter_quant_bias, 1, 31); |
60 | 1028 } |
1029 | |
329 | 1030 if(ff_rate_control_init(s) < 0) |
1031 return -1; | |
0 | 1032 |
1033 s->picture_number = 0; | |
1705 | 1034 s->input_picture_number = 0; |
277
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
271
diff
changeset
|
1035 s->picture_in_gop_number = 0; |
0 | 1036 /* motion detector init */ |
1037 s->f_code = 1; | |
324 | 1038 s->b_code = 1; |
0 | 1039 |
1040 return 0; | |
1041 } | |
1042 | |
1043 int MPV_encode_end(AVCodecContext *avctx) | |
1044 { | |
1045 MpegEncContext *s = avctx->priv_data; | |
1046 | |
1047 #ifdef STATS | |
1048 print_stats(); | |
1049 #endif | |
329 | 1050 |
1051 ff_rate_control_uninit(s); | |
1052 | |
0 | 1053 MPV_common_end(s); |
1054 if (s->out_format == FMT_MJPEG) | |
1055 mjpeg_close(s); | |
1458
40b69d238beb
AVI stream header FCC / more reliable detection of old xvid files
michaelni
parents:
1451
diff
changeset
|
1056 |
1424 | 1057 av_freep(&avctx->extradata); |
232
b640ec5948b0
- Now the ME is done for the entire picture when enconding, the
pulento
parents:
231
diff
changeset
|
1058 |
0 | 1059 return 0; |
1060 } | |
1061 | |
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
|
1062 #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
|
1063 |
1042 | 1064 void init_rl(RLTable *rl) |
1065 { | |
1064 | 1066 int8_t max_level[MAX_RUN+1], max_run[MAX_LEVEL+1]; |
1067 uint8_t index_run[MAX_RUN+1]; | |
1042 | 1068 int last, run, level, start, end, i; |
1069 | |
1070 /* compute max_level[], max_run[] and index_run[] */ | |
1071 for(last=0;last<2;last++) { | |
1072 if (last == 0) { | |
1073 start = 0; | |
1074 end = rl->last; | |
1075 } else { | |
1076 start = rl->last; | |
1077 end = rl->n; | |
1078 } | |
1079 | |
1080 memset(max_level, 0, MAX_RUN + 1); | |
1081 memset(max_run, 0, MAX_LEVEL + 1); | |
1082 memset(index_run, rl->n, MAX_RUN + 1); | |
1083 for(i=start;i<end;i++) { | |
1084 run = rl->table_run[i]; | |
1085 level = rl->table_level[i]; | |
1086 if (index_run[run] == rl->n) | |
1087 index_run[run] = i; | |
1088 if (level > max_level[run]) | |
1089 max_level[run] = level; | |
1090 if (run > max_run[level]) | |
1091 max_run[level] = run; | |
1092 } | |
1093 rl->max_level[last] = av_malloc(MAX_RUN + 1); | |
1094 memcpy(rl->max_level[last], max_level, MAX_RUN + 1); | |
1095 rl->max_run[last] = av_malloc(MAX_LEVEL + 1); | |
1096 memcpy(rl->max_run[last], max_run, MAX_LEVEL + 1); | |
1097 rl->index_run[last] = av_malloc(MAX_RUN + 1); | |
1098 memcpy(rl->index_run[last], index_run, MAX_RUN + 1); | |
1099 } | |
1100 } | |
1101 | |
0 | 1102 /* 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
|
1103 //FIXME check that this is ok for mpeg4 interlaced |
1064 | 1104 static void draw_edges_c(uint8_t *buf, int wrap, int width, int height, int w) |
0 | 1105 { |
1064 | 1106 uint8_t *ptr, *last_line; |
0 | 1107 int i; |
1108 | |
1109 last_line = buf + (height - 1) * wrap; | |
1110 for(i=0;i<w;i++) { | |
1111 /* top and bottom */ | |
1112 memcpy(buf - (i + 1) * wrap, buf, width); | |
1113 memcpy(last_line + (i + 1) * wrap, last_line, width); | |
1114 } | |
1115 /* left and right */ | |
1116 ptr = buf; | |
1117 for(i=0;i<height;i++) { | |
1118 memset(ptr - w, ptr[0], w); | |
1119 memset(ptr + width, ptr[width-1], w); | |
1120 ptr += wrap; | |
1121 } | |
1122 /* corners */ | |
1123 for(i=0;i<w;i++) { | |
1124 memset(buf - (i + 1) * wrap - w, buf[0], w); /* top left */ | |
1125 memset(buf - (i + 1) * wrap + width, buf[width-1], w); /* top right */ | |
1126 memset(last_line + (i + 1) * wrap - w, last_line[0], w); /* top left */ | |
1127 memset(last_line + (i + 1) * wrap + width, last_line[width-1], w); /* top right */ | |
1128 } | |
1129 } | |
1130 | |
1586 | 1131 int ff_find_unused_picture(MpegEncContext *s, int shared){ |
924 | 1132 int i; |
1133 | |
1134 if(shared){ | |
1135 for(i=0; i<MAX_PICTURE_COUNT; i++){ | |
1586 | 1136 if(s->picture[i].data[0]==NULL && s->picture[i].type==0) return i; |
924 | 1137 } |
1138 }else{ | |
1139 for(i=0; i<MAX_PICTURE_COUNT; i++){ | |
1586 | 1140 if(s->picture[i].data[0]==NULL && s->picture[i].type!=0) return i; //FIXME |
924 | 1141 } |
1142 for(i=0; i<MAX_PICTURE_COUNT; i++){ | |
1586 | 1143 if(s->picture[i].data[0]==NULL) return i; |
924 | 1144 } |
1145 } | |
1146 | |
1586 | 1147 assert(0); |
1148 return -1; | |
924 | 1149 } |
1150 | |
1597 | 1151 static void update_noise_reduction(MpegEncContext *s){ |
1152 int intra, i; | |
1153 | |
1154 for(intra=0; intra<2; intra++){ | |
1155 if(s->dct_count[intra] > (1<<16)){ | |
1156 for(i=0; i<64; i++){ | |
1157 s->dct_error_sum[intra][i] >>=1; | |
1158 } | |
1159 s->dct_count[intra] >>= 1; | |
1160 } | |
1161 | |
1162 for(i=0; i<64; i++){ | |
1163 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); | |
1164 } | |
1165 } | |
1166 } | |
1167 | |
1586 | 1168 /** |
1169 * generic function for encode/decode called after coding/decoding the header and before a frame is coded/decoded | |
1170 */ | |
771
d4cc92144266
handle direct rendering buffer allocation failure
michaelni
parents:
768
diff
changeset
|
1171 int MPV_frame_start(MpegEncContext *s, AVCodecContext *avctx) |
0 | 1172 { |
924 | 1173 int i; |
925 | 1174 AVFrame *pic; |
46
931417475f5b
fixed mpeg1 first block bug (pb with black picture optimisation for B frames)
glantau
parents:
40
diff
changeset
|
1175 s->mb_skiped = 0; |
1168 | 1176 |
1234 | 1177 assert(s->last_picture_ptr==NULL || s->out_format != FMT_H264 || s->codec_id == CODEC_ID_SVQ3); |
1228 | 1178 |
903 | 1179 /* mark&release old frames */ |
1396 | 1180 if (s->pict_type != B_TYPE && s->last_picture_ptr && s->last_picture_ptr->data[0]) { |
1138 | 1181 avctx->release_buffer(avctx, (AVFrame*)s->last_picture_ptr); |
903 | 1182 |
1183 /* release forgotten pictures */ | |
1184 /* if(mpeg124/h263) */ | |
1185 if(!s->encoding){ | |
1186 for(i=0; i<MAX_PICTURE_COUNT; i++){ | |
1138 | 1187 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
|
1188 av_log(avctx, AV_LOG_ERROR, "releasing zombie picture\n"); |
925 | 1189 avctx->release_buffer(avctx, (AVFrame*)&s->picture[i]); |
903 | 1190 } |
1191 } | |
1192 } | |
1193 } | |
910
eb448df811be
fixing files where the first frame isn a keyframe
michaelni
parents:
909
diff
changeset
|
1194 alloc: |
eb448df811be
fixing files where the first frame isn a keyframe
michaelni
parents:
909
diff
changeset
|
1195 if(!s->encoding){ |
1228 | 1196 /* release non refernce frames */ |
1197 for(i=0; i<MAX_PICTURE_COUNT; i++){ | |
1198 if(s->picture[i].data[0] && !s->picture[i].reference /*&& s->picture[i].type!=FF_BUFFER_TYPE_SHARED*/){ | |
1199 s->avctx->release_buffer(s->avctx, (AVFrame*)&s->picture[i]); | |
1200 } | |
1201 } | |
1202 | |
1586 | 1203 if(s->current_picture_ptr && s->current_picture_ptr->data[0]==NULL) |
1204 pic= (AVFrame*)s->current_picture_ptr; //we allready have a unused image (maybe it was set before reading the header) | |
1205 else{ | |
1206 i= ff_find_unused_picture(s, 0); | |
1207 pic= (AVFrame*)&s->picture[i]; | |
1208 } | |
1209 | |
1168 | 1210 pic->reference= s->pict_type != B_TYPE ? 3 : 0; |
1138 | 1211 |
1705 | 1212 pic->coded_picture_number= s->coded_picture_number++; |
903 | 1213 |
1384 | 1214 if( alloc_picture(s, (Picture*)pic, 0) < 0) |
1215 return -1; | |
903 | 1216 |
1586 | 1217 s->current_picture_ptr= (Picture*)pic; |
1658 | 1218 s->current_picture_ptr->top_field_first= s->top_field_first; //FIXME use only the vars from current_pic |
1659 | 1219 s->current_picture_ptr->interlaced_frame= !s->progressive_frame && !s->progressive_sequence; |
903 | 1220 } |
456 | 1221 |
1173 | 1222 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
|
1223 // 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
|
1224 // 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
|
1225 s->current_picture_ptr->key_frame= s->pict_type == I_TYPE; |
1173 | 1226 |
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
|
1227 copy_picture(&s->current_picture, s->current_picture_ptr); |
1173 | 1228 |
1234 | 1229 if(s->out_format != FMT_H264 || s->codec_id == CODEC_ID_SVQ3){ |
903 | 1230 if (s->pict_type != B_TYPE) { |
1138 | 1231 s->last_picture_ptr= s->next_picture_ptr; |
1232 s->next_picture_ptr= s->current_picture_ptr; | |
1233 } | |
1214 | 1234 |
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
|
1235 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
|
1236 if(s->next_picture_ptr) copy_picture(&s->next_picture, s->next_picture_ptr); |
1138 | 1237 |
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
|
1238 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
|
1239 av_log(avctx, AV_LOG_ERROR, "warning: first frame is no keyframe\n"); |
1393 | 1240 assert(s->pict_type != B_TYPE); //these should have been dropped if we dont have a reference |
1241 goto alloc; | |
1242 } | |
1243 | |
1244 assert(s->pict_type == I_TYPE || (s->last_picture_ptr && s->last_picture_ptr->data[0])); | |
1245 | |
1138 | 1246 if(s->picture_structure!=PICT_FRAME){ |
1247 int i; | |
1248 for(i=0; i<4; i++){ | |
1249 if(s->picture_structure == PICT_BOTTOM_FIELD){ | |
1250 s->current_picture.data[i] += s->current_picture.linesize[i]; | |
1251 } | |
1252 s->current_picture.linesize[i] *= 2; | |
1253 s->last_picture.linesize[i] *=2; | |
1254 s->next_picture.linesize[i] *=2; | |
1255 } | |
553 | 1256 } |
1168 | 1257 } |
903 | 1258 |
910
eb448df811be
fixing files where the first frame isn a keyframe
michaelni
parents:
909
diff
changeset
|
1259 s->hurry_up= s->avctx->hurry_up; |
eb448df811be
fixing files where the first frame isn a keyframe
michaelni
parents:
909
diff
changeset
|
1260 s->error_resilience= avctx->error_resilience; |
eb448df811be
fixing files where the first frame isn a keyframe
michaelni
parents:
909
diff
changeset
|
1261 |
591 | 1262 /* set dequantizer, we cant do it during init as it might change for mpeg4 |
1263 and we cant do it in the header decode as init isnt called for mpeg4 there yet */ | |
1689 | 1264 if(s->mpeg_quant || s->codec_id == CODEC_ID_MPEG2VIDEO){ |
1265 s->dct_unquantize_intra = s->dct_unquantize_mpeg2_intra; | |
1266 s->dct_unquantize_inter = s->dct_unquantize_mpeg2_inter; | |
1267 }else if(s->out_format == FMT_H263){ | |
1268 s->dct_unquantize_intra = s->dct_unquantize_h263_intra; | |
1269 s->dct_unquantize_inter = s->dct_unquantize_h263_inter; | |
1270 }else{ | |
1271 s->dct_unquantize_intra = s->dct_unquantize_mpeg1_intra; | |
1272 s->dct_unquantize_inter = s->dct_unquantize_mpeg1_inter; | |
1273 } | |
771
d4cc92144266
handle direct rendering buffer allocation failure
michaelni
parents:
768
diff
changeset
|
1274 |
1597 | 1275 if(s->dct_error_sum){ |
1276 assert(s->avctx->noise_reduction && s->encoding); | |
1277 | |
1278 update_noise_reduction(s); | |
1279 } | |
1280 | |
1381 | 1281 #ifdef HAVE_XVMC |
1282 if(s->avctx->xvmc_acceleration) | |
1283 return XVMC_field_start(s, avctx); | |
1284 #endif | |
771
d4cc92144266
handle direct rendering buffer allocation failure
michaelni
parents:
768
diff
changeset
|
1285 return 0; |
0 | 1286 } |
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
|
1287 |
0 | 1288 /* generic function for encode/decode called after a frame has been coded/decoded */ |
1289 void MPV_frame_end(MpegEncContext *s) | |
1290 { | |
903 | 1291 int i; |
0 | 1292 /* draw edge for correct motion prediction if outside */ |
1381 | 1293 #ifdef HAVE_XVMC |
1294 //just to make sure that all data is rendered. | |
1295 if(s->avctx->xvmc_acceleration){ | |
1296 XVMC_field_end(s); | |
1297 }else | |
1298 #endif | |
1542
576861d6343a
emu_edge checks simplification and avoid redundant checks for mpeg1/2 if emu_edge is set
michael
parents:
1539
diff
changeset
|
1299 if(s->unrestricted_mv && s->pict_type != B_TYPE && !s->intra_only && !(s->flags&CODEC_FLAG_EMU_EDGE)) { |
903 | 1300 draw_edges(s->current_picture.data[0], s->linesize , s->h_edge_pos , s->v_edge_pos , EDGE_WIDTH ); |
1301 draw_edges(s->current_picture.data[1], s->uvlinesize, s->h_edge_pos>>1, s->v_edge_pos>>1, EDGE_WIDTH/2); | |
1302 draw_edges(s->current_picture.data[2], s->uvlinesize, s->h_edge_pos>>1, s->v_edge_pos>>1, EDGE_WIDTH/2); | |
0 | 1303 } |
207 | 1304 emms_c(); |
329 | 1305 |
612 | 1306 s->last_pict_type = s->pict_type; |
329 | 1307 if(s->pict_type!=B_TYPE){ |
1308 s->last_non_b_pict_type= s->pict_type; | |
1309 } | |
1138 | 1310 #if 0 |
1311 /* copy back current_picture variables */ | |
903 | 1312 for(i=0; i<MAX_PICTURE_COUNT; i++){ |
1313 if(s->picture[i].data[0] == s->current_picture.data[0]){ | |
1314 s->picture[i]= s->current_picture; | |
1315 break; | |
1316 } | |
1317 } | |
1318 assert(i<MAX_PICTURE_COUNT); | |
1138 | 1319 #endif |
903 | 1320 |
1228 | 1321 if(s->encoding){ |
1322 /* release non refernce frames */ | |
1323 for(i=0; i<MAX_PICTURE_COUNT; i++){ | |
1324 if(s->picture[i].data[0] && !s->picture[i].reference /*&& s->picture[i].type!=FF_BUFFER_TYPE_SHARED*/){ | |
1325 s->avctx->release_buffer(s->avctx, (AVFrame*)&s->picture[i]); | |
1326 } | |
1327 } | |
324 | 1328 } |
1138 | 1329 // clear copies, to avoid confusion |
1330 #if 0 | |
1331 memset(&s->last_picture, 0, sizeof(Picture)); | |
1332 memset(&s->next_picture, 0, sizeof(Picture)); | |
1333 memset(&s->current_picture, 0, sizeof(Picture)); | |
1334 #endif | |
903 | 1335 } |
1336 | |
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
|
1337 /** |
1285 | 1338 * draws an line from (ex, ey) -> (sx, sy). |
1339 * @param w width of the image | |
1340 * @param h height of the image | |
1341 * @param stride stride/linesize of the image | |
1342 * @param color color of the arrow | |
1343 */ | |
1344 static void draw_line(uint8_t *buf, int sx, int sy, int ex, int ey, int w, int h, int stride, int color){ | |
1345 int t, x, y, f; | |
1346 | |
1347 sx= clip(sx, 0, w-1); | |
1348 sy= clip(sy, 0, h-1); | |
1349 ex= clip(ex, 0, w-1); | |
1350 ey= clip(ey, 0, h-1); | |
1351 | |
1352 buf[sy*stride + sx]+= color; | |
1353 | |
1354 if(ABS(ex - sx) > ABS(ey - sy)){ | |
1355 if(sx > ex){ | |
1356 t=sx; sx=ex; ex=t; | |
1357 t=sy; sy=ey; ey=t; | |
1358 } | |
1359 buf+= sx + sy*stride; | |
1360 ex-= sx; | |
1361 f= ((ey-sy)<<16)/ex; | |
1362 for(x= 0; x <= ex; x++){ | |
1363 y= ((x*f) + (1<<15))>>16; | |
1364 buf[y*stride + x]+= color; | |
1365 } | |
1366 }else{ | |
1367 if(sy > ey){ | |
1368 t=sx; sx=ex; ex=t; | |
1369 t=sy; sy=ey; ey=t; | |
1370 } | |
1371 buf+= sx + sy*stride; | |
1372 ey-= sy; | |
1373 if(ey) f= ((ex-sx)<<16)/ey; | |
1374 else f= 0; | |
1375 for(y= 0; y <= ey; y++){ | |
1376 x= ((y*f) + (1<<15))>>16; | |
1377 buf[y*stride + x]+= color; | |
1378 } | |
1379 } | |
1380 } | |
1381 | |
1382 /** | |
1383 * draws an arrow from (ex, ey) -> (sx, sy). | |
1384 * @param w width of the image | |
1385 * @param h height of the image | |
1386 * @param stride stride/linesize of the image | |
1387 * @param color color of the arrow | |
1388 */ | |
1389 static void draw_arrow(uint8_t *buf, int sx, int sy, int ex, int ey, int w, int h, int stride, int color){ | |
1390 int dx,dy; | |
1391 | |
1392 sx= clip(sx, -100, w+100); | |
1393 sy= clip(sy, -100, h+100); | |
1394 ex= clip(ex, -100, w+100); | |
1395 ey= clip(ey, -100, h+100); | |
1396 | |
1397 dx= ex - sx; | |
1398 dy= ey - sy; | |
1399 | |
1400 if(dx*dx + dy*dy > 3*3){ | |
1401 int rx= dx + dy; | |
1402 int ry= -dx + dy; | |
1403 int length= ff_sqrt((rx*rx + ry*ry)<<8); | |
1404 | |
1405 //FIXME subpixel accuracy | |
1406 rx= ROUNDED_DIV(rx*3<<4, length); | |
1407 ry= ROUNDED_DIV(ry*3<<4, length); | |
1408 | |
1409 draw_line(buf, sx, sy, sx + rx, sy + ry, w, h, stride, color); | |
1410 draw_line(buf, sx, sy, sx - ry, sy + rx, w, h, stride, color); | |
1411 } | |
1412 draw_line(buf, sx, sy, ex, ey, w, h, stride, color); | |
1413 } | |
1414 | |
1415 /** | |
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
|
1416 * 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
|
1417 */ |
1706
3ba5c493db6f
motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1705
diff
changeset
|
1418 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
|
1419 |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1173
diff
changeset
|
1420 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
|
1421 |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1173
diff
changeset
|
1422 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
|
1423 int x,y; |
1706
3ba5c493db6f
motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1705
diff
changeset
|
1424 |
3ba5c493db6f
motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1705
diff
changeset
|
1425 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
|
1426 switch (pict->pict_type) { |
3ba5c493db6f
motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1705
diff
changeset
|
1427 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
|
1428 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
|
1429 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
|
1430 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
|
1431 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
|
1432 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
|
1433 } |
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
|
1434 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
|
1435 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
|
1436 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
|
1437 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
|
1438 if(count>9) count=9; |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1597
diff
changeset
|
1439 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
|
1440 } |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1173
diff
changeset
|
1441 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
|
1442 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
|
1443 } |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1173
diff
changeset
|
1444 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
|
1445 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
|
1446 //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
|
1447 if(IS_PCM(mb_type)) |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1597
diff
changeset
|
1448 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
|
1449 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
|
1450 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
|
1451 else if(IS_INTRA4x4(mb_type)) |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1597
diff
changeset
|
1452 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
|
1453 else if(IS_INTRA16x16(mb_type)) |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1597
diff
changeset
|
1454 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
|
1455 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
|
1456 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
|
1457 else if(IS_DIRECT(mb_type)) |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1597
diff
changeset
|
1458 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
|
1459 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
|
1460 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
|
1461 else if(IS_GMC(mb_type)) |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1597
diff
changeset
|
1462 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
|
1463 else if(IS_SKIP(mb_type)) |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1597
diff
changeset
|
1464 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
|
1465 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
|
1466 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
|
1467 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
|
1468 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
|
1469 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
|
1470 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
|
1471 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
|
1472 } |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1173
diff
changeset
|
1473 |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1173
diff
changeset
|
1474 //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
|
1475 if(IS_8X8(mb_type)) |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1597
diff
changeset
|
1476 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
|
1477 else if(IS_16X8(mb_type)) |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1597
diff
changeset
|
1478 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
|
1479 else if(IS_8X16(mb_type)) |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1597
diff
changeset
|
1480 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
|
1481 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
|
1482 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
|
1483 else |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1597
diff
changeset
|
1484 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
|
1485 |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1173
diff
changeset
|
1486 |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1173
diff
changeset
|
1487 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
|
1488 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
|
1489 else |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1597
diff
changeset
|
1490 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
|
1491 } |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1597
diff
changeset
|
1492 // 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
|
1493 } |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1597
diff
changeset
|
1494 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
|
1495 } |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1173
diff
changeset
|
1496 } |
1668
30746f429df6
move motion_val & mb_type to AVFrame patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1662
diff
changeset
|
1497 |
1706
3ba5c493db6f
motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1705
diff
changeset
|
1498 if((s->avctx->debug&(FF_DEBUG_VIS_QP|FF_DEBUG_VIS_MB_TYPE)) || (s->avctx->debug_mv)){ |
1285 | 1499 const int shift= 1 + s->quarter_sample; |
1500 int mb_y; | |
1706
3ba5c493db6f
motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1705
diff
changeset
|
1501 uint8_t *ptr; |
1707 | 1502 int i; |
1723
033d889d7c2c
non YV12 vissualization fix by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1722
diff
changeset
|
1503 int h_chroma_shift, v_chroma_shift; |
1285 | 1504 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
|
1505 |
1723
033d889d7c2c
non YV12 vissualization fix by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1722
diff
changeset
|
1506 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
|
1507 for(i=0; i<3; i++){ |
1723
033d889d7c2c
non YV12 vissualization fix by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1722
diff
changeset
|
1508 memcpy(s->visualization_buffer[i], pict->data[i], (i==0) ? pict->linesize[i]*s->height:pict->linesize[i]*s->height >> v_chroma_shift); |
1706
3ba5c493db6f
motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1705
diff
changeset
|
1509 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
|
1510 } |
3ba5c493db6f
motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1705
diff
changeset
|
1511 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
|
1512 ptr= pict->data[0]; |
1285 | 1513 |
1514 for(mb_y=0; mb_y<s->mb_height; mb_y++){ | |
1515 int mb_x; | |
1516 for(mb_x=0; mb_x<s->mb_width; mb_x++){ | |
1517 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
|
1518 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
|
1519 int type; |
3ba5c493db6f
motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1705
diff
changeset
|
1520 for(type=0; type<3; type++){ |
3ba5c493db6f
motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1705
diff
changeset
|
1521 int direction; |
3ba5c493db6f
motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1705
diff
changeset
|
1522 switch (type) { |
3ba5c493db6f
motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1705
diff
changeset
|
1523 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
|
1524 continue; |
3ba5c493db6f
motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1705
diff
changeset
|
1525 direction = 0; |
3ba5c493db6f
motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1705
diff
changeset
|
1526 break; |
3ba5c493db6f
motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1705
diff
changeset
|
1527 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
|
1528 continue; |
3ba5c493db6f
motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1705
diff
changeset
|
1529 direction = 0; |
3ba5c493db6f
motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1705
diff
changeset
|
1530 break; |
3ba5c493db6f
motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1705
diff
changeset
|
1531 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
|
1532 continue; |
3ba5c493db6f
motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1705
diff
changeset
|
1533 direction = 1; |
3ba5c493db6f
motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1705
diff
changeset
|
1534 break; |
3ba5c493db6f
motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1705
diff
changeset
|
1535 } |
1712 | 1536 if(!USES_LIST(pict->mb_type[mb_index], direction)) |
1537 continue; | |
1538 | |
1706
3ba5c493db6f
motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1705
diff
changeset
|
1539 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
|
1540 int i; |
3ba5c493db6f
motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1705
diff
changeset
|
1541 for(i=0; i<4; i++){ |
1285 | 1542 int sx= mb_x*16 + 4 + 8*(i&1); |
1543 int sy= mb_y*16 + 4 + 8*(i>>1); | |
1544 int xy= 1 + mb_x*2 + (i&1) + (mb_y*2 + 1 + (i>>1))*(s->mb_width*2 + 2); | |
1706
3ba5c493db6f
motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1705
diff
changeset
|
1545 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
|
1546 int my= (pict->motion_val[direction][xy][1]>>shift) + sy; |
1285 | 1547 draw_arrow(ptr, sx, sy, mx, my, s->width, s->height, s->linesize, 100); |
1706
3ba5c493db6f
motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1705
diff
changeset
|
1548 } |
3ba5c493db6f
motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1705
diff
changeset
|
1549 }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
|
1550 int i; |
3ba5c493db6f
motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1705
diff
changeset
|
1551 for(i=0; i<2; i++){ |
1629
74685a0ec851
16x8 MV vissualization by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1628
diff
changeset
|
1552 int sx=mb_x*16 + 8; |
74685a0ec851
16x8 MV vissualization by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1628
diff
changeset
|
1553 int sy=mb_y*16 + 4 + 8*i; |
74685a0ec851
16x8 MV vissualization by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1628
diff
changeset
|
1554 int xy=1 + mb_x*2 + (mb_y*2 + 1 + i)*(s->mb_width*2 + 2); |
1706
3ba5c493db6f
motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1705
diff
changeset
|
1555 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
|
1556 int my=(pict->motion_val[direction][xy][1]>>shift) + sy; |
1629
74685a0ec851
16x8 MV vissualization by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1628
diff
changeset
|
1557 draw_arrow(ptr, sx, sy, mx, my, s->width, s->height, s->linesize, 100); |
1706
3ba5c493db6f
motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1705
diff
changeset
|
1558 } |
3ba5c493db6f
motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1705
diff
changeset
|
1559 }else{ |
3ba5c493db6f
motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1705
diff
changeset
|
1560 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
|
1561 int sy= mb_y*16 + 8; |
3ba5c493db6f
motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1705
diff
changeset
|
1562 int xy= 1 + mb_x*2 + (mb_y*2 + 1)*(s->mb_width*2 + 2); |
3ba5c493db6f
motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1705
diff
changeset
|
1563 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
|
1564 int my= (pict->motion_val[direction][xy][1]>>shift) + sy; |
3ba5c493db6f
motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1705
diff
changeset
|
1565 draw_arrow(ptr, sx, sy, mx, my, s->width, s->height, s->linesize, 100); |
1629
74685a0ec851
16x8 MV vissualization by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1628
diff
changeset
|
1566 } |
1706
3ba5c493db6f
motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1705
diff
changeset
|
1567 } |
1685 | 1568 } |
1569 if((s->avctx->debug&FF_DEBUG_VIS_QP) && pict->motion_val){ | |
1570 uint64_t c= (pict->qscale_table[mb_index]*128/31) * 0x0101010101010101ULL; | |
1571 int y; | |
1572 for(y=0; y<8; y++){ | |
1573 *(uint64_t*)(pict->data[1] + 8*mb_x + (8*mb_y + y)*pict->linesize[1])= c; | |
1574 *(uint64_t*)(pict->data[2] + 8*mb_x + (8*mb_y + y)*pict->linesize[2])= c; | |
1575 } | |
1576 } | |
1577 if((s->avctx->debug&FF_DEBUG_VIS_MB_TYPE) && pict->motion_val){ | |
1578 int mb_type= pict->mb_type[mb_index]; | |
1579 uint64_t u,v; | |
1580 int y; | |
1581 #define COLOR(theta, r)\ | |
1582 u= (int)(128 + r*cos(theta*3.141592/180));\ | |
1583 v= (int)(128 + r*sin(theta*3.141592/180)); | |
1584 | |
1585 | |
1586 u=v=128; | |
1587 if(IS_PCM(mb_type)){ | |
1588 COLOR(120,48) | |
1589 }else if((IS_INTRA(mb_type) && IS_ACPRED(mb_type)) || IS_INTRA16x16(mb_type)){ | |
1590 COLOR(30,48) | |
1591 }else if(IS_INTRA4x4(mb_type)){ | |
1592 COLOR(90,48) | |
1593 }else if(IS_DIRECT(mb_type) && IS_SKIP(mb_type)){ | |
1594 // COLOR(120,48) | |
1595 }else if(IS_DIRECT(mb_type)){ | |
1596 COLOR(150,48) | |
1597 }else if(IS_GMC(mb_type) && IS_SKIP(mb_type)){ | |
1598 COLOR(170,48) | |
1599 }else if(IS_GMC(mb_type)){ | |
1600 COLOR(190,48) | |
1601 }else if(IS_SKIP(mb_type)){ | |
1602 // COLOR(180,48) | |
1603 }else if(!USES_LIST(mb_type, 1)){ | |
1604 COLOR(240,48) | |
1605 }else if(!USES_LIST(mb_type, 0)){ | |
1606 COLOR(0,48) | |
1607 }else{ | |
1608 assert(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1)); | |
1609 COLOR(300,48) | |
1610 } | |
1611 | |
1612 u*= 0x0101010101010101ULL; | |
1613 v*= 0x0101010101010101ULL; | |
1614 for(y=0; y<8; y++){ | |
1615 *(uint64_t*)(pict->data[1] + 8*mb_x + (8*mb_y + y)*pict->linesize[1])= u; | |
1616 *(uint64_t*)(pict->data[2] + 8*mb_x + (8*mb_y + y)*pict->linesize[2])= v; | |
1617 } | |
1618 | |
1619 //segmentation | |
1620 if(IS_8X8(mb_type) || IS_16X8(mb_type)){ | |
1621 *(uint64_t*)(pict->data[0] + 16*mb_x + 0 + (16*mb_y + 8)*pict->linesize[0])^= 0x8080808080808080ULL; | |
1622 *(uint64_t*)(pict->data[0] + 16*mb_x + 8 + (16*mb_y + 8)*pict->linesize[0])^= 0x8080808080808080ULL; | |
1623 } | |
1624 if(IS_8X8(mb_type) || IS_8X16(mb_type)){ | |
1625 for(y=0; y<16; y++) | |
1626 pict->data[0][16*mb_x + 8 + (16*mb_y + y)*pict->linesize[0]]^= 0x80; | |
1627 } | |
1628 | |
1629 if(IS_INTERLACED(mb_type) && s->codec_id == CODEC_ID_H264){ | |
1630 // hmm | |
1631 } | |
1285 | 1632 } |
1633 s->mbskip_table[mb_index]=0; | |
1634 } | |
1635 } | |
1636 } | |
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
|
1637 } |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1173
diff
changeset
|
1638 |
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
|
1639 #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
|
1640 |
915 | 1641 static int get_sae(uint8_t *src, int ref, int stride){ |
1642 int x,y; | |
1643 int acc=0; | |
1644 | |
1645 for(y=0; y<16; y++){ | |
1646 for(x=0; x<16; x++){ | |
1647 acc+= ABS(src[x+y*stride] - ref); | |
1648 } | |
1649 } | |
1650 | |
1651 return acc; | |
1652 } | |
1653 | |
1654 static int get_intra_count(MpegEncContext *s, uint8_t *src, uint8_t *ref, int stride){ | |
1655 int x, y, w, h; | |
1656 int acc=0; | |
1657 | |
1658 w= s->width &~15; | |
1659 h= s->height&~15; | |
1660 | |
1661 for(y=0; y<h; y+=16){ | |
1662 for(x=0; x<w; x+=16){ | |
1663 int offset= x + y*stride; | |
1708 | 1664 int sad = s->dsp.sad[0](NULL, src + offset, ref + offset, stride, 16); |
915 | 1665 int mean= (s->dsp.pix_sum(src + offset, stride) + 128)>>8; |
1666 int sae = get_sae(src + offset, mean, stride); | |
1667 | |
1668 acc+= sae + 500 < sad; | |
1669 } | |
1670 } | |
1671 return acc; | |
1672 } | |
1673 | |
924 | 1674 |
925 | 1675 static int load_input_picture(MpegEncContext *s, AVFrame *pic_arg){ |
1373 | 1676 AVFrame *pic=NULL; |
924 | 1677 int i; |
903 | 1678 const int encoding_delay= s->max_b_frames; |
924 | 1679 int direct=1; |
1373 | 1680 |
1681 if(pic_arg){ | |
924 | 1682 if(encoding_delay && !(s->flags&CODEC_FLAG_INPUT_PRESERVED)) direct=0; |
1683 if(pic_arg->linesize[0] != s->linesize) direct=0; | |
1684 if(pic_arg->linesize[1] != s->uvlinesize) direct=0; | |
1685 if(pic_arg->linesize[2] != s->uvlinesize) direct=0; | |
1686 | |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1597
diff
changeset
|
1687 // av_log(AV_LOG_DEBUG, "%d %d %d %d\n",pic_arg->linesize[0], pic_arg->linesize[1], s->linesize, s->uvlinesize); |
924 | 1688 |
1689 if(direct){ | |
1586 | 1690 i= ff_find_unused_picture(s, 1); |
924 | 1691 |
925 | 1692 pic= (AVFrame*)&s->picture[i]; |
1168 | 1693 pic->reference= 3; |
903 | 1694 |
924 | 1695 for(i=0; i<4; i++){ |
1696 pic->data[i]= pic_arg->data[i]; | |
1697 pic->linesize[i]= pic_arg->linesize[i]; | |
1698 } | |
1699 alloc_picture(s, (Picture*)pic, 1); | |
1700 }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
|
1701 int offset= 16; |
1586 | 1702 i= ff_find_unused_picture(s, 0); |
924 | 1703 |
925 | 1704 pic= (AVFrame*)&s->picture[i]; |
1168 | 1705 pic->reference= 3; |
924 | 1706 |
1707 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
|
1708 |
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
|
1709 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
|
1710 && 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
|
1711 && pic->data[2] + offset == pic_arg->data[2]){ |
924 | 1712 // empty |
1713 }else{ | |
1714 int h_chroma_shift, v_chroma_shift; | |
1715 avcodec_get_chroma_sub_sample(s->avctx->pix_fmt, &h_chroma_shift, &v_chroma_shift); | |
1716 | |
1717 for(i=0; i<3; i++){ | |
1718 int src_stride= pic_arg->linesize[i]; | |
1719 int dst_stride= i ? s->uvlinesize : s->linesize; | |
1720 int h_shift= i ? h_chroma_shift : 0; | |
1721 int v_shift= i ? v_chroma_shift : 0; | |
1722 int w= s->width >>h_shift; | |
1723 int h= s->height>>v_shift; | |
1724 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
|
1725 uint8_t *dst= pic->data[i] + offset; |
924 | 1726 |
1727 if(src_stride==dst_stride) | |
1728 memcpy(dst, src, src_stride*h); | |
1729 else{ | |
1730 while(h--){ | |
1731 memcpy(dst, src, w); | |
1732 dst += dst_stride; | |
1733 src += src_stride; | |
1734 } | |
1735 } | |
1736 } | |
1737 } | |
324 | 1738 } |
1702 | 1739 copy_picture_attributes(pic, pic_arg); |
1740 | |
1705 | 1741 pic->display_picture_number= s->input_picture_number++; |
1373 | 1742 } |
903 | 1743 |
1744 /* shift buffer entries */ | |
1745 for(i=1; i<MAX_PICTURE_COUNT /*s->encoding_delay+1*/; i++) | |
1746 s->input_picture[i-1]= s->input_picture[i]; | |
1747 | |
1748 s->input_picture[encoding_delay]= (Picture*)pic; | |
1749 | |
1750 return 0; | |
1751 } | |
1752 | |
1753 static void select_input_picture(MpegEncContext *s){ | |
1754 int i; | |
924 | 1755 |
903 | 1756 for(i=1; i<MAX_PICTURE_COUNT; i++) |
1757 s->reordered_input_picture[i-1]= s->reordered_input_picture[i]; | |
1758 s->reordered_input_picture[MAX_PICTURE_COUNT-1]= NULL; | |
1759 | |
1760 /* set next picture types & ordering */ | |
1761 if(s->reordered_input_picture[0]==NULL && s->input_picture[0]){ | |
1138 | 1762 if(/*s->picture_in_gop_number >= s->gop_size ||*/ s->next_picture_ptr==NULL || s->intra_only){ |
915 | 1763 s->reordered_input_picture[0]= s->input_picture[0]; |
1764 s->reordered_input_picture[0]->pict_type= I_TYPE; | |
1705 | 1765 s->reordered_input_picture[0]->coded_picture_number= s->coded_picture_number++; |
915 | 1766 }else{ |
1767 int b_frames; | |
1768 | |
1769 if(s->flags&CODEC_FLAG_PASS2){ | |
1770 for(i=0; i<s->max_b_frames+1; i++){ | |
1771 int pict_num= s->input_picture[0]->display_picture_number + i; | |
1772 int pict_type= s->rc_context.entry[pict_num].new_pict_type; | |
1773 s->input_picture[i]->pict_type= pict_type; | |
1774 | |
1775 if(i + 1 >= s->rc_context.num_entries) break; | |
1776 } | |
1777 } | |
924 | 1778 |
915 | 1779 if(s->input_picture[0]->pict_type){ |
1780 /* user selected pict_type */ | |
909
8ae1e4c24e91
new PSNR code (now works with chroma, b frames, ...)
michaelni
parents:
903
diff
changeset
|
1781 for(b_frames=0; b_frames<s->max_b_frames+1; b_frames++){ |
8ae1e4c24e91
new PSNR code (now works with chroma, b frames, ...)
michaelni
parents:
903
diff
changeset
|
1782 if(s->input_picture[b_frames]->pict_type!=B_TYPE) break; |
8ae1e4c24e91
new PSNR code (now works with chroma, b frames, ...)
michaelni
parents:
903
diff
changeset
|
1783 } |
915 | 1784 |
909
8ae1e4c24e91
new PSNR code (now works with chroma, b frames, ...)
michaelni
parents:
903
diff
changeset
|
1785 if(b_frames > s->max_b_frames){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1597
diff
changeset
|
1786 av_log(s->avctx, AV_LOG_ERROR, "warning, too many bframes in a row\n"); |
909
8ae1e4c24e91
new PSNR code (now works with chroma, b frames, ...)
michaelni
parents:
903
diff
changeset
|
1787 b_frames = s->max_b_frames; |
8ae1e4c24e91
new PSNR code (now works with chroma, b frames, ...)
michaelni
parents:
903
diff
changeset
|
1788 } |
1687 | 1789 }else if(s->avctx->b_frame_strategy==0){ |
915 | 1790 b_frames= s->max_b_frames; |
1373 | 1791 while(b_frames && !s->input_picture[b_frames]) b_frames--; |
1687 | 1792 }else if(s->avctx->b_frame_strategy==1){ |
915 | 1793 for(i=1; i<s->max_b_frames+1; i++){ |
1373 | 1794 if(s->input_picture[i] && s->input_picture[i]->b_frame_score==0){ |
915 | 1795 s->input_picture[i]->b_frame_score= |
924 | 1796 get_intra_count(s, s->input_picture[i ]->data[0], |
1797 s->input_picture[i-1]->data[0], s->linesize) + 1; | |
915 | 1798 } |
1799 } | |
1800 for(i=0; i<s->max_b_frames; i++){ | |
1373 | 1801 if(s->input_picture[i]==NULL || s->input_picture[i]->b_frame_score - 1 > s->mb_num/40) break; |
915 | 1802 } |
1803 | |
1804 b_frames= FFMAX(0, i-1); | |
909
8ae1e4c24e91
new PSNR code (now works with chroma, b frames, ...)
michaelni
parents:
903
diff
changeset
|
1805 |
915 | 1806 /* reset scores */ |
1807 for(i=0; i<b_frames+1; i++){ | |
1808 s->input_picture[i]->b_frame_score=0; | |
1809 } | |
1810 }else{ | |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1597
diff
changeset
|
1811 av_log(s->avctx, AV_LOG_ERROR, "illegal b frame strategy\n"); |
915 | 1812 b_frames=0; |
909
8ae1e4c24e91
new PSNR code (now works with chroma, b frames, ...)
michaelni
parents:
903
diff
changeset
|
1813 } |
915 | 1814 |
1815 emms_c(); | |
1816 //static int b_count=0; | |
1817 //b_count+= b_frames; | |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1597
diff
changeset
|
1818 //av_log(s->avctx, AV_LOG_DEBUG, "b_frames: %d\n", b_count); |
1754
bdf3927bf8c5
closed gop support & flags2 as all bits in flags are used
michael
parents:
1751
diff
changeset
|
1819 if(s->picture_in_gop_number + b_frames >= s->gop_size){ |
bdf3927bf8c5
closed gop support & flags2 as all bits in flags are used
michael
parents:
1751
diff
changeset
|
1820 if(s->flags & CODEC_FLAG_CLOSED_GOP) |
bdf3927bf8c5
closed gop support & flags2 as all bits in flags are used
michael
parents:
1751
diff
changeset
|
1821 b_frames=0; |
bdf3927bf8c5
closed gop support & flags2 as all bits in flags are used
michael
parents:
1751
diff
changeset
|
1822 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
|
1823 } |
bdf3927bf8c5
closed gop support & flags2 as all bits in flags are used
michael
parents:
1751
diff
changeset
|
1824 |
bdf3927bf8c5
closed gop support & flags2 as all bits in flags are used
michael
parents:
1751
diff
changeset
|
1825 if( (s->flags & CODEC_FLAG_CLOSED_GOP) |
bdf3927bf8c5
closed gop support & flags2 as all bits in flags are used
michael
parents:
1751
diff
changeset
|
1826 && b_frames |
bdf3927bf8c5
closed gop support & flags2 as all bits in flags are used
michael
parents:
1751
diff
changeset
|
1827 && 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
|
1828 b_frames--; |
bdf3927bf8c5
closed gop support & flags2 as all bits in flags are used
michael
parents:
1751
diff
changeset
|
1829 |
915 | 1830 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
|
1831 if(s->reordered_input_picture[0]->pict_type != I_TYPE) |
915 | 1832 s->reordered_input_picture[0]->pict_type= P_TYPE; |
1705 | 1833 s->reordered_input_picture[0]->coded_picture_number= s->coded_picture_number++; |
915 | 1834 for(i=0; i<b_frames; i++){ |
1835 s->reordered_input_picture[i+1]= s->input_picture[i]; | |
1836 s->reordered_input_picture[i+1]->pict_type= B_TYPE; | |
1705 | 1837 s->reordered_input_picture[i+1]->coded_picture_number= s->coded_picture_number++; |
903 | 1838 } |
324 | 1839 } |
1840 } | |
903 | 1841 |
1842 if(s->reordered_input_picture[0]){ | |
1168 | 1843 s->reordered_input_picture[0]->reference= s->reordered_input_picture[0]->pict_type!=B_TYPE ? 3 : 0; |
1138 | 1844 |
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
|
1845 copy_picture(&s->new_picture, s->reordered_input_picture[0]); |
924 | 1846 |
1847 if(s->reordered_input_picture[0]->type == FF_BUFFER_TYPE_SHARED){ | |
1138 | 1848 // input is a shared pix, so we cant modifiy it -> alloc a new one & ensure that the shared one is reuseable |
1849 | |
1586 | 1850 int i= ff_find_unused_picture(s, 0); |
924 | 1851 Picture *pic= &s->picture[i]; |
1852 | |
1853 /* mark us unused / free shared pic */ | |
1854 for(i=0; i<4; i++) | |
1855 s->reordered_input_picture[0]->data[i]= NULL; | |
1856 s->reordered_input_picture[0]->type= 0; | |
1857 | |
1702 | 1858 copy_picture_attributes((AVFrame*)pic, (AVFrame*)s->reordered_input_picture[0]); |
1859 pic->reference = s->reordered_input_picture[0]->reference; | |
924 | 1860 |
1861 alloc_picture(s, pic, 0); | |
1862 | |
1138 | 1863 s->current_picture_ptr= pic; |
924 | 1864 }else{ |
1138 | 1865 // input is not a shared pix -> reuse buffer for current_pix |
1866 | |
924 | 1867 assert( s->reordered_input_picture[0]->type==FF_BUFFER_TYPE_USER |
1868 || s->reordered_input_picture[0]->type==FF_BUFFER_TYPE_INTERNAL); | |
1869 | |
1138 | 1870 s->current_picture_ptr= s->reordered_input_picture[0]; |
924 | 1871 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
|
1872 s->new_picture.data[i]+=16; |
924 | 1873 } |
903 | 1874 } |
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
|
1875 copy_picture(&s->current_picture, s->current_picture_ptr); |
903 | 1876 |
1877 s->picture_number= s->new_picture.display_picture_number; | |
1878 //printf("dpn:%d\n", s->picture_number); | |
1879 }else{ | |
1880 memset(&s->new_picture, 0, sizeof(Picture)); | |
324 | 1881 } |
1882 } | |
1883 | |
0 | 1884 int MPV_encode_picture(AVCodecContext *avctx, |
1885 unsigned char *buf, int buf_size, void *data) | |
1886 { | |
1887 MpegEncContext *s = avctx->priv_data; | |
925 | 1888 AVFrame *pic_arg = data; |
1684 | 1889 int i, stuffing_count; |
0 | 1890 |
1397 | 1891 if(avctx->pix_fmt != PIX_FMT_YUV420P){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1597
diff
changeset
|
1892 av_log(avctx, AV_LOG_ERROR, "this codec supports only YUV420P\n"); |
1397 | 1893 return -1; |
1894 } | |
1895 | |
1522
79dddc5cd990
removed the obsolete and unused parameters of init_put_bits
alex
parents:
1505
diff
changeset
|
1896 init_put_bits(&s->pb, buf, buf_size); |
0 | 1897 |
903 | 1898 s->picture_in_gop_number++; |
1899 | |
1900 load_input_picture(s, pic_arg); | |
329 | 1901 |
903 | 1902 select_input_picture(s); |
324 | 1903 |
1904 /* output? */ | |
903 | 1905 if(s->new_picture.data[0]){ |
1906 s->pict_type= s->new_picture.pict_type; | |
1907 //emms_c(); | |
1908 //printf("qs:%f %f %d\n", s->new_picture.quality, s->current_picture.quality, s->qscale); | |
553 | 1909 MPV_frame_start(s, avctx); |
286 | 1910 |
324 | 1911 encode_picture(s, s->picture_number); |
652 | 1912 |
376 | 1913 avctx->real_pict_num = s->picture_number; |
324 | 1914 avctx->header_bits = s->header_bits; |
1915 avctx->mv_bits = s->mv_bits; | |
1916 avctx->misc_bits = s->misc_bits; | |
1917 avctx->i_tex_bits = s->i_tex_bits; | |
1918 avctx->p_tex_bits = s->p_tex_bits; | |
1919 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
|
1920 avctx->p_count = s->mb_num - s->i_count - s->skip_count; //FIXME f/b_count in avctx |
324 | 1921 avctx->skip_count = s->skip_count; |
0 | 1922 |
324 | 1923 MPV_frame_end(s); |
1924 | |
1925 if (s->out_format == FMT_MJPEG) | |
1926 mjpeg_picture_trailer(s); | |
329 | 1927 |
1928 if(s->flags&CODEC_FLAG_PASS1) | |
1929 ff_write_pass1_stats(s); | |
1138 | 1930 |
1931 for(i=0; i<4; i++){ | |
1932 avctx->error[i] += s->current_picture_ptr->error[i]; | |
1933 } | |
324 | 1934 } |
1935 | |
0 | 1936 flush_put_bits(&s->pb); |
268 | 1937 s->frame_bits = (pbBufPtr(&s->pb) - s->pb.buf) * 8; |
1684 | 1938 |
1939 stuffing_count= ff_vbv_update(s, s->frame_bits); | |
1940 if(stuffing_count){ | |
1941 switch(s->codec_id){ | |
1942 case CODEC_ID_MPEG1VIDEO: | |
1943 case CODEC_ID_MPEG2VIDEO: | |
1944 while(stuffing_count--){ | |
1945 put_bits(&s->pb, 8, 0); | |
1946 } | |
1947 break; | |
1948 case CODEC_ID_MPEG4: | |
1949 put_bits(&s->pb, 16, 0); | |
1950 put_bits(&s->pb, 16, 0x1C3); | |
1951 stuffing_count -= 4; | |
1952 while(stuffing_count--){ | |
1953 put_bits(&s->pb, 8, 0xFF); | |
1954 } | |
1955 break; | |
1956 default: | |
1957 av_log(s->avctx, AV_LOG_ERROR, "vbv buffer overflow\n"); | |
1958 } | |
1959 flush_put_bits(&s->pb); | |
1960 s->frame_bits = (pbBufPtr(&s->pb) - s->pb.buf) * 8; | |
1961 } | |
1697 | 1962 |
1963 /* update mpeg1/2 vbv_delay for CBR */ | |
1964 if(s->avctx->rc_max_rate && s->avctx->rc_min_rate == s->avctx->rc_max_rate){ | |
1965 int vbv_delay; | |
1966 | |
1708 | 1967 assert(s->repeat_first_field==0); |
1697 | 1968 |
1703
6797179a0649
lrintf patch by ("Steven M. Schultz" <sms at 2BSD dot COM>)
michael
parents:
1702
diff
changeset
|
1969 vbv_delay= lrintf(90000 * s->rc_context.buffer_index / s->avctx->rc_max_rate); |
1697 | 1970 assert(vbv_delay < 0xFFFF); |
1971 | |
1972 s->vbv_delay_ptr[0] &= 0xF8; | |
1973 s->vbv_delay_ptr[0] |= vbv_delay>>13; | |
1974 s->vbv_delay_ptr[1] = vbv_delay>>5; | |
1975 s->vbv_delay_ptr[2] &= 0x07; | |
1976 s->vbv_delay_ptr[2] |= vbv_delay<<3; | |
1977 } | |
1978 | |
268 | 1979 s->total_bits += s->frame_bits; |
286 | 1980 avctx->frame_bits = s->frame_bits; |
909
8ae1e4c24e91
new PSNR code (now works with chroma, b frames, ...)
michaelni
parents:
903
diff
changeset
|
1981 |
1684 | 1982 return s->frame_bits/8; |
0 | 1983 } |
1984 | |
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
|
1985 #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
|
1986 |
255 | 1987 static inline void gmc1_motion(MpegEncContext *s, |
1064 | 1988 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr, |
255 | 1989 int dest_offset, |
1064 | 1990 uint8_t **ref_picture, int src_offset) |
255 | 1991 { |
1064 | 1992 uint8_t *ptr; |
556 | 1993 int offset, src_x, src_y, linesize, uvlinesize; |
255 | 1994 int motion_x, motion_y; |
566 | 1995 int emu=0; |
255 | 1996 |
1997 motion_x= s->sprite_offset[0][0]; | |
1998 motion_y= s->sprite_offset[0][1]; | |
1999 src_x = s->mb_x * 16 + (motion_x >> (s->sprite_warping_accuracy+1)); | |
2000 src_y = s->mb_y * 16 + (motion_y >> (s->sprite_warping_accuracy+1)); | |
2001 motion_x<<=(3-s->sprite_warping_accuracy); | |
2002 motion_y<<=(3-s->sprite_warping_accuracy); | |
2003 src_x = clip(src_x, -16, s->width); | |
2004 if (src_x == s->width) | |
2005 motion_x =0; | |
2006 src_y = clip(src_y, -16, s->height); | |
2007 if (src_y == s->height) | |
2008 motion_y =0; | |
753 | 2009 |
255 | 2010 linesize = s->linesize; |
556 | 2011 uvlinesize = s->uvlinesize; |
753 | 2012 |
255 | 2013 ptr = ref_picture[0] + (src_y * linesize) + src_x + src_offset; |
2014 | |
2015 dest_y+=dest_offset; | |
566 | 2016 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
|
2017 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
|
2018 || (unsigned)src_y >= s->v_edge_pos - 17){ |
1317
26c44d2433c1
make ff_emulated_edge_mc() independant of MpegEncContext
michaelni
parents:
1315
diff
changeset
|
2019 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 | 2020 ptr= s->edge_emu_buffer; |
2021 } | |
2022 } | |
753 | 2023 |
2024 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
|
2025 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
|
2026 s->dsp.gmc1(dest_y+8, ptr+8, linesize, 16, motion_x&15, motion_y&15, 128 - s->no_rounding); |
753 | 2027 }else{ |
2028 int dxy; | |
2029 | |
2030 dxy= ((motion_x>>3)&1) | ((motion_y>>2)&2); | |
2031 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
|
2032 s->dsp.put_no_rnd_pixels_tab[0][dxy](dest_y, ptr, linesize, 16); |
753 | 2033 }else{ |
853
eacc2dd8fd9d
* using DSPContext - so each codec could use its local (sub)set of CPU extension
kabi
parents:
847
diff
changeset
|
2034 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
|
2035 } |
753 | 2036 } |
2037 | |
2038 if(s->flags&CODEC_FLAG_GRAY) return; | |
255 | 2039 |
2040 motion_x= s->sprite_offset[1][0]; | |
2041 motion_y= s->sprite_offset[1][1]; | |
2042 src_x = s->mb_x * 8 + (motion_x >> (s->sprite_warping_accuracy+1)); | |
2043 src_y = s->mb_y * 8 + (motion_y >> (s->sprite_warping_accuracy+1)); | |
2044 motion_x<<=(3-s->sprite_warping_accuracy); | |
2045 motion_y<<=(3-s->sprite_warping_accuracy); | |
2046 src_x = clip(src_x, -8, s->width>>1); | |
2047 if (src_x == s->width>>1) | |
2048 motion_x =0; | |
2049 src_y = clip(src_y, -8, s->height>>1); | |
2050 if (src_y == s->height>>1) | |
2051 motion_y =0; | |
2052 | |
556 | 2053 offset = (src_y * uvlinesize) + src_x + (src_offset>>1); |
255 | 2054 ptr = ref_picture[1] + offset; |
1002 | 2055 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
|
2056 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
|
2057 || (unsigned)src_y >= (s->v_edge_pos>>1) - 9){ |
1317
26c44d2433c1
make ff_emulated_edge_mc() independant of MpegEncContext
michaelni
parents:
1315
diff
changeset
|
2058 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 | 2059 ptr= s->edge_emu_buffer; |
2060 emu=1; | |
2061 } | |
566 | 2062 } |
853
eacc2dd8fd9d
* using DSPContext - so each codec could use its local (sub)set of CPU extension
kabi
parents:
847
diff
changeset
|
2063 s->dsp.gmc1(dest_cb + (dest_offset>>1), ptr, uvlinesize, 8, motion_x&15, motion_y&15, 128 - s->no_rounding); |
566 | 2064 |
255 | 2065 ptr = ref_picture[2] + offset; |
566 | 2066 if(emu){ |
1317
26c44d2433c1
make ff_emulated_edge_mc() independant of MpegEncContext
michaelni
parents:
1315
diff
changeset
|
2067 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 | 2068 ptr= s->edge_emu_buffer; |
2069 } | |
853
eacc2dd8fd9d
* using DSPContext - so each codec could use its local (sub)set of CPU extension
kabi
parents:
847
diff
changeset
|
2070 s->dsp.gmc1(dest_cr + (dest_offset>>1), ptr, uvlinesize, 8, motion_x&15, motion_y&15, 128 - s->no_rounding); |
255 | 2071 |
2072 return; | |
2073 } | |
2074 | |
753 | 2075 static inline void gmc_motion(MpegEncContext *s, |
1064 | 2076 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr, |
753 | 2077 int dest_offset, |
1064 | 2078 uint8_t **ref_picture, int src_offset) |
753 | 2079 { |
1064 | 2080 uint8_t *ptr; |
753 | 2081 int linesize, uvlinesize; |
2082 const int a= s->sprite_warping_accuracy; | |
2083 int ox, oy; | |
2084 | |
2085 linesize = s->linesize; | |
2086 uvlinesize = s->uvlinesize; | |
2087 | |
2088 ptr = ref_picture[0] + src_offset; | |
2089 | |
2090 dest_y+=dest_offset; | |
2091 | |
2092 ox= s->sprite_offset[0][0] + s->sprite_delta[0][0]*s->mb_x*16 + s->sprite_delta[0][1]*s->mb_y*16; | |
2093 oy= s->sprite_offset[0][1] + s->sprite_delta[1][0]*s->mb_x*16 + s->sprite_delta[1][1]*s->mb_y*16; | |
2094 | |
853
eacc2dd8fd9d
* using DSPContext - so each codec could use its local (sub)set of CPU extension
kabi
parents:
847
diff
changeset
|
2095 s->dsp.gmc(dest_y, ptr, linesize, 16, |
753 | 2096 ox, |
2097 oy, | |
2098 s->sprite_delta[0][0], s->sprite_delta[0][1], | |
2099 s->sprite_delta[1][0], s->sprite_delta[1][1], | |
2100 a+1, (1<<(2*a+1)) - s->no_rounding, | |
2101 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
|
2102 s->dsp.gmc(dest_y+8, ptr, linesize, 16, |
753 | 2103 ox + s->sprite_delta[0][0]*8, |
2104 oy + s->sprite_delta[1][0]*8, | |
2105 s->sprite_delta[0][0], s->sprite_delta[0][1], | |
2106 s->sprite_delta[1][0], s->sprite_delta[1][1], | |
2107 a+1, (1<<(2*a+1)) - s->no_rounding, | |
2108 s->h_edge_pos, s->v_edge_pos); | |
2109 | |
2110 if(s->flags&CODEC_FLAG_GRAY) return; | |
2111 | |
2112 | |
2113 dest_cb+=dest_offset>>1; | |
2114 dest_cr+=dest_offset>>1; | |
2115 | |
2116 ox= s->sprite_offset[1][0] + s->sprite_delta[0][0]*s->mb_x*8 + s->sprite_delta[0][1]*s->mb_y*8; | |
2117 oy= s->sprite_offset[1][1] + s->sprite_delta[1][0]*s->mb_x*8 + s->sprite_delta[1][1]*s->mb_y*8; | |
2118 | |
2119 ptr = ref_picture[1] + (src_offset>>1); | |
853
eacc2dd8fd9d
* using DSPContext - so each codec could use its local (sub)set of CPU extension
kabi
parents:
847
diff
changeset
|
2120 s->dsp.gmc(dest_cb, ptr, uvlinesize, 8, |
753 | 2121 ox, |
2122 oy, | |
2123 s->sprite_delta[0][0], s->sprite_delta[0][1], | |
2124 s->sprite_delta[1][0], s->sprite_delta[1][1], | |
2125 a+1, (1<<(2*a+1)) - s->no_rounding, | |
2126 s->h_edge_pos>>1, s->v_edge_pos>>1); | |
2127 | |
2128 ptr = ref_picture[2] + (src_offset>>1); | |
853
eacc2dd8fd9d
* using DSPContext - so each codec could use its local (sub)set of CPU extension
kabi
parents:
847
diff
changeset
|
2129 s->dsp.gmc(dest_cr, ptr, uvlinesize, 8, |
753 | 2130 ox, |
2131 oy, | |
2132 s->sprite_delta[0][0], s->sprite_delta[0][1], | |
2133 s->sprite_delta[1][0], s->sprite_delta[1][1], | |
2134 a+1, (1<<(2*a+1)) - s->no_rounding, | |
2135 s->h_edge_pos>>1, s->v_edge_pos>>1); | |
2136 } | |
2137 | |
1317
26c44d2433c1
make ff_emulated_edge_mc() independant of MpegEncContext
michaelni
parents:
1315
diff
changeset
|
2138 /** |
26c44d2433c1
make ff_emulated_edge_mc() independant of MpegEncContext
michaelni
parents:
1315
diff
changeset
|
2139 * 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
|
2140 * @param buf destination buffer |
26c44d2433c1
make ff_emulated_edge_mc() independant of MpegEncContext
michaelni
parents:
1315
diff
changeset
|
2141 * @param src source buffer |
26c44d2433c1
make ff_emulated_edge_mc() independant of MpegEncContext
michaelni
parents:
1315
diff
changeset
|
2142 * @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
|
2143 * @param block_w width of block |
26c44d2433c1
make ff_emulated_edge_mc() independant of MpegEncContext
michaelni
parents:
1315
diff
changeset
|
2144 * @param block_h height of block |
26c44d2433c1
make ff_emulated_edge_mc() independant of MpegEncContext
michaelni
parents:
1315
diff
changeset
|
2145 * @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
|
2146 * @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
|
2147 * @param w width of the source buffer |
26c44d2433c1
make ff_emulated_edge_mc() independant of MpegEncContext
michaelni
parents:
1315
diff
changeset
|
2148 * @param h height of the source buffer |
26c44d2433c1
make ff_emulated_edge_mc() independant of MpegEncContext
michaelni
parents:
1315
diff
changeset
|
2149 */ |
26c44d2433c1
make ff_emulated_edge_mc() independant of MpegEncContext
michaelni
parents:
1315
diff
changeset
|
2150 void ff_emulated_edge_mc(uint8_t *buf, uint8_t *src, int linesize, int block_w, int block_h, |
553 | 2151 int src_x, int src_y, int w, int h){ |
2152 int x, y; | |
2153 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
|
2154 |
553 | 2155 if(src_y>= h){ |
2156 src+= (h-1-src_y)*linesize; | |
2157 src_y=h-1; | |
554 | 2158 }else if(src_y<=-block_h){ |
2159 src+= (1-block_h-src_y)*linesize; | |
2160 src_y=1-block_h; | |
553 | 2161 } |
2162 if(src_x>= w){ | |
2163 src+= (w-1-src_x); | |
2164 src_x=w-1; | |
554 | 2165 }else if(src_x<=-block_w){ |
2166 src+= (1-block_w-src_x); | |
2167 src_x=1-block_w; | |
553 | 2168 } |
2169 | |
847 | 2170 start_y= FFMAX(0, -src_y); |
2171 start_x= FFMAX(0, -src_x); | |
2172 end_y= FFMIN(block_h, h-src_y); | |
2173 end_x= FFMIN(block_w, w-src_x); | |
566 | 2174 |
553 | 2175 // copy existing part |
2176 for(y=start_y; y<end_y; y++){ | |
2177 for(x=start_x; x<end_x; x++){ | |
2178 buf[x + y*linesize]= src[x + y*linesize]; | |
2179 } | |
2180 } | |
2181 | |
2182 //top | |
2183 for(y=0; y<start_y; y++){ | |
2184 for(x=start_x; x<end_x; x++){ | |
2185 buf[x + y*linesize]= buf[x + start_y*linesize]; | |
2186 } | |
2187 } | |
2188 | |
2189 //bottom | |
2190 for(y=end_y; y<block_h; y++){ | |
2191 for(x=start_x; x<end_x; x++){ | |
2192 buf[x + y*linesize]= buf[x + (end_y-1)*linesize]; | |
2193 } | |
2194 } | |
2195 | |
2196 for(y=0; y<block_h; y++){ | |
2197 //left | |
2198 for(x=0; x<start_x; x++){ | |
2199 buf[x + y*linesize]= buf[start_x + y*linesize]; | |
2200 } | |
2201 | |
2202 //right | |
2203 for(x=end_x; x<block_w; x++){ | |
2204 buf[x + y*linesize]= buf[end_x - 1 + y*linesize]; | |
2205 } | |
2206 } | |
2207 } | |
2208 | |
1633 | 2209 static inline int hpel_motion(MpegEncContext *s, |
2210 uint8_t *dest, uint8_t *src, | |
2211 int src_x, int src_y, | |
2212 int width, int height, int stride, | |
2213 int h_edge_pos, int v_edge_pos, | |
2214 int w, int h, op_pixels_func *pix_op, | |
2215 int motion_x, int motion_y) | |
2216 { | |
2217 int dxy; | |
2218 int emu=0; | |
2219 | |
2220 dxy = ((motion_y & 1) << 1) | (motion_x & 1); | |
2221 src_x += motion_x >> 1; | |
2222 src_y += motion_y >> 1; | |
2223 | |
2224 /* WARNING: do no forget half pels */ | |
2225 src_x = clip(src_x, -16, width); //FIXME unneeded for emu? | |
2226 if (src_x == width) | |
2227 dxy &= ~1; | |
2228 src_y = clip(src_y, -16, height); | |
2229 if (src_y == height) | |
2230 dxy &= ~2; | |
2231 src += src_y * stride + src_x; | |
2232 | |
2233 if(s->unrestricted_mv && (s->flags&CODEC_FLAG_EMU_EDGE)){ | |
2234 if( (unsigned)src_x > h_edge_pos - (motion_x&1) - w | |
2235 || (unsigned)src_y > v_edge_pos - (motion_y&1) - h){ | |
2236 ff_emulated_edge_mc(s->edge_emu_buffer, src, stride, w+1, h+1, | |
2237 src_x, src_y, h_edge_pos, v_edge_pos); | |
2238 src= s->edge_emu_buffer; | |
2239 emu=1; | |
2240 } | |
2241 } | |
2242 pix_op[dxy](dest, src, stride, h); | |
2243 return emu; | |
2244 } | |
553 | 2245 |
0 | 2246 /* apply one mpeg motion vector to the three components */ |
2247 static inline void mpeg_motion(MpegEncContext *s, | |
1064 | 2248 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr, |
0 | 2249 int dest_offset, |
1064 | 2250 uint8_t **ref_picture, int src_offset, |
651 | 2251 int field_based, op_pixels_func (*pix_op)[4], |
0 | 2252 int motion_x, int motion_y, int h) |
2253 { | |
1064 | 2254 uint8_t *ptr; |
1633 | 2255 int dxy, offset, mx, my, src_x, src_y, height, v_edge_pos, uvlinesize; |
553 | 2256 int emu=0; |
651 | 2257 #if 0 |
255 | 2258 if(s->quarter_sample) |
2259 { | |
2260 motion_x>>=1; | |
2261 motion_y>>=1; | |
2262 } | |
651 | 2263 #endif |
1633 | 2264 |
0 | 2265 height = s->height >> field_based; |
582
5132a4ee50cd
different edge positions fixed with edge emu / dr1
michaelni
parents:
575
diff
changeset
|
2266 v_edge_pos = s->v_edge_pos >> field_based; |
1138 | 2267 uvlinesize = s->current_picture.linesize[1] << field_based; |
1633 | 2268 |
2269 emu= hpel_motion(s, | |
2270 dest_y + dest_offset, ref_picture[0] + src_offset, | |
2271 s->mb_x * 16, s->mb_y * (16 >> field_based), | |
2272 s->width, height, s->current_picture.linesize[0] << field_based, | |
2273 s->h_edge_pos, v_edge_pos, | |
2274 16, h, pix_op[0], | |
2275 motion_x, motion_y); | |
2276 | |
0 | 2277 |
485 | 2278 if(s->flags&CODEC_FLAG_GRAY) return; |
2279 | |
0 | 2280 if (s->out_format == FMT_H263) { |
2281 dxy = 0; | |
2282 if ((motion_x & 3) != 0) | |
2283 dxy |= 1; | |
2284 if ((motion_y & 3) != 0) | |
2285 dxy |= 2; | |
2286 mx = motion_x >> 2; | |
2287 my = motion_y >> 2; | |
2288 } else { | |
2289 mx = motion_x / 2; | |
2290 my = motion_y / 2; | |
2291 dxy = ((my & 1) << 1) | (mx & 1); | |
2292 mx >>= 1; | |
2293 my >>= 1; | |
2294 } | |
2295 | |
2296 src_x = s->mb_x * 8 + mx; | |
2297 src_y = s->mb_y * (8 >> field_based) + my; | |
2298 src_x = clip(src_x, -8, s->width >> 1); | |
2299 if (src_x == (s->width >> 1)) | |
2300 dxy &= ~1; | |
2301 src_y = clip(src_y, -8, height >> 1); | |
2302 if (src_y == (height >> 1)) | |
2303 dxy &= ~2; | |
565
44d744901ded
interlaced mpeg2 fix ... replacing linesize>>1 by uvlinesize brainlessly wasnt a good idea
michaelni
parents:
562
diff
changeset
|
2304 offset = (src_y * uvlinesize) + src_x + (src_offset >> 1); |
0 | 2305 ptr = ref_picture[1] + offset; |
553 | 2306 if(emu){ |
1317
26c44d2433c1
make ff_emulated_edge_mc() independant of MpegEncContext
michaelni
parents:
1315
diff
changeset
|
2307 ff_emulated_edge_mc(s->edge_emu_buffer, ptr - (src_offset >> 1), s->uvlinesize, 9, 9+field_based, |
763 | 2308 src_x, src_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1); |
2309 ptr= s->edge_emu_buffer + (src_offset >> 1); | |
553 | 2310 } |
651 | 2311 pix_op[1][dxy](dest_cb + (dest_offset >> 1), ptr, uvlinesize, h >> 1); |
553 | 2312 |
0 | 2313 ptr = ref_picture[2] + offset; |
553 | 2314 if(emu){ |
1317
26c44d2433c1
make ff_emulated_edge_mc() independant of MpegEncContext
michaelni
parents:
1315
diff
changeset
|
2315 ff_emulated_edge_mc(s->edge_emu_buffer, ptr - (src_offset >> 1), s->uvlinesize, 9, 9+field_based, |
763 | 2316 src_x, src_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1); |
2317 ptr= s->edge_emu_buffer + (src_offset >> 1); | |
553 | 2318 } |
651 | 2319 pix_op[1][dxy](dest_cr + (dest_offset >> 1), ptr, uvlinesize, h >> 1); |
0 | 2320 } |
1633 | 2321 //FIXME move to dsputil, avg variant, 16x16 version |
2322 static inline void put_obmc(uint8_t *dst, uint8_t *src[5], int stride){ | |
2323 int x; | |
2324 uint8_t * const top = src[1]; | |
2325 uint8_t * const left = src[2]; | |
2326 uint8_t * const mid = src[0]; | |
2327 uint8_t * const right = src[3]; | |
2328 uint8_t * const bottom= src[4]; | |
2329 #define OBMC_FILTER(x, t, l, m, r, b)\ | |
2330 dst[x]= (t*top[x] + l*left[x] + m*mid[x] + r*right[x] + b*bottom[x] + 4)>>3 | |
2331 #define OBMC_FILTER4(x, t, l, m, r, b)\ | |
2332 OBMC_FILTER(x , t, l, m, r, b);\ | |
2333 OBMC_FILTER(x+1 , t, l, m, r, b);\ | |
2334 OBMC_FILTER(x +stride, t, l, m, r, b);\ | |
2335 OBMC_FILTER(x+1+stride, t, l, m, r, b); | |
2336 | |
2337 x=0; | |
2338 OBMC_FILTER (x , 2, 2, 4, 0, 0); | |
2339 OBMC_FILTER (x+1, 2, 1, 5, 0, 0); | |
2340 OBMC_FILTER4(x+2, 2, 1, 5, 0, 0); | |
2341 OBMC_FILTER4(x+4, 2, 0, 5, 1, 0); | |
2342 OBMC_FILTER (x+6, 2, 0, 5, 1, 0); | |
2343 OBMC_FILTER (x+7, 2, 0, 4, 2, 0); | |
2344 x+= stride; | |
2345 OBMC_FILTER (x , 1, 2, 5, 0, 0); | |
2346 OBMC_FILTER (x+1, 1, 2, 5, 0, 0); | |
2347 OBMC_FILTER (x+6, 1, 0, 5, 2, 0); | |
2348 OBMC_FILTER (x+7, 1, 0, 5, 2, 0); | |
2349 x+= stride; | |
2350 OBMC_FILTER4(x , 1, 2, 5, 0, 0); | |
2351 OBMC_FILTER4(x+2, 1, 1, 6, 0, 0); | |
2352 OBMC_FILTER4(x+4, 1, 0, 6, 1, 0); | |
2353 OBMC_FILTER4(x+6, 1, 0, 5, 2, 0); | |
2354 x+= 2*stride; | |
2355 OBMC_FILTER4(x , 0, 2, 5, 0, 1); | |
2356 OBMC_FILTER4(x+2, 0, 1, 6, 0, 1); | |
2357 OBMC_FILTER4(x+4, 0, 0, 6, 1, 1); | |
2358 OBMC_FILTER4(x+6, 0, 0, 5, 2, 1); | |
2359 x+= 2*stride; | |
2360 OBMC_FILTER (x , 0, 2, 5, 0, 1); | |
2361 OBMC_FILTER (x+1, 0, 2, 5, 0, 1); | |
2362 OBMC_FILTER4(x+2, 0, 1, 5, 0, 2); | |
2363 OBMC_FILTER4(x+4, 0, 0, 5, 1, 2); | |
2364 OBMC_FILTER (x+6, 0, 0, 5, 2, 1); | |
2365 OBMC_FILTER (x+7, 0, 0, 5, 2, 1); | |
2366 x+= stride; | |
2367 OBMC_FILTER (x , 0, 2, 4, 0, 2); | |
2368 OBMC_FILTER (x+1, 0, 1, 5, 0, 2); | |
2369 OBMC_FILTER (x+6, 0, 0, 5, 1, 2); | |
2370 OBMC_FILTER (x+7, 0, 0, 4, 2, 2); | |
2371 } | |
2372 | |
2373 /* obmc for 1 8x8 luma block */ | |
2374 static inline void obmc_motion(MpegEncContext *s, | |
2375 uint8_t *dest, uint8_t *src, | |
2376 int src_x, int src_y, | |
2377 op_pixels_func *pix_op, | |
2378 int16_t mv[5][2]/* mid top left right bottom*/) | |
2379 #define MID 0 | |
2380 { | |
2381 int i; | |
2382 uint8_t *ptr[5]; | |
2383 | |
2384 assert(s->quarter_sample==0); | |
2385 | |
2386 for(i=0; i<5; i++){ | |
2387 if(i && mv[i][0]==mv[MID][0] && mv[i][1]==mv[MID][1]){ | |
2388 ptr[i]= ptr[MID]; | |
2389 }else{ | |
2390 ptr[i]= s->edge_emu_buffer + 16 + 8*(i&1) + s->linesize*8*(i>>1); | |
2391 hpel_motion(s, ptr[i], src, | |
2392 src_x, src_y, | |
2393 s->width, s->height, s->linesize, | |
2394 s->h_edge_pos, s->v_edge_pos, | |
2395 8, 8, pix_op, | |
2396 mv[i][0], mv[i][1]); | |
2397 } | |
2398 } | |
2399 | |
2400 put_obmc(dest, ptr, s->linesize); | |
2401 } | |
0 | 2402 |
255 | 2403 static inline void qpel_motion(MpegEncContext *s, |
1064 | 2404 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr, |
255 | 2405 int dest_offset, |
1064 | 2406 uint8_t **ref_picture, int src_offset, |
651 | 2407 int field_based, op_pixels_func (*pix_op)[4], |
2408 qpel_mc_func (*qpix_op)[16], | |
255 | 2409 int motion_x, int motion_y, int h) |
2410 { | |
1064 | 2411 uint8_t *ptr; |
671 | 2412 int dxy, offset, mx, my, src_x, src_y, height, v_edge_pos, linesize, uvlinesize; |
554 | 2413 int emu=0; |
255 | 2414 |
2415 dxy = ((motion_y & 3) << 2) | (motion_x & 3); | |
2416 src_x = s->mb_x * 16 + (motion_x >> 2); | |
2417 src_y = s->mb_y * (16 >> field_based) + (motion_y >> 2); | |
2418 | |
2419 height = s->height >> field_based; | |
582
5132a4ee50cd
different edge positions fixed with edge emu / dr1
michaelni
parents:
575
diff
changeset
|
2420 v_edge_pos = s->v_edge_pos >> field_based; |
255 | 2421 src_x = clip(src_x, -16, s->width); |
2422 if (src_x == s->width) | |
2423 dxy &= ~3; | |
2424 src_y = clip(src_y, -16, height); | |
2425 if (src_y == height) | |
2426 dxy &= ~12; | |
2427 linesize = s->linesize << field_based; | |
671 | 2428 uvlinesize = s->uvlinesize << field_based; |
255 | 2429 ptr = ref_picture[0] + (src_y * linesize) + src_x + src_offset; |
2430 dest_y += dest_offset; | |
2431 //printf("%d %d %d\n", src_x, src_y, dxy); | |
554 | 2432 |
2433 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
|
2434 if( (unsigned)src_x > s->h_edge_pos - (motion_x&3) - 16 |
576861d6343a
emu_edge checks simplification and avoid redundant checks for mpeg1/2 if emu_edge is set
michael
parents:
1539
diff
changeset
|
2435 || (unsigned)src_y > v_edge_pos - (motion_y&3) - h ){ |
1317
26c44d2433c1
make ff_emulated_edge_mc() independant of MpegEncContext
michaelni
parents:
1315
diff
changeset
|
2436 ff_emulated_edge_mc(s->edge_emu_buffer, ptr - src_offset, s->linesize, 17, 17+field_based, |
763 | 2437 src_x, src_y<<field_based, s->h_edge_pos, s->v_edge_pos); |
2438 ptr= s->edge_emu_buffer + src_offset; | |
554 | 2439 emu=1; |
2440 } | |
2441 } | |
671 | 2442 if(!field_based) |
2443 qpix_op[0][dxy](dest_y, ptr, linesize); | |
2444 else{ | |
2445 //damn interlaced mode | |
2446 //FIXME boundary mirroring is not exactly correct here | |
2447 qpix_op[1][dxy](dest_y , ptr , linesize); | |
2448 qpix_op[1][dxy](dest_y+8, ptr+8, linesize); | |
2449 } | |
651 | 2450 |
485 | 2451 if(s->flags&CODEC_FLAG_GRAY) return; |
2452 | |
671 | 2453 if(field_based){ |
2454 mx= motion_x/2; | |
2455 my= motion_y>>1; | |
1048 | 2456 }else if(s->workaround_bugs&FF_BUG_QPEL_CHROMA2){ |
2457 static const int rtab[8]= {0,0,1,1,0,0,0,1}; | |
2458 mx= (motion_x>>1) + rtab[motion_x&7]; | |
2459 my= (motion_y>>1) + rtab[motion_y&7]; | |
760 | 2460 }else if(s->workaround_bugs&FF_BUG_QPEL_CHROMA){ |
671 | 2461 mx= (motion_x>>1)|(motion_x&1); |
2462 my= (motion_y>>1)|(motion_y&1); | |
2463 }else{ | |
2464 mx= motion_x/2; | |
2465 my= motion_y/2; | |
2466 } | |
2467 mx= (mx>>1)|(mx&1); | |
2468 my= (my>>1)|(my&1); | |
1048 | 2469 |
671 | 2470 dxy= (mx&1) | ((my&1)<<1); |
2471 mx>>=1; | |
2472 my>>=1; | |
255 | 2473 |
2474 src_x = s->mb_x * 8 + mx; | |
2475 src_y = s->mb_y * (8 >> field_based) + my; | |
2476 src_x = clip(src_x, -8, s->width >> 1); | |
2477 if (src_x == (s->width >> 1)) | |
2478 dxy &= ~1; | |
2479 src_y = clip(src_y, -8, height >> 1); | |
2480 if (src_y == (height >> 1)) | |
2481 dxy &= ~2; | |
2482 | |
671 | 2483 offset = (src_y * uvlinesize) + src_x + (src_offset >> 1); |
255 | 2484 ptr = ref_picture[1] + offset; |
554 | 2485 if(emu){ |
1317
26c44d2433c1
make ff_emulated_edge_mc() independant of MpegEncContext
michaelni
parents:
1315
diff
changeset
|
2486 ff_emulated_edge_mc(s->edge_emu_buffer, ptr - (src_offset >> 1), s->uvlinesize, 9, 9 + field_based, |
763 | 2487 src_x, src_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1); |
2488 ptr= s->edge_emu_buffer + (src_offset >> 1); | |
554 | 2489 } |
671 | 2490 pix_op[1][dxy](dest_cb + (dest_offset >> 1), ptr, uvlinesize, h >> 1); |
554 | 2491 |
255 | 2492 ptr = ref_picture[2] + offset; |
554 | 2493 if(emu){ |
1317
26c44d2433c1
make ff_emulated_edge_mc() independant of MpegEncContext
michaelni
parents:
1315
diff
changeset
|
2494 ff_emulated_edge_mc(s->edge_emu_buffer, ptr - (src_offset >> 1), s->uvlinesize, 9, 9 + field_based, |
763 | 2495 src_x, src_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1); |
2496 ptr= s->edge_emu_buffer + (src_offset >> 1); | |
554 | 2497 } |
671 | 2498 pix_op[1][dxy](dest_cr + (dest_offset >> 1), ptr, uvlinesize, h >> 1); |
255 | 2499 } |
2500 | |
1013 | 2501 inline int ff_h263_round_chroma(int x){ |
2502 if (x >= 0) | |
2503 return (h263_chroma_roundtab[x & 0xf] + ((x >> 3) & ~1)); | |
2504 else { | |
2505 x = -x; | |
2506 return -(h263_chroma_roundtab[x & 0xf] + ((x >> 3) & ~1)); | |
2507 } | |
2508 } | |
255 | 2509 |
1225 | 2510 /** |
1633 | 2511 * h263 chorma 4mv motion compensation. |
2512 */ | |
2513 static inline void chroma_4mv_motion(MpegEncContext *s, | |
2514 uint8_t *dest_cb, uint8_t *dest_cr, | |
2515 uint8_t **ref_picture, | |
2516 op_pixels_func *pix_op, | |
2517 int mx, int my){ | |
2518 int dxy, emu=0, src_x, src_y, offset; | |
2519 uint8_t *ptr; | |
2520 | |
2521 /* In case of 8X8, we construct a single chroma motion vector | |
2522 with a special rounding */ | |
2523 mx= ff_h263_round_chroma(mx); | |
2524 my= ff_h263_round_chroma(my); | |
2525 | |
2526 dxy = ((my & 1) << 1) | (mx & 1); | |
2527 mx >>= 1; | |
2528 my >>= 1; | |
2529 | |
2530 src_x = s->mb_x * 8 + mx; | |
2531 src_y = s->mb_y * 8 + my; | |
2532 src_x = clip(src_x, -8, s->width/2); | |
2533 if (src_x == s->width/2) | |
2534 dxy &= ~1; | |
2535 src_y = clip(src_y, -8, s->height/2); | |
2536 if (src_y == s->height/2) | |
2537 dxy &= ~2; | |
2538 | |
2539 offset = (src_y * (s->uvlinesize)) + src_x; | |
2540 ptr = ref_picture[1] + offset; | |
2541 if(s->flags&CODEC_FLAG_EMU_EDGE){ | |
2542 if( (unsigned)src_x > (s->h_edge_pos>>1) - (dxy &1) - 8 | |
2543 || (unsigned)src_y > (s->v_edge_pos>>1) - (dxy>>1) - 8){ | |
2544 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); | |
2545 ptr= s->edge_emu_buffer; | |
2546 emu=1; | |
2547 } | |
2548 } | |
2549 pix_op[dxy](dest_cb, ptr, s->uvlinesize, 8); | |
2550 | |
2551 ptr = ref_picture[2] + offset; | |
2552 if(emu){ | |
2553 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); | |
2554 ptr= s->edge_emu_buffer; | |
2555 } | |
2556 pix_op[dxy](dest_cr, ptr, s->uvlinesize, 8); | |
2557 } | |
2558 | |
2559 /** | |
1225 | 2560 * motion compesation of a single macroblock |
2561 * @param s context | |
2562 * @param dest_y luma destination pointer | |
2563 * @param dest_cb chroma cb/u destination pointer | |
2564 * @param dest_cr chroma cr/v destination pointer | |
2565 * @param dir direction (0->forward, 1->backward) | |
2566 * @param ref_picture array[3] of pointers to the 3 planes of the reference picture | |
2567 * @param pic_op halfpel motion compensation function (average or put normally) | |
2568 * @param pic_op qpel motion compensation function (average or put normally) | |
2569 * the motion vectors are taken from s->mv and the MV type from s->mv_type | |
2570 */ | |
0 | 2571 static inline void MPV_motion(MpegEncContext *s, |
1064 | 2572 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr, |
2573 int dir, uint8_t **ref_picture, | |
651 | 2574 op_pixels_func (*pix_op)[4], qpel_mc_func (*qpix_op)[16]) |
0 | 2575 { |
1633 | 2576 int dxy, mx, my, src_x, src_y, motion_x, motion_y; |
0 | 2577 int mb_x, mb_y, i; |
1064 | 2578 uint8_t *ptr, *dest; |
0 | 2579 |
2580 mb_x = s->mb_x; | |
2581 mb_y = s->mb_y; | |
2582 | |
1655 | 2583 if(s->obmc && s->pict_type != B_TYPE){ |
1633 | 2584 int16_t mv_cache[4][4][2]; |
2585 const int xy= s->mb_x + s->mb_y*s->mb_stride; | |
2586 const int mot_stride= s->mb_width*2 + 2; | |
2587 const int mot_xy= 1 + mb_x*2 + (mb_y*2 + 1)*mot_stride; | |
2588 | |
2589 assert(!s->mb_skiped); | |
2590 | |
1668
30746f429df6
move motion_val & mb_type to AVFrame patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1662
diff
changeset
|
2591 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
|
2592 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
|
2593 memcpy(mv_cache[3][1], s->current_picture.motion_val[0][mot_xy+mot_stride], sizeof(int16_t)*4); |
1633 | 2594 |
2595 if(mb_y==0 || IS_INTRA(s->current_picture.mb_type[xy-s->mb_stride])){ | |
2596 memcpy(mv_cache[0][1], mv_cache[1][1], sizeof(int16_t)*4); | |
2597 }else{ | |
1668
30746f429df6
move motion_val & mb_type to AVFrame patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1662
diff
changeset
|
2598 memcpy(mv_cache[0][1], s->current_picture.motion_val[0][mot_xy-mot_stride], sizeof(int16_t)*4); |
1633 | 2599 } |
2600 | |
2601 if(mb_x==0 || IS_INTRA(s->current_picture.mb_type[xy-1])){ | |
2602 *(int32_t*)mv_cache[1][0]= *(int32_t*)mv_cache[1][1]; | |
2603 *(int32_t*)mv_cache[2][0]= *(int32_t*)mv_cache[2][1]; | |
2604 }else{ | |
1668
30746f429df6
move motion_val & mb_type to AVFrame patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1662
diff
changeset
|
2605 *(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
|
2606 *(int32_t*)mv_cache[2][0]= *(int32_t*)s->current_picture.motion_val[0][mot_xy-1+mot_stride]; |
1633 | 2607 } |
2608 | |
2609 if(mb_x+1>=s->mb_width || IS_INTRA(s->current_picture.mb_type[xy+1])){ | |
2610 *(int32_t*)mv_cache[1][3]= *(int32_t*)mv_cache[1][2]; | |
2611 *(int32_t*)mv_cache[2][3]= *(int32_t*)mv_cache[2][2]; | |
2612 }else{ | |
1668
30746f429df6
move motion_val & mb_type to AVFrame patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1662
diff
changeset
|
2613 *(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
|
2614 *(int32_t*)mv_cache[2][3]= *(int32_t*)s->current_picture.motion_val[0][mot_xy+2+mot_stride]; |
1633 | 2615 } |
2616 | |
2617 mx = 0; | |
2618 my = 0; | |
2619 for(i=0;i<4;i++) { | |
2620 const int x= (i&1)+1; | |
2621 const int y= (i>>1)+1; | |
2622 int16_t mv[5][2]= { | |
2623 {mv_cache[y][x ][0], mv_cache[y][x ][1]}, | |
2624 {mv_cache[y-1][x][0], mv_cache[y-1][x][1]}, | |
2625 {mv_cache[y][x-1][0], mv_cache[y][x-1][1]}, | |
2626 {mv_cache[y][x+1][0], mv_cache[y][x+1][1]}, | |
2627 {mv_cache[y+1][x][0], mv_cache[y+1][x][1]}}; | |
2628 //FIXME cleanup | |
2629 obmc_motion(s, dest_y + ((i & 1) * 8) + (i >> 1) * 8 * s->linesize, | |
2630 ref_picture[0], | |
2631 mb_x * 16 + (i & 1) * 8, mb_y * 16 + (i >>1) * 8, | |
2632 pix_op[1], | |
2633 mv); | |
2634 | |
2635 mx += mv[0][0]; | |
2636 my += mv[0][1]; | |
2637 } | |
2638 if(!(s->flags&CODEC_FLAG_GRAY)) | |
2639 chroma_4mv_motion(s, dest_cb, dest_cr, ref_picture, pix_op[1], mx, my); | |
2640 | |
2641 return; | |
2642 } | |
2643 | |
0 | 2644 switch(s->mv_type) { |
2645 case MV_TYPE_16X16: | |
1042 | 2646 #ifdef CONFIG_RISKY |
255 | 2647 if(s->mcsel){ |
753 | 2648 if(s->real_sprite_warping_points==1){ |
2649 gmc1_motion(s, dest_y, dest_cb, dest_cr, 0, | |
2650 ref_picture, 0); | |
2651 }else{ | |
2652 gmc_motion(s, dest_y, dest_cb, dest_cr, 0, | |
2653 ref_picture, 0); | |
2654 } | |
651 | 2655 }else if(s->quarter_sample){ |
255 | 2656 qpel_motion(s, dest_y, dest_cb, dest_cr, 0, |
2657 ref_picture, 0, | |
2658 0, pix_op, qpix_op, | |
2659 s->mv[dir][0][0], s->mv[dir][0][1], 16); | |
936 | 2660 }else if(s->mspel){ |
2661 ff_mspel_motion(s, dest_y, dest_cb, dest_cr, | |
2662 ref_picture, pix_op, | |
2663 s->mv[dir][0][0], s->mv[dir][0][1], 16); | |
1042 | 2664 }else |
2665 #endif | |
2666 { | |
255 | 2667 mpeg_motion(s, dest_y, dest_cb, dest_cr, 0, |
2668 ref_picture, 0, | |
2669 0, pix_op, | |
2670 s->mv[dir][0][0], s->mv[dir][0][1], 16); | |
2671 } | |
0 | 2672 break; |
2673 case MV_TYPE_8X8: | |
673 | 2674 mx = 0; |
2675 my = 0; | |
2676 if(s->quarter_sample){ | |
2677 for(i=0;i<4;i++) { | |
2678 motion_x = s->mv[dir][i][0]; | |
2679 motion_y = s->mv[dir][i][1]; | |
0 | 2680 |
673 | 2681 dxy = ((motion_y & 3) << 2) | (motion_x & 3); |
2682 src_x = mb_x * 16 + (motion_x >> 2) + (i & 1) * 8; | |
2683 src_y = mb_y * 16 + (motion_y >> 2) + (i >>1) * 8; | |
2684 | |
2685 /* WARNING: do no forget half pels */ | |
2686 src_x = clip(src_x, -16, s->width); | |
2687 if (src_x == s->width) | |
2688 dxy &= ~3; | |
2689 src_y = clip(src_y, -16, s->height); | |
2690 if (src_y == s->height) | |
2691 dxy &= ~12; | |
0 | 2692 |
673 | 2693 ptr = ref_picture[0] + (src_y * s->linesize) + (src_x); |
2694 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
|
2695 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
|
2696 || (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
|
2697 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 | 2698 ptr= s->edge_emu_buffer; |
2699 } | |
2700 } | |
2701 dest = dest_y + ((i & 1) * 8) + (i >> 1) * 8 * s->linesize; | |
2702 qpix_op[1][dxy](dest, ptr, s->linesize); | |
2703 | |
2704 mx += s->mv[dir][i][0]/2; | |
2705 my += s->mv[dir][i][1]/2; | |
2706 } | |
2707 }else{ | |
2708 for(i=0;i<4;i++) { | |
1633 | 2709 hpel_motion(s, dest_y + ((i & 1) * 8) + (i >> 1) * 8 * s->linesize, |
2710 ref_picture[0], | |
2711 mb_x * 16 + (i & 1) * 8, mb_y * 16 + (i >>1) * 8, | |
2712 s->width, s->height, s->linesize, | |
2713 s->h_edge_pos, s->v_edge_pos, | |
2714 8, 8, pix_op[1], | |
2715 s->mv[dir][i][0], s->mv[dir][i][1]); | |
673 | 2716 |
2717 mx += s->mv[dir][i][0]; | |
2718 my += s->mv[dir][i][1]; | |
554 | 2719 } |
0 | 2720 } |
673 | 2721 |
1633 | 2722 if(!(s->flags&CODEC_FLAG_GRAY)) |
2723 chroma_4mv_motion(s, dest_cb, dest_cr, ref_picture, pix_op[1], mx, my); | |
0 | 2724 break; |
2725 case MV_TYPE_FIELD: | |
2726 if (s->picture_structure == PICT_FRAME) { | |
671 | 2727 if(s->quarter_sample){ |
2728 /* top field */ | |
2729 qpel_motion(s, dest_y, dest_cb, dest_cr, 0, | |
2730 ref_picture, s->field_select[dir][0] ? s->linesize : 0, | |
2731 1, pix_op, qpix_op, | |
2732 s->mv[dir][0][0], s->mv[dir][0][1], 8); | |
2733 /* bottom field */ | |
2734 qpel_motion(s, dest_y, dest_cb, dest_cr, s->linesize, | |
2735 ref_picture, s->field_select[dir][1] ? s->linesize : 0, | |
2736 1, pix_op, qpix_op, | |
2737 s->mv[dir][1][0], s->mv[dir][1][1], 8); | |
2738 }else{ | |
2739 /* top field */ | |
2740 mpeg_motion(s, dest_y, dest_cb, dest_cr, 0, | |
2741 ref_picture, s->field_select[dir][0] ? s->linesize : 0, | |
2742 1, pix_op, | |
2743 s->mv[dir][0][0], s->mv[dir][0][1], 8); | |
2744 /* bottom field */ | |
2745 mpeg_motion(s, dest_y, dest_cb, dest_cr, s->linesize, | |
2746 ref_picture, s->field_select[dir][1] ? s->linesize : 0, | |
2747 1, pix_op, | |
2748 s->mv[dir][1][0], s->mv[dir][1][1], 8); | |
2749 } | |
0 | 2750 } else { |
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
|
2751 int offset; |
5e6e505d8997
field picture decoding support (16x16 MC blocks only as i dont have any samples which use other modes ...)
michaelni
parents:
1095
diff
changeset
|
2752 if(s->picture_structure == s->field_select[dir][0] + 1 || s->pict_type == B_TYPE || s->first_field){ |
1138 | 2753 offset= s->field_select[dir][0] ? s->linesize : 0; |
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
|
2754 }else{ |
5e6e505d8997
field picture decoding support (16x16 MC blocks only as i dont have any samples which use other modes ...)
michaelni
parents:
1095
diff
changeset
|
2755 ref_picture= s->current_picture.data; |
1138 | 2756 offset= s->field_select[dir][0] ? s->linesize : -s->linesize; |
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
|
2757 } |
5e6e505d8997
field picture decoding support (16x16 MC blocks only as i dont have any samples which use other modes ...)
michaelni
parents:
1095
diff
changeset
|
2758 |
5e6e505d8997
field picture decoding support (16x16 MC blocks only as i dont have any samples which use other modes ...)
michaelni
parents:
1095
diff
changeset
|
2759 mpeg_motion(s, dest_y, dest_cb, dest_cr, 0, |
5e6e505d8997
field picture decoding support (16x16 MC blocks only as i dont have any samples which use other modes ...)
michaelni
parents:
1095
diff
changeset
|
2760 ref_picture, offset, |
5e6e505d8997
field picture decoding support (16x16 MC blocks only as i dont have any samples which use other modes ...)
michaelni
parents:
1095
diff
changeset
|
2761 0, pix_op, |
5e6e505d8997
field picture decoding support (16x16 MC blocks only as i dont have any samples which use other modes ...)
michaelni
parents:
1095
diff
changeset
|
2762 s->mv[dir][0][0], s->mv[dir][0][1], 16); |
0 | 2763 } |
2764 break; | |
1339
338a2f6e6402
Mpeg2 16x8 Patch by ("Ivan Kalvachev" <ivan at cacad dot com>)
michaelni
parents:
1328
diff
changeset
|
2765 case MV_TYPE_16X8:{ |
338a2f6e6402
Mpeg2 16x8 Patch by ("Ivan Kalvachev" <ivan at cacad dot com>)
michaelni
parents:
1328
diff
changeset
|
2766 int offset; |
338a2f6e6402
Mpeg2 16x8 Patch by ("Ivan Kalvachev" <ivan at cacad dot com>)
michaelni
parents:
1328
diff
changeset
|
2767 uint8_t ** ref2picture; |
338a2f6e6402
Mpeg2 16x8 Patch by ("Ivan Kalvachev" <ivan at cacad dot com>)
michaelni
parents:
1328
diff
changeset
|
2768 |
338a2f6e6402
Mpeg2 16x8 Patch by ("Ivan Kalvachev" <ivan at cacad dot com>)
michaelni
parents:
1328
diff
changeset
|
2769 if(s->picture_structure == s->field_select[dir][0] + 1 || s->pict_type == B_TYPE || s->first_field){ |
338a2f6e6402
Mpeg2 16x8 Patch by ("Ivan Kalvachev" <ivan at cacad dot com>)
michaelni
parents:
1328
diff
changeset
|
2770 ref2picture= ref_picture; |
338a2f6e6402
Mpeg2 16x8 Patch by ("Ivan Kalvachev" <ivan at cacad dot com>)
michaelni
parents:
1328
diff
changeset
|
2771 offset= s->field_select[dir][0] ? s->linesize : 0; |
338a2f6e6402
Mpeg2 16x8 Patch by ("Ivan Kalvachev" <ivan at cacad dot com>)
michaelni
parents:
1328
diff
changeset
|
2772 }else{ |
338a2f6e6402
Mpeg2 16x8 Patch by ("Ivan Kalvachev" <ivan at cacad dot com>)
michaelni
parents:
1328
diff
changeset
|
2773 ref2picture= s->current_picture.data; |
338a2f6e6402
Mpeg2 16x8 Patch by ("Ivan Kalvachev" <ivan at cacad dot com>)
michaelni
parents:
1328
diff
changeset
|
2774 offset= s->field_select[dir][0] ? s->linesize : -s->linesize; |
338a2f6e6402
Mpeg2 16x8 Patch by ("Ivan Kalvachev" <ivan at cacad dot com>)
michaelni
parents:
1328
diff
changeset
|
2775 } |
338a2f6e6402
Mpeg2 16x8 Patch by ("Ivan Kalvachev" <ivan at cacad dot com>)
michaelni
parents:
1328
diff
changeset
|
2776 |
338a2f6e6402
Mpeg2 16x8 Patch by ("Ivan Kalvachev" <ivan at cacad dot com>)
michaelni
parents:
1328
diff
changeset
|
2777 mpeg_motion(s, dest_y, dest_cb, dest_cr, 0, |
338a2f6e6402
Mpeg2 16x8 Patch by ("Ivan Kalvachev" <ivan at cacad dot com>)
michaelni
parents:
1328
diff
changeset
|
2778 ref2picture, offset, |
338a2f6e6402
Mpeg2 16x8 Patch by ("Ivan Kalvachev" <ivan at cacad dot com>)
michaelni
parents:
1328
diff
changeset
|
2779 0, pix_op, |
338a2f6e6402
Mpeg2 16x8 Patch by ("Ivan Kalvachev" <ivan at cacad dot com>)
michaelni
parents:
1328
diff
changeset
|
2780 s->mv[dir][0][0], s->mv[dir][0][1], 8); |
338a2f6e6402
Mpeg2 16x8 Patch by ("Ivan Kalvachev" <ivan at cacad dot com>)
michaelni
parents:
1328
diff
changeset
|
2781 |
338a2f6e6402
Mpeg2 16x8 Patch by ("Ivan Kalvachev" <ivan at cacad dot com>)
michaelni
parents:
1328
diff
changeset
|
2782 |
338a2f6e6402
Mpeg2 16x8 Patch by ("Ivan Kalvachev" <ivan at cacad dot com>)
michaelni
parents:
1328
diff
changeset
|
2783 if(s->picture_structure == s->field_select[dir][1] + 1 || s->pict_type == B_TYPE || s->first_field){ |
338a2f6e6402
Mpeg2 16x8 Patch by ("Ivan Kalvachev" <ivan at cacad dot com>)
michaelni
parents:
1328
diff
changeset
|
2784 ref2picture= ref_picture; |
338a2f6e6402
Mpeg2 16x8 Patch by ("Ivan Kalvachev" <ivan at cacad dot com>)
michaelni
parents:
1328
diff
changeset
|
2785 offset= s->field_select[dir][1] ? s->linesize : 0; |
338a2f6e6402
Mpeg2 16x8 Patch by ("Ivan Kalvachev" <ivan at cacad dot com>)
michaelni
parents:
1328
diff
changeset
|
2786 }else{ |
338a2f6e6402
Mpeg2 16x8 Patch by ("Ivan Kalvachev" <ivan at cacad dot com>)
michaelni
parents:
1328
diff
changeset
|
2787 ref2picture= s->current_picture.data; |
338a2f6e6402
Mpeg2 16x8 Patch by ("Ivan Kalvachev" <ivan at cacad dot com>)
michaelni
parents:
1328
diff
changeset
|
2788 offset= s->field_select[dir][1] ? s->linesize : -s->linesize; |
338a2f6e6402
Mpeg2 16x8 Patch by ("Ivan Kalvachev" <ivan at cacad dot com>)
michaelni
parents:
1328
diff
changeset
|
2789 } |
338a2f6e6402
Mpeg2 16x8 Patch by ("Ivan Kalvachev" <ivan at cacad dot com>)
michaelni
parents:
1328
diff
changeset
|
2790 // I know it is ugly but this is the only way to fool emu_edge without rewrite mpeg_motion |
338a2f6e6402
Mpeg2 16x8 Patch by ("Ivan Kalvachev" <ivan at cacad dot com>)
michaelni
parents:
1328
diff
changeset
|
2791 mpeg_motion(s, dest_y+16*s->linesize, dest_cb+8*s->uvlinesize, dest_cr+8*s->uvlinesize, |
338a2f6e6402
Mpeg2 16x8 Patch by ("Ivan Kalvachev" <ivan at cacad dot com>)
michaelni
parents:
1328
diff
changeset
|
2792 0, |
338a2f6e6402
Mpeg2 16x8 Patch by ("Ivan Kalvachev" <ivan at cacad dot com>)
michaelni
parents:
1328
diff
changeset
|
2793 ref2picture, offset, |
338a2f6e6402
Mpeg2 16x8 Patch by ("Ivan Kalvachev" <ivan at cacad dot com>)
michaelni
parents:
1328
diff
changeset
|
2794 0, pix_op, |
338a2f6e6402
Mpeg2 16x8 Patch by ("Ivan Kalvachev" <ivan at cacad dot com>)
michaelni
parents:
1328
diff
changeset
|
2795 s->mv[dir][1][0], s->mv[dir][1][1]+16, 8); |
338a2f6e6402
Mpeg2 16x8 Patch by ("Ivan Kalvachev" <ivan at cacad dot com>)
michaelni
parents:
1328
diff
changeset
|
2796 } |
338a2f6e6402
Mpeg2 16x8 Patch by ("Ivan Kalvachev" <ivan at cacad dot com>)
michaelni
parents:
1328
diff
changeset
|
2797 |
338a2f6e6402
Mpeg2 16x8 Patch by ("Ivan Kalvachev" <ivan at cacad dot com>)
michaelni
parents:
1328
diff
changeset
|
2798 break; |
1326
6cdd3b8f4fd3
DMV support patch by ("Ivan Kalvachev" <ivan at cacad dot com>)
michaelni
parents:
1317
diff
changeset
|
2799 case MV_TYPE_DMV: |
6cdd3b8f4fd3
DMV support patch by ("Ivan Kalvachev" <ivan at cacad dot com>)
michaelni
parents:
1317
diff
changeset
|
2800 { |
6cdd3b8f4fd3
DMV support patch by ("Ivan Kalvachev" <ivan at cacad dot com>)
michaelni
parents:
1317
diff
changeset
|
2801 op_pixels_func (*dmv_pix_op)[4]; |
6cdd3b8f4fd3
DMV support patch by ("Ivan Kalvachev" <ivan at cacad dot com>)
michaelni
parents:
1317
diff
changeset
|
2802 int offset; |
6cdd3b8f4fd3
DMV support patch by ("Ivan Kalvachev" <ivan at cacad dot com>)
michaelni
parents:
1317
diff
changeset
|
2803 |
6cdd3b8f4fd3
DMV support patch by ("Ivan Kalvachev" <ivan at cacad dot com>)
michaelni
parents:
1317
diff
changeset
|
2804 dmv_pix_op = s->dsp.put_pixels_tab; |
6cdd3b8f4fd3
DMV support patch by ("Ivan Kalvachev" <ivan at cacad dot com>)
michaelni
parents:
1317
diff
changeset
|
2805 |
6cdd3b8f4fd3
DMV support patch by ("Ivan Kalvachev" <ivan at cacad dot com>)
michaelni
parents:
1317
diff
changeset
|
2806 if(s->picture_structure == PICT_FRAME){ |
6cdd3b8f4fd3
DMV support patch by ("Ivan Kalvachev" <ivan at cacad dot com>)
michaelni
parents:
1317
diff
changeset
|
2807 //put top field from top field |
6cdd3b8f4fd3
DMV support patch by ("Ivan Kalvachev" <ivan at cacad dot com>)
michaelni
parents:
1317
diff
changeset
|
2808 mpeg_motion(s, dest_y, dest_cb, dest_cr, 0, |
6cdd3b8f4fd3
DMV support patch by ("Ivan Kalvachev" <ivan at cacad dot com>)
michaelni
parents:
1317
diff
changeset
|
2809 ref_picture, 0, |
6cdd3b8f4fd3
DMV support patch by ("Ivan Kalvachev" <ivan at cacad dot com>)
michaelni
parents:
1317
diff
changeset
|
2810 1, dmv_pix_op, |
6cdd3b8f4fd3
DMV support patch by ("Ivan Kalvachev" <ivan at cacad dot com>)
michaelni
parents:
1317
diff
changeset
|
2811 s->mv[dir][0][0], s->mv[dir][0][1], 8); |
6cdd3b8f4fd3
DMV support patch by ("Ivan Kalvachev" <ivan at cacad dot com>)
michaelni
parents:
1317
diff
changeset
|
2812 //put bottom field from bottom field |
6cdd3b8f4fd3
DMV support patch by ("Ivan Kalvachev" <ivan at cacad dot com>)
michaelni
parents:
1317
diff
changeset
|
2813 mpeg_motion(s, dest_y, dest_cb, dest_cr, s->linesize, |
6cdd3b8f4fd3
DMV support patch by ("Ivan Kalvachev" <ivan at cacad dot com>)
michaelni
parents:
1317
diff
changeset
|
2814 ref_picture, s->linesize, |
6cdd3b8f4fd3
DMV support patch by ("Ivan Kalvachev" <ivan at cacad dot com>)
michaelni
parents:
1317
diff
changeset
|
2815 1, dmv_pix_op, |
6cdd3b8f4fd3
DMV support patch by ("Ivan Kalvachev" <ivan at cacad dot com>)
michaelni
parents:
1317
diff
changeset
|
2816 s->mv[dir][0][0], s->mv[dir][0][1], 8); |
6cdd3b8f4fd3
DMV support patch by ("Ivan Kalvachev" <ivan at cacad dot com>)
michaelni
parents:
1317
diff
changeset
|
2817 |
6cdd3b8f4fd3
DMV support patch by ("Ivan Kalvachev" <ivan at cacad dot com>)
michaelni
parents:
1317
diff
changeset
|
2818 dmv_pix_op = s->dsp.avg_pixels_tab; |
6cdd3b8f4fd3
DMV support patch by ("Ivan Kalvachev" <ivan at cacad dot com>)
michaelni
parents:
1317
diff
changeset
|
2819 |
6cdd3b8f4fd3
DMV support patch by ("Ivan Kalvachev" <ivan at cacad dot com>)
michaelni
parents:
1317
diff
changeset
|
2820 //avg top field from bottom field |
6cdd3b8f4fd3
DMV support patch by ("Ivan Kalvachev" <ivan at cacad dot com>)
michaelni
parents:
1317
diff
changeset
|
2821 mpeg_motion(s, dest_y, dest_cb, dest_cr, 0, |
6cdd3b8f4fd3
DMV support patch by ("Ivan Kalvachev" <ivan at cacad dot com>)
michaelni
parents:
1317
diff
changeset
|
2822 ref_picture, s->linesize, |
6cdd3b8f4fd3
DMV support patch by ("Ivan Kalvachev" <ivan at cacad dot com>)
michaelni
parents:
1317
diff
changeset
|
2823 1, dmv_pix_op, |
6cdd3b8f4fd3
DMV support patch by ("Ivan Kalvachev" <ivan at cacad dot com>)
michaelni
parents:
1317
diff
changeset
|
2824 s->mv[dir][2][0], s->mv[dir][2][1], 8); |
6cdd3b8f4fd3
DMV support patch by ("Ivan Kalvachev" <ivan at cacad dot com>)
michaelni
parents:
1317
diff
changeset
|
2825 //avg bottom field from top field |
6cdd3b8f4fd3
DMV support patch by ("Ivan Kalvachev" <ivan at cacad dot com>)
michaelni
parents:
1317
diff
changeset
|
2826 mpeg_motion(s, dest_y, dest_cb, dest_cr, s->linesize, |
6cdd3b8f4fd3
DMV support patch by ("Ivan Kalvachev" <ivan at cacad dot com>)
michaelni
parents:
1317
diff
changeset
|
2827 ref_picture, 0, |
6cdd3b8f4fd3
DMV support patch by ("Ivan Kalvachev" <ivan at cacad dot com>)
michaelni
parents:
1317
diff
changeset
|
2828 1, dmv_pix_op, |
6cdd3b8f4fd3
DMV support patch by ("Ivan Kalvachev" <ivan at cacad dot com>)
michaelni
parents:
1317
diff
changeset
|
2829 s->mv[dir][3][0], s->mv[dir][3][1], 8); |
6cdd3b8f4fd3
DMV support patch by ("Ivan Kalvachev" <ivan at cacad dot com>)
michaelni
parents:
1317
diff
changeset
|
2830 |
6cdd3b8f4fd3
DMV support patch by ("Ivan Kalvachev" <ivan at cacad dot com>)
michaelni
parents:
1317
diff
changeset
|
2831 }else{ |
6cdd3b8f4fd3
DMV support patch by ("Ivan Kalvachev" <ivan at cacad dot com>)
michaelni
parents:
1317
diff
changeset
|
2832 offset=(s->picture_structure == PICT_BOTTOM_FIELD)? |
6cdd3b8f4fd3
DMV support patch by ("Ivan Kalvachev" <ivan at cacad dot com>)
michaelni
parents:
1317
diff
changeset
|
2833 s->linesize : 0; |
6cdd3b8f4fd3
DMV support patch by ("Ivan Kalvachev" <ivan at cacad dot com>)
michaelni
parents:
1317
diff
changeset
|
2834 |
6cdd3b8f4fd3
DMV support patch by ("Ivan Kalvachev" <ivan at cacad dot com>)
michaelni
parents:
1317
diff
changeset
|
2835 //put field from the same parity |
6cdd3b8f4fd3
DMV support patch by ("Ivan Kalvachev" <ivan at cacad dot com>)
michaelni
parents:
1317
diff
changeset
|
2836 //same parity is never in the same frame |
6cdd3b8f4fd3
DMV support patch by ("Ivan Kalvachev" <ivan at cacad dot com>)
michaelni
parents:
1317
diff
changeset
|
2837 mpeg_motion(s, dest_y, dest_cb, dest_cr, 0, |
6cdd3b8f4fd3
DMV support patch by ("Ivan Kalvachev" <ivan at cacad dot com>)
michaelni
parents:
1317
diff
changeset
|
2838 ref_picture,offset, |
6cdd3b8f4fd3
DMV support patch by ("Ivan Kalvachev" <ivan at cacad dot com>)
michaelni
parents:
1317
diff
changeset
|
2839 0,dmv_pix_op, |
6cdd3b8f4fd3
DMV support patch by ("Ivan Kalvachev" <ivan at cacad dot com>)
michaelni
parents:
1317
diff
changeset
|
2840 s->mv[dir][0][0],s->mv[dir][0][1],16); |
6cdd3b8f4fd3
DMV support patch by ("Ivan Kalvachev" <ivan at cacad dot com>)
michaelni
parents:
1317
diff
changeset
|
2841 |
6cdd3b8f4fd3
DMV support patch by ("Ivan Kalvachev" <ivan at cacad dot com>)
michaelni
parents:
1317
diff
changeset
|
2842 // after put we make avg of the same block |
6cdd3b8f4fd3
DMV support patch by ("Ivan Kalvachev" <ivan at cacad dot com>)
michaelni
parents:
1317
diff
changeset
|
2843 dmv_pix_op=s->dsp.avg_pixels_tab; |
6cdd3b8f4fd3
DMV support patch by ("Ivan Kalvachev" <ivan at cacad dot com>)
michaelni
parents:
1317
diff
changeset
|
2844 |
6cdd3b8f4fd3
DMV support patch by ("Ivan Kalvachev" <ivan at cacad dot com>)
michaelni
parents:
1317
diff
changeset
|
2845 //opposite parity is always in the same frame if this is second field |
6cdd3b8f4fd3
DMV support patch by ("Ivan Kalvachev" <ivan at cacad dot com>)
michaelni
parents:
1317
diff
changeset
|
2846 if(!s->first_field){ |
6cdd3b8f4fd3
DMV support patch by ("Ivan Kalvachev" <ivan at cacad dot com>)
michaelni
parents:
1317
diff
changeset
|
2847 ref_picture = s->current_picture.data; |
6cdd3b8f4fd3
DMV support patch by ("Ivan Kalvachev" <ivan at cacad dot com>)
michaelni
parents:
1317
diff
changeset
|
2848 //top field is one linesize from frame beginig |
6cdd3b8f4fd3
DMV support patch by ("Ivan Kalvachev" <ivan at cacad dot com>)
michaelni
parents:
1317
diff
changeset
|
2849 offset=(s->picture_structure == PICT_BOTTOM_FIELD)? |
6cdd3b8f4fd3
DMV support patch by ("Ivan Kalvachev" <ivan at cacad dot com>)
michaelni
parents:
1317
diff
changeset
|
2850 -s->linesize : s->linesize; |
6cdd3b8f4fd3
DMV support patch by ("Ivan Kalvachev" <ivan at cacad dot com>)
michaelni
parents:
1317
diff
changeset
|
2851 }else |
6cdd3b8f4fd3
DMV support patch by ("Ivan Kalvachev" <ivan at cacad dot com>)
michaelni
parents:
1317
diff
changeset
|
2852 offset=(s->picture_structure == PICT_BOTTOM_FIELD)? |
6cdd3b8f4fd3
DMV support patch by ("Ivan Kalvachev" <ivan at cacad dot com>)
michaelni
parents:
1317
diff
changeset
|
2853 0 : s->linesize; |
6cdd3b8f4fd3
DMV support patch by ("Ivan Kalvachev" <ivan at cacad dot com>)
michaelni
parents:
1317
diff
changeset
|
2854 |
6cdd3b8f4fd3
DMV support patch by ("Ivan Kalvachev" <ivan at cacad dot com>)
michaelni
parents:
1317
diff
changeset
|
2855 //avg field from the opposite parity |
6cdd3b8f4fd3
DMV support patch by ("Ivan Kalvachev" <ivan at cacad dot com>)
michaelni
parents:
1317
diff
changeset
|
2856 mpeg_motion(s, dest_y, dest_cb, dest_cr,0, |
6cdd3b8f4fd3
DMV support patch by ("Ivan Kalvachev" <ivan at cacad dot com>)
michaelni
parents:
1317
diff
changeset
|
2857 ref_picture, offset, |
6cdd3b8f4fd3
DMV support patch by ("Ivan Kalvachev" <ivan at cacad dot com>)
michaelni
parents:
1317
diff
changeset
|
2858 0,dmv_pix_op, |
6cdd3b8f4fd3
DMV support patch by ("Ivan Kalvachev" <ivan at cacad dot com>)
michaelni
parents:
1317
diff
changeset
|
2859 s->mv[dir][2][0],s->mv[dir][2][1],16); |
6cdd3b8f4fd3
DMV support patch by ("Ivan Kalvachev" <ivan at cacad dot com>)
michaelni
parents:
1317
diff
changeset
|
2860 } |
6cdd3b8f4fd3
DMV support patch by ("Ivan Kalvachev" <ivan at cacad dot com>)
michaelni
parents:
1317
diff
changeset
|
2861 } |
6cdd3b8f4fd3
DMV support patch by ("Ivan Kalvachev" <ivan at cacad dot com>)
michaelni
parents:
1317
diff
changeset
|
2862 break; |
1633 | 2863 default: assert(0); |
0 | 2864 } |
2865 } | |
2866 | |
2867 | |
2868 /* put block[] to dest[] */ | |
2869 static inline void put_dct(MpegEncContext *s, | |
1651 | 2870 DCTELEM *block, int i, uint8_t *dest, int line_size, int qscale) |
0 | 2871 { |
1689 | 2872 s->dct_unquantize_intra(s, block, i, qscale); |
1092 | 2873 s->dsp.idct_put (dest, line_size, block); |
0 | 2874 } |
2875 | |
2876 /* add block[] to dest[] */ | |
2877 static inline void add_dct(MpegEncContext *s, | |
1064 | 2878 DCTELEM *block, int i, uint8_t *dest, int line_size) |
0 | 2879 { |
2880 if (s->block_last_index[i] >= 0) { | |
1092 | 2881 s->dsp.idct_add (dest, line_size, block); |
481 | 2882 } |
2883 } | |
2884 | |
2885 static inline void add_dequant_dct(MpegEncContext *s, | |
1644 | 2886 DCTELEM *block, int i, uint8_t *dest, int line_size, int qscale) |
481 | 2887 { |
2888 if (s->block_last_index[i] >= 0) { | |
1689 | 2889 s->dct_unquantize_inter(s, block, i, qscale); |
324 | 2890 |
1092 | 2891 s->dsp.idct_add (dest, line_size, block); |
0 | 2892 } |
2893 } | |
2894 | |
456 | 2895 /** |
2896 * cleans dc, ac, coded_block for the current non intra MB | |
2897 */ | |
2898 void ff_clean_intra_table_entries(MpegEncContext *s) | |
2899 { | |
2900 int wrap = s->block_wrap[0]; | |
2901 int xy = s->block_index[0]; | |
2902 | |
2903 s->dc_val[0][xy ] = | |
2904 s->dc_val[0][xy + 1 ] = | |
2905 s->dc_val[0][xy + wrap] = | |
2906 s->dc_val[0][xy + 1 + wrap] = 1024; | |
2907 /* ac pred */ | |
1064 | 2908 memset(s->ac_val[0][xy ], 0, 32 * sizeof(int16_t)); |
2909 memset(s->ac_val[0][xy + wrap], 0, 32 * sizeof(int16_t)); | |
456 | 2910 if (s->msmpeg4_version>=3) { |
2911 s->coded_block[xy ] = | |
2912 s->coded_block[xy + 1 ] = | |
2913 s->coded_block[xy + wrap] = | |
2914 s->coded_block[xy + 1 + wrap] = 0; | |
2915 } | |
2916 /* chroma */ | |
2917 wrap = s->block_wrap[4]; | |
2918 xy = s->mb_x + 1 + (s->mb_y + 1) * wrap; | |
2919 s->dc_val[1][xy] = | |
2920 s->dc_val[2][xy] = 1024; | |
2921 /* ac pred */ | |
1064 | 2922 memset(s->ac_val[1][xy], 0, 16 * sizeof(int16_t)); |
2923 memset(s->ac_val[2][xy], 0, 16 * sizeof(int16_t)); | |
456 | 2924 |
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
|
2925 s->mbintra_table[s->mb_x + s->mb_y*s->mb_stride]= 0; |
456 | 2926 } |
2927 | |
0 | 2928 /* generic function called after a macroblock has been parsed by the |
2929 decoder or after it has been encoded by the encoder. | |
2930 | |
2931 Important variables used: | |
2932 s->mb_intra : true if intra macroblock | |
2933 s->mv_dir : motion vector direction | |
2934 s->mv_type : motion vector type | |
2935 s->mv : motion vector | |
2936 s->interlaced_dct : true if interlaced dct used (mpeg2) | |
2937 */ | |
2938 void MPV_decode_mb(MpegEncContext *s, DCTELEM block[6][64]) | |
2939 { | |
244 | 2940 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
|
2941 const int mb_xy = s->mb_y * s->mb_stride + s->mb_x; |
1381 | 2942 #ifdef HAVE_XVMC |
2943 if(s->avctx->xvmc_acceleration){ | |
1580
628bf341e099
XvMC speedup by removing one memcpy and doing MB packing
iive
parents:
1579
diff
changeset
|
2944 XVMC_decode_mb(s);//xvmc uses pblocks |
1381 | 2945 return; |
2946 } | |
2947 #endif | |
0 | 2948 |
2949 mb_x = s->mb_x; | |
2950 mb_y = s->mb_y; | |
2951 | |
903 | 2952 s->current_picture.qscale_table[mb_xy]= s->qscale; |
108
1e4a4af694d1
exporting qscale data for postprocessing (for MPlayer)
arpi_esp
parents:
79
diff
changeset
|
2953 |
0 | 2954 /* update DC predictors for P macroblocks */ |
2955 if (!s->mb_intra) { | |
249
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
2956 if (s->h263_pred || s->h263_aic) { |
481 | 2957 if(s->mbintra_table[mb_xy]) |
456 | 2958 ff_clean_intra_table_entries(s); |
0 | 2959 } else { |
456 | 2960 s->last_dc[0] = |
2961 s->last_dc[1] = | |
0 | 2962 s->last_dc[2] = 128 << s->intra_dc_precision; |
2963 } | |
2964 } | |
249
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
2965 else if (s->h263_pred || s->h263_aic) |
481 | 2966 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
|
2967 |
909
8ae1e4c24e91
new PSNR code (now works with chroma, b frames, ...)
michaelni
parents:
903
diff
changeset
|
2968 if ((s->flags&CODEC_FLAG_PSNR) || !(s->encoding && (s->intra_only || s->pict_type==B_TYPE))) { //FIXME precalc |
1064 | 2969 uint8_t *dest_y, *dest_cb, *dest_cr; |
481 | 2970 int dct_linesize, dct_offset; |
651 | 2971 op_pixels_func (*op_pix)[4]; |
2972 qpel_mc_func (*op_qpix)[16]; | |
1138 | 2973 const int linesize= s->current_picture.linesize[0]; //not s->linesize as this woulnd be wrong for field pics |
2974 const int uvlinesize= s->current_picture.linesize[1]; | |
1632 | 2975 const int readable= s->pict_type != B_TYPE || s->encoding || s->avctx->draw_horiz_band; |
7
1d3ac9654178
added skip macroblock optimization (big perf win on black regions for example)
glantau
parents:
0
diff
changeset
|
2976 |
903 | 2977 /* avoid copy if macroblock skipped in last frame too */ |
2978 /* skip only during decoding as we might trash the buffers during encoding a bit */ | |
2979 if(!s->encoding){ | |
1064 | 2980 uint8_t *mbskip_ptr = &s->mbskip_table[mb_xy]; |
903 | 2981 const int age= s->current_picture.age; |
2982 | |
2983 assert(age); | |
2984 | |
7
1d3ac9654178
added skip macroblock optimization (big perf win on black regions for example)
glantau
parents:
0
diff
changeset
|
2985 if (s->mb_skiped) { |
903 | 2986 s->mb_skiped= 0; |
2987 assert(s->pict_type!=I_TYPE); | |
2988 | |
556 | 2989 (*mbskip_ptr) ++; /* indicate that this time we skiped it */ |
2990 if(*mbskip_ptr >99) *mbskip_ptr= 99; | |
2991 | |
903 | 2992 /* 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
|
2993 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
|
2994 return; |
903 | 2995 } |
1021
2d7c9f5738de
trying to fix mb skip bug in mpeg1/2 if slices are not used
michaelni
parents:
1014
diff
changeset
|
2996 } 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
|
2997 (*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
|
2998 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
|
2999 } else{ |
7
1d3ac9654178
added skip macroblock optimization (big perf win on black regions for example)
glantau
parents:
0
diff
changeset
|
3000 *mbskip_ptr = 0; /* not skipped */ |
1d3ac9654178
added skip macroblock optimization (big perf win on black regions for example)
glantau
parents:
0
diff
changeset
|
3001 } |
717 | 3002 } |
0 | 3003 |
3004 if (s->interlaced_dct) { | |
1138 | 3005 dct_linesize = linesize * 2; |
3006 dct_offset = linesize; | |
0 | 3007 } else { |
1138 | 3008 dct_linesize = linesize; |
3009 dct_offset = linesize * 8; | |
0 | 3010 } |
1632 | 3011 if(readable){ |
3012 dest_y= s->dest[0]; | |
3013 dest_cb= s->dest[1]; | |
3014 dest_cr= s->dest[2]; | |
3015 }else{ | |
3016 dest_y = s->edge_emu_buffer+32; //FIXME cleanup scratchpad pointers | |
3017 dest_cb= s->edge_emu_buffer+48; | |
3018 dest_cr= s->edge_emu_buffer+56; | |
3019 } | |
0 | 3020 if (!s->mb_intra) { |
3021 /* motion handling */ | |
456 | 3022 /* decoding or more than one mb_type (MC was allready done otherwise) */ |
1389 | 3023 if(!s->encoding){ |
327 | 3024 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
|
3025 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
|
3026 op_qpix= s->dsp.put_qpel_pixels_tab; |
324 | 3027 }else{ |
853
eacc2dd8fd9d
* using DSPContext - so each codec could use its local (sub)set of CPU extension
kabi
parents:
847
diff
changeset
|
3028 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
|
3029 op_qpix= s->dsp.put_no_rnd_qpel_pixels_tab; |
324 | 3030 } |
0 | 3031 |
324 | 3032 if (s->mv_dir & MV_DIR_FORWARD) { |
903 | 3033 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
|
3034 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
|
3035 op_qpix= s->dsp.avg_qpel_pixels_tab; |
324 | 3036 } |
3037 if (s->mv_dir & MV_DIR_BACKWARD) { | |
903 | 3038 MPV_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.data, op_pix, op_qpix); |
324 | 3039 } |
0 | 3040 } |
3041 | |
481 | 3042 /* skip dequant / idct if we are really late ;) */ |
814 | 3043 if(s->hurry_up>1) return; |
481 | 3044 |
0 | 3045 /* add dct residue */ |
1421 | 3046 if(s->encoding || !( s->h263_msmpeg4 || s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO |
711 | 3047 || (s->codec_id==CODEC_ID_MPEG4 && !s->mpeg_quant))){ |
1644 | 3048 add_dequant_dct(s, block[0], 0, dest_y, dct_linesize, s->qscale); |
3049 add_dequant_dct(s, block[1], 1, dest_y + 8, dct_linesize, s->qscale); | |
3050 add_dequant_dct(s, block[2], 2, dest_y + dct_offset, dct_linesize, s->qscale); | |
3051 add_dequant_dct(s, block[3], 3, dest_y + dct_offset + 8, dct_linesize, s->qscale); | |
0 | 3052 |
485 | 3053 if(!(s->flags&CODEC_FLAG_GRAY)){ |
1644 | 3054 add_dequant_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale); |
3055 add_dequant_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale); | |
485 | 3056 } |
936 | 3057 } else if(s->codec_id != CODEC_ID_WMV2){ |
481 | 3058 add_dct(s, block[0], 0, dest_y, dct_linesize); |
3059 add_dct(s, block[1], 1, dest_y + 8, dct_linesize); | |
3060 add_dct(s, block[2], 2, dest_y + dct_offset, dct_linesize); | |
3061 add_dct(s, block[3], 3, dest_y + dct_offset + 8, dct_linesize); | |
3062 | |
485 | 3063 if(!(s->flags&CODEC_FLAG_GRAY)){ |
1138 | 3064 add_dct(s, block[4], 4, dest_cb, uvlinesize); |
3065 add_dct(s, block[5], 5, dest_cr, uvlinesize); | |
485 | 3066 } |
1042 | 3067 } |
3068 #ifdef CONFIG_RISKY | |
3069 else{ | |
936 | 3070 ff_wmv2_add_mb(s, block, dest_y, dest_cb, dest_cr); |
481 | 3071 } |
1042 | 3072 #endif |
0 | 3073 } else { |
3074 /* dct only in intra block */ | |
1421 | 3075 if(s->encoding || !(s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO)){ |
1651 | 3076 put_dct(s, block[0], 0, dest_y, dct_linesize, s->qscale); |
3077 put_dct(s, block[1], 1, dest_y + 8, dct_linesize, s->qscale); | |
3078 put_dct(s, block[2], 2, dest_y + dct_offset, dct_linesize, s->qscale); | |
3079 put_dct(s, block[3], 3, dest_y + dct_offset + 8, dct_linesize, s->qscale); | |
0 | 3080 |
711 | 3081 if(!(s->flags&CODEC_FLAG_GRAY)){ |
1651 | 3082 put_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale); |
3083 put_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale); | |
711 | 3084 } |
3085 }else{ | |
1092 | 3086 s->dsp.idct_put(dest_y , dct_linesize, block[0]); |
3087 s->dsp.idct_put(dest_y + 8, dct_linesize, block[1]); | |
3088 s->dsp.idct_put(dest_y + dct_offset , dct_linesize, block[2]); | |
3089 s->dsp.idct_put(dest_y + dct_offset + 8, dct_linesize, block[3]); | |
711 | 3090 |
3091 if(!(s->flags&CODEC_FLAG_GRAY)){ | |
1138 | 3092 s->dsp.idct_put(dest_cb, uvlinesize, block[4]); |
3093 s->dsp.idct_put(dest_cr, uvlinesize, block[5]); | |
711 | 3094 } |
485 | 3095 } |
0 | 3096 } |
1632 | 3097 if(!readable){ |
3098 s->dsp.put_pixels_tab[0][0](s->dest[0], dest_y , linesize,16); | |
3099 s->dsp.put_pixels_tab[1][0](s->dest[1], dest_cb, uvlinesize, 8); | |
3100 s->dsp.put_pixels_tab[1][0](s->dest[2], dest_cr, uvlinesize, 8); | |
3101 } | |
0 | 3102 } |
294 | 3103 } |
3104 | |
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
|
3105 #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
|
3106 |
605
40874804a5af
same dc skip behavior for chroma & luma elimination, its confusing otherwise imho
michaelni
parents:
604
diff
changeset
|
3107 static inline void dct_single_coeff_elimination(MpegEncContext *s, int n, int threshold) |
456 | 3108 { |
3109 static const char tab[64]= | |
3110 {3,2,2,1,1,1,1,1, | |
3111 1,1,1,1,1,1,1,1, | |
3112 1,1,1,1,1,1,1,1, | |
3113 0,0,0,0,0,0,0,0, | |
3114 0,0,0,0,0,0,0,0, | |
3115 0,0,0,0,0,0,0,0, | |
3116 0,0,0,0,0,0,0,0, | |
3117 0,0,0,0,0,0,0,0}; | |
3118 int score=0; | |
3119 int run=0; | |
3120 int i; | |
3121 DCTELEM *block= s->block[n]; | |
3122 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
|
3123 int skip_dc; |
456 | 3124 |
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
|
3125 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
|
3126 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
|
3127 threshold= -threshold; |
605
40874804a5af
same dc skip behavior for chroma & luma elimination, its confusing otherwise imho
michaelni
parents:
604
diff
changeset
|
3128 }else |
40874804a5af
same dc skip behavior for chroma & luma elimination, its confusing otherwise imho
michaelni
parents:
604
diff
changeset
|
3129 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
|
3130 |
456 | 3131 /* are all which we could set to zero are allready zero? */ |
3132 if(last_index<=skip_dc - 1) return; | |
3133 | |
3134 for(i=0; i<=last_index; i++){ | |
706
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
3135 const int j = s->intra_scantable.permutated[i]; |
456 | 3136 const int level = ABS(block[j]); |
3137 if(level==1){ | |
3138 if(skip_dc && i==0) continue; | |
3139 score+= tab[run]; | |
3140 run=0; | |
3141 }else if(level>1){ | |
3142 return; | |
3143 }else{ | |
3144 run++; | |
3145 } | |
3146 } | |
3147 if(score >= threshold) return; | |
3148 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
|
3149 const int j = s->intra_scantable.permutated[i]; |
456 | 3150 block[j]=0; |
3151 } | |
3152 if(block[0]) s->block_last_index[n]= 0; | |
3153 else s->block_last_index[n]= -1; | |
3154 } | |
3155 | |
344 | 3156 static inline void clip_coeffs(MpegEncContext *s, DCTELEM *block, int last_index) |
3157 { | |
3158 int i; | |
3159 const int maxlevel= s->max_qcoeff; | |
3160 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
|
3161 int overflow=0; |
706
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
3162 |
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
3163 if(s->mb_intra){ |
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
3164 i=1; //skip clipping of intra dc |
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
3165 }else |
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
3166 i=0; |
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
3167 |
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
3168 for(;i<=last_index; i++){ |
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
3169 const int j= s->intra_scantable.permutated[i]; |
344 | 3170 int level = block[j]; |
3171 | |
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
|
3172 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
|
3173 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
|
3174 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
|
3175 }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
|
3176 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
|
3177 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
|
3178 } |
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
|
3179 |
344 | 3180 block[j]= level; |
3181 } | |
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
|
3182 |
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
|
3183 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
|
3184 av_log(s->avctx, AV_LOG_INFO, "warning, cliping %d dct coefficents to %d..%d\n", overflow, minlevel, maxlevel); |
344 | 3185 } |
324 | 3186 |
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
|
3187 #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
|
3188 |
1098
b7f267d168b7
mpeg2 field pictures + sliced mode (doesnt work with mplayer though, dunno why)
michaelni
parents:
1096
diff
changeset
|
3189 /** |
b7f267d168b7
mpeg2 field pictures + sliced mode (doesnt work with mplayer though, dunno why)
michaelni
parents:
1096
diff
changeset
|
3190 * |
b7f267d168b7
mpeg2 field pictures + sliced mode (doesnt work with mplayer though, dunno why)
michaelni
parents:
1096
diff
changeset
|
3191 * @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
|
3192 */ |
b7f267d168b7
mpeg2 field pictures + sliced mode (doesnt work with mplayer though, dunno why)
michaelni
parents:
1096
diff
changeset
|
3193 void ff_draw_horiz_band(MpegEncContext *s, int y, int h){ |
1368 | 3194 if (s->avctx->draw_horiz_band) { |
1370 | 3195 AVFrame *src; |
1368 | 3196 int offset[4]; |
1370 | 3197 |
3198 if(s->picture_structure != PICT_FRAME){ | |
3199 h <<= 1; | |
3200 y <<= 1; | |
3201 if(s->first_field && !(s->avctx->slice_flags&SLICE_FLAG_ALLOW_FIELD)) return; | |
3202 } | |
3203 | |
1098
b7f267d168b7
mpeg2 field pictures + sliced mode (doesnt work with mplayer though, dunno why)
michaelni
parents:
1096
diff
changeset
|
3204 h= FFMIN(h, s->height - y); |
b7f267d168b7
mpeg2 field pictures + sliced mode (doesnt work with mplayer though, dunno why)
michaelni
parents:
1096
diff
changeset
|
3205 |
1370 | 3206 if(s->pict_type==B_TYPE || s->low_delay || (s->avctx->slice_flags&SLICE_FLAG_CODED_ORDER)) |
3207 src= (AVFrame*)s->current_picture_ptr; | |
3208 else if(s->last_picture_ptr) | |
3209 src= (AVFrame*)s->last_picture_ptr; | |
3210 else | |
3211 return; | |
3212 | |
1369 | 3213 if(s->pict_type==B_TYPE && s->picture_structure == PICT_FRAME && s->out_format != FMT_H264){ |
1368 | 3214 offset[0]= |
3215 offset[1]= | |
3216 offset[2]= | |
3217 offset[3]= 0; | |
3218 }else{ | |
3219 offset[0]= y * s->linesize;; | |
3220 offset[1]= | |
3221 offset[2]= (y>>1) * s->uvlinesize;; | |
3222 offset[3]= 0; | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
731
diff
changeset
|
3223 } |
1368 | 3224 |
813 | 3225 emms_c(); |
3226 | |
1370 | 3227 s->avctx->draw_horiz_band(s->avctx, src, offset, |
3228 y, s->picture_structure, h); | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
731
diff
changeset
|
3229 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
731
diff
changeset
|
3230 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
731
diff
changeset
|
3231 |
1389 | 3232 void ff_init_block_index(MpegEncContext *s){ //FIXME maybe rename |
3233 const int linesize= s->current_picture.linesize[0]; //not s->linesize as this woulnd be wrong for field pics | |
3234 const int uvlinesize= s->current_picture.linesize[1]; | |
3235 | |
3236 s->block_index[0]= s->block_wrap[0]*(s->mb_y*2 + 1) - 1 + s->mb_x*2; | |
3237 s->block_index[1]= s->block_wrap[0]*(s->mb_y*2 + 1) + s->mb_x*2; | |
3238 s->block_index[2]= s->block_wrap[0]*(s->mb_y*2 + 2) - 1 + s->mb_x*2; | |
3239 s->block_index[3]= s->block_wrap[0]*(s->mb_y*2 + 2) + s->mb_x*2; | |
3240 s->block_index[4]= s->block_wrap[4]*(s->mb_y + 1) + s->block_wrap[0]*(s->mb_height*2 + 2) + s->mb_x; | |
3241 s->block_index[5]= s->block_wrap[4]*(s->mb_y + 1 + s->mb_height + 2) + s->block_wrap[0]*(s->mb_height*2 + 2) + s->mb_x; | |
3242 | |
3243 if(s->pict_type==B_TYPE && s->avctx->draw_horiz_band && s->picture_structure==PICT_FRAME){ | |
3244 s->dest[0] = s->current_picture.data[0] + s->mb_x * 16 - 16; | |
3245 s->dest[1] = s->current_picture.data[1] + s->mb_x * 8 - 8; | |
3246 s->dest[2] = s->current_picture.data[2] + s->mb_x * 8 - 8; | |
3247 }else{ | |
3248 s->dest[0] = s->current_picture.data[0] + (s->mb_y * 16* linesize ) + s->mb_x * 16 - 16; | |
3249 s->dest[1] = s->current_picture.data[1] + (s->mb_y * 8 * uvlinesize) + s->mb_x * 8 - 8; | |
3250 s->dest[2] = s->current_picture.data[2] + (s->mb_y * 8 * uvlinesize) + s->mb_x * 8 - 8; | |
3251 } | |
3252 } | |
3253 | |
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
|
3254 #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
|
3255 |
324 | 3256 static void encode_mb(MpegEncContext *s, int motion_x, int motion_y) |
294 | 3257 { |
3258 const int mb_x= s->mb_x; | |
3259 const int mb_y= s->mb_y; | |
3260 int i; | |
456 | 3261 int skip_dct[6]; |
697 | 3262 int dct_offset = s->linesize*8; //default for progressive frames |
3263 | |
456 | 3264 for(i=0; i<6; i++) skip_dct[i]=0; |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
673
diff
changeset
|
3265 |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
673
diff
changeset
|
3266 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
|
3267 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
|
3268 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
|
3269 |
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
|
3270 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
|
3271 update_qscale(s); |
1616 | 3272 |
3273 if(!(s->flags&CODEC_FLAG_QP_RD)){ | |
3274 s->dquant= s->qscale - last_qp; | |
3275 | |
3276 if(s->out_format==FMT_H263) | |
3277 s->dquant= clip(s->dquant, -2, 2); //FIXME RD | |
697 | 3278 |
1616 | 3279 if(s->codec_id==CODEC_ID_MPEG4){ |
3280 if(!s->mb_intra){ | |
3281 if((s->mv_dir&MV_DIRECT) || s->mv_type==MV_TYPE_8X8) | |
3282 s->dquant=0; | |
3283 } | |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
673
diff
changeset
|
3284 } |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
673
diff
changeset
|
3285 } |
1652 | 3286 ff_set_qscale(s, last_qp + s->dquant); |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
673
diff
changeset
|
3287 } |
294 | 3288 |
324 | 3289 if (s->mb_intra) { |
1064 | 3290 uint8_t *ptr; |
697 | 3291 int wrap_y; |
570
274d9c5a75ee
use edge emu for encoding of width or height %16!=0 files
michaelni
parents:
569
diff
changeset
|
3292 int emu=0; |
294 | 3293 |
697 | 3294 wrap_y = s->linesize; |
903 | 3295 ptr = s->new_picture.data[0] + (mb_y * 16 * wrap_y) + mb_x * 16; |
697 | 3296 |
570
274d9c5a75ee
use edge emu for encoding of width or height %16!=0 files
michaelni
parents:
569
diff
changeset
|
3297 if(mb_x*16+16 > s->width || mb_y*16+16 > s->height){ |
1317
26c44d2433c1
make ff_emulated_edge_mc() independant of MpegEncContext
michaelni
parents:
1315
diff
changeset
|
3298 ff_emulated_edge_mc(s->edge_emu_buffer, ptr, wrap_y, 16, 16, mb_x*16, mb_y*16, s->width, s->height); |
570
274d9c5a75ee
use edge emu for encoding of width or height %16!=0 files
michaelni
parents:
569
diff
changeset
|
3299 ptr= s->edge_emu_buffer; |
274d9c5a75ee
use edge emu for encoding of width or height %16!=0 files
michaelni
parents:
569
diff
changeset
|
3300 emu=1; |
274d9c5a75ee
use edge emu for encoding of width or height %16!=0 files
michaelni
parents:
569
diff
changeset
|
3301 } |
697 | 3302 |
3303 if(s->flags&CODEC_FLAG_INTERLACED_DCT){ | |
3304 int progressive_score, interlaced_score; | |
1708 | 3305 |
1729 | 3306 s->interlaced_dct=0; |
3307 progressive_score= s->dsp.ildct_cmp[4](s, ptr , NULL, wrap_y, 8) | |
3308 +s->dsp.ildct_cmp[4](s, ptr + wrap_y*8, NULL, wrap_y, 8) - 400; | |
3309 | |
3310 if(progressive_score > 0){ | |
3311 interlaced_score = s->dsp.ildct_cmp[4](s, ptr , NULL, wrap_y*2, 8) | |
3312 +s->dsp.ildct_cmp[4](s, ptr + wrap_y , NULL, wrap_y*2, 8); | |
3313 if(progressive_score > interlaced_score){ | |
3314 s->interlaced_dct=1; | |
697 | 3315 |
1729 | 3316 dct_offset= wrap_y; |
3317 wrap_y<<=1; | |
3318 } | |
3319 } | |
697 | 3320 } |
3321 | |
853
eacc2dd8fd9d
* using DSPContext - so each codec could use its local (sub)set of CPU extension
kabi
parents:
847
diff
changeset
|
3322 s->dsp.get_pixels(s->block[0], ptr , wrap_y); |
eacc2dd8fd9d
* using DSPContext - so each codec could use its local (sub)set of CPU extension
kabi
parents:
847
diff
changeset
|
3323 s->dsp.get_pixels(s->block[1], ptr + 8, wrap_y); |
eacc2dd8fd9d
* using DSPContext - so each codec could use its local (sub)set of CPU extension
kabi
parents:
847
diff
changeset
|
3324 s->dsp.get_pixels(s->block[2], ptr + dct_offset , wrap_y); |
eacc2dd8fd9d
* using DSPContext - so each codec could use its local (sub)set of CPU extension
kabi
parents:
847
diff
changeset
|
3325 s->dsp.get_pixels(s->block[3], ptr + dct_offset + 8, wrap_y); |
294 | 3326 |
487 | 3327 if(s->flags&CODEC_FLAG_GRAY){ |
3328 skip_dct[4]= 1; | |
3329 skip_dct[5]= 1; | |
3330 }else{ | |
697 | 3331 int wrap_c = s->uvlinesize; |
903 | 3332 ptr = s->new_picture.data[1] + (mb_y * 8 * wrap_c) + mb_x * 8; |
570
274d9c5a75ee
use edge emu for encoding of width or height %16!=0 files
michaelni
parents:
569
diff
changeset
|
3333 if(emu){ |
1317
26c44d2433c1
make ff_emulated_edge_mc() independant of MpegEncContext
michaelni
parents:
1315
diff
changeset
|
3334 ff_emulated_edge_mc(s->edge_emu_buffer, ptr, wrap_c, 8, 8, mb_x*8, mb_y*8, s->width>>1, s->height>>1); |
570
274d9c5a75ee
use edge emu for encoding of width or height %16!=0 files
michaelni
parents:
569
diff
changeset
|
3335 ptr= s->edge_emu_buffer; |
274d9c5a75ee
use edge emu for encoding of width or height %16!=0 files
michaelni
parents:
569
diff
changeset
|
3336 } |
853
eacc2dd8fd9d
* using DSPContext - so each codec could use its local (sub)set of CPU extension
kabi
parents:
847
diff
changeset
|
3337 s->dsp.get_pixels(s->block[4], ptr, wrap_c); |
294 | 3338 |
903 | 3339 ptr = s->new_picture.data[2] + (mb_y * 8 * wrap_c) + mb_x * 8; |
570
274d9c5a75ee
use edge emu for encoding of width or height %16!=0 files
michaelni
parents:
569
diff
changeset
|
3340 if(emu){ |
1317
26c44d2433c1
make ff_emulated_edge_mc() independant of MpegEncContext
michaelni
parents:
1315
diff
changeset
|
3341 ff_emulated_edge_mc(s->edge_emu_buffer, ptr, wrap_c, 8, 8, mb_x*8, mb_y*8, s->width>>1, s->height>>1); |
570
274d9c5a75ee
use edge emu for encoding of width or height %16!=0 files
michaelni
parents:
569
diff
changeset
|
3342 ptr= s->edge_emu_buffer; |
274d9c5a75ee
use edge emu for encoding of width or height %16!=0 files
michaelni
parents:
569
diff
changeset
|
3343 } |
853
eacc2dd8fd9d
* using DSPContext - so each codec could use its local (sub)set of CPU extension
kabi
parents:
847
diff
changeset
|
3344 s->dsp.get_pixels(s->block[5], ptr, wrap_c); |
487 | 3345 } |
324 | 3346 }else{ |
651 | 3347 op_pixels_func (*op_pix)[4]; |
3348 qpel_mc_func (*op_qpix)[16]; | |
1064 | 3349 uint8_t *dest_y, *dest_cb, *dest_cr; |
3350 uint8_t *ptr_y, *ptr_cb, *ptr_cr; | |
456 | 3351 int wrap_y, wrap_c; |
570
274d9c5a75ee
use edge emu for encoding of width or height %16!=0 files
michaelni
parents:
569
diff
changeset
|
3352 int emu=0; |
294 | 3353 |
1389 | 3354 dest_y = s->dest[0]; |
3355 dest_cb = s->dest[1]; | |
3356 dest_cr = s->dest[2]; | |
456 | 3357 wrap_y = s->linesize; |
697 | 3358 wrap_c = s->uvlinesize; |
903 | 3359 ptr_y = s->new_picture.data[0] + (mb_y * 16 * wrap_y) + mb_x * 16; |
3360 ptr_cb = s->new_picture.data[1] + (mb_y * 8 * wrap_c) + mb_x * 8; | |
3361 ptr_cr = s->new_picture.data[2] + (mb_y * 8 * wrap_c) + mb_x * 8; | |
324 | 3362 |
327 | 3363 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
|
3364 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
|
3365 op_qpix= s->dsp.put_qpel_pixels_tab; |
295 | 3366 }else{ |
853
eacc2dd8fd9d
* using DSPContext - so each codec could use its local (sub)set of CPU extension
kabi
parents:
847
diff
changeset
|
3367 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
|
3368 op_qpix= s->dsp.put_no_rnd_qpel_pixels_tab; |
324 | 3369 } |
295 | 3370 |
324 | 3371 if (s->mv_dir & MV_DIR_FORWARD) { |
903 | 3372 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
|
3373 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
|
3374 op_qpix= s->dsp.avg_qpel_pixels_tab; |
324 | 3375 } |
3376 if (s->mv_dir & MV_DIR_BACKWARD) { | |
903 | 3377 MPV_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.data, op_pix, op_qpix); |
324 | 3378 } |
295 | 3379 |
570
274d9c5a75ee
use edge emu for encoding of width or height %16!=0 files
michaelni
parents:
569
diff
changeset
|
3380 if(mb_x*16+16 > s->width || mb_y*16+16 > s->height){ |
1317
26c44d2433c1
make ff_emulated_edge_mc() independant of MpegEncContext
michaelni
parents:
1315
diff
changeset
|
3381 ff_emulated_edge_mc(s->edge_emu_buffer, ptr_y, wrap_y, 16, 16, mb_x*16, mb_y*16, s->width, s->height); |
570
274d9c5a75ee
use edge emu for encoding of width or height %16!=0 files
michaelni
parents:
569
diff
changeset
|
3382 ptr_y= s->edge_emu_buffer; |
274d9c5a75ee
use edge emu for encoding of width or height %16!=0 files
michaelni
parents:
569
diff
changeset
|
3383 emu=1; |
274d9c5a75ee
use edge emu for encoding of width or height %16!=0 files
michaelni
parents:
569
diff
changeset
|
3384 } |
697 | 3385 |
3386 if(s->flags&CODEC_FLAG_INTERLACED_DCT){ | |
3387 int progressive_score, interlaced_score; | |
1729 | 3388 |
3389 s->interlaced_dct=0; | |
3390 progressive_score= s->dsp.ildct_cmp[0](s, dest_y , ptr_y , wrap_y, 8) | |
3391 +s->dsp.ildct_cmp[0](s, dest_y + wrap_y*8, ptr_y + wrap_y*8, wrap_y, 8) - 400; | |
697 | 3392 |
1729 | 3393 if(s->avctx->ildct_cmp == FF_CMP_VSSE) progressive_score -= 400; |
3394 | |
3395 if(progressive_score>0){ | |
3396 interlaced_score = s->dsp.ildct_cmp[0](s, dest_y , ptr_y , wrap_y*2, 8) | |
3397 +s->dsp.ildct_cmp[0](s, dest_y + wrap_y , ptr_y + wrap_y , wrap_y*2, 8); | |
697 | 3398 |
1729 | 3399 if(progressive_score > interlaced_score){ |
3400 s->interlaced_dct=1; | |
3401 | |
3402 dct_offset= wrap_y; | |
3403 wrap_y<<=1; | |
3404 } | |
3405 } | |
697 | 3406 } |
3407 | |
853
eacc2dd8fd9d
* using DSPContext - so each codec could use its local (sub)set of CPU extension
kabi
parents:
847
diff
changeset
|
3408 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
|
3409 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
|
3410 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
|
3411 s->dsp.diff_pixels(s->block[3], ptr_y + dct_offset + 8, dest_y + dct_offset + 8, wrap_y); |
487 | 3412 |
3413 if(s->flags&CODEC_FLAG_GRAY){ | |
3414 skip_dct[4]= 1; | |
3415 skip_dct[5]= 1; | |
3416 }else{ | |
570
274d9c5a75ee
use edge emu for encoding of width or height %16!=0 files
michaelni
parents:
569
diff
changeset
|
3417 if(emu){ |
1317
26c44d2433c1
make ff_emulated_edge_mc() independant of MpegEncContext
michaelni
parents:
1315
diff
changeset
|
3418 ff_emulated_edge_mc(s->edge_emu_buffer, ptr_cb, wrap_c, 8, 8, mb_x*8, mb_y*8, s->width>>1, s->height>>1); |
570
274d9c5a75ee
use edge emu for encoding of width or height %16!=0 files
michaelni
parents:
569
diff
changeset
|
3419 ptr_cb= s->edge_emu_buffer; |
274d9c5a75ee
use edge emu for encoding of width or height %16!=0 files
michaelni
parents:
569
diff
changeset
|
3420 } |
853
eacc2dd8fd9d
* using DSPContext - so each codec could use its local (sub)set of CPU extension
kabi
parents:
847
diff
changeset
|
3421 s->dsp.diff_pixels(s->block[4], ptr_cb, dest_cb, wrap_c); |
570
274d9c5a75ee
use edge emu for encoding of width or height %16!=0 files
michaelni
parents:
569
diff
changeset
|
3422 if(emu){ |
1317
26c44d2433c1
make ff_emulated_edge_mc() independant of MpegEncContext
michaelni
parents:
1315
diff
changeset
|
3423 ff_emulated_edge_mc(s->edge_emu_buffer, ptr_cr, wrap_c, 8, 8, mb_x*8, mb_y*8, s->width>>1, s->height>>1); |
570
274d9c5a75ee
use edge emu for encoding of width or height %16!=0 files
michaelni
parents:
569
diff
changeset
|
3424 ptr_cr= s->edge_emu_buffer; |
274d9c5a75ee
use edge emu for encoding of width or height %16!=0 files
michaelni
parents:
569
diff
changeset
|
3425 } |
853
eacc2dd8fd9d
* using DSPContext - so each codec could use its local (sub)set of CPU extension
kabi
parents:
847
diff
changeset
|
3426 s->dsp.diff_pixels(s->block[5], ptr_cr, dest_cr, wrap_c); |
487 | 3427 } |
456 | 3428 /* 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
|
3429 if(s->current_picture.mc_mb_var[s->mb_stride*mb_y+ mb_x]<2*s->qscale*s->qscale){ |
697 | 3430 //FIXME optimize |
1708 | 3431 if(s->dsp.sad[1](NULL, ptr_y , dest_y , wrap_y, 8) < 20*s->qscale) skip_dct[0]= 1; |
3432 if(s->dsp.sad[1](NULL, ptr_y + 8, dest_y + 8, wrap_y, 8) < 20*s->qscale) skip_dct[1]= 1; | |
3433 if(s->dsp.sad[1](NULL, ptr_y +dct_offset , dest_y +dct_offset , wrap_y, 8) < 20*s->qscale) skip_dct[2]= 1; | |
3434 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; | |
3435 if(s->dsp.sad[1](NULL, ptr_cb , dest_cb , wrap_c, 8) < 20*s->qscale) skip_dct[4]= 1; | |
3436 if(s->dsp.sad[1](NULL, ptr_cr , dest_cr , wrap_c, 8) < 20*s->qscale) skip_dct[5]= 1; | |
456 | 3437 #if 0 |
3438 { | |
3439 static int stat[7]; | |
3440 int num=0; | |
3441 for(i=0; i<6; i++) | |
3442 if(skip_dct[i]) num++; | |
3443 stat[num]++; | |
3444 | |
3445 if(s->mb_x==0 && s->mb_y==0){ | |
3446 for(i=0; i<7; i++){ | |
3447 printf("%6d %1d\n", stat[i], i); | |
3448 } | |
3449 } | |
3450 } | |
3451 #endif | |
3452 } | |
324 | 3453 |
294 | 3454 } |
3455 | |
3456 /* DCT & quantize */ | |
344 | 3457 if(s->out_format==FMT_MJPEG){ |
3458 for(i=0;i<6;i++) { | |
3459 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
|
3460 s->block_last_index[i] = s->dct_quantize(s, s->block[i], i, 8, &overflow); |
350
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
347
diff
changeset
|
3461 if (overflow) clip_coeffs(s, s->block[i], s->block_last_index[i]); |
344 | 3462 } |
3463 }else{ | |
3464 for(i=0;i<6;i++) { | |
456 | 3465 if(!skip_dct[i]){ |
3466 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
|
3467 s->block_last_index[i] = s->dct_quantize(s, s->block[i], i, s->qscale, &overflow); |
344 | 3468 // 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
|
3469 // 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
|
3470 // of improve it. Just INTRADC clipping deserves changes in quantizer |
456 | 3471 if (overflow) clip_coeffs(s, s->block[i], s->block_last_index[i]); |
3472 }else | |
3473 s->block_last_index[i]= -1; | |
344 | 3474 } |
1490
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1480
diff
changeset
|
3475 |
456 | 3476 if(s->luma_elim_threshold && !s->mb_intra) |
3477 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
|
3478 dct_single_coeff_elimination(s, i, s->luma_elim_threshold); |
456 | 3479 if(s->chroma_elim_threshold && !s->mb_intra) |
3480 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
|
3481 dct_single_coeff_elimination(s, i, s->chroma_elim_threshold); |
1497 | 3482 |
3483 if(s->flags & CODEC_FLAG_CBP_RD){ | |
3484 for(i=0;i<6;i++) { | |
3485 if(s->block_last_index[i] == -1) | |
3486 s->coded_score[i]= INT_MAX/256; | |
3487 } | |
3488 } | |
294 | 3489 } |
3490 | |
487 | 3491 if((s->flags&CODEC_FLAG_GRAY) && s->mb_intra){ |
3492 s->block_last_index[4]= | |
3493 s->block_last_index[5]= 0; | |
3494 s->block[4][0]= | |
1011 | 3495 s->block[5][0]= (1024 + s->c_dc_scale/2)/ s->c_dc_scale; |
487 | 3496 } |
3497 | |
1708 | 3498 //non c quantize code returns incorrect block_last_index FIXME |
3499 if(s->alternate_scan && s->dct_quantize != dct_quantize_c){ | |
3500 for(i=0; i<6; i++){ | |
3501 int j; | |
3502 if(s->block_last_index[i]>0){ | |
3503 for(j=63; j>0; j--){ | |
3504 if(s->block[i][ s->intra_scantable.permutated[j] ]) break; | |
3505 } | |
3506 s->block_last_index[i]= j; | |
3507 } | |
3508 } | |
3509 } | |
3510 | |
294 | 3511 /* huffman encode */ |
936 | 3512 switch(s->codec_id){ //FIXME funct ptr could be slightly faster |
3513 case CODEC_ID_MPEG1VIDEO: | |
1421 | 3514 case CODEC_ID_MPEG2VIDEO: |
936 | 3515 mpeg1_encode_mb(s, s->block, motion_x, motion_y); break; |
1042 | 3516 #ifdef CONFIG_RISKY |
936 | 3517 case CODEC_ID_MPEG4: |
3518 mpeg4_encode_mb(s, s->block, motion_x, motion_y); break; | |
3519 case CODEC_ID_MSMPEG4V2: | |
3520 case CODEC_ID_MSMPEG4V3: | |
3521 case CODEC_ID_WMV1: | |
3522 msmpeg4_encode_mb(s, s->block, motion_x, motion_y); break; | |
3523 case CODEC_ID_WMV2: | |
3524 ff_wmv2_encode_mb(s, s->block, motion_x, motion_y); break; | |
3525 case CODEC_ID_H263: | |
3526 case CODEC_ID_H263P: | |
1353
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1344
diff
changeset
|
3527 case CODEC_ID_FLV1: |
936 | 3528 case CODEC_ID_RV10: |
3529 h263_encode_mb(s, s->block, motion_x, motion_y); break; | |
1042 | 3530 #endif |
3531 case CODEC_ID_MJPEG: | |
3532 mjpeg_encode_mb(s, s->block); break; | |
936 | 3533 default: |
3534 assert(0); | |
294 | 3535 } |
3536 } | |
3537 | |
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
|
3538 #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
|
3539 |
1026 | 3540 /** |
3541 * combines the (truncated) bitstream to a complete frame | |
3542 * @returns -1 if no complete frame could be created | |
3543 */ | |
3544 int ff_combine_frame( MpegEncContext *s, int next, uint8_t **buf, int *buf_size){ | |
3545 ParseContext *pc= &s->parse_context; | |
1218
358bbc952e27
10l (returning negative number of consumed bytes if the first startcode of a frame was split between 2 buffers)
michaelni
parents:
1215
diff
changeset
|
3546 |
358bbc952e27
10l (returning negative number of consumed bytes if the first startcode of a frame was split between 2 buffers)
michaelni
parents:
1215
diff
changeset
|
3547 #if 0 |
358bbc952e27
10l (returning negative number of consumed bytes if the first startcode of a frame was split between 2 buffers)
michaelni
parents:
1215
diff
changeset
|
3548 if(pc->overread){ |
358bbc952e27
10l (returning negative number of consumed bytes if the first startcode of a frame was split between 2 buffers)
michaelni
parents:
1215
diff
changeset
|
3549 printf("overread %d, state:%X next:%d index:%d o_index:%d\n", pc->overread, pc->state, next, pc->index, pc->overread_index); |
358bbc952e27
10l (returning negative number of consumed bytes if the first startcode of a frame was split between 2 buffers)
michaelni
parents:
1215
diff
changeset
|
3550 printf("%X %X %X %X\n", (*buf)[0], (*buf)[1],(*buf)[2],(*buf)[3]); |
358bbc952e27
10l (returning negative number of consumed bytes if the first startcode of a frame was split between 2 buffers)
michaelni
parents:
1215
diff
changeset
|
3551 } |
358bbc952e27
10l (returning negative number of consumed bytes if the first startcode of a frame was split between 2 buffers)
michaelni
parents:
1215
diff
changeset
|
3552 #endif |
358bbc952e27
10l (returning negative number of consumed bytes if the first startcode of a frame was split between 2 buffers)
michaelni
parents:
1215
diff
changeset
|
3553 |
358bbc952e27
10l (returning negative number of consumed bytes if the first startcode of a frame was split between 2 buffers)
michaelni
parents:
1215
diff
changeset
|
3554 /* copy overreaded byes from last frame into buffer */ |
358bbc952e27
10l (returning negative number of consumed bytes if the first startcode of a frame was split between 2 buffers)
michaelni
parents:
1215
diff
changeset
|
3555 for(; pc->overread>0; pc->overread--){ |
358bbc952e27
10l (returning negative number of consumed bytes if the first startcode of a frame was split between 2 buffers)
michaelni
parents:
1215
diff
changeset
|
3556 pc->buffer[pc->index++]= pc->buffer[pc->overread_index++]; |
358bbc952e27
10l (returning negative number of consumed bytes if the first startcode of a frame was split between 2 buffers)
michaelni
parents:
1215
diff
changeset
|
3557 } |
358bbc952e27
10l (returning negative number of consumed bytes if the first startcode of a frame was split between 2 buffers)
michaelni
parents:
1215
diff
changeset
|
3558 |
1026 | 3559 pc->last_index= pc->index; |
3560 | |
1218
358bbc952e27
10l (returning negative number of consumed bytes if the first startcode of a frame was split between 2 buffers)
michaelni
parents:
1215
diff
changeset
|
3561 /* copy into buffer end return */ |
358bbc952e27
10l (returning negative number of consumed bytes if the first startcode of a frame was split between 2 buffers)
michaelni
parents:
1215
diff
changeset
|
3562 if(next == END_NOT_FOUND){ |
1026 | 3563 pc->buffer= av_fast_realloc(pc->buffer, &pc->buffer_size, (*buf_size) + pc->index + FF_INPUT_BUFFER_PADDING_SIZE); |
3564 | |
3565 memcpy(&pc->buffer[pc->index], *buf, *buf_size); | |
3566 pc->index += *buf_size; | |
3567 return -1; | |
3568 } | |
1288 | 3569 |
3570 *buf_size= | |
1218
358bbc952e27
10l (returning negative number of consumed bytes if the first startcode of a frame was split between 2 buffers)
michaelni
parents:
1215
diff
changeset
|
3571 pc->overread_index= pc->index + next; |
358bbc952e27
10l (returning negative number of consumed bytes if the first startcode of a frame was split between 2 buffers)
michaelni
parents:
1215
diff
changeset
|
3572 |
358bbc952e27
10l (returning negative number of consumed bytes if the first startcode of a frame was split between 2 buffers)
michaelni
parents:
1215
diff
changeset
|
3573 /* append to buffer */ |
1026 | 3574 if(pc->index){ |
3575 pc->buffer= av_fast_realloc(pc->buffer, &pc->buffer_size, next + pc->index + FF_INPUT_BUFFER_PADDING_SIZE); | |
3576 | |
3577 memcpy(&pc->buffer[pc->index], *buf, next + FF_INPUT_BUFFER_PADDING_SIZE ); | |
3578 pc->index = 0; | |
3579 *buf= pc->buffer; | |
3580 } | |
3581 | |
1218
358bbc952e27
10l (returning negative number of consumed bytes if the first startcode of a frame was split between 2 buffers)
michaelni
parents:
1215
diff
changeset
|
3582 /* store overread bytes */ |
358bbc952e27
10l (returning negative number of consumed bytes if the first startcode of a frame was split between 2 buffers)
michaelni
parents:
1215
diff
changeset
|
3583 for(;next < 0; next++){ |
358bbc952e27
10l (returning negative number of consumed bytes if the first startcode of a frame was split between 2 buffers)
michaelni
parents:
1215
diff
changeset
|
3584 pc->state = (pc->state<<8) | pc->buffer[pc->last_index + next]; |
358bbc952e27
10l (returning negative number of consumed bytes if the first startcode of a frame was split between 2 buffers)
michaelni
parents:
1215
diff
changeset
|
3585 pc->overread++; |
358bbc952e27
10l (returning negative number of consumed bytes if the first startcode of a frame was split between 2 buffers)
michaelni
parents:
1215
diff
changeset
|
3586 } |
358bbc952e27
10l (returning negative number of consumed bytes if the first startcode of a frame was split between 2 buffers)
michaelni
parents:
1215
diff
changeset
|
3587 |
358bbc952e27
10l (returning negative number of consumed bytes if the first startcode of a frame was split between 2 buffers)
michaelni
parents:
1215
diff
changeset
|
3588 #if 0 |
358bbc952e27
10l (returning negative number of consumed bytes if the first startcode of a frame was split between 2 buffers)
michaelni
parents:
1215
diff
changeset
|
3589 if(pc->overread){ |
358bbc952e27
10l (returning negative number of consumed bytes if the first startcode of a frame was split between 2 buffers)
michaelni
parents:
1215
diff
changeset
|
3590 printf("overread %d, state:%X next:%d index:%d o_index:%d\n", pc->overread, pc->state, next, pc->index, pc->overread_index); |
358bbc952e27
10l (returning negative number of consumed bytes if the first startcode of a frame was split between 2 buffers)
michaelni
parents:
1215
diff
changeset
|
3591 printf("%X %X %X %X\n", (*buf)[0], (*buf)[1],(*buf)[2],(*buf)[3]); |
358bbc952e27
10l (returning negative number of consumed bytes if the first startcode of a frame was split between 2 buffers)
michaelni
parents:
1215
diff
changeset
|
3592 } |
358bbc952e27
10l (returning negative number of consumed bytes if the first startcode of a frame was split between 2 buffers)
michaelni
parents:
1215
diff
changeset
|
3593 #endif |
358bbc952e27
10l (returning negative number of consumed bytes if the first startcode of a frame was split between 2 buffers)
michaelni
parents:
1215
diff
changeset
|
3594 |
1026 | 3595 return 0; |
3596 } | |
3597 | |
1368 | 3598 void ff_mpeg_flush(AVCodecContext *avctx){ |
3599 int i; | |
3600 MpegEncContext *s = avctx->priv_data; | |
3601 | |
1751 | 3602 if(s==NULL || s->picture==NULL) |
3603 return; | |
3604 | |
1368 | 3605 for(i=0; i<MAX_PICTURE_COUNT; i++){ |
3606 if(s->picture[i].data[0] && ( s->picture[i].type == FF_BUFFER_TYPE_INTERNAL | |
3607 || s->picture[i].type == FF_BUFFER_TYPE_USER)) | |
3608 avctx->release_buffer(avctx, (AVFrame*)&s->picture[i]); | |
3609 } | |
1601 | 3610 s->current_picture_ptr = s->last_picture_ptr = s->next_picture_ptr = NULL; |
1395 | 3611 |
3612 s->parse_context.state= -1; | |
3613 s->parse_context.frame_start_found= 0; | |
3614 s->parse_context.overread= 0; | |
3615 s->parse_context.overread_index= 0; | |
3616 s->parse_context.index= 0; | |
3617 s->parse_context.last_index= 0; | |
1368 | 3618 } |
3619 | |
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
|
3620 #ifdef CONFIG_ENCODERS |
1064 | 3621 void ff_copy_bits(PutBitContext *pb, uint8_t *src, int length) |
294 | 3622 { |
326 | 3623 int bytes= length>>4; |
3624 int bits= length&15; | |
3625 int i; | |
3626 | |
456 | 3627 if(length==0) return; |
3628 | |
326 | 3629 for(i=0; i<bytes; i++) put_bits(pb, 16, be2me_16(((uint16_t*)src)[i])); |
3630 put_bits(pb, bits, be2me_16(((uint16_t*)src)[i])>>(16-bits)); | |
0 | 3631 } |
3632 | |
456 | 3633 static inline void copy_context_before_encode(MpegEncContext *d, MpegEncContext *s, int type){ |
326 | 3634 int i; |
3635 | |
3636 memcpy(d->last_mv, s->last_mv, 2*2*2*sizeof(int)); //FIXME is memcpy faster then a loop? | |
3637 | |
3638 /* mpeg1 */ | |
1160 | 3639 d->mb_skip_run= s->mb_skip_run; |
326 | 3640 for(i=0; i<3; i++) |
3641 d->last_dc[i]= s->last_dc[i]; | |
3642 | |
3643 /* statistics */ | |
3644 d->mv_bits= s->mv_bits; | |
3645 d->i_tex_bits= s->i_tex_bits; | |
3646 d->p_tex_bits= s->p_tex_bits; | |
3647 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
|
3648 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
|
3649 d->b_count= s->b_count; |
326 | 3650 d->skip_count= s->skip_count; |
3651 d->misc_bits= s->misc_bits; | |
329 | 3652 d->last_bits= 0; |
327 | 3653 |
1389 | 3654 d->mb_skiped= 0; |
912 | 3655 d->qscale= s->qscale; |
1616 | 3656 d->dquant= s->dquant; |
326 | 3657 } |
3658 | |
456 | 3659 static inline void copy_context_after_encode(MpegEncContext *d, MpegEncContext *s, int type){ |
326 | 3660 int i; |
3661 | |
3662 memcpy(d->mv, s->mv, 2*4*2*sizeof(int)); | |
3663 memcpy(d->last_mv, s->last_mv, 2*2*2*sizeof(int)); //FIXME is memcpy faster then a loop? | |
3664 | |
3665 /* mpeg1 */ | |
1160 | 3666 d->mb_skip_run= s->mb_skip_run; |
326 | 3667 for(i=0; i<3; i++) |
3668 d->last_dc[i]= s->last_dc[i]; | |
3669 | |
3670 /* statistics */ | |
3671 d->mv_bits= s->mv_bits; | |
3672 d->i_tex_bits= s->i_tex_bits; | |
3673 d->p_tex_bits= s->p_tex_bits; | |
3674 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
|
3675 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
|
3676 d->b_count= s->b_count; |
326 | 3677 d->skip_count= s->skip_count; |
3678 d->misc_bits= s->misc_bits; | |
3679 | |
3680 d->mb_intra= s->mb_intra; | |
327 | 3681 d->mb_skiped= s->mb_skiped; |
326 | 3682 d->mv_type= s->mv_type; |
3683 d->mv_dir= s->mv_dir; | |
3684 d->pb= s->pb; | |
456 | 3685 if(s->data_partitioning){ |
3686 d->pb2= s->pb2; | |
3687 d->tex_pb= s->tex_pb; | |
3688 } | |
326 | 3689 d->block= s->block; |
3690 for(i=0; i<6; i++) | |
3691 d->block_last_index[i]= s->block_last_index[i]; | |
755 | 3692 d->interlaced_dct= s->interlaced_dct; |
912 | 3693 d->qscale= s->qscale; |
326 | 3694 } |
3695 | |
456 | 3696 static inline void encode_mb_hq(MpegEncContext *s, MpegEncContext *backup, MpegEncContext *best, int type, |
3697 PutBitContext pb[2], PutBitContext pb2[2], PutBitContext tex_pb[2], | |
3698 int *dmin, int *next_block, int motion_x, int motion_y) | |
3699 { | |
1389 | 3700 int score; |
3701 uint8_t *dest_backup[3]; | |
456 | 3702 |
3703 copy_context_before_encode(s, backup, type); | |
3704 | |
3705 s->block= s->blocks[*next_block]; | |
3706 s->pb= pb[*next_block]; | |
3707 if(s->data_partitioning){ | |
3708 s->pb2 = pb2 [*next_block]; | |
3709 s->tex_pb= tex_pb[*next_block]; | |
3710 } | |
1389 | 3711 |
3712 if(*next_block){ | |
3713 memcpy(dest_backup, s->dest, sizeof(s->dest)); | |
3714 s->dest[0] = s->me.scratchpad; | |
3715 s->dest[1] = s->me.scratchpad + 16; | |
3716 s->dest[2] = s->me.scratchpad + 16 + 8; | |
3717 assert(2*s->uvlinesize == s->linesize); //should be no prob for encoding | |
3718 assert(s->linesize >= 64); //FIXME | |
3719 } | |
456 | 3720 |
3721 encode_mb(s, motion_x, motion_y); | |
1389 | 3722 |
3723 score= get_bit_count(&s->pb); | |
456 | 3724 if(s->data_partitioning){ |
1389 | 3725 score+= get_bit_count(&s->pb2); |
3726 score+= get_bit_count(&s->tex_pb); | |
456 | 3727 } |
1389 | 3728 |
3729 if(s->avctx->mb_decision == FF_MB_DECISION_RD){ | |
3730 MPV_decode_mb(s, s->block); | |
3731 | |
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
|
3732 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
|
3733 score += sse_mb(s) << FF_LAMBDA_SHIFT; |
1389 | 3734 } |
3735 | |
3736 if(*next_block){ | |
3737 memcpy(s->dest, dest_backup, sizeof(s->dest)); | |
3738 } | |
3739 | |
3740 if(score<*dmin){ | |
3741 *dmin= score; | |
456 | 3742 *next_block^=1; |
3743 | |
3744 copy_context_after_encode(best, s, type); | |
3745 } | |
3746 } | |
909
8ae1e4c24e91
new PSNR code (now works with chroma, b frames, ...)
michaelni
parents:
903
diff
changeset
|
3747 |
1389 | 3748 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
|
3749 uint32_t *sq = squareTbl + 256; |
8ae1e4c24e91
new PSNR code (now works with chroma, b frames, ...)
michaelni
parents:
903
diff
changeset
|
3750 int acc=0; |
8ae1e4c24e91
new PSNR code (now works with chroma, b frames, ...)
michaelni
parents:
903
diff
changeset
|
3751 int x,y; |
8ae1e4c24e91
new PSNR code (now works with chroma, b frames, ...)
michaelni
parents:
903
diff
changeset
|
3752 |
8ae1e4c24e91
new PSNR code (now works with chroma, b frames, ...)
michaelni
parents:
903
diff
changeset
|
3753 if(w==16 && h==16) |
1708 | 3754 return s->dsp.sse[0](NULL, src1, src2, stride, 16); |
936 | 3755 else if(w==8 && h==8) |
1708 | 3756 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
|
3757 |
8ae1e4c24e91
new PSNR code (now works with chroma, b frames, ...)
michaelni
parents:
903
diff
changeset
|
3758 for(y=0; y<h; y++){ |
8ae1e4c24e91
new PSNR code (now works with chroma, b frames, ...)
michaelni
parents:
903
diff
changeset
|
3759 for(x=0; x<w; x++){ |
8ae1e4c24e91
new PSNR code (now works with chroma, b frames, ...)
michaelni
parents:
903
diff
changeset
|
3760 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
|
3761 } |
8ae1e4c24e91
new PSNR code (now works with chroma, b frames, ...)
michaelni
parents:
903
diff
changeset
|
3762 } |
936 | 3763 |
3764 assert(acc>=0); | |
3765 | |
909
8ae1e4c24e91
new PSNR code (now works with chroma, b frames, ...)
michaelni
parents:
903
diff
changeset
|
3766 return acc; |
8ae1e4c24e91
new PSNR code (now works with chroma, b frames, ...)
michaelni
parents:
903
diff
changeset
|
3767 } |
326 | 3768 |
1389 | 3769 static int sse_mb(MpegEncContext *s){ |
3770 int w= 16; | |
3771 int h= 16; | |
3772 | |
3773 if(s->mb_x*16 + 16 > s->width ) w= s->width - s->mb_x*16; | |
3774 if(s->mb_y*16 + 16 > s->height) h= s->height- s->mb_y*16; | |
3775 | |
3776 if(w==16 && h==16) | |
1708 | 3777 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) |
3778 +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) | |
3779 +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); | |
1389 | 3780 else |
3781 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) | |
3782 +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) | |
3783 +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); | |
3784 } | |
3785 | |
0 | 3786 static void encode_picture(MpegEncContext *s, int picture_number) |
3787 { | |
766 | 3788 int mb_x, mb_y, pdif = 0; |
1708 | 3789 int i, j; |
286 | 3790 int bits; |
326 | 3791 MpegEncContext best_s, backup_s; |
1064 | 3792 uint8_t bit_buf[2][3000]; |
3793 uint8_t bit_buf2[2][3000]; | |
3794 uint8_t bit_buf_tex[2][3000]; | |
456 | 3795 PutBitContext pb[2], pb2[2], tex_pb[2]; |
3796 | |
3797 for(i=0; i<2; i++){ | |
1522
79dddc5cd990
removed the obsolete and unused parameters of init_put_bits
alex
parents:
1505
diff
changeset
|
3798 init_put_bits(&pb [i], bit_buf [i], 3000); |
79dddc5cd990
removed the obsolete and unused parameters of init_put_bits
alex
parents:
1505
diff
changeset
|
3799 init_put_bits(&pb2 [i], bit_buf2 [i], 3000); |
79dddc5cd990
removed the obsolete and unused parameters of init_put_bits
alex
parents:
1505
diff
changeset
|
3800 init_put_bits(&tex_pb[i], bit_buf_tex[i], 3000); |
456 | 3801 } |
0 | 3802 |
3803 s->picture_number = picture_number; | |
294 | 3804 |
268 | 3805 /* Reset the average MB variance */ |
903 | 3806 s->current_picture.mb_var_sum = 0; |
3807 s->current_picture.mc_mb_var_sum = 0; | |
327 | 3808 |
1042 | 3809 #ifdef CONFIG_RISKY |
327 | 3810 /* we need to initialize some time vars before we can encode b-frames */ |
1051
e5a9dbf597d4
mpeg1 bframe encoding patch by (Rapha«³l LEGRAND) with some modifications by me
michaelni
parents:
1048
diff
changeset
|
3811 // RAL: Condition added for MPEG1VIDEO |
1421 | 3812 if (s->codec_id == CODEC_ID_MPEG1VIDEO || s->codec_id == CODEC_ID_MPEG2VIDEO || (s->h263_pred && !s->h263_msmpeg4)) |
327 | 3813 ff_set_mpeg4_time(s, s->picture_number); |
1042 | 3814 #endif |
3815 | |
608 | 3816 s->scene_change_score=0; |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
673
diff
changeset
|
3817 |
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
|
3818 s->lambda= s->current_picture_ptr->quality; //FIXME qscale / ... stuff for ME ratedistoration |
936 | 3819 |
1089 | 3820 if(s->pict_type==I_TYPE){ |
1163 | 3821 if(s->msmpeg4_version >= 3) s->no_rounding=1; |
3822 else s->no_rounding=0; | |
1089 | 3823 }else if(s->pict_type!=B_TYPE){ |
3824 if(s->flipflop_rounding || s->codec_id == CODEC_ID_H263P || s->codec_id == CODEC_ID_MPEG4) | |
936 | 3825 s->no_rounding ^= 1; |
3826 } | |
1089 | 3827 |
268 | 3828 /* Estimate motion for every MB */ |
1013 | 3829 s->mb_intra=0; //for the rate distoration & bit compare functions |
324 | 3830 if(s->pict_type != I_TYPE){ |
951 | 3831 if(s->pict_type != B_TYPE){ |
3832 if((s->avctx->pre_me && s->last_non_b_pict_type==I_TYPE) || s->avctx->pre_me==2){ | |
952 | 3833 s->me.pre_pass=1; |
954 | 3834 s->me.dia_size= s->avctx->pre_dia_size; |
952 | 3835 |
951 | 3836 for(mb_y=s->mb_height-1; mb_y >=0 ; mb_y--) { |
1757
3906ddbaffec
optimization & bugfix extracted from the 4k line diff between ffmpeg 0.4.7 and http://www.alicestreet.com/ffh263.html
michael
parents:
1754
diff
changeset
|
3837 s->mb_y = mb_y; |
951 | 3838 for(mb_x=s->mb_width-1; mb_x >=0 ; mb_x--) { |
3839 s->mb_x = mb_x; | |
3840 ff_pre_estimate_p_frame_motion(s, mb_x, mb_y); | |
3841 } | |
3842 } | |
952 | 3843 s->me.pre_pass=0; |
951 | 3844 } |
3845 } | |
3846 | |
954 | 3847 s->me.dia_size= s->avctx->dia_size; |
294 | 3848 for(mb_y=0; mb_y < s->mb_height; mb_y++) { |
1757
3906ddbaffec
optimization & bugfix extracted from the 4k line diff between ffmpeg 0.4.7 and http://www.alicestreet.com/ffh263.html
michael
parents:
1754
diff
changeset
|
3849 s->mb_y = mb_y; |
294 | 3850 s->block_index[0]= s->block_wrap[0]*(mb_y*2 + 1) - 1; |
3851 s->block_index[1]= s->block_wrap[0]*(mb_y*2 + 1); | |
3852 s->block_index[2]= s->block_wrap[0]*(mb_y*2 + 2) - 1; | |
3853 s->block_index[3]= s->block_wrap[0]*(mb_y*2 + 2); | |
3854 for(mb_x=0; mb_x < s->mb_width; mb_x++) { | |
3855 s->mb_x = mb_x; | |
3856 s->block_index[0]+=2; | |
3857 s->block_index[1]+=2; | |
3858 s->block_index[2]+=2; | |
3859 s->block_index[3]+=2; | |
954 | 3860 |
294 | 3861 /* compute motion vector & mb_type and store in context */ |
324 | 3862 if(s->pict_type==B_TYPE) |
3863 ff_estimate_b_frame_motion(s, mb_x, mb_y); | |
3864 else | |
3865 ff_estimate_p_frame_motion(s, mb_x, mb_y); | |
268 | 3866 } |
3867 } | |
456 | 3868 }else /* if(s->pict_type == I_TYPE) */{ |
294 | 3869 /* I-Frame */ |
1708 | 3870 for(i=0; i<s->mb_stride*s->mb_height; i++) |
3871 s->mb_type[i]= CANDIDATE_MB_TYPE_INTRA; | |
612 | 3872 |
3873 if(!s->fixed_qscale){ | |
3874 /* finding spatial complexity for I-frame rate control */ | |
3875 for(mb_y=0; mb_y < s->mb_height; mb_y++) { | |
3876 for(mb_x=0; mb_x < s->mb_width; mb_x++) { | |
3877 int xx = mb_x * 16; | |
3878 int yy = mb_y * 16; | |
903 | 3879 uint8_t *pix = s->new_picture.data[0] + (yy * s->linesize) + xx; |
612 | 3880 int varc; |
853
eacc2dd8fd9d
* using DSPContext - so each codec could use its local (sub)set of CPU extension
kabi
parents:
847
diff
changeset
|
3881 int sum = s->dsp.pix_sum(pix, s->linesize); |
612 | 3882 |
853
eacc2dd8fd9d
* using DSPContext - so each codec could use its local (sub)set of CPU extension
kabi
parents:
847
diff
changeset
|
3883 varc = (s->dsp.pix_norm1(pix, s->linesize) - (((unsigned)(sum*sum))>>8) + 500 + 128)>>8; |
612 | 3884 |
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
|
3885 s->current_picture.mb_var [s->mb_stride * mb_y + mb_x] = varc; |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1173
diff
changeset
|
3886 s->current_picture.mb_mean[s->mb_stride * mb_y + mb_x] = (sum+128)>>8; |
903 | 3887 s->current_picture.mb_var_sum += varc; |
612 | 3888 } |
3889 } | |
3890 } | |
268 | 3891 } |
814 | 3892 emms_c(); |
3893 | |
1471 | 3894 if(s->scene_change_score > s->avctx->scenechange_threshold && s->pict_type == P_TYPE){ |
271 | 3895 s->pict_type= I_TYPE; |
1708 | 3896 for(i=0; i<s->mb_stride*s->mb_height; i++) |
3897 s->mb_type[i]= CANDIDATE_MB_TYPE_INTRA; | |
903 | 3898 //printf("Scene change detected, encoding as I Frame %d %d\n", s->current_picture.mb_var_sum, s->current_picture.mc_mb_var_sum); |
271 | 3899 } |
903 | 3900 |
1089 | 3901 if(!s->umvplus){ |
1086 | 3902 if(s->pict_type==P_TYPE || s->pict_type==S_TYPE) { |
1708 | 3903 s->f_code= ff_get_best_fcode(s, s->p_mv_table, CANDIDATE_MB_TYPE_INTER); |
3904 | |
3905 if(s->flags & CODEC_FLAG_INTERLACED_ME){ | |
3906 int a,b; | |
3907 a= ff_get_best_fcode(s, s->p_field_mv_table[0][0], CANDIDATE_MB_TYPE_INTER_I); //FIXME field_select | |
3908 b= ff_get_best_fcode(s, s->p_field_mv_table[1][1], CANDIDATE_MB_TYPE_INTER_I); | |
3909 s->f_code= FFMAX(s->f_code, FFMAX(a,b)); | |
3910 } | |
3911 | |
1086 | 3912 ff_fix_long_p_mvs(s); |
1708 | 3913 ff_fix_long_mvs(s, NULL, 0, s->p_mv_table, s->f_code, CANDIDATE_MB_TYPE_INTER, 0); |
3914 if(s->flags & CODEC_FLAG_INTERLACED_ME){ | |
3915 for(i=0; i<2; i++){ | |
3916 for(j=0; j<2; j++) | |
3917 ff_fix_long_mvs(s, s->p_field_select_table[i], j, | |
3918 s->p_field_mv_table[i][j], s->f_code, CANDIDATE_MB_TYPE_INTER_I, 0); | |
3919 } | |
3920 } | |
1086 | 3921 } |
3922 | |
3923 if(s->pict_type==B_TYPE){ | |
3924 int a, b; | |
3925 | |
1708 | 3926 a = ff_get_best_fcode(s, s->b_forw_mv_table, CANDIDATE_MB_TYPE_FORWARD); |
3927 b = ff_get_best_fcode(s, s->b_bidir_forw_mv_table, CANDIDATE_MB_TYPE_BIDIR); | |
1086 | 3928 s->f_code = FFMAX(a, b); |
3929 | |
1708 | 3930 a = ff_get_best_fcode(s, s->b_back_mv_table, CANDIDATE_MB_TYPE_BACKWARD); |
3931 b = ff_get_best_fcode(s, s->b_bidir_back_mv_table, CANDIDATE_MB_TYPE_BIDIR); | |
1086 | 3932 s->b_code = FFMAX(a, b); |
3933 | |
1708 | 3934 ff_fix_long_mvs(s, NULL, 0, s->b_forw_mv_table, s->f_code, CANDIDATE_MB_TYPE_FORWARD, 1); |
3935 ff_fix_long_mvs(s, NULL, 0, s->b_back_mv_table, s->b_code, CANDIDATE_MB_TYPE_BACKWARD, 1); | |
3936 ff_fix_long_mvs(s, NULL, 0, s->b_bidir_forw_mv_table, s->f_code, CANDIDATE_MB_TYPE_BIDIR, 1); | |
3937 ff_fix_long_mvs(s, NULL, 0, s->b_bidir_back_mv_table, s->b_code, CANDIDATE_MB_TYPE_BIDIR, 1); | |
3938 if(s->flags & CODEC_FLAG_INTERLACED_ME){ | |
3939 int dir; | |
3940 for(dir=0; dir<2; dir++){ | |
3941 for(i=0; i<2; i++){ | |
3942 for(j=0; j<2; j++){ | |
3943 int type= dir ? (CANDIDATE_MB_TYPE_BACKWARD_I|CANDIDATE_MB_TYPE_BIDIR_I) | |
3944 : (CANDIDATE_MB_TYPE_FORWARD_I |CANDIDATE_MB_TYPE_BIDIR_I); | |
3945 ff_fix_long_mvs(s, s->b_field_select_table[dir][i], j, | |
3946 s->b_field_mv_table[dir][i][j], dir ? s->b_code : s->f_code, type, 1); | |
3947 } | |
3948 } | |
3949 } | |
3950 } | |
1086 | 3951 } |
277
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
271
diff
changeset
|
3952 } |
324 | 3953 |
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
|
3954 if (!s->fixed_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
|
3955 s->current_picture.quality = ff_rate_estimate_qscale(s); |
277
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
271
diff
changeset
|
3956 |
695 | 3957 if(s->adaptive_quant){ |
1042 | 3958 #ifdef CONFIG_RISKY |
695 | 3959 switch(s->codec_id){ |
3960 case CODEC_ID_MPEG4: | |
3961 ff_clean_mpeg4_qscales(s); | |
3962 break; | |
3963 case CODEC_ID_H263: | |
3964 case CODEC_ID_H263P: | |
1353
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1344
diff
changeset
|
3965 case CODEC_ID_FLV1: |
695 | 3966 ff_clean_h263_qscales(s); |
3967 break; | |
3968 } | |
1042 | 3969 #endif |
695 | 3970 |
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
|
3971 s->lambda= s->lambda_table[0]; |
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
|
3972 //FIXME broken |
695 | 3973 }else |
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
|
3974 s->lambda= s->current_picture.quality; |
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
|
3975 //printf("%d %d\n", s->avctx->global_quality, s->current_picture.quality); |
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
|
3976 update_qscale(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
|
3977 |
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
|
3978 if(s->qscale < 3 && s->max_qcoeff<=128 && s->pict_type==I_TYPE && !(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
|
3979 s->qscale= 3; //reduce cliping problems |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
673
diff
changeset
|
3980 |
0 | 3981 if (s->out_format == FMT_MJPEG) { |
3982 /* for mjpeg, we do include qscale in the matrix */ | |
533
3c07cf9595de
adding ff prefix to avoid global name conficts with xvid (patch by Marko Kreen <marko at l-t.ee>)
michaelni
parents:
514
diff
changeset
|
3983 s->intra_matrix[0] = ff_mpeg1_default_intra_matrix[0]; |
706
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
3984 for(i=1;i<64;i++){ |
1092 | 3985 int j= s->dsp.idct_permutation[i]; |
706
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
3986 |
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
3987 s->intra_matrix[j] = CLAMP_TO_8BIT((ff_mpeg1_default_intra_matrix[i] * s->qscale) >> 3); |
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
3988 } |
1579
039cb2296de2
make convert_matrix() independant of MpegEncContext
michael
parents:
1573
diff
changeset
|
3989 convert_matrix(&s->dsp, s->q_intra_matrix, s->q_intra_matrix16, |
1554
d736e24bf303
move mmx quantizer matrixes out of MpegEncContext (23k -> 7k) (no meassureable slowdown)
michael
parents:
1553
diff
changeset
|
3990 s->intra_matrix, s->intra_quant_bias, 8, 8); |
0 | 3991 } |
903 | 3992 |
3993 //FIXME var duplication | |
3994 s->current_picture.key_frame= s->pict_type == I_TYPE; | |
3995 s->current_picture.pict_type= s->pict_type; | |
3996 | |
3997 if(s->current_picture.key_frame) | |
3998 s->picture_in_gop_number=0; | |
0 | 3999 |
286 | 4000 s->last_bits= get_bit_count(&s->pb); |
0 | 4001 switch(s->out_format) { |
4002 case FMT_MJPEG: | |
4003 mjpeg_picture_header(s); | |
4004 break; | |
1042 | 4005 #ifdef CONFIG_RISKY |
0 | 4006 case FMT_H263: |
936 | 4007 if (s->codec_id == CODEC_ID_WMV2) |
4008 ff_wmv2_encode_picture_header(s, picture_number); | |
4009 else if (s->h263_msmpeg4) | |
0 | 4010 msmpeg4_encode_picture_header(s, picture_number); |
4011 else if (s->h263_pred) | |
4012 mpeg4_encode_picture_header(s, picture_number); | |
1641 | 4013 else if (s->codec_id == CODEC_ID_RV10) |
0 | 4014 rv10_encode_picture_header(s, picture_number); |
1354 | 4015 else if (s->codec_id == CODEC_ID_FLV1) |
4016 ff_flv_encode_picture_header(s, picture_number); | |
0 | 4017 else |
4018 h263_encode_picture_header(s, picture_number); | |
4019 break; | |
1042 | 4020 #endif |
0 | 4021 case FMT_MPEG1: |
4022 mpeg1_encode_picture_header(s, picture_number); | |
4023 break; | |
1444 | 4024 case FMT_H264: |
4025 break; | |
1757
3906ddbaffec
optimization & bugfix extracted from the 4k line diff between ffmpeg 0.4.7 and http://www.alicestreet.com/ffh263.html
michael
parents:
1754
diff
changeset
|
4026 default: |
3906ddbaffec
optimization & bugfix extracted from the 4k line diff between ffmpeg 0.4.7 and http://www.alicestreet.com/ffh263.html
michael
parents:
1754
diff
changeset
|
4027 assert(0); |
0 | 4028 } |
286 | 4029 bits= get_bit_count(&s->pb); |
4030 s->header_bits= bits - s->last_bits; | |
4031 s->last_bits= bits; | |
4032 s->mv_bits=0; | |
4033 s->misc_bits=0; | |
4034 s->i_tex_bits=0; | |
4035 s->p_tex_bits=0; | |
4036 s->i_count=0; | |
656
e47fa3e3f2d5
statistics for forw & back p-MBs instead of just one counter for both
michaelni
parents:
652
diff
changeset
|
4037 s->f_count=0; |
e47fa3e3f2d5
statistics for forw & back p-MBs instead of just one counter for both
michaelni
parents:
652
diff
changeset
|
4038 s->b_count=0; |
286 | 4039 s->skip_count=0; |
4040 | |
909
8ae1e4c24e91
new PSNR code (now works with chroma, b frames, ...)
michaelni
parents:
903
diff
changeset
|
4041 for(i=0; i<3; i++){ |
8ae1e4c24e91
new PSNR code (now works with chroma, b frames, ...)
michaelni
parents:
903
diff
changeset
|
4042 /* init last dc values */ |
8ae1e4c24e91
new PSNR code (now works with chroma, b frames, ...)
michaelni
parents:
903
diff
changeset
|
4043 /* note: quant matrix value (8) is implied here */ |
8ae1e4c24e91
new PSNR code (now works with chroma, b frames, ...)
michaelni
parents:
903
diff
changeset
|
4044 s->last_dc[i] = 128; |
8ae1e4c24e91
new PSNR code (now works with chroma, b frames, ...)
michaelni
parents:
903
diff
changeset
|
4045 |
1148 | 4046 s->current_picture_ptr->error[i] = 0; |
909
8ae1e4c24e91
new PSNR code (now works with chroma, b frames, ...)
michaelni
parents:
903
diff
changeset
|
4047 } |
1160 | 4048 s->mb_skip_run = 0; |
1708 | 4049 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
|
4050 |
e5a9dbf597d4
mpeg1 bframe encoding patch by (Rapha«³l LEGRAND) with some modifications by me
michaelni
parents:
1048
diff
changeset
|
4051 s->last_mv_dir = 0; |
0 | 4052 |
1042 | 4053 #ifdef CONFIG_RISKY |
1353
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1344
diff
changeset
|
4054 switch(s->codec_id){ |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1344
diff
changeset
|
4055 case CODEC_ID_H263: |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1344
diff
changeset
|
4056 case CODEC_ID_H263P: |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1344
diff
changeset
|
4057 case CODEC_ID_FLV1: |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
731
diff
changeset
|
4058 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
|
4059 break; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1344
diff
changeset
|
4060 case CODEC_ID_MPEG4: |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1344
diff
changeset
|
4061 if(s->partitioned_frame) |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1344
diff
changeset
|
4062 ff_mpeg4_init_partitions(s); |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1344
diff
changeset
|
4063 break; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1344
diff
changeset
|
4064 } |
1042 | 4065 #endif |
456 | 4066 |
4067 s->resync_mb_x=0; | |
4068 s->resync_mb_y=0; | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
731
diff
changeset
|
4069 s->first_slice_line = 1; |
766 | 4070 s->ptr_lastgob = s->pb.buf; |
233
3f5b72726118
- More work on preliminary bit rate control, just to be able to get an
pulento
parents:
232
diff
changeset
|
4071 for(mb_y=0; mb_y < s->mb_height; mb_y++) { |
1389 | 4072 s->mb_x=0; |
4073 s->mb_y= mb_y; | |
4074 | |
1652 | 4075 ff_set_qscale(s, s->qscale); |
1389 | 4076 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
|
4077 |
232
b640ec5948b0
- Now the ME is done for the entire picture when enconding, the
pulento
parents:
231
diff
changeset
|
4078 for(mb_x=0; mb_x < s->mb_width; mb_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
|
4079 const int xy= mb_y*s->mb_stride + mb_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
|
4080 int mb_type= s->mb_type[xy]; |
456 | 4081 // int d; |
1389 | 4082 int dmin= INT_MAX; |
1708 | 4083 int dir; |
0 | 4084 |
232
b640ec5948b0
- Now the ME is done for the entire picture when enconding, the
pulento
parents:
231
diff
changeset
|
4085 s->mb_x = mb_x; |
1389 | 4086 ff_update_block_index(s); |
456 | 4087 |
766 | 4088 /* write gob / video packet header */ |
1042 | 4089 #ifdef CONFIG_RISKY |
1661 | 4090 if(s->rtp_mode){ |
766 | 4091 int current_packet_size, is_gob_start; |
4092 | |
4093 current_packet_size= pbBufPtr(&s->pb) - s->ptr_lastgob; | |
1661 | 4094 |
4095 is_gob_start= s->avctx->rtp_payload_size && current_packet_size >= s->avctx->rtp_payload_size && mb_y + mb_x>0; | |
4096 | |
4097 switch(s->codec_id){ | |
4098 case CODEC_ID_H263: | |
4099 case CODEC_ID_H263P: | |
4100 if(!s->h263_slice_structured) | |
4101 if(s->mb_x || s->mb_y%s->gob_index) is_gob_start=0; | |
4102 break; | |
4103 case CODEC_ID_MPEG2VIDEO: | |
4104 if(s->mb_x==0 && s->mb_y!=0) is_gob_start=1; | |
4105 case CODEC_ID_MPEG1VIDEO: | |
4106 if(s->mb_skip_run) is_gob_start=0; | |
4107 break; | |
4108 } | |
766 | 4109 |
1661 | 4110 if(is_gob_start){ |
4111 if(s->codec_id==CODEC_ID_MPEG4 && s->partitioned_frame){ | |
4112 ff_mpeg4_merge_partitions(s); | |
4113 ff_mpeg4_init_partitions(s); | |
4114 } | |
4115 | |
4116 if(s->codec_id==CODEC_ID_MPEG4) | |
4117 ff_mpeg4_stuffing(&s->pb); | |
4118 | |
4119 align_put_bits(&s->pb); | |
1662 | 4120 flush_put_bits(&s->pb); |
4121 | |
4122 assert((get_bit_count(&s->pb)&7) == 0); | |
1661 | 4123 current_packet_size= pbBufPtr(&s->pb) - s->ptr_lastgob; |
1688 | 4124 |
4125 if(s->avctx->error_rate && s->resync_mb_x + s->resync_mb_y > 0){ | |
4126 int r= get_bit_count(&s->pb)/8 + s->picture_number + s->codec_id + s->mb_x + s->mb_y; | |
4127 int d= 100 / s->avctx->error_rate; | |
4128 if(r % d == 0){ | |
4129 current_packet_size=0; | |
4130 #ifndef ALT_BITSTREAM_WRITER | |
4131 s->pb.buf_ptr= s->ptr_lastgob; | |
4132 #endif | |
4133 assert(pbBufPtr(&s->pb) == s->ptr_lastgob); | |
4134 } | |
4135 } | |
1661 | 4136 |
4137 if (s->avctx->rtp_callback) | |
4138 s->avctx->rtp_callback(s->ptr_lastgob, current_packet_size, 0); | |
4139 | |
4140 switch(s->codec_id){ | |
4141 case CODEC_ID_MPEG4: | |
456 | 4142 ff_mpeg4_encode_video_packet_header(s); |
4143 ff_mpeg4_clean_buffers(s); | |
1661 | 4144 break; |
4145 case CODEC_ID_MPEG1VIDEO: | |
4146 case CODEC_ID_MPEG2VIDEO: | |
1421 | 4147 ff_mpeg1_encode_slice_header(s); |
4148 ff_mpeg1_clean_buffers(s); | |
1661 | 4149 break; |
4150 case CODEC_ID_H263: | |
4151 case CODEC_ID_H263P: | |
4152 h263_encode_gob_header(s, mb_y); | |
4153 break; | |
1160 | 4154 } |
1661 | 4155 |
4156 if(s->flags&CODEC_FLAG_PASS1){ | |
4157 int bits= get_bit_count(&s->pb); | |
4158 s->misc_bits+= bits - s->last_bits; | |
4159 s->last_bits= bits; | |
766 | 4160 } |
1661 | 4161 |
1662 | 4162 s->ptr_lastgob += current_packet_size; |
456 | 4163 s->first_slice_line=1; |
4164 s->resync_mb_x=mb_x; | |
4165 s->resync_mb_y=mb_y; | |
4166 } | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
731
diff
changeset
|
4167 } |
1042 | 4168 #endif |
456 | 4169 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
731
diff
changeset
|
4170 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
|
4171 && 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
|
4172 s->first_slice_line=0; |
456 | 4173 } |
4174 | |
1389 | 4175 s->mb_skiped=0; |
1616 | 4176 s->dquant=0; //only for QP_RD |
4177 | |
4178 if(mb_type & (mb_type-1) || (s->flags & CODEC_FLAG_QP_RD)){ // more than 1 MB type possible | |
327 | 4179 int next_block=0; |
456 | 4180 int pb_bits_count, pb2_bits_count, tex_pb_bits_count; |
326 | 4181 |
4182 copy_context_before_encode(&backup_s, s, -1); | |
456 | 4183 backup_s.pb= s->pb; |
4184 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
|
4185 best_s.partitioned_frame= s->partitioned_frame; |
456 | 4186 if(s->data_partitioning){ |
4187 backup_s.pb2= s->pb2; | |
4188 backup_s.tex_pb= s->tex_pb; | |
4189 } | |
326 | 4190 |
1708 | 4191 if(mb_type&CANDIDATE_MB_TYPE_INTER){ |
327 | 4192 s->mv_dir = MV_DIR_FORWARD; |
295 | 4193 s->mv_type = MV_TYPE_16X16; |
294 | 4194 s->mb_intra= 0; |
324 | 4195 s->mv[0][0][0] = s->p_mv_table[xy][0]; |
4196 s->mv[0][0][1] = s->p_mv_table[xy][1]; | |
1708 | 4197 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER, pb, pb2, tex_pb, |
456 | 4198 &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]); |
0 | 4199 } |
1708 | 4200 if(mb_type&CANDIDATE_MB_TYPE_INTER_I){ |
4201 s->mv_dir = MV_DIR_FORWARD; | |
4202 s->mv_type = MV_TYPE_FIELD; | |
4203 s->mb_intra= 0; | |
4204 for(i=0; i<2; i++){ | |
4205 j= s->field_select[0][i] = s->p_field_select_table[i][xy]; | |
4206 s->mv[0][i][0] = s->p_field_mv_table[i][j][xy][0]; | |
4207 s->mv[0][i][1] = s->p_field_mv_table[i][j][xy][1]; | |
4208 } | |
4209 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER_I, pb, pb2, tex_pb, | |
4210 &dmin, &next_block, 0, 0); | |
4211 } | |
4212 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
|
4213 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
|
4214 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
|
4215 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
|
4216 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
|
4217 s->mv[0][0][1] = 0; |
1708 | 4218 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
|
4219 &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
|
4220 } |
1708 | 4221 if(mb_type&CANDIDATE_MB_TYPE_INTER4V){ |
327 | 4222 s->mv_dir = MV_DIR_FORWARD; |
295 | 4223 s->mv_type = MV_TYPE_8X8; |
4224 s->mb_intra= 0; | |
4225 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
|
4226 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
|
4227 s->mv[0][i][1] = s->current_picture.motion_val[0][s->block_index[i]][1]; |
295 | 4228 } |
1708 | 4229 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER4V, pb, pb2, tex_pb, |
456 | 4230 &dmin, &next_block, 0, 0); |
327 | 4231 } |
1708 | 4232 if(mb_type&CANDIDATE_MB_TYPE_FORWARD){ |
327 | 4233 s->mv_dir = MV_DIR_FORWARD; |
4234 s->mv_type = MV_TYPE_16X16; | |
4235 s->mb_intra= 0; | |
4236 s->mv[0][0][0] = s->b_forw_mv_table[xy][0]; | |
4237 s->mv[0][0][1] = s->b_forw_mv_table[xy][1]; | |
1708 | 4238 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_FORWARD, pb, pb2, tex_pb, |
456 | 4239 &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]); |
327 | 4240 } |
1708 | 4241 if(mb_type&CANDIDATE_MB_TYPE_BACKWARD){ |
327 | 4242 s->mv_dir = MV_DIR_BACKWARD; |
4243 s->mv_type = MV_TYPE_16X16; | |
4244 s->mb_intra= 0; | |
4245 s->mv[1][0][0] = s->b_back_mv_table[xy][0]; | |
4246 s->mv[1][0][1] = s->b_back_mv_table[xy][1]; | |
1708 | 4247 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BACKWARD, pb, pb2, tex_pb, |
456 | 4248 &dmin, &next_block, s->mv[1][0][0], s->mv[1][0][1]); |
327 | 4249 } |
1708 | 4250 if(mb_type&CANDIDATE_MB_TYPE_BIDIR){ |
327 | 4251 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD; |
4252 s->mv_type = MV_TYPE_16X16; | |
4253 s->mb_intra= 0; | |
4254 s->mv[0][0][0] = s->b_bidir_forw_mv_table[xy][0]; | |
4255 s->mv[0][0][1] = s->b_bidir_forw_mv_table[xy][1]; | |
4256 s->mv[1][0][0] = s->b_bidir_back_mv_table[xy][0]; | |
4257 s->mv[1][0][1] = s->b_bidir_back_mv_table[xy][1]; | |
1708 | 4258 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BIDIR, pb, pb2, tex_pb, |
456 | 4259 &dmin, &next_block, 0, 0); |
327 | 4260 } |
1708 | 4261 if(mb_type&CANDIDATE_MB_TYPE_DIRECT){ |
936 | 4262 int mx= s->b_direct_mv_table[xy][0]; |
4263 int my= s->b_direct_mv_table[xy][1]; | |
4264 | |
327 | 4265 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT; |
4266 s->mb_intra= 0; | |
1042 | 4267 #ifdef CONFIG_RISKY |
936 | 4268 ff_mpeg4_set_direct_mv(s, mx, my); |
1042 | 4269 #endif |
1708 | 4270 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_DIRECT, pb, pb2, tex_pb, |
936 | 4271 &dmin, &next_block, mx, my); |
295 | 4272 } |
1708 | 4273 if(mb_type&CANDIDATE_MB_TYPE_FORWARD_I){ |
4274 s->mv_dir = MV_DIR_FORWARD; | |
4275 s->mv_type = MV_TYPE_FIELD; | |
4276 s->mb_intra= 0; | |
4277 for(i=0; i<2; i++){ | |
4278 j= s->field_select[0][i] = s->b_field_select_table[0][i][xy]; | |
4279 s->mv[0][i][0] = s->b_field_mv_table[0][i][j][xy][0]; | |
4280 s->mv[0][i][1] = s->b_field_mv_table[0][i][j][xy][1]; | |
4281 } | |
4282 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_FORWARD_I, pb, pb2, tex_pb, | |
4283 &dmin, &next_block, 0, 0); | |
4284 } | |
4285 if(mb_type&CANDIDATE_MB_TYPE_BACKWARD_I){ | |
4286 s->mv_dir = MV_DIR_BACKWARD; | |
4287 s->mv_type = MV_TYPE_FIELD; | |
4288 s->mb_intra= 0; | |
4289 for(i=0; i<2; i++){ | |
4290 j= s->field_select[1][i] = s->b_field_select_table[1][i][xy]; | |
4291 s->mv[1][i][0] = s->b_field_mv_table[1][i][j][xy][0]; | |
4292 s->mv[1][i][1] = s->b_field_mv_table[1][i][j][xy][1]; | |
4293 } | |
4294 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BACKWARD_I, pb, pb2, tex_pb, | |
4295 &dmin, &next_block, 0, 0); | |
4296 } | |
4297 if(mb_type&CANDIDATE_MB_TYPE_BIDIR_I){ | |
4298 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD; | |
4299 s->mv_type = MV_TYPE_FIELD; | |
4300 s->mb_intra= 0; | |
4301 for(dir=0; dir<2; dir++){ | |
4302 for(i=0; i<2; i++){ | |
4303 j= s->field_select[dir][i] = s->b_field_select_table[dir][i][xy]; | |
4304 s->mv[dir][i][0] = s->b_field_mv_table[dir][i][j][xy][0]; | |
4305 s->mv[dir][i][1] = s->b_field_mv_table[dir][i][j][xy][1]; | |
4306 } | |
4307 } | |
4308 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BIDIR_I, pb, pb2, tex_pb, | |
4309 &dmin, &next_block, 0, 0); | |
4310 } | |
4311 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
|
4312 s->mv_dir = 0; |
295 | 4313 s->mv_type = MV_TYPE_16X16; |
294 | 4314 s->mb_intra= 1; |
4315 s->mv[0][0][0] = 0; | |
4316 s->mv[0][0][1] = 0; | |
1708 | 4317 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTRA, pb, pb2, tex_pb, |
456 | 4318 &dmin, &next_block, 0, 0); |
1389 | 4319 if(s->h263_pred || s->h263_aic){ |
4320 if(best_s.mb_intra) | |
4321 s->mbintra_table[mb_x + mb_y*s->mb_stride]=1; | |
4322 else | |
4323 ff_clean_intra_table_entries(s); //old mode? | |
4324 } | |
295 | 4325 } |
1616 | 4326 |
4327 if(s->flags & CODEC_FLAG_QP_RD){ | |
4328 if(best_s.mv_type==MV_TYPE_16X16 && !(best_s.mv_dir&MV_DIRECT)){ | |
4329 const int last_qp= backup_s.qscale; | |
4330 int dquant, dir, qp, dc[6]; | |
1617 | 4331 DCTELEM ac[6][16]; |
1623 | 4332 const int mvdir= (best_s.mv_dir&MV_DIR_BACKWARD) ? 1 : 0; |
1616 | 4333 |
4334 assert(backup_s.dquant == 0); | |
4335 | |
4336 //FIXME intra | |
4337 s->mv_dir= best_s.mv_dir; | |
4338 s->mv_type = MV_TYPE_16X16; | |
4339 s->mb_intra= best_s.mb_intra; | |
4340 s->mv[0][0][0] = best_s.mv[0][0][0]; | |
4341 s->mv[0][0][1] = best_s.mv[0][0][1]; | |
4342 s->mv[1][0][0] = best_s.mv[1][0][0]; | |
4343 s->mv[1][0][1] = best_s.mv[1][0][1]; | |
4344 | |
4345 dir= s->pict_type == B_TYPE ? 2 : 1; | |
1623 | 4346 if(last_qp + dir > s->avctx->qmax) dir= -dir; |
1616 | 4347 for(dquant= dir; dquant<=2 && dquant>=-2; dquant += dir){ |
4348 qp= last_qp + dquant; | |
4349 if(qp < s->avctx->qmin || qp > s->avctx->qmax) | |
4350 break; | |
4351 backup_s.dquant= dquant; | |
1617 | 4352 if(s->mb_intra){ |
4353 for(i=0; i<6; i++){ | |
4354 dc[i]= s->dc_val[0][ s->block_index[i] ]; | |
4355 memcpy(ac[i], s->ac_val[0][s->block_index[i]], sizeof(DCTELEM)*16); | |
4356 } | |
1616 | 4357 } |
1617 | 4358 |
1708 | 4359 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER /* wrong but unused */, pb, pb2, tex_pb, |
1623 | 4360 &dmin, &next_block, s->mv[mvdir][0][0], s->mv[mvdir][0][1]); |
1616 | 4361 if(best_s.qscale != qp){ |
1617 | 4362 if(s->mb_intra){ |
4363 for(i=0; i<6; i++){ | |
4364 s->dc_val[0][ s->block_index[i] ]= dc[i]; | |
4365 memcpy(s->ac_val[0][s->block_index[i]], ac[i], sizeof(DCTELEM)*16); | |
4366 } | |
1616 | 4367 } |
4368 if(dir > 0 && dquant==dir){ | |
4369 dquant= 0; | |
4370 dir= -dir; | |
4371 }else | |
4372 break; | |
4373 } | |
4374 } | |
4375 qp= best_s.qscale; | |
4376 s->current_picture.qscale_table[xy]= qp; | |
4377 } | |
4378 } | |
4379 | |
326 | 4380 copy_context_after_encode(s, &best_s, -1); |
456 | 4381 |
4382 pb_bits_count= get_bit_count(&s->pb); | |
4383 flush_put_bits(&s->pb); | |
4384 ff_copy_bits(&backup_s.pb, bit_buf[next_block^1], pb_bits_count); | |
4385 s->pb= backup_s.pb; | |
4386 | |
4387 if(s->data_partitioning){ | |
4388 pb2_bits_count= get_bit_count(&s->pb2); | |
4389 flush_put_bits(&s->pb2); | |
4390 ff_copy_bits(&backup_s.pb2, bit_buf2[next_block^1], pb2_bits_count); | |
4391 s->pb2= backup_s.pb2; | |
4392 | |
4393 tex_pb_bits_count= get_bit_count(&s->tex_pb); | |
4394 flush_put_bits(&s->tex_pb); | |
4395 ff_copy_bits(&backup_s.tex_pb, bit_buf_tex[next_block^1], tex_pb_bits_count); | |
4396 s->tex_pb= backup_s.tex_pb; | |
4397 } | |
329 | 4398 s->last_bits= get_bit_count(&s->pb); |
1451
62c16edd18c6
--disable-risky fix by (Luca Abeni <lucabe72 at email dot it>)
michaelni
parents:
1444
diff
changeset
|
4399 |
62c16edd18c6
--disable-risky fix by (Luca Abeni <lucabe72 at email dot it>)
michaelni
parents:
1444
diff
changeset
|
4400 #ifdef CONFIG_RISKY |
1389 | 4401 if (s->out_format == FMT_H263 && s->pict_type!=B_TYPE) |
4402 ff_h263_update_motion_val(s); | |
1451
62c16edd18c6
--disable-risky fix by (Luca Abeni <lucabe72 at email dot it>)
michaelni
parents:
1444
diff
changeset
|
4403 #endif |
1389 | 4404 |
4405 if(next_block==0){ | |
4406 s->dsp.put_pixels_tab[0][0](s->dest[0], s->me.scratchpad , s->linesize ,16); | |
4407 s->dsp.put_pixels_tab[1][0](s->dest[1], s->me.scratchpad + 16, s->uvlinesize, 8); | |
4408 s->dsp.put_pixels_tab[1][0](s->dest[2], s->me.scratchpad + 24, s->uvlinesize, 8); | |
4409 } | |
4410 | |
4411 if(s->avctx->mb_decision == FF_MB_DECISION_BITS) | |
4412 MPV_decode_mb(s, s->block); | |
294 | 4413 } else { |
324 | 4414 int motion_x, motion_y; |
4415 s->mv_type=MV_TYPE_16X16; | |
294 | 4416 // only one MB-Type possible |
1013 | 4417 |
327 | 4418 switch(mb_type){ |
1708 | 4419 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
|
4420 s->mv_dir = 0; |
294 | 4421 s->mb_intra= 1; |
324 | 4422 motion_x= s->mv[0][0][0] = 0; |
4423 motion_y= s->mv[0][0][1] = 0; | |
327 | 4424 break; |
1708 | 4425 case CANDIDATE_MB_TYPE_INTER: |
324 | 4426 s->mv_dir = MV_DIR_FORWARD; |
4427 s->mb_intra= 0; | |
4428 motion_x= s->mv[0][0][0] = s->p_mv_table[xy][0]; | |
4429 motion_y= s->mv[0][0][1] = s->p_mv_table[xy][1]; | |
327 | 4430 break; |
1708 | 4431 case CANDIDATE_MB_TYPE_INTER_I: |
4432 s->mv_dir = MV_DIR_FORWARD; | |
4433 s->mv_type = MV_TYPE_FIELD; | |
4434 s->mb_intra= 0; | |
4435 for(i=0; i<2; i++){ | |
4436 j= s->field_select[0][i] = s->p_field_select_table[i][xy]; | |
4437 s->mv[0][i][0] = s->p_field_mv_table[i][j][xy][0]; | |
4438 s->mv[0][i][1] = s->p_field_mv_table[i][j][xy][1]; | |
4439 } | |
4440 motion_x = motion_y = 0; | |
4441 break; | |
4442 case CANDIDATE_MB_TYPE_INTER4V: | |
456 | 4443 s->mv_dir = MV_DIR_FORWARD; |
4444 s->mv_type = MV_TYPE_8X8; | |
4445 s->mb_intra= 0; | |
4446 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
|
4447 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
|
4448 s->mv[0][i][1] = s->current_picture.motion_val[0][s->block_index[i]][1]; |
456 | 4449 } |
4450 motion_x= motion_y= 0; | |
4451 break; | |
1708 | 4452 case CANDIDATE_MB_TYPE_DIRECT: |
324 | 4453 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT; |
4454 s->mb_intra= 0; | |
327 | 4455 motion_x=s->b_direct_mv_table[xy][0]; |
4456 motion_y=s->b_direct_mv_table[xy][1]; | |
1042 | 4457 #ifdef CONFIG_RISKY |
936 | 4458 ff_mpeg4_set_direct_mv(s, motion_x, motion_y); |
1042 | 4459 #endif |
327 | 4460 break; |
1708 | 4461 case CANDIDATE_MB_TYPE_BIDIR: |
324 | 4462 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD; |
294 | 4463 s->mb_intra= 0; |
324 | 4464 motion_x=0; |
4465 motion_y=0; | |
4466 s->mv[0][0][0] = s->b_bidir_forw_mv_table[xy][0]; | |
4467 s->mv[0][0][1] = s->b_bidir_forw_mv_table[xy][1]; | |
4468 s->mv[1][0][0] = s->b_bidir_back_mv_table[xy][0]; | |
4469 s->mv[1][0][1] = s->b_bidir_back_mv_table[xy][1]; | |
327 | 4470 break; |
1708 | 4471 case CANDIDATE_MB_TYPE_BACKWARD: |
324 | 4472 s->mv_dir = MV_DIR_BACKWARD; |
4473 s->mb_intra= 0; | |
4474 motion_x= s->mv[1][0][0] = s->b_back_mv_table[xy][0]; | |
4475 motion_y= s->mv[1][0][1] = s->b_back_mv_table[xy][1]; | |
327 | 4476 break; |
1708 | 4477 case CANDIDATE_MB_TYPE_FORWARD: |
324 | 4478 s->mv_dir = MV_DIR_FORWARD; |
4479 s->mb_intra= 0; | |
4480 motion_x= s->mv[0][0][0] = s->b_forw_mv_table[xy][0]; | |
4481 motion_y= s->mv[0][0][1] = s->b_forw_mv_table[xy][1]; | |
4482 // printf(" %d %d ", motion_x, motion_y); | |
327 | 4483 break; |
1708 | 4484 case CANDIDATE_MB_TYPE_FORWARD_I: |
4485 s->mv_dir = MV_DIR_FORWARD; | |
4486 s->mv_type = MV_TYPE_FIELD; | |
4487 s->mb_intra= 0; | |
4488 for(i=0; i<2; i++){ | |
4489 j= s->field_select[0][i] = s->b_field_select_table[0][i][xy]; | |
4490 s->mv[0][i][0] = s->b_field_mv_table[0][i][j][xy][0]; | |
4491 s->mv[0][i][1] = s->b_field_mv_table[0][i][j][xy][1]; | |
4492 } | |
4493 motion_x=motion_y=0; | |
4494 break; | |
4495 case CANDIDATE_MB_TYPE_BACKWARD_I: | |
4496 s->mv_dir = MV_DIR_BACKWARD; | |
4497 s->mv_type = MV_TYPE_FIELD; | |
4498 s->mb_intra= 0; | |
4499 for(i=0; i<2; i++){ | |
4500 j= s->field_select[1][i] = s->b_field_select_table[1][i][xy]; | |
4501 s->mv[1][i][0] = s->b_field_mv_table[1][i][j][xy][0]; | |
4502 s->mv[1][i][1] = s->b_field_mv_table[1][i][j][xy][1]; | |
4503 } | |
4504 motion_x=motion_y=0; | |
4505 break; | |
4506 case CANDIDATE_MB_TYPE_BIDIR_I: | |
4507 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD; | |
4508 s->mv_type = MV_TYPE_FIELD; | |
4509 s->mb_intra= 0; | |
4510 for(dir=0; dir<2; dir++){ | |
4511 for(i=0; i<2; i++){ | |
4512 j= s->field_select[dir][i] = s->b_field_select_table[dir][i][xy]; | |
4513 s->mv[dir][i][0] = s->b_field_mv_table[dir][i][j][xy][0]; | |
4514 s->mv[dir][i][1] = s->b_field_mv_table[dir][i][j][xy][1]; | |
4515 } | |
4516 } | |
4517 motion_x=motion_y=0; | |
4518 break; | |
327 | 4519 default: |
324 | 4520 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
|
4521 av_log(s->avctx, AV_LOG_ERROR, "illegal MB type\n"); |
294 | 4522 } |
1051
e5a9dbf597d4
mpeg1 bframe encoding patch by (Rapha«³l LEGRAND) with some modifications by me
michaelni
parents:
1048
diff
changeset
|
4523 |
324 | 4524 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
|
4525 |
e5a9dbf597d4
mpeg1 bframe encoding patch by (Rapha«³l LEGRAND) with some modifications by me
michaelni
parents:
1048
diff
changeset
|
4526 // RAL: Update last macrobloc type |
e5a9dbf597d4
mpeg1 bframe encoding patch by (Rapha«³l LEGRAND) with some modifications by me
michaelni
parents:
1048
diff
changeset
|
4527 s->last_mv_dir = s->mv_dir; |
1389 | 4528 |
1451
62c16edd18c6
--disable-risky fix by (Luca Abeni <lucabe72 at email dot it>)
michaelni
parents:
1444
diff
changeset
|
4529 #ifdef CONFIG_RISKY |
1389 | 4530 if (s->out_format == FMT_H263 && s->pict_type!=B_TYPE) |
4531 ff_h263_update_motion_val(s); | |
1451
62c16edd18c6
--disable-risky fix by (Luca Abeni <lucabe72 at email dot it>)
michaelni
parents:
1444
diff
changeset
|
4532 #endif |
62c16edd18c6
--disable-risky fix by (Luca Abeni <lucabe72 at email dot it>)
michaelni
parents:
1444
diff
changeset
|
4533 |
1389 | 4534 MPV_decode_mb(s, s->block); |
248
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
244
diff
changeset
|
4535 } |
1051
e5a9dbf597d4
mpeg1 bframe encoding patch by (Rapha«³l LEGRAND) with some modifications by me
michaelni
parents:
1048
diff
changeset
|
4536 |
327 | 4537 /* clean the MV table in IPS frames for direct mode in B frames */ |
4538 if(s->mb_intra /* && I,P,S_TYPE */){ | |
4539 s->p_mv_table[xy][0]=0; | |
4540 s->p_mv_table[xy][1]=0; | |
4541 } | |
909
8ae1e4c24e91
new PSNR code (now works with chroma, b frames, ...)
michaelni
parents:
903
diff
changeset
|
4542 |
8ae1e4c24e91
new PSNR code (now works with chroma, b frames, ...)
michaelni
parents:
903
diff
changeset
|
4543 if(s->flags&CODEC_FLAG_PSNR){ |
8ae1e4c24e91
new PSNR code (now works with chroma, b frames, ...)
michaelni
parents:
903
diff
changeset
|
4544 int w= 16; |
8ae1e4c24e91
new PSNR code (now works with chroma, b frames, ...)
michaelni
parents:
903
diff
changeset
|
4545 int h= 16; |
8ae1e4c24e91
new PSNR code (now works with chroma, b frames, ...)
michaelni
parents:
903
diff
changeset
|
4546 |
8ae1e4c24e91
new PSNR code (now works with chroma, b frames, ...)
michaelni
parents:
903
diff
changeset
|
4547 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
|
4548 if(s->mb_y*16 + 16 > s->height) h= s->height- s->mb_y*16; |
936 | 4549 |
1148 | 4550 s->current_picture_ptr->error[0] += sse( |
1389 | 4551 s, s->new_picture.data[0] + s->mb_x*16 + s->mb_y*s->linesize*16, |
4552 s->dest[0], w, h, s->linesize); | |
1148 | 4553 s->current_picture_ptr->error[1] += sse( |
1389 | 4554 s, s->new_picture.data[1] + s->mb_x*8 + s->mb_y*s->uvlinesize*8, |
4555 s->dest[1], w>>1, h>>1, s->uvlinesize); | |
1148 | 4556 s->current_picture_ptr->error[2] += sse( |
1389 | 4557 s, s->new_picture .data[2] + s->mb_x*8 + s->mb_y*s->uvlinesize*8, |
4558 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
|
4559 } |
1644 | 4560 if(s->loop_filter) |
4561 ff_h263_loop_filter(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
|
4562 //printf("MB %d %d bits\n", s->mb_x+s->mb_y*s->mb_stride, get_bit_count(&s->pb)); |
0 | 4563 } |
4564 } | |
294 | 4565 emms_c(); |
286 | 4566 |
1042 | 4567 #ifdef CONFIG_RISKY |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
731
diff
changeset
|
4568 if(s->codec_id==CODEC_ID_MPEG4 && s->partitioned_frame) |
456 | 4569 ff_mpeg4_merge_partitions(s); |
4570 | |
4571 if (s->msmpeg4_version && s->msmpeg4_version<4 && s->pict_type == I_TYPE) | |
208 | 4572 msmpeg4_encode_ext_header(s); |
4573 | |
456 | 4574 if(s->codec_id==CODEC_ID_MPEG4) |
4575 ff_mpeg4_stuffing(&s->pb); | |
1042 | 4576 #endif |
456 | 4577 |
231 | 4578 /* Send the last GOB if RTP */ |
1661 | 4579 if (s->avctx->rtp_callback) { |
231 | 4580 flush_put_bits(&s->pb); |
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
|
4581 pdif = pbBufPtr(&s->pb) - s->ptr_lastgob; |
231 | 4582 /* Call the RTP callback to send the last GOB */ |
1661 | 4583 s->avctx->rtp_callback(s->ptr_lastgob, pdif, 0); |
231 | 4584 } |
0 | 4585 } |
4586 | |
1686
68abbec33289
Here are juste two added #ifdef CONFIG_ENCODERS to allow
michael
parents:
1685
diff
changeset
|
4587 #endif //CONFIG_ENCODERS |
68abbec33289
Here are juste two added #ifdef CONFIG_ENCODERS to allow
michael
parents:
1685
diff
changeset
|
4588 |
1719 | 4589 static void denoise_dct_c(MpegEncContext *s, DCTELEM *block){ |
1597 | 4590 const int intra= s->mb_intra; |
4591 int i; | |
4592 | |
1599 | 4593 s->dct_count[intra]++; |
4594 | |
1597 | 4595 for(i=0; i<64; i++){ |
4596 int level= block[i]; | |
4597 | |
4598 if(level){ | |
4599 if(level>0){ | |
4600 s->dct_error_sum[intra][i] += level; | |
4601 level -= s->dct_offset[intra][i]; | |
4602 if(level<0) level=0; | |
4603 }else{ | |
4604 s->dct_error_sum[intra][i] -= level; | |
4605 level += s->dct_offset[intra][i]; | |
4606 if(level>0) level=0; | |
4607 } | |
4608 block[i]= level; | |
4609 } | |
4610 } | |
4611 } | |
4612 | |
1686
68abbec33289
Here are juste two added #ifdef CONFIG_ENCODERS to allow
michael
parents:
1685
diff
changeset
|
4613 #ifdef CONFIG_ENCODERS |
68abbec33289
Here are juste two added #ifdef CONFIG_ENCODERS to allow
michael
parents:
1685
diff
changeset
|
4614 |
945 | 4615 static int dct_quantize_trellis_c(MpegEncContext *s, |
4616 DCTELEM *block, int n, | |
4617 int qscale, int *overflow){ | |
4618 const int *qmat; | |
1064 | 4619 const uint8_t *scantable= s->intra_scantable.scantable; |
1718 | 4620 const uint8_t *perm_scantable= s->intra_scantable.permutated; |
945 | 4621 int max=0; |
4622 unsigned int threshold1, threshold2; | |
4623 int bias=0; | |
4624 int run_tab[65]; | |
4625 int level_tab[65]; | |
4626 int score_tab[65]; | |
1718 | 4627 int survivor[65]; |
4628 int survivor_count; | |
946 | 4629 int last_run=0; |
4630 int last_level=0; | |
4631 int last_score= 0; | |
1718 | 4632 int last_i; |
1715 | 4633 int coeff[2][64]; |
945 | 4634 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
|
4635 int qmul, qadd, start_i, last_non_zero, i, dc; |
945 | 4636 const int esc_length= s->ac_esc_length; |
4637 uint8_t * length; | |
4638 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
|
4639 const int lambda= s->lambda2 >> (FF_LAMBDA_SHIFT - 6); |
945 | 4640 |
1092 | 4641 s->dsp.fdct (block); |
1597 | 4642 |
4643 if(s->dct_error_sum) | |
1719 | 4644 s->denoise_dct(s, block); |
945 | 4645 qmul= qscale*16; |
4646 qadd= ((qscale-1)|1)*8; | |
946 | 4647 |
945 | 4648 if (s->mb_intra) { |
4649 int q; | |
4650 if (!s->h263_aic) { | |
4651 if (n < 4) | |
4652 q = s->y_dc_scale; | |
4653 else | |
4654 q = s->c_dc_scale; | |
4655 q = q << 3; | |
4656 } else{ | |
4657 /* For AIC we skip quant/dequant of INTRADC */ | |
4658 q = 1 << 3; | |
4659 qadd=0; | |
4660 } | |
4661 | |
4662 /* note: block[0] is assumed to be positive */ | |
4663 block[0] = (block[0] + (q >> 1)) / q; | |
4664 start_i = 1; | |
4665 last_non_zero = 0; | |
4666 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
|
4667 if(s->mpeg_quant || s->out_format == FMT_MPEG1) |
945 | 4668 bias= 1<<(QMAT_SHIFT-1); |
4669 length = s->intra_ac_vlc_length; | |
4670 last_length= s->intra_ac_vlc_last_length; | |
4671 } else { | |
4672 start_i = 0; | |
4673 last_non_zero = -1; | |
4674 qmat = s->q_inter_matrix[qscale]; | |
4675 length = s->inter_ac_vlc_length; | |
4676 last_length= s->inter_ac_vlc_last_length; | |
4677 } | |
1718 | 4678 last_i= start_i; |
945 | 4679 |
4680 threshold1= (1<<QMAT_SHIFT) - bias - 1; | |
4681 threshold2= (threshold1<<1); | |
946 | 4682 |
1715 | 4683 for(i=63; i>=start_i; i--) { |
4684 const int j = scantable[i]; | |
4685 int level = block[j] * qmat[j]; | |
4686 | |
4687 if(((unsigned)(level+threshold1))>threshold2){ | |
4688 last_non_zero = i; | |
4689 break; | |
4690 } | |
4691 } | |
4692 | |
4693 for(i=start_i; i<=last_non_zero; i++) { | |
945 | 4694 const int j = scantable[i]; |
1715 | 4695 int level = block[j] * qmat[j]; |
945 | 4696 |
4697 // if( bias+level >= (1<<(QMAT_SHIFT - 3)) | |
4698 // || bias-level >= (1<<(QMAT_SHIFT - 3))){ | |
4699 if(((unsigned)(level+threshold1))>threshold2){ | |
4700 if(level>0){ | |
4701 level= (bias + level)>>QMAT_SHIFT; | |
1718 | 4702 coeff[0][i]= level; |
4703 coeff[1][i]= level-1; | |
946 | 4704 // coeff[2][k]= level-2; |
945 | 4705 }else{ |
4706 level= (bias - level)>>QMAT_SHIFT; | |
1718 | 4707 coeff[0][i]= -level; |
4708 coeff[1][i]= -level+1; | |
946 | 4709 // coeff[2][k]= -level+2; |
945 | 4710 } |
1718 | 4711 coeff_count[i]= FFMIN(level, 2); |
4712 assert(coeff_count[i]); | |
945 | 4713 max |=level; |
4714 }else{ | |
1718 | 4715 coeff[0][i]= (level>>31)|1; |
4716 coeff_count[i]= 1; | |
945 | 4717 } |
4718 } | |
4719 | |
4720 *overflow= s->max_qcoeff < max; //overflow might have happend | |
4721 | |
4722 if(last_non_zero < start_i){ | |
4723 memset(block + start_i, 0, (64-start_i)*sizeof(DCTELEM)); | |
4724 return last_non_zero; | |
4725 } | |
4726 | |
1718 | 4727 score_tab[start_i]= 0; |
4728 survivor[0]= start_i; | |
4729 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
|
4730 |
1718 | 4731 for(i=start_i; i<=last_non_zero; i++){ |
4732 int level_index, j; | |
4733 const int dct_coeff= ABS(block[ scantable[i] ]); | |
945 | 4734 const int zero_distoration= dct_coeff*dct_coeff; |
946 | 4735 int best_score=256*256*256*120; |
945 | 4736 for(level_index=0; level_index < coeff_count[i]; level_index++){ |
4737 int distoration; | |
4738 int level= coeff[level_index][i]; | |
1716 | 4739 const int alevel= ABS(level); |
945 | 4740 int unquant_coeff; |
4741 | |
4742 assert(level); | |
4743 | |
4744 if(s->out_format == FMT_H263){ | |
1716 | 4745 unquant_coeff= alevel*qmul + qadd; |
947 | 4746 }else{ //MPEG1 |
1718 | 4747 j= s->dsp.idct_permutation[ scantable[i] ]; //FIXME optimize |
947 | 4748 if(s->mb_intra){ |
1716 | 4749 unquant_coeff = (int)( alevel * qscale * s->intra_matrix[j]) >> 3; |
947 | 4750 unquant_coeff = (unquant_coeff - 1) | 1; |
4751 }else{ | |
1716 | 4752 unquant_coeff = ((( alevel << 1) + 1) * qscale * ((int) s->inter_matrix[j])) >> 4; |
947 | 4753 unquant_coeff = (unquant_coeff - 1) | 1; |
4754 } | |
4755 unquant_coeff<<= 3; | |
4756 } | |
946 | 4757 |
1715 | 4758 distoration= (unquant_coeff - dct_coeff) * (unquant_coeff - dct_coeff) - zero_distoration; |
945 | 4759 level+=64; |
4760 if((level&(~127)) == 0){ | |
1718 | 4761 for(j=survivor_count-1; j>=0; j--){ |
4762 int run= i - survivor[j]; | |
947 | 4763 int score= distoration + length[UNI_AC_ENC_INDEX(run, level)]*lambda; |
945 | 4764 score += score_tab[i-run]; |
4765 | |
4766 if(score < best_score){ | |
1718 | 4767 best_score= score; |
945 | 4768 run_tab[i+1]= run; |
4769 level_tab[i+1]= level-64; | |
4770 } | |
4771 } | |
4772 | |
4773 if(s->out_format == FMT_H263){ | |
1718 | 4774 for(j=survivor_count-1; j>=0; j--){ |
4775 int run= i - survivor[j]; | |
947 | 4776 int score= distoration + last_length[UNI_AC_ENC_INDEX(run, level)]*lambda; |
945 | 4777 score += score_tab[i-run]; |
946 | 4778 if(score < last_score){ |
4779 last_score= score; | |
4780 last_run= run; | |
4781 last_level= level-64; | |
4782 last_i= i+1; | |
945 | 4783 } |
4784 } | |
4785 } | |
4786 }else{ | |
4787 distoration += esc_length*lambda; | |
1718 | 4788 for(j=survivor_count-1; j>=0; j--){ |
4789 int run= i - survivor[j]; | |
945 | 4790 int score= distoration + score_tab[i-run]; |
4791 | |
4792 if(score < best_score){ | |
1718 | 4793 best_score= score; |
945 | 4794 run_tab[i+1]= run; |
4795 level_tab[i+1]= level-64; | |
4796 } | |
4797 } | |
4798 | |
4799 if(s->out_format == FMT_H263){ | |
1718 | 4800 for(j=survivor_count-1; j>=0; j--){ |
4801 int run= i - survivor[j]; | |
945 | 4802 int score= distoration + score_tab[i-run]; |
946 | 4803 if(score < last_score){ |
4804 last_score= score; | |
4805 last_run= run; | |
4806 last_level= level-64; | |
4807 last_i= i+1; | |
945 | 4808 } |
4809 } | |
4810 } | |
4811 } | |
4812 } | |
946 | 4813 |
1718 | 4814 score_tab[i+1]= best_score; |
4815 | |
946 | 4816 //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 | 4817 if(last_non_zero <= 27){ |
4818 for(; survivor_count; survivor_count--){ | |
4819 if(score_tab[ survivor[survivor_count-1] ] <= best_score) | |
4820 break; | |
4821 } | |
4822 }else{ | |
4823 for(; survivor_count; survivor_count--){ | |
4824 if(score_tab[ survivor[survivor_count-1] ] <= best_score + lambda) | |
4825 break; | |
4826 } | |
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
|
4827 } |
1718 | 4828 |
4829 survivor[ survivor_count++ ]= i+1; | |
945 | 4830 } |
946 | 4831 |
945 | 4832 if(s->out_format != FMT_H263){ |
946 | 4833 last_score= 256*256*256*120; |
1718 | 4834 for(i= survivor[0]; i<=last_non_zero + 1; i++){ |
946 | 4835 int score= score_tab[i]; |
947 | 4836 if(i) score += lambda*2; //FIXME exacter? |
4837 | |
946 | 4838 if(score < last_score){ |
4839 last_score= score; | |
4840 last_i= i; | |
4841 last_level= level_tab[i]; | |
4842 last_run= run_tab[i]; | |
4843 } | |
945 | 4844 } |
4845 } | |
1490
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1480
diff
changeset
|
4846 |
1715 | 4847 s->coded_score[n] = last_score; |
945 | 4848 |
1716 | 4849 dc= ABS(block[0]); |
1718 | 4850 last_non_zero= last_i - 1; |
945 | 4851 memset(block + start_i, 0, (64-start_i)*sizeof(DCTELEM)); |
4852 | |
4853 if(last_non_zero < start_i) | |
4854 return last_non_zero; | |
1490
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1480
diff
changeset
|
4855 |
1480
8657d6800d15
slight quality improvement ( < +0.04 PSNR) for high bitrate videos with trellis quantization
michaelni
parents:
1471
diff
changeset
|
4856 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
|
4857 int best_level= 0; |
8657d6800d15
slight quality improvement ( < +0.04 PSNR) for high bitrate videos with trellis quantization
michaelni
parents:
1471
diff
changeset
|
4858 int best_score= dc * dc; |
1490
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1480
diff
changeset
|
4859 |
1480
8657d6800d15
slight quality improvement ( < +0.04 PSNR) for high bitrate videos with trellis quantization
michaelni
parents:
1471
diff
changeset
|
4860 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
|
4861 int level= coeff[i][0]; |
1716 | 4862 int alevel= ABS(level); |
4863 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
|
4864 |
8657d6800d15
slight quality improvement ( < +0.04 PSNR) for high bitrate videos with trellis quantization
michaelni
parents:
1471
diff
changeset
|
4865 if(s->out_format == FMT_H263){ |
1716 | 4866 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
|
4867 }else{ //MPEG1 |
1716 | 4868 unquant_coeff = ((( alevel << 1) + 1) * qscale * ((int) s->inter_matrix[0])) >> 4; |
4869 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
|
4870 } |
8657d6800d15
slight quality improvement ( < +0.04 PSNR) for high bitrate videos with trellis quantization
michaelni
parents:
1471
diff
changeset
|
4871 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
|
4872 unquant_coeff<<= 3 + 3; |
8657d6800d15
slight quality improvement ( < +0.04 PSNR) for high bitrate videos with trellis quantization
michaelni
parents:
1471
diff
changeset
|
4873 |
1716 | 4874 distortion= (unquant_coeff - dc) * (unquant_coeff - dc); |
1490
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1480
diff
changeset
|
4875 level+=64; |
1716 | 4876 if((level&(~127)) == 0) score= distortion + last_length[UNI_AC_ENC_INDEX(0, level)]*lambda; |
4877 else score= distortion + esc_length*lambda; | |
1490
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1480
diff
changeset
|
4878 |
1480
8657d6800d15
slight quality improvement ( < +0.04 PSNR) for high bitrate videos with trellis quantization
michaelni
parents:
1471
diff
changeset
|
4879 if(score < best_score){ |
8657d6800d15
slight quality improvement ( < +0.04 PSNR) for high bitrate videos with trellis quantization
michaelni
parents:
1471
diff
changeset
|
4880 best_score= score; |
1490
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1480
diff
changeset
|
4881 best_level= level - 64; |
1480
8657d6800d15
slight quality improvement ( < +0.04 PSNR) for high bitrate videos with trellis quantization
michaelni
parents:
1471
diff
changeset
|
4882 } |
8657d6800d15
slight quality improvement ( < +0.04 PSNR) for high bitrate videos with trellis quantization
michaelni
parents:
1471
diff
changeset
|
4883 } |
8657d6800d15
slight quality improvement ( < +0.04 PSNR) for high bitrate videos with trellis quantization
michaelni
parents:
1471
diff
changeset
|
4884 block[0]= best_level; |
1490
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1480
diff
changeset
|
4885 s->coded_score[n] = best_score - dc*dc; |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1480
diff
changeset
|
4886 if(best_level == 0) return -1; |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1480
diff
changeset
|
4887 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
|
4888 } |
1490
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1480
diff
changeset
|
4889 |
946 | 4890 i= last_i; |
4891 assert(last_level); | |
1718 | 4892 |
4893 block[ perm_scantable[last_non_zero] ]= last_level; | |
946 | 4894 i -= last_run + 1; |
945 | 4895 |
1718 | 4896 for(; i>start_i; i -= run_tab[i] + 1){ |
4897 block[ perm_scantable[i-1] ]= level_tab[i]; | |
945 | 4898 } |
4899 | |
4900 return last_non_zero; | |
4901 } | |
4902 | |
220 | 4903 static int dct_quantize_c(MpegEncContext *s, |
0 | 4904 DCTELEM *block, int n, |
344 | 4905 int qscale, int *overflow) |
0 | 4906 { |
1715 | 4907 int i, j, level, last_non_zero, q, start_i; |
0 | 4908 const int *qmat; |
1064 | 4909 const uint8_t *scantable= s->intra_scantable.scantable; |
344 | 4910 int bias; |
4911 int max=0; | |
4912 unsigned int threshold1, threshold2; | |
828
ace3ccd18dd2
Altivec Patch (Mark III) by (Dieter Shirley <dieters at schemasoft dot com>)
michaelni
parents:
815
diff
changeset
|
4913 |
1092 | 4914 s->dsp.fdct (block); |
0 | 4915 |
1597 | 4916 if(s->dct_error_sum) |
1719 | 4917 s->denoise_dct(s, block); |
1597 | 4918 |
0 | 4919 if (s->mb_intra) { |
350
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
347
diff
changeset
|
4920 if (!s->h263_aic) { |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
347
diff
changeset
|
4921 if (n < 4) |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
347
diff
changeset
|
4922 q = s->y_dc_scale; |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
347
diff
changeset
|
4923 else |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
347
diff
changeset
|
4924 q = s->c_dc_scale; |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
347
diff
changeset
|
4925 q = q << 3; |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
347
diff
changeset
|
4926 } else |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
347
diff
changeset
|
4927 /* 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
|
4928 q = 1 << 3; |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
347
diff
changeset
|
4929 |
0 | 4930 /* note: block[0] is assumed to be positive */ |
4931 block[0] = (block[0] + (q >> 1)) / q; | |
1715 | 4932 start_i = 1; |
0 | 4933 last_non_zero = 0; |
344 | 4934 qmat = s->q_intra_matrix[qscale]; |
635 | 4935 bias= s->intra_quant_bias<<(QMAT_SHIFT - QUANT_BIAS_SHIFT); |
0 | 4936 } else { |
1715 | 4937 start_i = 0; |
0 | 4938 last_non_zero = -1; |
344 | 4939 qmat = s->q_inter_matrix[qscale]; |
635 | 4940 bias= s->inter_quant_bias<<(QMAT_SHIFT - QUANT_BIAS_SHIFT); |
0 | 4941 } |
635 | 4942 threshold1= (1<<QMAT_SHIFT) - bias - 1; |
4943 threshold2= (threshold1<<1); | |
1715 | 4944 for(i=63;i>=start_i;i--) { |
764 | 4945 j = scantable[i]; |
1715 | 4946 level = block[j] * qmat[j]; |
4947 | |
4948 if(((unsigned)(level+threshold1))>threshold2){ | |
4949 last_non_zero = i; | |
4950 break; | |
4951 }else{ | |
4952 block[j]=0; | |
4953 } | |
4954 } | |
4955 for(i=start_i; i<=last_non_zero; i++) { | |
4956 j = scantable[i]; | |
4957 level = block[j] * qmat[j]; | |
344 | 4958 |
1215 | 4959 // if( bias+level >= (1<<QMAT_SHIFT) |
4960 // || bias-level >= (1<<QMAT_SHIFT)){ | |
344 | 4961 if(((unsigned)(level+threshold1))>threshold2){ |
4962 if(level>0){ | |
635 | 4963 level= (bias + level)>>QMAT_SHIFT; |
344 | 4964 block[j]= level; |
4965 }else{ | |
635 | 4966 level= (bias - level)>>QMAT_SHIFT; |
344 | 4967 block[j]= -level; |
0 | 4968 } |
344 | 4969 max |=level; |
4970 }else{ | |
4971 block[j]=0; | |
0 | 4972 } |
4973 } | |
344 | 4974 *overflow= s->max_qcoeff < max; //overflow might have happend |
4975 | |
764 | 4976 /* we need this permutation so that we correct the IDCT, we only permute the !=0 elements */ |
1092 | 4977 if (s->dsp.idct_permutation_type != FF_NO_IDCT_PERM) |
4978 ff_block_permute(block, s->dsp.idct_permutation, scantable, last_non_zero); | |
764 | 4979 |
0 | 4980 return last_non_zero; |
4981 } | |
4982 | |
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
|
4983 #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
|
4984 |
1689 | 4985 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
|
4986 DCTELEM *block, int n, int qscale) |
0 | 4987 { |
200 | 4988 int i, level, nCoeffs; |
1064 | 4989 const uint16_t *quant_matrix; |
0 | 4990 |
706
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
4991 nCoeffs= s->block_last_index[n]; |
200 | 4992 |
1689 | 4993 if (n < 4) |
4994 block[0] = block[0] * s->y_dc_scale; | |
4995 else | |
4996 block[0] = block[0] * s->c_dc_scale; | |
4997 /* XXX: only mpeg1 */ | |
4998 quant_matrix = s->intra_matrix; | |
4999 for(i=1;i<=nCoeffs;i++) { | |
5000 int j= s->intra_scantable.permutated[i]; | |
5001 level = block[j]; | |
5002 if (level) { | |
5003 if (level < 0) { | |
5004 level = -level; | |
5005 level = (int)(level * qscale * quant_matrix[j]) >> 3; | |
5006 level = (level - 1) | 1; | |
5007 level = -level; | |
5008 } else { | |
5009 level = (int)(level * qscale * quant_matrix[j]) >> 3; | |
5010 level = (level - 1) | 1; | |
0 | 5011 } |
1689 | 5012 block[j] = level; |
0 | 5013 } |
5014 } | |
5015 } | |
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
|
5016 |
1689 | 5017 static void dct_unquantize_mpeg1_inter_c(MpegEncContext *s, |
5018 DCTELEM *block, int n, int qscale) | |
5019 { | |
5020 int i, level, nCoeffs; | |
5021 const uint16_t *quant_matrix; | |
5022 | |
5023 nCoeffs= s->block_last_index[n]; | |
5024 | |
5025 quant_matrix = s->inter_matrix; | |
5026 for(i=0; i<=nCoeffs; i++) { | |
5027 int j= s->intra_scantable.permutated[i]; | |
5028 level = block[j]; | |
5029 if (level) { | |
5030 if (level < 0) { | |
5031 level = -level; | |
5032 level = (((level << 1) + 1) * qscale * | |
5033 ((int) (quant_matrix[j]))) >> 4; | |
5034 level = (level - 1) | 1; | |
5035 level = -level; | |
5036 } else { | |
5037 level = (((level << 1) + 1) * qscale * | |
5038 ((int) (quant_matrix[j]))) >> 4; | |
5039 level = (level - 1) | 1; | |
5040 } | |
5041 block[j] = level; | |
5042 } | |
5043 } | |
5044 } | |
5045 | |
5046 static void dct_unquantize_mpeg2_intra_c(MpegEncContext *s, | |
325 | 5047 DCTELEM *block, int n, int qscale) |
5048 { | |
5049 int i, level, nCoeffs; | |
1064 | 5050 const uint16_t *quant_matrix; |
325 | 5051 |
706
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
5052 if(s->alternate_scan) nCoeffs= 63; |
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
5053 else nCoeffs= s->block_last_index[n]; |
325 | 5054 |
1689 | 5055 if (n < 4) |
5056 block[0] = block[0] * s->y_dc_scale; | |
5057 else | |
5058 block[0] = block[0] * s->c_dc_scale; | |
5059 quant_matrix = s->intra_matrix; | |
5060 for(i=1;i<=nCoeffs;i++) { | |
5061 int j= s->intra_scantable.permutated[i]; | |
5062 level = block[j]; | |
5063 if (level) { | |
5064 if (level < 0) { | |
5065 level = -level; | |
5066 level = (int)(level * qscale * quant_matrix[j]) >> 3; | |
5067 level = -level; | |
5068 } else { | |
5069 level = (int)(level * qscale * quant_matrix[j]) >> 3; | |
5070 } | |
5071 block[j] = level; | |
5072 } | |
5073 } | |
5074 } | |
5075 | |
5076 static void dct_unquantize_mpeg2_inter_c(MpegEncContext *s, | |
5077 DCTELEM *block, int n, int qscale) | |
5078 { | |
5079 int i, level, nCoeffs; | |
5080 const uint16_t *quant_matrix; | |
5081 int sum=-1; | |
5082 | |
5083 if(s->alternate_scan) nCoeffs= 63; | |
5084 else nCoeffs= s->block_last_index[n]; | |
5085 | |
5086 quant_matrix = s->inter_matrix; | |
5087 for(i=0; i<=nCoeffs; i++) { | |
5088 int j= s->intra_scantable.permutated[i]; | |
5089 level = block[j]; | |
5090 if (level) { | |
5091 if (level < 0) { | |
5092 level = -level; | |
5093 level = (((level << 1) + 1) * qscale * | |
5094 ((int) (quant_matrix[j]))) >> 4; | |
5095 level = -level; | |
5096 } else { | |
5097 level = (((level << 1) + 1) * qscale * | |
5098 ((int) (quant_matrix[j]))) >> 4; | |
5099 } | |
5100 block[j] = level; | |
5101 sum+=level; | |
5102 } | |
5103 } | |
5104 block[63]^=sum&1; | |
5105 } | |
5106 | |
5107 static void dct_unquantize_h263_intra_c(MpegEncContext *s, | |
5108 DCTELEM *block, int n, int qscale) | |
5109 { | |
5110 int i, level, qmul, qadd; | |
5111 int nCoeffs; | |
5112 | |
5113 assert(s->block_last_index[n]>=0); | |
5114 | |
5115 qmul = qscale << 1; | |
5116 | |
5117 if (!s->h263_aic) { | |
325 | 5118 if (n < 4) |
5119 block[0] = block[0] * s->y_dc_scale; | |
5120 else | |
5121 block[0] = block[0] * s->c_dc_scale; | |
1689 | 5122 qadd = (qscale - 1) | 1; |
5123 }else{ | |
5124 qadd = 0; | |
5125 } | |
5126 if(s->ac_pred) | |
5127 nCoeffs=63; | |
5128 else | |
5129 nCoeffs= s->inter_scantable.raster_end[ s->block_last_index[n] ]; | |
5130 | |
5131 for(i=1; i<=nCoeffs; i++) { | |
5132 level = block[i]; | |
5133 if (level) { | |
5134 if (level < 0) { | |
5135 level = level * qmul - qadd; | |
5136 } else { | |
5137 level = level * qmul + qadd; | |
325 | 5138 } |
1689 | 5139 block[i] = level; |
325 | 5140 } |
5141 } | |
5142 } | |
5143 | |
1689 | 5144 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
|
5145 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
|
5146 { |
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
|
5147 int i, level, qmul, qadd; |
200 | 5148 int nCoeffs; |
249
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
5149 |
706
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
5150 assert(s->block_last_index[n]>=0); |
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
5151 |
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
5152 qadd = (qscale - 1) | 1; |
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
5153 qmul = qscale << 1; |
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
5154 |
1689 | 5155 nCoeffs= s->inter_scantable.raster_end[ s->block_last_index[n] ]; |
5156 | |
5157 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
|
5158 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
|
5159 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
|
5160 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
|
5161 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
|
5162 } 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
|
5163 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
|
5164 } |
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
|
5165 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
|
5166 } |
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
|
5167 } |
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
|
5168 } |
0 | 5169 |
1059 | 5170 static const AVOption mpeg4_options[] = |
5171 { | |
5172 AVOPTION_CODEC_INT("bitrate", "desired video bitrate", bit_rate, 4, 240000000, 800000), | |
5173 AVOPTION_CODEC_INT("ratetol", "number of bits the bitstream is allowed to diverge from the reference" | |
5174 "the reference can be CBR (for CBR pass1) or VBR (for pass2)", | |
5175 bit_rate_tolerance, 4, 240000000, 8000), | |
5176 AVOPTION_CODEC_INT("qmin", "minimum quantizer", qmin, 1, 31, 2), | |
5177 AVOPTION_CODEC_INT("qmax", "maximum quantizer", qmax, 1, 31, 31), | |
5178 AVOPTION_CODEC_STRING("rc_eq", "rate control equation", | |
5179 rc_eq, "tex^qComp,option1,options2", 0), | |
5180 AVOPTION_CODEC_INT("rc_minrate", "rate control minimum bitrate", | |
5181 rc_min_rate, 4, 24000000, 0), | |
5182 AVOPTION_CODEC_INT("rc_maxrate", "rate control maximum bitrate", | |
5183 rc_max_rate, 4, 24000000, 0), | |
1130 | 5184 AVOPTION_CODEC_DOUBLE("rc_buf_aggresivity", "rate control buffer aggresivity", |
5185 rc_buffer_aggressivity, 4, 24000000, 0), | |
5186 AVOPTION_CODEC_DOUBLE("rc_initial_cplx", "initial complexity for pass1 ratecontrol", | |
5187 rc_initial_cplx, 0., 9999999., 0), | |
5188 AVOPTION_CODEC_DOUBLE("i_quant_factor", "qscale factor between p and i frames", | |
5189 i_quant_factor, 0., 0., 0), | |
5190 AVOPTION_CODEC_DOUBLE("i_quant_offset", "qscale offset between p and i frames", | |
5191 i_quant_factor, -999999., 999999., 0), | |
5192 AVOPTION_CODEC_INT("dct_algo", "dct alghorithm", | |
5193 dct_algo, 0, 5, 0), // fixme - "Auto,FastInt,Int,MMX,MLib,Altivec" | |
5194 AVOPTION_CODEC_DOUBLE("lumi_masking", "luminance masking", | |
5195 lumi_masking, 0., 999999., 0), | |
5196 AVOPTION_CODEC_DOUBLE("temporal_cplx_masking", "temporary complexity masking", | |
5197 temporal_cplx_masking, 0., 999999., 0), | |
5198 AVOPTION_CODEC_DOUBLE("spatial_cplx_masking", "spatial complexity masking", | |
5199 spatial_cplx_masking, 0., 999999., 0), | |
5200 AVOPTION_CODEC_DOUBLE("p_masking", "p block masking", | |
5201 p_masking, 0., 999999., 0), | |
5202 AVOPTION_CODEC_DOUBLE("dark_masking", "darkness masking", | |
5203 dark_masking, 0., 999999., 0), | |
5204 AVOPTION_CODEC_INT("idct_algo", "idct alghorithm", | |
5205 idct_algo, 0, 8, 0), // fixme - "Auto,Int,Simple,SimpleMMX,LibMPEG2MMX,PS2,MLib,ARM,Altivec" | |
5206 | |
5207 AVOPTION_CODEC_INT("mb_qmin", "minimum MB quantizer", | |
5208 mb_qmin, 0, 8, 0), | |
5209 AVOPTION_CODEC_INT("mb_qmax", "maximum MB quantizer", | |
5210 mb_qmin, 0, 8, 0), | |
5211 | |
5212 AVOPTION_CODEC_INT("me_cmp", "ME compare function", | |
5213 me_cmp, 0, 24000000, 0), | |
5214 AVOPTION_CODEC_INT("me_sub_cmp", "subpixel ME compare function", | |
5215 me_sub_cmp, 0, 24000000, 0), | |
5216 | |
5217 | |
5218 AVOPTION_CODEC_INT("dia_size", "ME diamond size & shape", | |
5219 dia_size, 0, 24000000, 0), | |
5220 AVOPTION_CODEC_INT("last_predictor_count", "amount of previous MV predictors", | |
5221 last_predictor_count, 0, 24000000, 0), | |
5222 | |
5223 AVOPTION_CODEC_INT("pre_me", "pre pass for ME", | |
5224 pre_me, 0, 24000000, 0), | |
5225 AVOPTION_CODEC_INT("me_pre_cmp", "ME pre pass compare function", | |
5226 me_pre_cmp, 0, 24000000, 0), | |
5227 | |
5228 AVOPTION_CODEC_INT("me_range", "maximum ME search range", | |
5229 me_range, 0, 24000000, 0), | |
5230 AVOPTION_CODEC_INT("pre_dia_size", "ME pre pass diamod size & shape", | |
5231 pre_dia_size, 0, 24000000, 0), | |
5232 AVOPTION_CODEC_INT("me_subpel_quality", "subpel ME quality", | |
5233 me_subpel_quality, 0, 24000000, 0), | |
5234 AVOPTION_CODEC_INT("me_range", "maximum ME search range", | |
5235 me_range, 0, 24000000, 0), | |
1059 | 5236 AVOPTION_CODEC_FLAG("psnr", "calculate PSNR of compressed frames", |
5237 flags, CODEC_FLAG_PSNR, 0), | |
5238 AVOPTION_CODEC_RCOVERRIDE("rc_override", "ratecontrol override (=startframe,endframe,qscale,quality_factor)", | |
5239 rc_override), | |
1124
64c7c76ed17c
* 'externaly' visible option list begins avoptions_ prefix
kabi
parents:
1116
diff
changeset
|
5240 AVOPTION_SUB(avoptions_common), |
1059 | 5241 AVOPTION_END() |
5242 }; | |
5243 | |
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
|
5244 #ifdef CONFIG_ENCODERS |
1042 | 5245 #ifdef CONFIG_RISKY |
0 | 5246 AVCodec h263_encoder = { |
5247 "h263", | |
5248 CODEC_TYPE_VIDEO, | |
5249 CODEC_ID_H263, | |
5250 sizeof(MpegEncContext), | |
5251 MPV_encode_init, | |
5252 MPV_encode_picture, | |
5253 MPV_encode_end, | |
5254 }; | |
5255 | |
5256 AVCodec h263p_encoder = { | |
5257 "h263p", | |
5258 CODEC_TYPE_VIDEO, | |
5259 CODEC_ID_H263P, | |
5260 sizeof(MpegEncContext), | |
5261 MPV_encode_init, | |
5262 MPV_encode_picture, | |
5263 MPV_encode_end, | |
5264 }; | |
5265 | |
1353
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1344
diff
changeset
|
5266 AVCodec flv_encoder = { |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1344
diff
changeset
|
5267 "flv", |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1344
diff
changeset
|
5268 CODEC_TYPE_VIDEO, |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1344
diff
changeset
|
5269 CODEC_ID_FLV1, |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1344
diff
changeset
|
5270 sizeof(MpegEncContext), |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1344
diff
changeset
|
5271 MPV_encode_init, |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1344
diff
changeset
|
5272 MPV_encode_picture, |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1344
diff
changeset
|
5273 MPV_encode_end, |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1344
diff
changeset
|
5274 }; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1344
diff
changeset
|
5275 |
0 | 5276 AVCodec rv10_encoder = { |
5277 "rv10", | |
5278 CODEC_TYPE_VIDEO, | |
5279 CODEC_ID_RV10, | |
5280 sizeof(MpegEncContext), | |
5281 MPV_encode_init, | |
5282 MPV_encode_picture, | |
5283 MPV_encode_end, | |
5284 }; | |
5285 | |
71 | 5286 AVCodec mpeg4_encoder = { |
5287 "mpeg4", | |
0 | 5288 CODEC_TYPE_VIDEO, |
71 | 5289 CODEC_ID_MPEG4, |
0 | 5290 sizeof(MpegEncContext), |
5291 MPV_encode_init, | |
5292 MPV_encode_picture, | |
5293 MPV_encode_end, | |
1059 | 5294 .options = mpeg4_options, |
0 | 5295 }; |
5296 | |
307 | 5297 AVCodec msmpeg4v1_encoder = { |
5298 "msmpeg4v1", | |
0 | 5299 CODEC_TYPE_VIDEO, |
307 | 5300 CODEC_ID_MSMPEG4V1, |
0 | 5301 sizeof(MpegEncContext), |
5302 MPV_encode_init, | |
5303 MPV_encode_picture, | |
5304 MPV_encode_end, | |
1130 | 5305 .options = mpeg4_options, |
0 | 5306 }; |
307 | 5307 |
5308 AVCodec msmpeg4v2_encoder = { | |
5309 "msmpeg4v2", | |
5310 CODEC_TYPE_VIDEO, | |
5311 CODEC_ID_MSMPEG4V2, | |
5312 sizeof(MpegEncContext), | |
5313 MPV_encode_init, | |
5314 MPV_encode_picture, | |
5315 MPV_encode_end, | |
1130 | 5316 .options = mpeg4_options, |
307 | 5317 }; |
5318 | |
5319 AVCodec msmpeg4v3_encoder = { | |
5320 "msmpeg4", | |
5321 CODEC_TYPE_VIDEO, | |
5322 CODEC_ID_MSMPEG4V3, | |
5323 sizeof(MpegEncContext), | |
5324 MPV_encode_init, | |
5325 MPV_encode_picture, | |
5326 MPV_encode_end, | |
1130 | 5327 .options = mpeg4_options, |
307 | 5328 }; |
499 | 5329 |
5330 AVCodec wmv1_encoder = { | |
5331 "wmv1", | |
5332 CODEC_TYPE_VIDEO, | |
5333 CODEC_ID_WMV1, | |
5334 sizeof(MpegEncContext), | |
5335 MPV_encode_init, | |
5336 MPV_encode_picture, | |
5337 MPV_encode_end, | |
1130 | 5338 .options = mpeg4_options, |
499 | 5339 }; |
5340 | |
1042 | 5341 #endif |
5342 | |
5343 AVCodec mjpeg_encoder = { | |
5344 "mjpeg", | |
5345 CODEC_TYPE_VIDEO, | |
5346 CODEC_ID_MJPEG, | |
5347 sizeof(MpegEncContext), | |
5348 MPV_encode_init, | |
5349 MPV_encode_picture, | |
5350 MPV_encode_end, | |
5351 }; | |
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
|
5352 |
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
|
5353 #endif //CONFIG_ENCODERS |