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