annotate mpegvideo.c @ 2169:db8baace74d8 libavcodec

Minor Patch for shared libs on Mac OSX by (Bill May <wmay at cisco dot com>)
author michael
date Fri, 13 Aug 2004 15:30:42 +0000
parents f3f5dabef677
children c17d0cbbdf66
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
rev   line source
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1 /*
986e461dc072 Initial revision
glantau
parents:
diff changeset
2 * The simplest mpeg encoder (well, it was the simplest!)
429
718a22dc121f license/copyright change
glantau
parents: 396
diff changeset
3 * Copyright (c) 2000,2001 Fabrice Bellard.
1739
07a484280a82 copyright year update of the files i touched and remembered, things look annoyingly unmaintained otherwise
michael
parents: 1729
diff changeset
4 * Copyright (c) 2002-2004 Michael Niedermayer <michaelni@gmx.at>
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
5 *
429
718a22dc121f license/copyright change
glantau
parents: 396
diff changeset
6 * This library is free software; you can redistribute it and/or
718a22dc121f license/copyright change
glantau
parents: 396
diff changeset
7 * modify it under the terms of the GNU Lesser General Public
718a22dc121f license/copyright change
glantau
parents: 396
diff changeset
8 * License as published by the Free Software Foundation; either
718a22dc121f license/copyright change
glantau
parents: 396
diff changeset
9 * version 2 of the License, or (at your option) any later version.
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
10 *
429
718a22dc121f license/copyright change
glantau
parents: 396
diff changeset
11 * This library is distributed in the hope that it will be useful,
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
429
718a22dc121f license/copyright change
glantau
parents: 396
diff changeset
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
718a22dc121f license/copyright change
glantau
parents: 396
diff changeset
14 * Lesser General Public License for more details.
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
15 *
429
718a22dc121f license/copyright change
glantau
parents: 396
diff changeset
16 * You should have received a copy of the GNU Lesser General Public
718a22dc121f license/copyright change
glantau
parents: 396
diff changeset
17 * License along with this library; if not, write to the Free Software
718a22dc121f license/copyright change
glantau
parents: 396
diff changeset
18 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
295
6622b0fd036c mpeg4 4MV encoding
michaelni
parents: 294
diff changeset
19 *
325
15efd80cf51e mpeg2/mpeg4 dequantizer support (c & mmx)
michaelni
parents: 324
diff changeset
20 * 4MV & hq & b-frame encoding stuff by Michael Niedermayer <michaelni@gmx.at>
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
21 */
701
85b071dfc7e3 ff_get_fourcc() & XVIX support
michaelni
parents: 697
diff changeset
22
1106
1e39f273ecd6 per file doxy
michaelni
parents: 1099
diff changeset
23 /**
1e39f273ecd6 per file doxy
michaelni
parents: 1099
diff changeset
24 * @file mpegvideo.c
1e39f273ecd6 per file doxy
michaelni
parents: 1099
diff changeset
25 * The simplest mpeg encoder (well, it was the simplest!).
1e39f273ecd6 per file doxy
michaelni
parents: 1099
diff changeset
26 */
1e39f273ecd6 per file doxy
michaelni
parents: 1099
diff changeset
27
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
28 #include "avcodec.h"
986e461dc072 Initial revision
glantau
parents:
diff changeset
29 #include "dsputil.h"
986e461dc072 Initial revision
glantau
parents:
diff changeset
30 #include "mpegvideo.h"
1557
5d53c03186a1 floating point AAN DCT
michael
parents: 1556
diff changeset
31 #include "faandct.h"
2024
f65d87bfdd5a some of the warning fixes by (Michael Roitzsch <mroi at users dot sourceforge dot net>)
michael
parents: 2015
diff changeset
32 #include <limits.h>
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
33
17
b69fe46fd708 Adding fastmemcpy stuff to speedup mplayer project
nickols_k
parents: 13
diff changeset
34 #ifdef USE_FASTMEMCPY
b69fe46fd708 Adding fastmemcpy stuff to speedup mplayer project
nickols_k
parents: 13
diff changeset
35 #include "fastmemcpy.h"
b69fe46fd708 Adding fastmemcpy stuff to speedup mplayer project
nickols_k
parents: 13
diff changeset
36 #endif
b69fe46fd708 Adding fastmemcpy stuff to speedup mplayer project
nickols_k
parents: 13
diff changeset
37
1422
efeed6e29f9b oooooops, having 2 Eterms open and doing cvs diff in one and cvs commit in the other sucks, especially if they are in different directories (MPlayer/main/libavcodec vs. ffmpeg/libavcodec)
michaelni
parents: 1421
diff changeset
38 //#undef NDEBUG
efeed6e29f9b oooooops, having 2 Eterms open and doing cvs diff in one and cvs commit in the other sucks, especially if they are in different directories (MPlayer/main/libavcodec vs. ffmpeg/libavcodec)
michaelni
parents: 1421
diff changeset
39 //#include <assert.h>
706
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 704
diff changeset
40
1070
6da5ae9ee199 more #ifdef CONFIG_ENCODERS patch by (Wolfgang Hesseler <qv at multimediaware dot com>) with modifications by me (s/WOLFGANG/CONFIG_ENCODERS/ and some other fixes)
michaelni
parents: 1064
diff changeset
41 #ifdef CONFIG_ENCODERS
13
174ef88f619a use block[] in structure to have it aligned on 8 bytes for mmx optimizations - dct_unquantize is always a function pointer - added specialized dct_unquantize_h263
glantau
parents: 8
diff changeset
42 static void encode_picture(MpegEncContext *s, int picture_number);
1070
6da5ae9ee199 more #ifdef CONFIG_ENCODERS patch by (Wolfgang Hesseler <qv at multimediaware dot com>) with modifications by me (s/WOLFGANG/CONFIG_ENCODERS/ and some other fixes)
michaelni
parents: 1064
diff changeset
43 #endif //CONFIG_ENCODERS
1689
1a2db2073848 split intra / inter dequantization
michael
parents: 1688
diff changeset
44 static void dct_unquantize_mpeg1_intra_c(MpegEncContext *s,
1a2db2073848 split intra / inter dequantization
michael
parents: 1688
diff changeset
45 DCTELEM *block, int n, int qscale);
1a2db2073848 split intra / inter dequantization
michael
parents: 1688
diff changeset
46 static void dct_unquantize_mpeg1_inter_c(MpegEncContext *s,
1a2db2073848 split intra / inter dequantization
michael
parents: 1688
diff changeset
47 DCTELEM *block, int n, int qscale);
1a2db2073848 split intra / inter dequantization
michael
parents: 1688
diff changeset
48 static void dct_unquantize_mpeg2_intra_c(MpegEncContext *s,
13
174ef88f619a use block[] in structure to have it aligned on 8 bytes for mmx optimizations - dct_unquantize is always a function pointer - added specialized dct_unquantize_h263
glantau
parents: 8
diff changeset
49 DCTELEM *block, int n, int qscale);
1689
1a2db2073848 split intra / inter dequantization
michael
parents: 1688
diff changeset
50 static void dct_unquantize_mpeg2_inter_c(MpegEncContext *s,
325
15efd80cf51e mpeg2/mpeg4 dequantizer support (c & mmx)
michaelni
parents: 324
diff changeset
51 DCTELEM *block, int n, int qscale);
1689
1a2db2073848 split intra / inter dequantization
michael
parents: 1688
diff changeset
52 static void dct_unquantize_h263_intra_c(MpegEncContext *s,
1a2db2073848 split intra / inter dequantization
michael
parents: 1688
diff changeset
53 DCTELEM *block, int n, int qscale);
1a2db2073848 split intra / inter dequantization
michael
parents: 1688
diff changeset
54 static void dct_unquantize_h263_inter_c(MpegEncContext *s,
13
174ef88f619a use block[] in structure to have it aligned on 8 bytes for mmx optimizations - dct_unquantize is always a function pointer - added specialized dct_unquantize_h263
glantau
parents: 8
diff changeset
55 DCTELEM *block, int n, int qscale);
2044
b6f2add2511e h261 decoder by (Maarten Daniels <maarten.daniels at student dot luc dot ac dot be>)
michael
parents: 2042
diff changeset
56 static void dct_unquantize_h261_intra_c(MpegEncContext *s,
b6f2add2511e h261 decoder by (Maarten Daniels <maarten.daniels at student dot luc dot ac dot be>)
michael
parents: 2042
diff changeset
57 DCTELEM *block, int n, int qscale);
b6f2add2511e h261 decoder by (Maarten Daniels <maarten.daniels at student dot luc dot ac dot be>)
michael
parents: 2042
diff changeset
58 static void dct_unquantize_h261_inter_c(MpegEncContext *s,
b6f2add2511e h261 decoder by (Maarten Daniels <maarten.daniels at student dot luc dot ac dot be>)
michael
parents: 2042
diff changeset
59 DCTELEM *block, int n, int qscale);
1064
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1059
diff changeset
60 static void draw_edges_c(uint8_t *buf, int wrap, int width, int height, int w);
1070
6da5ae9ee199 more #ifdef CONFIG_ENCODERS patch by (Wolfgang Hesseler <qv at multimediaware dot com>) with modifications by me (s/WOLFGANG/CONFIG_ENCODERS/ and some other fixes)
michaelni
parents: 1064
diff changeset
61 #ifdef CONFIG_ENCODERS
344
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
62 static int dct_quantize_c(MpegEncContext *s, DCTELEM *block, int n, int qscale, int *overflow);
945
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
63 static int dct_quantize_trellis_c(MpegEncContext *s, DCTELEM *block, int n, int qscale, int *overflow);
1777
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
64 static int dct_quantize_refine(MpegEncContext *s, DCTELEM *block, int16_t *weight, DCTELEM *orig, int n, int qscale);
1389
da0b3a50d209 rate distortion mb decision support
michaelni
parents: 1384
diff changeset
65 static int sse_mb(MpegEncContext *s);
1719
4e72fb256b25 denoise_dct_mmx()
michael
parents: 1718
diff changeset
66 static void denoise_dct_c(MpegEncContext *s, DCTELEM *block);
1070
6da5ae9ee199 more #ifdef CONFIG_ENCODERS patch by (Wolfgang Hesseler <qv at multimediaware dot com>) with modifications by me (s/WOLFGANG/CONFIG_ENCODERS/ and some other fixes)
michaelni
parents: 1064
diff changeset
67 #endif //CONFIG_ENCODERS
206
994aa8623443 (commit by michael)
arpi_esp
parents: 200
diff changeset
68
1381
f07e17427140 initial XvMC support
iive
parents: 1373
diff changeset
69 #ifdef HAVE_XVMC
f07e17427140 initial XvMC support
iive
parents: 1373
diff changeset
70 extern int XVMC_field_start(MpegEncContext*s, AVCodecContext *avctx);
f07e17427140 initial XvMC support
iive
parents: 1373
diff changeset
71 extern void XVMC_field_end(MpegEncContext *s);
1580
628bf341e099 XvMC speedup by removing one memcpy and doing MB packing
iive
parents: 1579
diff changeset
72 extern void XVMC_decode_mb(MpegEncContext *s);
1381
f07e17427140 initial XvMC support
iive
parents: 1373
diff changeset
73 #endif
f07e17427140 initial XvMC support
iive
parents: 1373
diff changeset
74
1064
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1059
diff changeset
75 void (*draw_edges)(uint8_t *buf, int wrap, int width, int height, int w)= draw_edges_c;
206
994aa8623443 (commit by michael)
arpi_esp
parents: 200
diff changeset
76
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
77
986e461dc072 Initial revision
glantau
parents:
diff changeset
78 /* enable all paranoid tests for rounding, overflows, etc... */
986e461dc072 Initial revision
glantau
parents:
diff changeset
79 //#define PARANOID
986e461dc072 Initial revision
glantau
parents:
diff changeset
80
986e461dc072 Initial revision
glantau
parents:
diff changeset
81 //#define DEBUG
986e461dc072 Initial revision
glantau
parents:
diff changeset
82
321
2b00e171b1d4 - ME method compatibility with legacy apps.
pulento
parents: 320
diff changeset
83
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
84 /* for jpeg fast DCT */
986e461dc072 Initial revision
glantau
parents:
diff changeset
85 #define CONST_BITS 14
986e461dc072 Initial revision
glantau
parents:
diff changeset
86
853
eacc2dd8fd9d * using DSPContext - so each codec could use its local (sub)set of CPU extension
kabi
parents: 847
diff changeset
87 static const uint16_t aanscales[64] = {
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
88 /* precomputed values scaled up by 14 bits */
986e461dc072 Initial revision
glantau
parents:
diff changeset
89 16384, 22725, 21407, 19266, 16384, 12873, 8867, 4520,
986e461dc072 Initial revision
glantau
parents:
diff changeset
90 22725, 31521, 29692, 26722, 22725, 17855, 12299, 6270,
986e461dc072 Initial revision
glantau
parents:
diff changeset
91 21407, 29692, 27969, 25172, 21407, 16819, 11585, 5906,
986e461dc072 Initial revision
glantau
parents:
diff changeset
92 19266, 26722, 25172, 22654, 19266, 15137, 10426, 5315,
986e461dc072 Initial revision
glantau
parents:
diff changeset
93 16384, 22725, 21407, 19266, 16384, 12873, 8867, 4520,
986e461dc072 Initial revision
glantau
parents:
diff changeset
94 12873, 17855, 16819, 15137, 12873, 10114, 6967, 3552,
936
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
95 8867 , 12299, 11585, 10426, 8867, 6967, 4799, 2446,
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
96 4520 , 6270, 5906, 5315, 4520, 3552, 2446, 1247
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
97 };
986e461dc072 Initial revision
glantau
parents:
diff changeset
98
853
eacc2dd8fd9d * using DSPContext - so each codec could use its local (sub)set of CPU extension
kabi
parents: 847
diff changeset
99 static const uint8_t h263_chroma_roundtab[16] = {
1013
5d4c95f323d0 finetuneing thresholds/factors
michaelni
parents: 1011
diff changeset
100 // 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
101 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2,
986e461dc072 Initial revision
glantau
parents:
diff changeset
102 };
986e461dc072 Initial revision
glantau
parents:
diff changeset
103
1644
835cf346975e h263 loop filter
michael
parents: 1641
diff changeset
104 static const uint8_t ff_default_chroma_qscale_table[32]={
835cf346975e h263 loop filter
michael
parents: 1641
diff changeset
105 // 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
835cf346975e h263 loop filter
michael
parents: 1641
diff changeset
106 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31
835cf346975e h263 loop filter
michael
parents: 1641
diff changeset
107 };
835cf346975e h263 loop filter
michael
parents: 1641
diff changeset
108
1070
6da5ae9ee199 more #ifdef CONFIG_ENCODERS patch by (Wolfgang Hesseler <qv at multimediaware dot com>) with modifications by me (s/WOLFGANG/CONFIG_ENCODERS/ and some other fixes)
michaelni
parents: 1064
diff changeset
109 #ifdef CONFIG_ENCODERS
1162
8c15d82c1893 some static -> dynamic alloc & 16->8 bit
michaelni
parents: 1160
diff changeset
110 static uint8_t (*default_mv_penalty)[MAX_MV*2+1]=NULL;
1064
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1059
diff changeset
111 static uint8_t default_fcode_tab[MAX_MV*2+1];
277
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 271
diff changeset
112
998
6129c88a6393 get_format()
michaelni
parents: 956
diff changeset
113 enum PixelFormat ff_yuv420p_list[2]= {PIX_FMT_YUV420P, -1};
6129c88a6393 get_format()
michaelni
parents: 956
diff changeset
114
1579
039cb2296de2 make convert_matrix() independant of MpegEncContext
michael
parents: 1573
diff changeset
115 static void convert_matrix(DSPContext *dsp, int (*qmat)[64], uint16_t (*qmat16)[2][64],
1064
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1059
diff changeset
116 const uint16_t *quant_matrix, int bias, int qmin, int qmax)
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
117 {
344
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
118 int qscale;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
119
709
afeff6ccb7f5 convert only needed matrixes in convert_matrix() (mjpeg calls it for every frame)
michaelni
parents: 706
diff changeset
120 for(qscale=qmin; qscale<=qmax; qscale++){
344
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
121 int i;
1579
039cb2296de2 make convert_matrix() independant of MpegEncContext
michael
parents: 1573
diff changeset
122 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
123 #ifdef FAAN_POSTSCALE
1579
039cb2296de2 make convert_matrix() independant of MpegEncContext
michael
parents: 1573
diff changeset
124 || dsp->fdct == ff_faandct
1562
bf452704100f optionally merge postscale into quantization table for the float aan dct
michael
parents: 1557
diff changeset
125 #endif
bf452704100f optionally merge postscale into quantization table for the float aan dct
michael
parents: 1557
diff changeset
126 ) {
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
127 for(i=0;i<64;i++) {
1579
039cb2296de2 make convert_matrix() independant of MpegEncContext
michael
parents: 1573
diff changeset
128 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
129 /* 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
130 /* 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
131 /* (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
132 /* 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
133
1064
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1059
diff changeset
134 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
135 (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
136 }
1579
039cb2296de2 make convert_matrix() independant of MpegEncContext
michael
parents: 1573
diff changeset
137 } else if (dsp->fdct == fdct_ifast
1562
bf452704100f optionally merge postscale into quantization table for the float aan dct
michael
parents: 1557
diff changeset
138 #ifndef FAAN_POSTSCALE
1579
039cb2296de2 make convert_matrix() independant of MpegEncContext
michael
parents: 1573
diff changeset
139 || dsp->fdct == ff_faandct
1562
bf452704100f optionally merge postscale into quantization table for the float aan dct
michael
parents: 1557
diff changeset
140 #endif
bf452704100f optionally merge postscale into quantization table for the float aan dct
michael
parents: 1557
diff changeset
141 ) {
344
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
142 for(i=0;i<64;i++) {
1579
039cb2296de2 make convert_matrix() independant of MpegEncContext
michael
parents: 1573
diff changeset
143 const int j= dsp->idct_permutation[i];
344
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
144 /* 16 <= qscale * quant_matrix[i] <= 7905 */
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
145 /* 19952 <= aanscales[i] * qscale * quant_matrix[i] <= 249205026 */
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
146 /* (1<<36)/19952 >= (1<<36)/(aanscales[i] * qscale * quant_matrix[i]) >= (1<<36)/249205026 */
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
147 /* 3444240 >= (1<<36)/(aanscales[i] * qscale * quant_matrix[i]) >= 275 */
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
148
1064
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1059
diff changeset
149 qmat[qscale][i] = (int)((uint64_t_C(1) << (QMAT_SHIFT + 14)) /
344
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
150 (aanscales[i] * qscale * quant_matrix[j]));
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
151 }
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
152 } else {
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
153 for(i=0;i<64;i++) {
1579
039cb2296de2 make convert_matrix() independant of MpegEncContext
michael
parents: 1573
diff changeset
154 const int j= dsp->idct_permutation[i];
344
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
155 /* We can safely suppose that 16 <= quant_matrix[i] <= 255
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
156 So 16 <= qscale * quant_matrix[i] <= 7905
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
157 so (1<<19) / 16 >= (1<<19) / (qscale * quant_matrix[i]) >= (1<<19) / 7905
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
158 so 32768 >= (1<<19) / (qscale * quant_matrix[i]) >= 67
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
159 */
1064
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1059
diff changeset
160 qmat[qscale][i] = (int)((uint64_t_C(1) << QMAT_SHIFT) / (qscale * quant_matrix[j]));
945
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
161 // 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
162 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
163
d736e24bf303 move mmx quantizer matrixes out of MpegEncContext (23k -> 7k) (no meassureable slowdown)
michael
parents: 1553
diff changeset
164 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
165 qmat16[qscale][1][i]= ROUNDED_DIV(bias<<(16-QUANT_BIAS_SHIFT), qmat16[qscale][0][i]);
344
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
166 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
167 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
168 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
169 }
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
170
010f76d07a27 use lagrange multipler instead of qp for ratecontrol, this may break some things, tell me ASAP if u notice anything broken
michaelni
parents: 1497
diff changeset
171 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
172 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
173 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
174
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
175 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
176 }
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
177 #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
178
1273
a979fab41ed8 ASV1 codec
michaelni
parents: 1264
diff changeset
179 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
180 int i;
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 704
diff changeset
181 int end;
764
d4726182dfd2 optimize block_permute()
michaelni
parents: 763
diff changeset
182
d4726182dfd2 optimize block_permute()
michaelni
parents: 763
diff changeset
183 st->scantable= src_scantable;
706
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 704
diff changeset
184
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 704
diff changeset
185 for(i=0; i<64; i++){
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 704
diff changeset
186 int j;
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 704
diff changeset
187 j = src_scantable[i];
1273
a979fab41ed8 ASV1 codec
michaelni
parents: 1264
diff changeset
188 st->permutated[i] = permutation[j];
828
ace3ccd18dd2 Altivec Patch (Mark III) by (Dieter Shirley <dieters at schemasoft dot com>)
michaelni
parents: 815
diff changeset
189 #ifdef ARCH_POWERPC
ace3ccd18dd2 Altivec Patch (Mark III) by (Dieter Shirley <dieters at schemasoft dot com>)
michaelni
parents: 815
diff changeset
190 st->inverse[j] = i;
ace3ccd18dd2 Altivec Patch (Mark III) by (Dieter Shirley <dieters at schemasoft dot com>)
michaelni
parents: 815
diff changeset
191 #endif
706
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 704
diff changeset
192 }
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 end=-1;
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 704
diff changeset
195 for(i=0; i<64; i++){
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 704
diff changeset
196 int j;
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 704
diff changeset
197 j = st->permutated[i];
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 704
diff changeset
198 if(j>end) end=j;
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 704
diff changeset
199 st->raster_end[i]= end;
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 704
diff changeset
200 }
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 704
diff changeset
201 }
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 704
diff changeset
202
1530
3b31998fe22f disable encoders where appropriate (patch courtesy of BERO
melanson
parents: 1523
diff changeset
203 #ifdef CONFIG_ENCODERS
1411
c2e63cb94d06 custom quant matrix encoding support
michaelni
parents: 1402
diff changeset
204 void ff_write_quant_matrix(PutBitContext *pb, int16_t *matrix){
c2e63cb94d06 custom quant matrix encoding support
michaelni
parents: 1402
diff changeset
205 int i;
c2e63cb94d06 custom quant matrix encoding support
michaelni
parents: 1402
diff changeset
206
c2e63cb94d06 custom quant matrix encoding support
michaelni
parents: 1402
diff changeset
207 if(matrix){
c2e63cb94d06 custom quant matrix encoding support
michaelni
parents: 1402
diff changeset
208 put_bits(pb, 1, 1);
c2e63cb94d06 custom quant matrix encoding support
michaelni
parents: 1402
diff changeset
209 for(i=0;i<64;i++) {
c2e63cb94d06 custom quant matrix encoding support
michaelni
parents: 1402
diff changeset
210 put_bits(pb, 8, matrix[ ff_zigzag_direct[i] ]);
c2e63cb94d06 custom quant matrix encoding support
michaelni
parents: 1402
diff changeset
211 }
c2e63cb94d06 custom quant matrix encoding support
michaelni
parents: 1402
diff changeset
212 }else
c2e63cb94d06 custom quant matrix encoding support
michaelni
parents: 1402
diff changeset
213 put_bits(pb, 1, 0);
c2e63cb94d06 custom quant matrix encoding support
michaelni
parents: 1402
diff changeset
214 }
1530
3b31998fe22f disable encoders where appropriate (patch courtesy of BERO
melanson
parents: 1523
diff changeset
215 #endif //CONFIG_ENCODERS
1411
c2e63cb94d06 custom quant matrix encoding support
michaelni
parents: 1402
diff changeset
216
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
217 /* 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
218 int DCT_common_init(MpegEncContext *s)
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
219 {
1689
1a2db2073848 split intra / inter dequantization
michael
parents: 1688
diff changeset
220 s->dct_unquantize_h263_intra = dct_unquantize_h263_intra_c;
1a2db2073848 split intra / inter dequantization
michael
parents: 1688
diff changeset
221 s->dct_unquantize_h263_inter = dct_unquantize_h263_inter_c;
2044
b6f2add2511e h261 decoder by (Maarten Daniels <maarten.daniels at student dot luc dot ac dot be>)
michael
parents: 2042
diff changeset
222 s->dct_unquantize_h261_intra = dct_unquantize_h261_intra_c;
b6f2add2511e h261 decoder by (Maarten Daniels <maarten.daniels at student dot luc dot ac dot be>)
michael
parents: 2042
diff changeset
223 s->dct_unquantize_h261_inter = dct_unquantize_h261_inter_c;
1689
1a2db2073848 split intra / inter dequantization
michael
parents: 1688
diff changeset
224 s->dct_unquantize_mpeg1_intra = dct_unquantize_mpeg1_intra_c;
1a2db2073848 split intra / inter dequantization
michael
parents: 1688
diff changeset
225 s->dct_unquantize_mpeg1_inter = dct_unquantize_mpeg1_inter_c;
1a2db2073848 split intra / inter dequantization
michael
parents: 1688
diff changeset
226 s->dct_unquantize_mpeg2_intra = dct_unquantize_mpeg2_intra_c;
1a2db2073848 split intra / inter dequantization
michael
parents: 1688
diff changeset
227 s->dct_unquantize_mpeg2_inter = dct_unquantize_mpeg2_inter_c;
1092
f59c3f66363b MpegEncContext.(i)dct_* -> DspContext.(i)dct_*
michaelni
parents: 1089
diff changeset
228
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
229 #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
230 s->dct_quantize= dct_quantize_c;
1719
4e72fb256b25 denoise_dct_mmx()
michael
parents: 1718
diff changeset
231 s->denoise_dct= denoise_dct_c;
1092
f59c3f66363b MpegEncContext.(i)dct_* -> DspContext.(i)dct_*
michaelni
parents: 1089
diff changeset
232 #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
233
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
234 #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
235 MPV_common_init_mmx(s);
8
1b4461b5a7fb Sync with mplayer's stuff
nickols_k
parents: 7
diff changeset
236 #endif
514
c9f724e3a797 Update and activate dct_unquantize_h263_mvi. Thanks to M«©ns Rullg«©rd
mellum
parents: 506
diff changeset
237 #ifdef ARCH_ALPHA
c9f724e3a797 Update and activate dct_unquantize_h263_mvi. Thanks to M«©ns Rullg«©rd
mellum
parents: 506
diff changeset
238 MPV_common_init_axp(s);
c9f724e3a797 Update and activate dct_unquantize_h263_mvi. Thanks to M«©ns Rullg«©rd
mellum
parents: 506
diff changeset
239 #endif
628
f596db4aa871 sun solaris compilation bugfix, patch by (Martin Olschewski <olschewski at zpr dot uni-koeln dot de>)
michaelni
parents: 625
diff changeset
240 #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
241 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
242 #endif
721
71f669e9f633 ps2 optimizations update patch by (Leon van Stuivenberg <leonvs at iae dot nl>)
michaelni
parents: 717
diff changeset
243 #ifdef HAVE_MMI
71f669e9f633 ps2 optimizations update patch by (Leon van Stuivenberg <leonvs at iae dot nl>)
michaelni
parents: 717
diff changeset
244 MPV_common_init_mmi(s);
71f669e9f633 ps2 optimizations update patch by (Leon van Stuivenberg <leonvs at iae dot nl>)
michaelni
parents: 717
diff changeset
245 #endif
730
b24ea84b23e2 trying to fix the non-x86 IDCTs (untested)
michaelni
parents: 726
diff changeset
246 #ifdef ARCH_ARMV4L
874
8cc0d241da37 * compilation fix (ARM users please check)
kabi
parents: 862
diff changeset
247 MPV_common_init_armv4l(s);
730
b24ea84b23e2 trying to fix the non-x86 IDCTs (untested)
michaelni
parents: 726
diff changeset
248 #endif
828
ace3ccd18dd2 Altivec Patch (Mark III) by (Dieter Shirley <dieters at schemasoft dot com>)
michaelni
parents: 815
diff changeset
249 #ifdef ARCH_POWERPC
ace3ccd18dd2 Altivec Patch (Mark III) by (Dieter Shirley <dieters at schemasoft dot com>)
michaelni
parents: 815
diff changeset
250 MPV_common_init_ppc(s);
ace3ccd18dd2 Altivec Patch (Mark III) by (Dieter Shirley <dieters at schemasoft dot com>)
michaelni
parents: 815
diff changeset
251 #endif
730
b24ea84b23e2 trying to fix the non-x86 IDCTs (untested)
michaelni
parents: 726
diff changeset
252
1070
6da5ae9ee199 more #ifdef CONFIG_ENCODERS patch by (Wolfgang Hesseler <qv at multimediaware dot com>) with modifications by me (s/WOLFGANG/CONFIG_ENCODERS/ and some other fixes)
michaelni
parents: 1064
diff changeset
253 #ifdef CONFIG_ENCODERS
1007
b2cf2a1d9a51 more compare functions (rd & bit)
michaelni
parents: 1002
diff changeset
254 s->fast_dct_quantize= s->dct_quantize;
b2cf2a1d9a51 more compare functions (rd & bit)
michaelni
parents: 1002
diff changeset
255
945
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
256 if(s->flags&CODEC_FLAG_TRELLIS_QUANT){
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
257 s->dct_quantize= dct_quantize_trellis_c; //move before MPV_common_init_*
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
258 }
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
259
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
260 #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
261
706
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 704
diff changeset
262 /* load & permutate scantables
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 704
diff changeset
263 note: only wmv uses differnt ones
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 704
diff changeset
264 */
1708
dea5b2946999 interlaced motion estimation
michael
parents: 1707
diff changeset
265 if(s->alternate_scan){
dea5b2946999 interlaced motion estimation
michael
parents: 1707
diff changeset
266 ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable , ff_alternate_vertical_scan);
dea5b2946999 interlaced motion estimation
michael
parents: 1707
diff changeset
267 ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable , ff_alternate_vertical_scan);
dea5b2946999 interlaced motion estimation
michael
parents: 1707
diff changeset
268 }else{
dea5b2946999 interlaced motion estimation
michael
parents: 1707
diff changeset
269 ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable , ff_zigzag_direct);
dea5b2946999 interlaced motion estimation
michael
parents: 1707
diff changeset
270 ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable , ff_zigzag_direct);
dea5b2946999 interlaced motion estimation
michael
parents: 1707
diff changeset
271 }
1273
a979fab41ed8 ASV1 codec
michaelni
parents: 1264
diff changeset
272 ff_init_scantable(s->dsp.idct_permutation, &s->intra_h_scantable, ff_alternate_horizontal_scan);
a979fab41ed8 ASV1 codec
michaelni
parents: 1264
diff changeset
273 ff_init_scantable(s->dsp.idct_permutation, &s->intra_v_scantable, ff_alternate_vertical_scan);
591
d3f374218030 fixing mpeg4 mpeg quantizers
michaelni
parents: 588
diff changeset
274
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
275 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
276 }
a91203b34e71 moved dct init out from mpv_common_init to dct_common_init (for less-uglier way for dv)
al3x
parents: 721
diff changeset
277
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
278 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
279 *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
280 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
281 }
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
282
1938
e2501e6e7ff7 unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents: 1918
diff changeset
283 static void copy_picture_attributes(MpegEncContext *s, AVFrame *dst, AVFrame *src){
e2501e6e7ff7 unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents: 1918
diff changeset
284 int i;
e2501e6e7ff7 unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents: 1918
diff changeset
285
1702
fbab59f03144 10l (forgot to copy top_field_first flag)
michael
parents: 1697
diff changeset
286 dst->pict_type = src->pict_type;
fbab59f03144 10l (forgot to copy top_field_first flag)
michael
parents: 1697
diff changeset
287 dst->quality = src->quality;
fbab59f03144 10l (forgot to copy top_field_first flag)
michael
parents: 1697
diff changeset
288 dst->coded_picture_number = src->coded_picture_number;
fbab59f03144 10l (forgot to copy top_field_first flag)
michael
parents: 1697
diff changeset
289 dst->display_picture_number = src->display_picture_number;
fbab59f03144 10l (forgot to copy top_field_first flag)
michael
parents: 1697
diff changeset
290 // dst->reference = src->reference;
fbab59f03144 10l (forgot to copy top_field_first flag)
michael
parents: 1697
diff changeset
291 dst->pts = src->pts;
fbab59f03144 10l (forgot to copy top_field_first flag)
michael
parents: 1697
diff changeset
292 dst->interlaced_frame = src->interlaced_frame;
fbab59f03144 10l (forgot to copy top_field_first flag)
michael
parents: 1697
diff changeset
293 dst->top_field_first = src->top_field_first;
1938
e2501e6e7ff7 unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents: 1918
diff changeset
294
1945
32f68745c431 passing AVFrame instead of AVPicture around in ffmpeg, that way stuff like motion vectors can be passed from the decoder to the encoder
michael
parents: 1944
diff changeset
295 if(s->avctx->me_threshold){
32f68745c431 passing AVFrame instead of AVPicture around in ffmpeg, that way stuff like motion vectors can be passed from the decoder to the encoder
michael
parents: 1944
diff changeset
296 if(!src->motion_val[0])
32f68745c431 passing AVFrame instead of AVPicture around in ffmpeg, that way stuff like motion vectors can be passed from the decoder to the encoder
michael
parents: 1944
diff changeset
297 av_log(s->avctx, AV_LOG_ERROR, "AVFrame.motion_val not set!\n");
32f68745c431 passing AVFrame instead of AVPicture around in ffmpeg, that way stuff like motion vectors can be passed from the decoder to the encoder
michael
parents: 1944
diff changeset
298 if(!src->mb_type)
32f68745c431 passing AVFrame instead of AVPicture around in ffmpeg, that way stuff like motion vectors can be passed from the decoder to the encoder
michael
parents: 1944
diff changeset
299 av_log(s->avctx, AV_LOG_ERROR, "AVFrame.mb_type not set!\n");
32f68745c431 passing AVFrame instead of AVPicture around in ffmpeg, that way stuff like motion vectors can be passed from the decoder to the encoder
michael
parents: 1944
diff changeset
300 if(!src->ref_index[0])
32f68745c431 passing AVFrame instead of AVPicture around in ffmpeg, that way stuff like motion vectors can be passed from the decoder to the encoder
michael
parents: 1944
diff changeset
301 av_log(s->avctx, AV_LOG_ERROR, "AVFrame.ref_index not set!\n");
1938
e2501e6e7ff7 unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents: 1918
diff changeset
302 if(src->motion_subsample_log2 != dst->motion_subsample_log2)
1955
5dafb10e0252 reuse motion vectors/mb types/field select values of the source video, if the SSE for a macroblock which is predicted with these values is below me_threshold
michael
parents: 1948
diff changeset
303 av_log(s->avctx, AV_LOG_ERROR, "AVFrame.motion_subsample_log2 doesnt match! (%d!=%d)\n",
5dafb10e0252 reuse motion vectors/mb types/field select values of the source video, if the SSE for a macroblock which is predicted with these values is below me_threshold
michael
parents: 1948
diff changeset
304 src->motion_subsample_log2, dst->motion_subsample_log2);
1945
32f68745c431 passing AVFrame instead of AVPicture around in ffmpeg, that way stuff like motion vectors can be passed from the decoder to the encoder
michael
parents: 1944
diff changeset
305
32f68745c431 passing AVFrame instead of AVPicture around in ffmpeg, that way stuff like motion vectors can be passed from the decoder to the encoder
michael
parents: 1944
diff changeset
306 memcpy(dst->mb_type, src->mb_type, s->mb_stride * s->mb_height * sizeof(dst->mb_type[0]));
32f68745c431 passing AVFrame instead of AVPicture around in ffmpeg, that way stuff like motion vectors can be passed from the decoder to the encoder
michael
parents: 1944
diff changeset
307
32f68745c431 passing AVFrame instead of AVPicture around in ffmpeg, that way stuff like motion vectors can be passed from the decoder to the encoder
michael
parents: 1944
diff changeset
308 for(i=0; i<2; i++){
1938
e2501e6e7ff7 unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents: 1918
diff changeset
309 int stride= ((16*s->mb_width )>>src->motion_subsample_log2) + 1;
e2501e6e7ff7 unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents: 1918
diff changeset
310 int height= ((16*s->mb_height)>>src->motion_subsample_log2);
e2501e6e7ff7 unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents: 1918
diff changeset
311
1945
32f68745c431 passing AVFrame instead of AVPicture around in ffmpeg, that way stuff like motion vectors can be passed from the decoder to the encoder
michael
parents: 1944
diff changeset
312 if(src->motion_val[i] && src->motion_val[i] != dst->motion_val[i]){
32f68745c431 passing AVFrame instead of AVPicture around in ffmpeg, that way stuff like motion vectors can be passed from the decoder to the encoder
michael
parents: 1944
diff changeset
313 memcpy(dst->motion_val[i], src->motion_val[i], 2*stride*height*sizeof(int16_t));
32f68745c431 passing AVFrame instead of AVPicture around in ffmpeg, that way stuff like motion vectors can be passed from the decoder to the encoder
michael
parents: 1944
diff changeset
314 }
32f68745c431 passing AVFrame instead of AVPicture around in ffmpeg, that way stuff like motion vectors can be passed from the decoder to the encoder
michael
parents: 1944
diff changeset
315 if(src->ref_index[i] && src->ref_index[i] != dst->ref_index[i]){
1948
d10578f7fd40 exporting field_select/ref_index values
michael
parents: 1947
diff changeset
316 memcpy(dst->ref_index[i], src->ref_index[i], s->b8_stride*2*s->mb_height*sizeof(int8_t));
1945
32f68745c431 passing AVFrame instead of AVPicture around in ffmpeg, that way stuff like motion vectors can be passed from the decoder to the encoder
michael
parents: 1944
diff changeset
317 }
1938
e2501e6e7ff7 unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents: 1918
diff changeset
318 }
e2501e6e7ff7 unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents: 1918
diff changeset
319 }
1702
fbab59f03144 10l (forgot to copy top_field_first flag)
michael
parents: 1697
diff changeset
320 }
fbab59f03144 10l (forgot to copy top_field_first flag)
michael
parents: 1697
diff changeset
321
903
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
322 /**
924
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
323 * allocates a Picture
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
324 * The pixels are allocated/set by calling get_buffer() if shared=0
903
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
325 */
924
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
326 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
327 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
328 const int mb_array_size= s->mb_stride*s->mb_height;
1655
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
329 const int b8_array_size= s->b8_stride*s->mb_height*2;
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
330 const int b4_array_size= s->b4_stride*s->mb_height*4;
1168
5af9aeadbdc3 H264 decoder & demuxer
michaelni
parents: 1165
diff changeset
331 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
332
924
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
333 if(shared){
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
334 assert(pic->data[0]);
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
335 assert(pic->type == 0 || pic->type == FF_BUFFER_TYPE_SHARED);
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
336 pic->type= FF_BUFFER_TYPE_SHARED;
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
337 }else{
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
338 int r;
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
339
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
340 assert(!pic->data[0]);
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
341
925
7fccaa0d699d AVVideoFrame -> AVFrame
michaelni
parents: 924
diff changeset
342 r= s->avctx->get_buffer(s->avctx, (AVFrame*)pic);
924
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
343
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
344 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
345 av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed (%d %d %d %p)\n", r, pic->age, pic->type, pic->data[0]);
924
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
346 return -1;
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
347 }
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
348
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
349 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
350 av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed (stride changed)\n");
924
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
351 return -1;
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
352 }
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
353
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
354 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
355 av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed (uv stride missmatch)\n");
924
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
356 return -1;
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
357 }
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
358
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
359 s->linesize = pic->linesize[0];
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
360 s->uvlinesize= pic->linesize[1];
903
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
361 }
924
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
362
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
363 if(pic->qscale_table==NULL){
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
364 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
365 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
366 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
367 CHECKED_ALLOCZ(pic->mb_mean , mb_array_size * sizeof(int8_t))
924
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
368 }
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
369
1177
fea03d2c4946 simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents: 1173
diff changeset
370 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
371 CHECKED_ALLOCZ(pic->qscale_table , mb_array_size * sizeof(uint8_t))
1742
e39651dd13a9 type fixes, found by Wolfgang Hesseler
michael
parents: 1739
diff changeset
372 CHECKED_ALLOCZ(pic->mb_type_base , big_mb_num * sizeof(uint32_t))
1177
fea03d2c4946 simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents: 1173
diff changeset
373 pic->mb_type= pic->mb_type_base + s->mb_stride+1;
1168
5af9aeadbdc3 H264 decoder & demuxer
michaelni
parents: 1165
diff changeset
374 if(s->out_format == FMT_H264){
5af9aeadbdc3 H264 decoder & demuxer
michaelni
parents: 1165
diff changeset
375 for(i=0; i<2; i++){
1885
6588eda7d107 alignment fix
michael
parents: 1884
diff changeset
376 CHECKED_ALLOCZ(pic->motion_val_base[i], 2 * (b4_array_size+2) * sizeof(int16_t))
6588eda7d107 alignment fix
michael
parents: 1884
diff changeset
377 pic->motion_val[i]= pic->motion_val_base[i]+2;
1948
d10578f7fd40 exporting field_select/ref_index values
michael
parents: 1947
diff changeset
378 CHECKED_ALLOCZ(pic->ref_index[i], b8_array_size * sizeof(uint8_t))
1655
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
379 }
1669
072666f04bca motion_subsample_log2
michael
parents: 1668
diff changeset
380 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
381 }else if(s->out_format == FMT_H263 || s->encoding || (s->avctx->debug&FF_DEBUG_MV) || (s->avctx->debug_mv)){
1655
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
382 for(i=0; i<2; i++){
1938
e2501e6e7ff7 unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents: 1918
diff changeset
383 CHECKED_ALLOCZ(pic->motion_val_base[i], 2 * (b8_array_size+2) * sizeof(int16_t))
1885
6588eda7d107 alignment fix
michael
parents: 1884
diff changeset
384 pic->motion_val[i]= pic->motion_val_base[i]+2;
1948
d10578f7fd40 exporting field_select/ref_index values
michael
parents: 1947
diff changeset
385 CHECKED_ALLOCZ(pic->ref_index[i], b8_array_size * sizeof(uint8_t))
1168
5af9aeadbdc3 H264 decoder & demuxer
michaelni
parents: 1165
diff changeset
386 }
1669
072666f04bca motion_subsample_log2
michael
parents: 1668
diff changeset
387 pic->motion_subsample_log2= 3;
1168
5af9aeadbdc3 H264 decoder & demuxer
michaelni
parents: 1165
diff changeset
388 }
1833
ba27ce284d07 export DCT coefficients patch by (Wolfgang Hesseler <wolfgang.hesseler at imk dot fraunhofer dot de>)
michael
parents: 1831
diff changeset
389 if(s->avctx->debug&FF_DEBUG_DCT_COEFF) {
ba27ce284d07 export DCT coefficients patch by (Wolfgang Hesseler <wolfgang.hesseler at imk dot fraunhofer dot de>)
michael
parents: 1831
diff changeset
390 CHECKED_ALLOCZ(pic->dct_coeff, 64 * mb_array_size * sizeof(DCTELEM)*6)
ba27ce284d07 export DCT coefficients patch by (Wolfgang Hesseler <wolfgang.hesseler at imk dot fraunhofer dot de>)
michael
parents: 1831
diff changeset
391 }
1177
fea03d2c4946 simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents: 1173
diff changeset
392 pic->qstride= s->mb_stride;
1546
5d06823e2ee9 export mpeg2 active display area / pan scan
michael
parents: 1542
diff changeset
393 CHECKED_ALLOCZ(pic->pan_scan , 1 * sizeof(AVPanScan))
924
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
394 }
1168
5af9aeadbdc3 H264 decoder & demuxer
michaelni
parents: 1165
diff changeset
395
1021
2d7c9f5738de trying to fix mb skip bug in mpeg1/2 if slices are not used
michaelni
parents: 1014
diff changeset
396 //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
397 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
398 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
399 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
400 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
401
903
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
402 return 0;
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
403 fail: //for the CHECKED_ALLOCZ macro
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
404 return -1;
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
405 }
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
406
924
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
407 /**
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
408 * deallocates a picture
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
409 */
903
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
410 static void free_picture(MpegEncContext *s, Picture *pic){
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
411 int i;
924
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
412
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
413 if(pic->data[0] && pic->type!=FF_BUFFER_TYPE_SHARED){
925
7fccaa0d699d AVVideoFrame -> AVFrame
michaelni
parents: 924
diff changeset
414 s->avctx->release_buffer(s->avctx, (AVFrame*)pic);
924
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
415 }
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
416
903
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
417 av_freep(&pic->mb_var);
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
418 av_freep(&pic->mc_mb_var);
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
419 av_freep(&pic->mb_mean);
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
420 av_freep(&pic->mbskip_table);
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
421 av_freep(&pic->qscale_table);
1168
5af9aeadbdc3 H264 decoder & demuxer
michaelni
parents: 1165
diff changeset
422 av_freep(&pic->mb_type_base);
1833
ba27ce284d07 export DCT coefficients patch by (Wolfgang Hesseler <wolfgang.hesseler at imk dot fraunhofer dot de>)
michael
parents: 1831
diff changeset
423 av_freep(&pic->dct_coeff);
1546
5d06823e2ee9 export mpeg2 active display area / pan scan
michael
parents: 1542
diff changeset
424 av_freep(&pic->pan_scan);
1168
5af9aeadbdc3 H264 decoder & demuxer
michaelni
parents: 1165
diff changeset
425 pic->mb_type= NULL;
5af9aeadbdc3 H264 decoder & demuxer
michaelni
parents: 1165
diff changeset
426 for(i=0; i<2; i++){
1655
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
427 av_freep(&pic->motion_val_base[i]);
1168
5af9aeadbdc3 H264 decoder & demuxer
michaelni
parents: 1165
diff changeset
428 av_freep(&pic->ref_index[i]);
5af9aeadbdc3 H264 decoder & demuxer
michaelni
parents: 1165
diff changeset
429 }
1214
327c5a36dfe7 fixing mixed dr1 + internal buffers
michaelni
parents: 1189
diff changeset
430
327c5a36dfe7 fixing mixed dr1 + internal buffers
michaelni
parents: 1189
diff changeset
431 if(pic->type == FF_BUFFER_TYPE_SHARED){
924
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
432 for(i=0; i<4; i++){
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
433 pic->base[i]=
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
434 pic->data[i]= NULL;
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
435 }
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
436 pic->type= 0;
903
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
437 }
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
438 }
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
439
1799
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
440 static int init_duplicate_context(MpegEncContext *s, MpegEncContext *base){
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
441 int i;
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
442
1838
8cdbb74c2f4b 10l (vdpart fix)
michael
parents: 1834
diff changeset
443 // edge emu needs blocksize + filter length - 1 (=17x17 for halfpel / 21x21 for h264)
1799
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
444 CHECKED_ALLOCZ(s->allocated_edge_emu_buffer, (s->width+64)*2*17*2); //(width + edge + align)*interlaced*MBsize*tolerance
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
445 s->edge_emu_buffer= s->allocated_edge_emu_buffer + (s->width+64)*2*17;
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
446
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
447 //FIXME should be linesize instead of s->width*2 but that isnt known before get_buffer()
2074
2faafe7a3db6 mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents: 2066
diff changeset
448 CHECKED_ALLOCZ(s->me.scratchpad, (s->width+64)*4*16*2*sizeof(uint8_t))
1799
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
449 s->rd_scratchpad= s->me.scratchpad;
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
450 s->b_scratchpad= s->me.scratchpad;
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
451 s->obmc_scratchpad= s->me.scratchpad + 16;
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
452 if (s->encoding) {
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
453 CHECKED_ALLOCZ(s->me.map , ME_MAP_SIZE*sizeof(uint32_t))
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
454 CHECKED_ALLOCZ(s->me.score_map, ME_MAP_SIZE*sizeof(uint32_t))
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
455 if(s->avctx->noise_reduction){
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
456 CHECKED_ALLOCZ(s->dct_error_sum, 2 * 64 * sizeof(int))
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
457 }
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
458 }
1848
c72589baee53 initial chroma_format changes,xvmc tweaks and codec_cap
iive
parents: 1846
diff changeset
459 CHECKED_ALLOCZ(s->blocks, 64*12*2 * sizeof(DCTELEM))
1799
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
460 s->block= s->blocks[0];
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
461
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
462 for(i=0;i<12;i++){
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
463 s->pblocks[i] = (short *)(&s->block[i]);
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
464 }
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
465 return 0;
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
466 fail:
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
467 return -1; //free() through MPV_common_end()
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
468 }
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
469
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
470 static void free_duplicate_context(MpegEncContext *s){
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
471 if(s==NULL) return;
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
472
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
473 av_freep(&s->allocated_edge_emu_buffer); s->edge_emu_buffer= NULL;
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
474 av_freep(&s->me.scratchpad);
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
475 s->rd_scratchpad=
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
476 s->b_scratchpad=
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
477 s->obmc_scratchpad= NULL;
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
478
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
479 av_freep(&s->dct_error_sum);
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
480 av_freep(&s->me.map);
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
481 av_freep(&s->me.score_map);
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
482 av_freep(&s->blocks);
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
483 s->block= NULL;
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
484 }
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
485
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
486 static void backup_duplicate_context(MpegEncContext *bak, MpegEncContext *src){
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
487 #define COPY(a) bak->a= src->a
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
488 COPY(allocated_edge_emu_buffer);
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
489 COPY(edge_emu_buffer);
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
490 COPY(me.scratchpad);
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
491 COPY(rd_scratchpad);
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
492 COPY(b_scratchpad);
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
493 COPY(obmc_scratchpad);
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
494 COPY(me.map);
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
495 COPY(me.score_map);
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
496 COPY(blocks);
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
497 COPY(block);
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
498 COPY(start_mb_y);
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
499 COPY(end_mb_y);
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
500 COPY(me.map_generation);
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
501 COPY(pb);
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
502 COPY(dct_error_sum);
1810
fc6b38b5dd40 noise reduction with threads bugfix
michael
parents: 1805
diff changeset
503 COPY(dct_count[0]);
fc6b38b5dd40 noise reduction with threads bugfix
michael
parents: 1805
diff changeset
504 COPY(dct_count[1]);
1799
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
505 #undef COPY
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
506 }
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
507
1827
fcbf31baa1af multithreaded mpeg2 decoding
michael
parents: 1820
diff changeset
508 void ff_update_duplicate_context(MpegEncContext *dst, MpegEncContext *src){
1799
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
509 MpegEncContext bak;
1827
fcbf31baa1af multithreaded mpeg2 decoding
michael
parents: 1820
diff changeset
510 int i;
1799
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
511 //FIXME copy only needed parts
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
512 //START_TIMER
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
513 backup_duplicate_context(&bak, dst);
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
514 memcpy(dst, src, sizeof(MpegEncContext));
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
515 backup_duplicate_context(dst, &bak);
1827
fcbf31baa1af multithreaded mpeg2 decoding
michael
parents: 1820
diff changeset
516 for(i=0;i<12;i++){
fcbf31baa1af multithreaded mpeg2 decoding
michael
parents: 1820
diff changeset
517 dst->pblocks[i] = (short *)(&dst->block[i]);
fcbf31baa1af multithreaded mpeg2 decoding
michael
parents: 1820
diff changeset
518 }
1799
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
519 //STOP_TIMER("update_duplicate_context") //about 10k cycles / 0.01 sec for 1000frames on 1ghz with 2 threads
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
520 }
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
521
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
522 static void update_duplicate_context_after_me(MpegEncContext *dst, MpegEncContext *src){
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
523 #define COPY(a) dst->a= src->a
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
524 COPY(pict_type);
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
525 COPY(current_picture);
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
526 COPY(f_code);
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
527 COPY(b_code);
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
528 COPY(qscale);
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
529 COPY(lambda);
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
530 COPY(lambda2);
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
531 COPY(picture_in_gop_number);
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
532 COPY(gop_picture_number);
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
533 COPY(frame_pred_frame_dct); //FIXME dont set in encode_header
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
534 COPY(progressive_frame); //FIXME dont set in encode_header
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
535 COPY(partitioned_frame); //FIXME dont set in encode_header
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
536 #undef COPY
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
537 }
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
538
1892
5ac49e7a1b8f init cleanup
michael
parents: 1885
diff changeset
539 /**
5ac49e7a1b8f init cleanup
michael
parents: 1885
diff changeset
540 * sets the given MpegEncContext to common defaults (same for encoding and decoding).
5ac49e7a1b8f init cleanup
michael
parents: 1885
diff changeset
541 * the changed fields will not depend upon the prior state of the MpegEncContext.
5ac49e7a1b8f init cleanup
michael
parents: 1885
diff changeset
542 */
5ac49e7a1b8f init cleanup
michael
parents: 1885
diff changeset
543 static void MPV_common_defaults(MpegEncContext *s){
5ac49e7a1b8f init cleanup
michael
parents: 1885
diff changeset
544 s->y_dc_scale_table=
5ac49e7a1b8f init cleanup
michael
parents: 1885
diff changeset
545 s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
5ac49e7a1b8f init cleanup
michael
parents: 1885
diff changeset
546 s->chroma_qscale_table= ff_default_chroma_qscale_table;
5ac49e7a1b8f init cleanup
michael
parents: 1885
diff changeset
547 s->progressive_frame= 1;
5ac49e7a1b8f init cleanup
michael
parents: 1885
diff changeset
548 s->progressive_sequence= 1;
5ac49e7a1b8f init cleanup
michael
parents: 1885
diff changeset
549 s->picture_structure= PICT_FRAME;
5ac49e7a1b8f init cleanup
michael
parents: 1885
diff changeset
550
5ac49e7a1b8f init cleanup
michael
parents: 1885
diff changeset
551 s->coded_picture_number = 0;
5ac49e7a1b8f init cleanup
michael
parents: 1885
diff changeset
552 s->picture_number = 0;
5ac49e7a1b8f init cleanup
michael
parents: 1885
diff changeset
553 s->input_picture_number = 0;
5ac49e7a1b8f init cleanup
michael
parents: 1885
diff changeset
554
5ac49e7a1b8f init cleanup
michael
parents: 1885
diff changeset
555 s->picture_in_gop_number = 0;
1894
3135de68d556 moving f/b_code init to where it should be
michael
parents: 1892
diff changeset
556
3135de68d556 moving f/b_code init to where it should be
michael
parents: 1892
diff changeset
557 s->f_code = 1;
3135de68d556 moving f/b_code init to where it should be
michael
parents: 1892
diff changeset
558 s->b_code = 1;
1892
5ac49e7a1b8f init cleanup
michael
parents: 1885
diff changeset
559 }
5ac49e7a1b8f init cleanup
michael
parents: 1885
diff changeset
560
5ac49e7a1b8f init cleanup
michael
parents: 1885
diff changeset
561 /**
5ac49e7a1b8f init cleanup
michael
parents: 1885
diff changeset
562 * sets the given MpegEncContext to defaults for decoding.
5ac49e7a1b8f init cleanup
michael
parents: 1885
diff changeset
563 * the changed fields will not depend upon the prior state of the MpegEncContext.
5ac49e7a1b8f init cleanup
michael
parents: 1885
diff changeset
564 */
5ac49e7a1b8f init cleanup
michael
parents: 1885
diff changeset
565 void MPV_decode_defaults(MpegEncContext *s){
5ac49e7a1b8f init cleanup
michael
parents: 1885
diff changeset
566 MPV_common_defaults(s);
5ac49e7a1b8f init cleanup
michael
parents: 1885
diff changeset
567 }
5ac49e7a1b8f init cleanup
michael
parents: 1885
diff changeset
568
5ac49e7a1b8f init cleanup
michael
parents: 1885
diff changeset
569 /**
5ac49e7a1b8f init cleanup
michael
parents: 1885
diff changeset
570 * sets the given MpegEncContext to defaults for encoding.
5ac49e7a1b8f init cleanup
michael
parents: 1885
diff changeset
571 * the changed fields will not depend upon the prior state of the MpegEncContext.
5ac49e7a1b8f init cleanup
michael
parents: 1885
diff changeset
572 */
1902
a5588762c4fa Compile fix by (Chip <szarlada at freemail dot hu>)
michael
parents: 1894
diff changeset
573
a5588762c4fa Compile fix by (Chip <szarlada at freemail dot hu>)
michael
parents: 1894
diff changeset
574 #ifdef CONFIG_ENCODERS
2024
f65d87bfdd5a some of the warning fixes by (Michael Roitzsch <mroi at users dot sourceforge dot net>)
michael
parents: 2015
diff changeset
575 static void MPV_encode_defaults(MpegEncContext *s){
1892
5ac49e7a1b8f init cleanup
michael
parents: 1885
diff changeset
576 static int done=0;
5ac49e7a1b8f init cleanup
michael
parents: 1885
diff changeset
577
5ac49e7a1b8f init cleanup
michael
parents: 1885
diff changeset
578 MPV_common_defaults(s);
5ac49e7a1b8f init cleanup
michael
parents: 1885
diff changeset
579
5ac49e7a1b8f init cleanup
michael
parents: 1885
diff changeset
580 if(!done){
5ac49e7a1b8f init cleanup
michael
parents: 1885
diff changeset
581 int i;
5ac49e7a1b8f init cleanup
michael
parents: 1885
diff changeset
582 done=1;
5ac49e7a1b8f init cleanup
michael
parents: 1885
diff changeset
583
5ac49e7a1b8f init cleanup
michael
parents: 1885
diff changeset
584 default_mv_penalty= av_mallocz( sizeof(uint8_t)*(MAX_FCODE+1)*(2*MAX_MV+1) );
5ac49e7a1b8f init cleanup
michael
parents: 1885
diff changeset
585 memset(default_mv_penalty, 0, sizeof(uint8_t)*(MAX_FCODE+1)*(2*MAX_MV+1));
5ac49e7a1b8f init cleanup
michael
parents: 1885
diff changeset
586 memset(default_fcode_tab , 0, sizeof(uint8_t)*(2*MAX_MV+1));
5ac49e7a1b8f init cleanup
michael
parents: 1885
diff changeset
587
5ac49e7a1b8f init cleanup
michael
parents: 1885
diff changeset
588 for(i=-16; i<16; i++){
5ac49e7a1b8f init cleanup
michael
parents: 1885
diff changeset
589 default_fcode_tab[i + MAX_MV]= 1;
5ac49e7a1b8f init cleanup
michael
parents: 1885
diff changeset
590 }
5ac49e7a1b8f init cleanup
michael
parents: 1885
diff changeset
591 }
5ac49e7a1b8f init cleanup
michael
parents: 1885
diff changeset
592 s->me.mv_penalty= default_mv_penalty;
5ac49e7a1b8f init cleanup
michael
parents: 1885
diff changeset
593 s->fcode_tab= default_fcode_tab;
5ac49e7a1b8f init cleanup
michael
parents: 1885
diff changeset
594 }
1902
a5588762c4fa Compile fix by (Chip <szarlada at freemail dot hu>)
michael
parents: 1894
diff changeset
595 #endif //CONFIG_ENCODERS
1892
5ac49e7a1b8f init cleanup
michael
parents: 1885
diff changeset
596
5ac49e7a1b8f init cleanup
michael
parents: 1885
diff changeset
597 /**
5ac49e7a1b8f init cleanup
michael
parents: 1885
diff changeset
598 * init common structure for both encoder and decoder.
5ac49e7a1b8f init cleanup
michael
parents: 1885
diff changeset
599 * this assumes that some variables like width/height are already set
5ac49e7a1b8f init cleanup
michael
parents: 1885
diff changeset
600 */
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
601 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
602 {
1708
dea5b2946999 interlaced motion estimation
michael
parents: 1707
diff changeset
603 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
604
1991
michael
parents: 1989
diff changeset
605 if(s->avctx->thread_count > MAX_THREADS || (16*s->avctx->thread_count > s->height && s->height)){
1989
michael
parents: 1988
diff changeset
606 av_log(s->avctx, AV_LOG_ERROR, "too many threads\n");
michael
parents: 1988
diff changeset
607 return -1;
michael
parents: 1988
diff changeset
608 }
michael
parents: 1988
diff changeset
609
1092
f59c3f66363b MpegEncContext.(i)dct_* -> DspContext.(i)dct_*
michaelni
parents: 1089
diff changeset
610 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
611 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
612
754
b2767c9d6455 init flags before using it (found by arpi)
michaelni
parents: 753
diff changeset
613 s->flags= s->avctx->flags;
1754
bdf3927bf8c5 closed gop support & flags2 as all bits in flags are used
michael
parents: 1751
diff changeset
614 s->flags2= s->avctx->flags2;
726
a91203b34e71 moved dct init out from mpv_common_init to dct_common_init (for less-uglier way for dv)
al3x
parents: 721
diff changeset
615
903
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
616 s->mb_width = (s->width + 15) / 16;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
617 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
618 s->mb_stride = s->mb_width + 1;
1655
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
619 s->b8_stride = s->mb_width*2 + 1;
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
620 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
621 mb_array_size= s->mb_height * s->mb_stride;
1708
dea5b2946999 interlaced motion estimation
michael
parents: 1707
diff changeset
622 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
623
2074
2faafe7a3db6 mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents: 2066
diff changeset
624 /* set chroma shifts */
2faafe7a3db6 mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents: 2066
diff changeset
625 avcodec_get_chroma_sub_sample(s->avctx->pix_fmt,&(s->chroma_x_shift),
2faafe7a3db6 mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents: 2066
diff changeset
626 &(s->chroma_y_shift) );
2faafe7a3db6 mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents: 2066
diff changeset
627
853
eacc2dd8fd9d * using DSPContext - so each codec could use its local (sub)set of CPU extension
kabi
parents: 847
diff changeset
628 /* 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
629 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
630 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
631
eacc2dd8fd9d * using DSPContext - so each codec could use its local (sub)set of CPU extension
kabi
parents: 847
diff changeset
632 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
633
fea03d2c4946 simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents: 1173
diff changeset
634 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
635 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
636 s->block_wrap[2]=
1938
e2501e6e7ff7 unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents: 1918
diff changeset
637 s->block_wrap[3]= s->b8_stride;
1177
fea03d2c4946 simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents: 1173
diff changeset
638 s->block_wrap[4]=
1938
e2501e6e7ff7 unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents: 1918
diff changeset
639 s->block_wrap[5]= s->mb_stride;
1892
5ac49e7a1b8f init cleanup
michael
parents: 1885
diff changeset
640
1938
e2501e6e7ff7 unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents: 1918
diff changeset
641 y_size = s->b8_stride * (2 * s->mb_height + 1);
e2501e6e7ff7 unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents: 1918
diff changeset
642 c_size = s->mb_stride * (s->mb_height + 1);
756
f2644bb12a43 fixing h263 decoding (did segfault)
michaelni
parents: 755
diff changeset
643 yc_size = y_size + 2 * c_size;
1892
5ac49e7a1b8f init cleanup
michael
parents: 1885
diff changeset
644
701
85b071dfc7e3 ff_get_fourcc() & XVIX support
michaelni
parents: 697
diff changeset
645 /* convert fourcc to upper case */
1116
86a5d0ce86bf merging fourcc with codec_tag
michaelni
parents: 1106
diff changeset
646 s->avctx->codec_tag= toupper( s->avctx->codec_tag &0xFF)
86a5d0ce86bf merging fourcc with codec_tag
michaelni
parents: 1106
diff changeset
647 + (toupper((s->avctx->codec_tag>>8 )&0xFF)<<8 )
86a5d0ce86bf merging fourcc with codec_tag
michaelni
parents: 1106
diff changeset
648 + (toupper((s->avctx->codec_tag>>16)&0xFF)<<16)
86a5d0ce86bf merging fourcc with codec_tag
michaelni
parents: 1106
diff changeset
649 + (toupper((s->avctx->codec_tag>>24)&0xFF)<<24);
582
5132a4ee50cd different edge positions fixed with edge emu / dr1
michaelni
parents: 575
diff changeset
650
1458
40b69d238beb AVI stream header FCC / more reliable detection of old xvid files
michaelni
parents: 1451
diff changeset
651 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
652 + (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
653 + (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
654 + (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
655
925
7fccaa0d699d AVVideoFrame -> AVFrame
michaelni
parents: 924
diff changeset
656 s->avctx->coded_frame= (AVFrame*)&s->current_picture;
903
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
657
1177
fea03d2c4946 simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents: 1173
diff changeset
658 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
659 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
660 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
661 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
662 }
fea03d2c4946 simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents: 1173
diff changeset
663 }
fea03d2c4946 simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents: 1173
diff changeset
664 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
665
232
b640ec5948b0 - Now the ME is done for the entire picture when enconding, the
pulento
parents: 231
diff changeset
666 if (s->encoding) {
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
667 /* 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
668 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
669 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
670 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
671 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
672 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
673 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
674 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
675 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
676 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
677 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
678 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
679 s->b_direct_mv_table = s->b_direct_mv_table_base + s->mb_stride + 1;
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
680
650
ef4a33aad86e reducing sizeof MpegEncContext to avoid stack overflow on crap M$ windo$
michaelni
parents: 635
diff changeset
681 if(s->msmpeg4_version){
ef4a33aad86e reducing sizeof MpegEncContext to avoid stack overflow on crap M$ windo$
michaelni
parents: 635
diff changeset
682 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
683 }
612
c0005de2be59 new ratecontrol code
michaelni
parents: 611
diff changeset
684 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
685
fea03d2c4946 simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents: 1173
diff changeset
686 /* Allocate MB type table */
1708
dea5b2946999 interlaced motion estimation
michael
parents: 1707
diff changeset
687 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
688
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
689 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
690
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
691 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
692 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
693 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
694 CHECKED_ALLOCZ(s->q_inter_matrix16, 64*32*2 * sizeof(uint16_t))
1556
5ebb4ae753d3 112 bytes smaller MpegEncContext
michael
parents: 1555
diff changeset
695 CHECKED_ALLOCZ(s->input_picture, MAX_PICTURE_COUNT * sizeof(Picture*))
5ebb4ae753d3 112 bytes smaller MpegEncContext
michael
parents: 1555
diff changeset
696 CHECKED_ALLOCZ(s->reordered_input_picture, MAX_PICTURE_COUNT * sizeof(Picture*))
1597
4c9165372ab3 noise reduction of dct coefficients
michael
parents: 1586
diff changeset
697
4c9165372ab3 noise reduction of dct coefficients
michael
parents: 1586
diff changeset
698 if(s->avctx->noise_reduction){
4c9165372ab3 noise reduction of dct coefficients
michael
parents: 1586
diff changeset
699 CHECKED_ALLOCZ(s->dct_offset, 2 * 64 * sizeof(uint16_t))
4c9165372ab3 noise reduction of dct coefficients
michael
parents: 1586
diff changeset
700 }
232
b640ec5948b0 - Now the ME is done for the entire picture when enconding, the
pulento
parents: 231
diff changeset
701 }
1552
26c6ecba99a1 dynamic alloc of picture structs instead of putting them in MpegEncContext
michael
parents: 1546
diff changeset
702 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
703
1177
fea03d2c4946 simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents: 1173
diff changeset
704 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
705
1708
dea5b2946999 interlaced motion estimation
michael
parents: 1707
diff changeset
706 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
707 /* interlaced direct mode decoding tables */
1708
dea5b2946999 interlaced motion estimation
michael
parents: 1707
diff changeset
708 for(i=0; i<2; i++){
dea5b2946999 interlaced motion estimation
michael
parents: 1707
diff changeset
709 int j, k;
dea5b2946999 interlaced motion estimation
michael
parents: 1707
diff changeset
710 for(j=0; j<2; j++){
dea5b2946999 interlaced motion estimation
michael
parents: 1707
diff changeset
711 for(k=0; k<2; k++){
dea5b2946999 interlaced motion estimation
michael
parents: 1707
diff changeset
712 CHECKED_ALLOCZ(s->b_field_mv_table_base[i][j][k] , mv_table_size * 2 * sizeof(int16_t))
dea5b2946999 interlaced motion estimation
michael
parents: 1707
diff changeset
713 s->b_field_mv_table[i][j][k] = s->b_field_mv_table_base[i][j][k] + s->mb_stride + 1;
dea5b2946999 interlaced motion estimation
michael
parents: 1707
diff changeset
714 }
dea5b2946999 interlaced motion estimation
michael
parents: 1707
diff changeset
715 CHECKED_ALLOCZ(s->b_field_select_table[i][j] , mb_array_size * 2 * sizeof(uint8_t))
dea5b2946999 interlaced motion estimation
michael
parents: 1707
diff changeset
716 CHECKED_ALLOCZ(s->p_field_mv_table_base[i][j] , mv_table_size * 2 * sizeof(int16_t))
dea5b2946999 interlaced motion estimation
michael
parents: 1707
diff changeset
717 s->p_field_mv_table[i][j] = s->p_field_mv_table_base[i][j] + s->mb_stride + 1;
dea5b2946999 interlaced motion estimation
michael
parents: 1707
diff changeset
718 }
dea5b2946999 interlaced motion estimation
michael
parents: 1707
diff changeset
719 CHECKED_ALLOCZ(s->p_field_select_table[i] , mb_array_size * 2 * sizeof(uint8_t))
dea5b2946999 interlaced motion estimation
michael
parents: 1707
diff changeset
720 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
721 }
767
c75c3f1bef4b regression test for H263+
michaelni
parents: 766
diff changeset
722 if (s->out_format == FMT_H263) {
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
723 /* ac values */
1938
e2501e6e7ff7 unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents: 1918
diff changeset
724 CHECKED_ALLOCZ(s->ac_val_base, yc_size * sizeof(int16_t) * 16);
e2501e6e7ff7 unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents: 1918
diff changeset
725 s->ac_val[0] = s->ac_val_base + s->b8_stride + 1;
e2501e6e7ff7 unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents: 1918
diff changeset
726 s->ac_val[1] = s->ac_val_base + y_size + s->mb_stride + 1;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
727 s->ac_val[2] = s->ac_val[1] + c_size;
986e461dc072 Initial revision
glantau
parents:
diff changeset
728
986e461dc072 Initial revision
glantau
parents:
diff changeset
729 /* cbp values */
1938
e2501e6e7ff7 unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents: 1918
diff changeset
730 CHECKED_ALLOCZ(s->coded_block_base, y_size);
e2501e6e7ff7 unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents: 1918
diff changeset
731 s->coded_block= s->coded_block_base + s->b8_stride + 1;
333
8aa87f1dfc52 divx 5.01 support
michaelni
parents: 329
diff changeset
732
8aa87f1dfc52 divx 5.01 support
michaelni
parents: 329
diff changeset
733 /* divx501 bitstream reorder buffer */
456
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
734 CHECKED_ALLOCZ(s->bitstream_buffer, BITSTREAM_BUFFER_SIZE);
843
8c81f1ee9271 cleanup
michaelni
parents: 842
diff changeset
735
456
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
736 /* 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
737 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
738 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
739 }
756
f2644bb12a43 fixing h263 decoding (did segfault)
michaelni
parents: 755
diff changeset
740
f2644bb12a43 fixing h263 decoding (did segfault)
michaelni
parents: 755
diff changeset
741 if (s->h263_pred || s->h263_plus || !s->encoding) {
f2644bb12a43 fixing h263 decoding (did segfault)
michaelni
parents: 755
diff changeset
742 /* dc values */
f2644bb12a43 fixing h263 decoding (did segfault)
michaelni
parents: 755
diff changeset
743 //MN: we need these for error resilience of intra-frames
1938
e2501e6e7ff7 unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents: 1918
diff changeset
744 CHECKED_ALLOCZ(s->dc_val_base, yc_size * sizeof(int16_t));
e2501e6e7ff7 unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents: 1918
diff changeset
745 s->dc_val[0] = s->dc_val_base + s->b8_stride + 1;
e2501e6e7ff7 unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents: 1918
diff changeset
746 s->dc_val[1] = s->dc_val_base + y_size + s->mb_stride + 1;
756
f2644bb12a43 fixing h263 decoding (did segfault)
michaelni
parents: 755
diff changeset
747 s->dc_val[2] = s->dc_val[1] + c_size;
f2644bb12a43 fixing h263 decoding (did segfault)
michaelni
parents: 755
diff changeset
748 for(i=0;i<yc_size;i++)
1938
e2501e6e7ff7 unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents: 1918
diff changeset
749 s->dc_val_base[i] = 1024;
756
f2644bb12a43 fixing h263 decoding (did segfault)
michaelni
parents: 755
diff changeset
750 }
f2644bb12a43 fixing h263 decoding (did segfault)
michaelni
parents: 755
diff changeset
751
611
3214d3f4519e error concealment needs the mbintra_table so it should allways be allocated
michaelni
parents: 608
diff changeset
752 /* 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
753 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
754 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
755
7
1d3ac9654178 added skip macroblock optimization (big perf win on black regions for example)
glantau
parents: 0
diff changeset
756 /* 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
757 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
758 //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
759 CHECKED_ALLOCZ(s->prev_pict_types, PREV_PICT_TYPES_BUFFER_SIZE);
294
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 292
diff changeset
760
842
e460775adb38 cleanup (breaks compatibility, requested by fabrice)
michaelni
parents: 828
diff changeset
761 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
762 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
763 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
764 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
765 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
766 }
842
e460775adb38 cleanup (breaks compatibility, requested by fabrice)
michaelni
parents: 828
diff changeset
767
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
768 s->context_initialized = 1;
1799
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
769
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
770 s->thread_context[0]= s;
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
771 for(i=1; i<s->avctx->thread_count; i++){
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
772 s->thread_context[i]= av_malloc(sizeof(MpegEncContext));
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
773 memcpy(s->thread_context[i], s, sizeof(MpegEncContext));
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
774 }
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
775
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
776 for(i=0; i<s->avctx->thread_count; i++){
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
777 if(init_duplicate_context(s->thread_context[i], s) < 0)
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
778 goto fail;
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
779 s->thread_context[i]->start_mb_y= (s->mb_height*(i ) + s->avctx->thread_count/2) / s->avctx->thread_count;
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
780 s->thread_context[i]->end_mb_y = (s->mb_height*(i+1) + s->avctx->thread_count/2) / s->avctx->thread_count;
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
781 }
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
782
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
783 return 0;
986e461dc072 Initial revision
glantau
parents:
diff changeset
784 fail:
244
3860331a1ecb * eliminating duplicated code from MPV_common_end
kabi
parents: 239
diff changeset
785 MPV_common_end(s);
3860331a1ecb * eliminating duplicated code from MPV_common_end
kabi
parents: 239
diff changeset
786 return -1;
3860331a1ecb * eliminating duplicated code from MPV_common_end
kabi
parents: 239
diff changeset
787 }
3860331a1ecb * eliminating duplicated code from MPV_common_end
kabi
parents: 239
diff changeset
788
3860331a1ecb * eliminating duplicated code from MPV_common_end
kabi
parents: 239
diff changeset
789 /* init common structure for both encoder and decoder */
3860331a1ecb * eliminating duplicated code from MPV_common_end
kabi
parents: 239
diff changeset
790 void MPV_common_end(MpegEncContext *s)
3860331a1ecb * eliminating duplicated code from MPV_common_end
kabi
parents: 239
diff changeset
791 {
1708
dea5b2946999 interlaced motion estimation
michael
parents: 1707
diff changeset
792 int i, j, k;
244
3860331a1ecb * eliminating duplicated code from MPV_common_end
kabi
parents: 239
diff changeset
793
1799
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
794 for(i=0; i<s->avctx->thread_count; i++){
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
795 free_duplicate_context(s->thread_context[i]);
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
796 }
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
797 for(i=1; i<s->avctx->thread_count; i++){
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
798 av_freep(&s->thread_context[i]);
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
799 }
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
800
1344
447b88b784ee memleak fix by (Jake Page <jake at CS dot Stanford dot EDU>)
michaelni
parents: 1339
diff changeset
801 av_freep(&s->parse_context.buffer);
447b88b784ee memleak fix by (Jake Page <jake at CS dot Stanford dot EDU>)
michaelni
parents: 1339
diff changeset
802 s->parse_context.buffer_size=0;
447b88b784ee memleak fix by (Jake Page <jake at CS dot Stanford dot EDU>)
michaelni
parents: 1339
diff changeset
803
396
fce0a2520551 removed useless header includes - use av memory functions
glantau
parents: 376
diff changeset
804 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
805 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
806 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
807 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
808 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
809 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
810 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
811 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
812 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
813 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
814 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
815 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
816 s->b_direct_mv_table= NULL;
1708
dea5b2946999 interlaced motion estimation
michael
parents: 1707
diff changeset
817 for(i=0; i<2; i++){
dea5b2946999 interlaced motion estimation
michael
parents: 1707
diff changeset
818 for(j=0; j<2; j++){
dea5b2946999 interlaced motion estimation
michael
parents: 1707
diff changeset
819 for(k=0; k<2; k++){
dea5b2946999 interlaced motion estimation
michael
parents: 1707
diff changeset
820 av_freep(&s->b_field_mv_table_base[i][j][k]);
dea5b2946999 interlaced motion estimation
michael
parents: 1707
diff changeset
821 s->b_field_mv_table[i][j][k]=NULL;
dea5b2946999 interlaced motion estimation
michael
parents: 1707
diff changeset
822 }
dea5b2946999 interlaced motion estimation
michael
parents: 1707
diff changeset
823 av_freep(&s->b_field_select_table[i][j]);
dea5b2946999 interlaced motion estimation
michael
parents: 1707
diff changeset
824 av_freep(&s->p_field_mv_table_base[i][j]);
dea5b2946999 interlaced motion estimation
michael
parents: 1707
diff changeset
825 s->p_field_mv_table[i][j]=NULL;
dea5b2946999 interlaced motion estimation
michael
parents: 1707
diff changeset
826 }
dea5b2946999 interlaced motion estimation
michael
parents: 1707
diff changeset
827 av_freep(&s->p_field_select_table[i]);
dea5b2946999 interlaced motion estimation
michael
parents: 1707
diff changeset
828 }
1177
fea03d2c4946 simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents: 1173
diff changeset
829
1938
e2501e6e7ff7 unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents: 1918
diff changeset
830 av_freep(&s->dc_val_base);
e2501e6e7ff7 unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents: 1918
diff changeset
831 av_freep(&s->ac_val_base);
e2501e6e7ff7 unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents: 1918
diff changeset
832 av_freep(&s->coded_block_base);
396
fce0a2520551 removed useless header includes - use av memory functions
glantau
parents: 376
diff changeset
833 av_freep(&s->mbintra_table);
456
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
834 av_freep(&s->cbp_table);
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
835 av_freep(&s->pred_dir_table);
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
836
396
fce0a2520551 removed useless header includes - use av memory functions
glantau
parents: 376
diff changeset
837 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
838 av_freep(&s->prev_pict_types);
396
fce0a2520551 removed useless header includes - use av memory functions
glantau
parents: 376
diff changeset
839 av_freep(&s->bitstream_buffer);
612
c0005de2be59 new ratecontrol code
michaelni
parents: 611
diff changeset
840 av_freep(&s->avctx->stats_out);
650
ef4a33aad86e reducing sizeof MpegEncContext to avoid stack overflow on crap M$ windo$
michaelni
parents: 635
diff changeset
841 av_freep(&s->ac_stats);
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 731
diff changeset
842 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
843 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
844 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
845 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
846 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
847 av_freep(&s->q_intra_matrix16);
d736e24bf303 move mmx quantizer matrixes out of MpegEncContext (23k -> 7k) (no meassureable slowdown)
michael
parents: 1553
diff changeset
848 av_freep(&s->q_inter_matrix16);
1556
5ebb4ae753d3 112 bytes smaller MpegEncContext
michael
parents: 1555
diff changeset
849 av_freep(&s->input_picture);
5ebb4ae753d3 112 bytes smaller MpegEncContext
michael
parents: 1555
diff changeset
850 av_freep(&s->reordered_input_picture);
1597
4c9165372ab3 noise reduction of dct coefficients
michael
parents: 1586
diff changeset
851 av_freep(&s->dct_offset);
903
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
852
1573
a4aa536938b8 segfault fix
michael
parents: 1562
diff changeset
853 if(s->picture){
a4aa536938b8 segfault fix
michael
parents: 1562
diff changeset
854 for(i=0; i<MAX_PICTURE_COUNT; i++){
a4aa536938b8 segfault fix
michael
parents: 1562
diff changeset
855 free_picture(s, &s->picture[i]);
a4aa536938b8 segfault fix
michael
parents: 1562
diff changeset
856 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
857 }
1552
26c6ecba99a1 dynamic alloc of picture structs instead of putting them in MpegEncContext
michael
parents: 1546
diff changeset
858 av_freep(&s->picture);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
859 s->context_initialized = 0;
1523
925bcd748f4b fix decoding if the aspect ratio changes
michael
parents: 1522
diff changeset
860 s->last_picture_ptr=
925bcd748f4b fix decoding if the aspect ratio changes
michael
parents: 1522
diff changeset
861 s->next_picture_ptr=
925bcd748f4b fix decoding if the aspect ratio changes
michael
parents: 1522
diff changeset
862 s->current_picture_ptr= NULL;
1918
ea20f38b8d57 nicer looking arrows for the motion vector vissualization
michael
parents: 1916
diff changeset
863
1706
3ba5c493db6f motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents: 1705
diff changeset
864 for(i=0; i<3; i++)
1918
ea20f38b8d57 nicer looking arrows for the motion vector vissualization
michael
parents: 1916
diff changeset
865 av_freep(&s->visualization_buffer[i]);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
866 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
867
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
868 #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
869
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
870 /* init video encoder */
986e461dc072 Initial revision
glantau
parents:
diff changeset
871 int MPV_encode_init(AVCodecContext *avctx)
986e461dc072 Initial revision
glantau
parents:
diff changeset
872 {
986e461dc072 Initial revision
glantau
parents:
diff changeset
873 MpegEncContext *s = avctx->priv_data;
1424
39ebefd82728 fixing CODEC_FLAG_GLOBAL_HEADER
michaelni
parents: 1422
diff changeset
874 int i, dummy;
1315
6696d3bf4ff2 lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents: 1288
diff changeset
875 int chroma_h_shift, chroma_v_shift;
1892
5ac49e7a1b8f init cleanup
michael
parents: 1885
diff changeset
876
5ac49e7a1b8f init cleanup
michael
parents: 1885
diff changeset
877 MPV_encode_defaults(s);
315
40d8092e2ff0 * using pixtype as enum - by Philip Gladstone
kabi
parents: 312
diff changeset
878
1402
f662e9c86cf2 * fixing a regression in mpeg encoder (not setting pix_fmt),
romansh
parents: 1397
diff changeset
879 avctx->pix_fmt = PIX_FMT_YUV420P; // FIXME
f662e9c86cf2 * fixing a regression in mpeg encoder (not setting pix_fmt),
romansh
parents: 1397
diff changeset
880
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
881 s->bit_rate = avctx->bit_rate;
986e461dc072 Initial revision
glantau
parents:
diff changeset
882 s->width = avctx->width;
986e461dc072 Initial revision
glantau
parents:
diff changeset
883 s->height = avctx->height;
456
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
884 if(avctx->gop_size > 600){
1598
932d306bf1dc av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents: 1597
diff changeset
885 av_log(avctx, AV_LOG_ERROR, "Warning keyframe interval too large! reducing it ...\n");
456
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
886 avctx->gop_size=600;
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
887 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
888 s->gop_size = avctx->gop_size;
194
27d1773552c9 mpeg4 encoder fix by Michael Niedermayer <michaelni@gmx.at>
arpi_esp
parents: 191
diff changeset
889 s->avctx = avctx;
294
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 292
diff changeset
890 s->flags= avctx->flags;
1754
bdf3927bf8c5 closed gop support & flags2 as all bits in flags are used
michael
parents: 1751
diff changeset
891 s->flags2= avctx->flags2;
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
892 s->max_b_frames= avctx->max_b_frames;
344
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
893 s->codec_id= avctx->codec->id;
456
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
894 s->luma_elim_threshold = avctx->luma_elim_threshold;
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
895 s->chroma_elim_threshold= avctx->chroma_elim_threshold;
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
896 s->strict_std_compliance= avctx->strict_std_compliance;
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
897 s->data_partitioning= avctx->flags & CODEC_FLAG_PART;
936
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
898 s->quarter_sample= (avctx->flags & CODEC_FLAG_QPEL)!=0;
599
b1a191202f96 mpeg4 mpeg quantizer encoding
michaelni
parents: 598
diff changeset
899 s->mpeg_quant= avctx->mpeg_quant;
1661
4c9fd29f1606 h263 slice structured mode
michael
parents: 1659
diff changeset
900 s->rtp_mode= !!avctx->rtp_payload_size;
1992
938e47c809b0 intra_dc_precission>0 encoding support
michael
parents: 1991
diff changeset
901 s->intra_dc_precision= avctx->intra_dc_precision;
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
902
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
903 if (s->gop_size <= 1) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
904 s->intra_only = 1;
986e461dc072 Initial revision
glantau
parents:
diff changeset
905 s->gop_size = 12;
986e461dc072 Initial revision
glantau
parents:
diff changeset
906 } else {
986e461dc072 Initial revision
glantau
parents:
diff changeset
907 s->intra_only = 0;
986e461dc072 Initial revision
glantau
parents:
diff changeset
908 }
693
b6a7ff92df57 darkness masking (lumi masking does only bright stuff now)
michaelni
parents: 690
diff changeset
909
936
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
910 s->me_method = avctx->me_method;
693
b6a7ff92df57 darkness masking (lumi masking does only bright stuff now)
michaelni
parents: 690
diff changeset
911
320
cda7d0857baf - ME setting moved to AVCodecContext/MpegEncContext, no longer a global.
pulento
parents: 315
diff changeset
912 /* Fixed QSCALE */
1708
dea5b2946999 interlaced motion estimation
michael
parents: 1707
diff changeset
913 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
914
690
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 673
diff changeset
915 s->adaptive_quant= ( s->avctx->lumi_masking
693
b6a7ff92df57 darkness masking (lumi masking does only bright stuff now)
michaelni
parents: 690
diff changeset
916 || s->avctx->dark_masking
690
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 673
diff changeset
917 || s->avctx->temporal_cplx_masking
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 673
diff changeset
918 || s->avctx->spatial_cplx_masking
1616
13a20c0594f2 rate distored optimal lambda->qp support
michael
parents: 1601
diff changeset
919 || s->avctx->p_masking
13a20c0594f2 rate distored optimal lambda->qp support
michael
parents: 1601
diff changeset
920 || (s->flags&CODEC_FLAG_QP_RD))
690
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 673
diff changeset
921 && !s->fixed_qscale;
697
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
922
1708
dea5b2946999 interlaced motion estimation
michael
parents: 1707
diff changeset
923 s->obmc= !!(s->flags & CODEC_FLAG_OBMC);
dea5b2946999 interlaced motion estimation
michael
parents: 1707
diff changeset
924 s->loop_filter= !!(s->flags & CODEC_FLAG_LOOP_FILTER);
dea5b2946999 interlaced motion estimation
michael
parents: 1707
diff changeset
925 s->alternate_scan= !!(s->flags & CODEC_FLAG_ALT_SCAN);
1633
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1632
diff changeset
926
1711
f2f8eddf1b13 rate limit tips and checks
michael
parents: 1708
diff changeset
927 if(avctx->rc_max_rate && !avctx->rc_buffer_size){
f2f8eddf1b13 rate limit tips and checks
michael
parents: 1708
diff changeset
928 av_log(avctx, AV_LOG_ERROR, "a vbv buffer size is needed, for encoding with a maximum bitrate\n");
f2f8eddf1b13 rate limit tips and checks
michael
parents: 1708
diff changeset
929 return -1;
f2f8eddf1b13 rate limit tips and checks
michael
parents: 1708
diff changeset
930 }
f2f8eddf1b13 rate limit tips and checks
michael
parents: 1708
diff changeset
931
f2f8eddf1b13 rate limit tips and checks
michael
parents: 1708
diff changeset
932 if(avctx->rc_min_rate && avctx->rc_max_rate != avctx->rc_min_rate){
f2f8eddf1b13 rate limit tips and checks
michael
parents: 1708
diff changeset
933 av_log(avctx, AV_LOG_INFO, "Warning min_rate > 0 but min_rate != max_rate isnt recommanded!\n");
1907
7ff22288289e huge vbv buffer size + CBR fix
michael
parents: 1904
diff changeset
934 }
7ff22288289e huge vbv buffer size + CBR fix
michael
parents: 1904
diff changeset
935
2063
99556d33f102 sanity checks
michael
parents: 2054
diff changeset
936 if(avctx->rc_min_rate && avctx->rc_min_rate > avctx->bit_rate){
99556d33f102 sanity checks
michael
parents: 2054
diff changeset
937 av_log(avctx, AV_LOG_INFO, "bitrate below min bitrate\n");
99556d33f102 sanity checks
michael
parents: 2054
diff changeset
938 return -1;
99556d33f102 sanity checks
michael
parents: 2054
diff changeset
939 }
99556d33f102 sanity checks
michael
parents: 2054
diff changeset
940
99556d33f102 sanity checks
michael
parents: 2054
diff changeset
941 if(avctx->rc_max_rate && avctx->rc_max_rate < avctx->bit_rate){
99556d33f102 sanity checks
michael
parents: 2054
diff changeset
942 av_log(avctx, AV_LOG_INFO, "bitrate above max bitrate\n");
99556d33f102 sanity checks
michael
parents: 2054
diff changeset
943 return -1;
99556d33f102 sanity checks
michael
parents: 2054
diff changeset
944 }
99556d33f102 sanity checks
michael
parents: 2054
diff changeset
945
1907
7ff22288289e huge vbv buffer size + CBR fix
michael
parents: 1904
diff changeset
946 if( s->avctx->rc_max_rate && s->avctx->rc_min_rate == s->avctx->rc_max_rate
7ff22288289e huge vbv buffer size + CBR fix
michael
parents: 1904
diff changeset
947 && (s->codec_id == CODEC_ID_MPEG1VIDEO || s->codec_id == CODEC_ID_MPEG2VIDEO)
7ff22288289e huge vbv buffer size + CBR fix
michael
parents: 1904
diff changeset
948 && 90000LL * (avctx->rc_buffer_size-1) > s->avctx->rc_max_rate*0xFFFFLL){
1711
f2f8eddf1b13 rate limit tips and checks
michael
parents: 1708
diff changeset
949
1907
7ff22288289e huge vbv buffer size + CBR fix
michael
parents: 1904
diff changeset
950 av_log(avctx, AV_LOG_INFO, "Warning vbv_delay will be set to 0xFFFF (=VBR) as the specified vbv buffer is too large for the given bitrate!\n");
7ff22288289e huge vbv buffer size + CBR fix
michael
parents: 1904
diff changeset
951 }
7ff22288289e huge vbv buffer size + CBR fix
michael
parents: 1904
diff changeset
952
1633
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1632
diff changeset
953 if((s->flags & CODEC_FLAG_4MV) && s->codec_id != CODEC_ID_MPEG4
1790
be1f5b6137e1 - made --extra-cflags option work on darwin
michael
parents: 1786
diff changeset
954 && s->codec_id != CODEC_ID_H263 && s->codec_id != CODEC_ID_H263P && s->codec_id != CODEC_ID_FLV1){
1598
932d306bf1dc av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents: 1597
diff changeset
955 av_log(avctx, AV_LOG_ERROR, "4MV not supported by codec\n");
1188
c5f239397e90 check validity of some flags
michaelni
parents: 1177
diff changeset
956 return -1;
c5f239397e90 check validity of some flags
michaelni
parents: 1177
diff changeset
957 }
1711
f2f8eddf1b13 rate limit tips and checks
michael
parents: 1708
diff changeset
958
1633
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1632
diff changeset
959 if(s->obmc && s->avctx->mb_decision != FF_MB_DECISION_SIMPLE){
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1632
diff changeset
960 av_log(avctx, AV_LOG_ERROR, "OBMC is only supported with simple mb decission\n");
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1632
diff changeset
961 return -1;
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1632
diff changeset
962 }
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1632
diff changeset
963
1644
835cf346975e h263 loop filter
michael
parents: 1641
diff changeset
964 if(s->obmc && s->codec_id != CODEC_ID_H263 && s->codec_id != CODEC_ID_H263P){
835cf346975e h263 loop filter
michael
parents: 1641
diff changeset
965 av_log(avctx, AV_LOG_ERROR, "OBMC is only supported with H263(+)\n");
835cf346975e h263 loop filter
michael
parents: 1641
diff changeset
966 return -1;
835cf346975e h263 loop filter
michael
parents: 1641
diff changeset
967 }
835cf346975e h263 loop filter
michael
parents: 1641
diff changeset
968
1188
c5f239397e90 check validity of some flags
michaelni
parents: 1177
diff changeset
969 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
970 av_log(avctx, AV_LOG_ERROR, "qpel not supported by codec\n");
1188
c5f239397e90 check validity of some flags
michaelni
parents: 1177
diff changeset
971 return -1;
c5f239397e90 check validity of some flags
michaelni
parents: 1177
diff changeset
972 }
c5f239397e90 check validity of some flags
michaelni
parents: 1177
diff changeset
973
c5f239397e90 check validity of some flags
michaelni
parents: 1177
diff changeset
974 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
975 av_log(avctx, AV_LOG_ERROR, "data partitioning not supported by codec\n");
1188
c5f239397e90 check validity of some flags
michaelni
parents: 1177
diff changeset
976 return -1;
c5f239397e90 check validity of some flags
michaelni
parents: 1177
diff changeset
977 }
c5f239397e90 check validity of some flags
michaelni
parents: 1177
diff changeset
978
1421
340c90faa1dc mpeg2 encoding
michaelni
parents: 1416
diff changeset
979 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
980 av_log(avctx, AV_LOG_ERROR, "b frames not supported by codec\n");
1188
c5f239397e90 check validity of some flags
michaelni
parents: 1177
diff changeset
981 return -1;
c5f239397e90 check validity of some flags
michaelni
parents: 1177
diff changeset
982 }
1958
57ffe72703e0 sanity check
michael
parents: 1955
diff changeset
983
57ffe72703e0 sanity check
michael
parents: 1955
diff changeset
984 if((s->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME|CODEC_FLAG_ALT_SCAN))
57ffe72703e0 sanity check
michael
parents: 1955
diff changeset
985 && s->codec_id != CODEC_ID_MPEG4 && s->codec_id != CODEC_ID_MPEG2VIDEO){
57ffe72703e0 sanity check
michael
parents: 1955
diff changeset
986 av_log(avctx, AV_LOG_ERROR, "interlacing not supported by codec\n");
57ffe72703e0 sanity check
michael
parents: 1955
diff changeset
987 return -1;
57ffe72703e0 sanity check
michael
parents: 1955
diff changeset
988 }
57ffe72703e0 sanity check
michael
parents: 1955
diff changeset
989
1188
c5f239397e90 check validity of some flags
michaelni
parents: 1177
diff changeset
990 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
991 av_log(avctx, AV_LOG_ERROR, "mpeg2 style quantization not supporetd by codec\n");
1188
c5f239397e90 check validity of some flags
michaelni
parents: 1177
diff changeset
992 return -1;
c5f239397e90 check validity of some flags
michaelni
parents: 1177
diff changeset
993 }
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
994
1490
0355f2b3519a rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents: 1480
diff changeset
995 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
996 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
997 return -1;
0355f2b3519a rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents: 1480
diff changeset
998 }
0355f2b3519a rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents: 1480
diff changeset
999
1622
f4794fafc4ce qprd needs mbd=2
michael
parents: 1617
diff changeset
1000 if((s->flags & CODEC_FLAG_QP_RD) && s->avctx->mb_decision != FF_MB_DECISION_RD){
f4794fafc4ce qprd needs mbd=2
michael
parents: 1617
diff changeset
1001 av_log(avctx, AV_LOG_ERROR, "QP RD needs mbd=2\n");
f4794fafc4ce qprd needs mbd=2
michael
parents: 1617
diff changeset
1002 return -1;
f4794fafc4ce qprd needs mbd=2
michael
parents: 1617
diff changeset
1003 }
f4794fafc4ce qprd needs mbd=2
michael
parents: 1617
diff changeset
1004
1754
bdf3927bf8c5 closed gop support & flags2 as all bits in flags are used
michael
parents: 1751
diff changeset
1005 if(s->avctx->scenechange_threshold < 1000000000 && (s->flags & CODEC_FLAG_CLOSED_GOP)){
bdf3927bf8c5 closed gop support & flags2 as all bits in flags are used
michael
parents: 1751
diff changeset
1006 av_log(avctx, AV_LOG_ERROR, "closed gop with scene change detection arent supported yet\n");
bdf3927bf8c5 closed gop support & flags2 as all bits in flags are used
michael
parents: 1751
diff changeset
1007 return -1;
bdf3927bf8c5 closed gop support & flags2 as all bits in flags are used
michael
parents: 1751
diff changeset
1008 }
1799
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
1009
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
1010 if(s->avctx->thread_count > 1 && s->codec_id != CODEC_ID_MPEG4
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
1011 && s->codec_id != CODEC_ID_MPEG1VIDEO && s->codec_id != CODEC_ID_MPEG2VIDEO
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
1012 && (s->codec_id != CODEC_ID_H263P || !(s->flags & CODEC_FLAG_H263P_SLICE_STRUCT))){
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
1013 av_log(avctx, AV_LOG_ERROR, "multi threaded encoding not supported by codec\n");
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
1014 return -1;
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
1015 }
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
1016
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
1017 if(s->avctx->thread_count > 1)
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
1018 s->rtp_mode= 1;
1760
ebe7fa49ddcc mpeg4 pts fix
michael
parents: 1757
diff changeset
1019
ebe7fa49ddcc mpeg4 pts fix
michael
parents: 1757
diff changeset
1020 i= ff_gcd(avctx->frame_rate, avctx->frame_rate_base);
ebe7fa49ddcc mpeg4 pts fix
michael
parents: 1757
diff changeset
1021 if(i > 1){
ebe7fa49ddcc mpeg4 pts fix
michael
parents: 1757
diff changeset
1022 av_log(avctx, AV_LOG_INFO, "removing common factors from framerate\n");
ebe7fa49ddcc mpeg4 pts fix
michael
parents: 1757
diff changeset
1023 avctx->frame_rate /= i;
ebe7fa49ddcc mpeg4 pts fix
michael
parents: 1757
diff changeset
1024 avctx->frame_rate_base /= i;
ebe7fa49ddcc mpeg4 pts fix
michael
parents: 1757
diff changeset
1025 // return -1;
ebe7fa49ddcc mpeg4 pts fix
michael
parents: 1757
diff changeset
1026 }
1754
bdf3927bf8c5 closed gop support & flags2 as all bits in flags are used
michael
parents: 1751
diff changeset
1027
1150
dde68a430ba9 user setable quantizer bias
michaelni
parents: 1148
diff changeset
1028 if(s->codec_id==CODEC_ID_MJPEG){
dde68a430ba9 user setable quantizer bias
michaelni
parents: 1148
diff changeset
1029 s->intra_quant_bias= 1<<(QUANT_BIAS_SHIFT-1); //(a + x/2)/x
dde68a430ba9 user setable quantizer bias
michaelni
parents: 1148
diff changeset
1030 s->inter_quant_bias= 0;
1421
340c90faa1dc mpeg2 encoding
michaelni
parents: 1416
diff changeset
1031 }else if(s->mpeg_quant || s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO){
1150
dde68a430ba9 user setable quantizer bias
michaelni
parents: 1148
diff changeset
1032 s->intra_quant_bias= 3<<(QUANT_BIAS_SHIFT-3); //(a + x*3/8)/x
dde68a430ba9 user setable quantizer bias
michaelni
parents: 1148
diff changeset
1033 s->inter_quant_bias= 0;
dde68a430ba9 user setable quantizer bias
michaelni
parents: 1148
diff changeset
1034 }else{
dde68a430ba9 user setable quantizer bias
michaelni
parents: 1148
diff changeset
1035 s->intra_quant_bias=0;
dde68a430ba9 user setable quantizer bias
michaelni
parents: 1148
diff changeset
1036 s->inter_quant_bias=-(1<<(QUANT_BIAS_SHIFT-2)); //(a - x/4)/x
dde68a430ba9 user setable quantizer bias
michaelni
parents: 1148
diff changeset
1037 }
dde68a430ba9 user setable quantizer bias
michaelni
parents: 1148
diff changeset
1038
dde68a430ba9 user setable quantizer bias
michaelni
parents: 1148
diff changeset
1039 if(avctx->intra_quant_bias != FF_DEFAULT_QUANT_BIAS)
dde68a430ba9 user setable quantizer bias
michaelni
parents: 1148
diff changeset
1040 s->intra_quant_bias= avctx->intra_quant_bias;
dde68a430ba9 user setable quantizer bias
michaelni
parents: 1148
diff changeset
1041 if(avctx->inter_quant_bias != FF_DEFAULT_QUANT_BIAS)
dde68a430ba9 user setable quantizer bias
michaelni
parents: 1148
diff changeset
1042 s->inter_quant_bias= avctx->inter_quant_bias;
1315
6696d3bf4ff2 lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents: 1288
diff changeset
1043
6696d3bf4ff2 lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents: 1288
diff changeset
1044 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
1045
1424
39ebefd82728 fixing CODEC_FLAG_GLOBAL_HEADER
michaelni
parents: 1422
diff changeset
1046 av_reduce(&s->time_increment_resolution, &dummy, s->avctx->frame_rate, s->avctx->frame_rate_base, (1<<16)-1);
39ebefd82728 fixing CODEC_FLAG_GLOBAL_HEADER
michaelni
parents: 1422
diff changeset
1047 s->time_increment_bits = av_log2(s->time_increment_resolution - 1) + 1;
39ebefd82728 fixing CODEC_FLAG_GLOBAL_HEADER
michaelni
parents: 1422
diff changeset
1048
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1049 switch(avctx->codec->id) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
1050 case CODEC_ID_MPEG1VIDEO:
986e461dc072 Initial revision
glantau
parents:
diff changeset
1051 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
1052 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
1053 avctx->delay= s->low_delay ? 0 : (s->max_b_frames + 1);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1054 break;
1421
340c90faa1dc mpeg2 encoding
michaelni
parents: 1416
diff changeset
1055 case CODEC_ID_MPEG2VIDEO:
340c90faa1dc mpeg2 encoding
michaelni
parents: 1416
diff changeset
1056 s->out_format = FMT_MPEG1;
340c90faa1dc mpeg2 encoding
michaelni
parents: 1416
diff changeset
1057 s->low_delay= 0; //s->max_b_frames ? 0 : 1;
340c90faa1dc mpeg2 encoding
michaelni
parents: 1416
diff changeset
1058 avctx->delay= s->low_delay ? 0 : (s->max_b_frames + 1);
1661
4c9fd29f1606 h263 slice structured mode
michael
parents: 1659
diff changeset
1059 s->rtp_mode= 1;
1421
340c90faa1dc mpeg2 encoding
michaelni
parents: 1416
diff changeset
1060 break;
1315
6696d3bf4ff2 lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents: 1288
diff changeset
1061 case CODEC_ID_LJPEG:
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1062 case CODEC_ID_MJPEG:
986e461dc072 Initial revision
glantau
parents:
diff changeset
1063 s->out_format = FMT_MJPEG;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1064 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
1065 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
1066 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
1067 s->mjpeg_vsample[0] = 1<<chroma_v_shift;
6696d3bf4ff2 lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents: 1288
diff changeset
1068 s->mjpeg_vsample[1] = 1;
232
b640ec5948b0 - Now the ME is done for the entire picture when enconding, the
pulento
parents: 231
diff changeset
1069 s->mjpeg_vsample[2] = 1;
1315
6696d3bf4ff2 lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents: 1288
diff changeset
1070 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
1071 s->mjpeg_hsample[1] = 1;
b640ec5948b0 - Now the ME is done for the entire picture when enconding, the
pulento
parents: 231
diff changeset
1072 s->mjpeg_hsample[2] = 1;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1073 if (mjpeg_init(s) < 0)
986e461dc072 Initial revision
glantau
parents:
diff changeset
1074 return -1;
336
c56b45669214 export delay info
michaelni
parents: 333
diff changeset
1075 avctx->delay=0;
924
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
1076 s->low_delay=1;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1077 break;
1042
a78f6f72d54e --disable-risky support
michaelni
parents: 1026
diff changeset
1078 #ifdef CONFIG_RISKY
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1079 case CODEC_ID_H263:
232
b640ec5948b0 - Now the ME is done for the entire picture when enconding, the
pulento
parents: 231
diff changeset
1080 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
1081 av_log(avctx, AV_LOG_INFO, "Input picture size isn't suitable for h263 codec! try h263+\n");
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1082 return -1;
232
b640ec5948b0 - Now the ME is done for the entire picture when enconding, the
pulento
parents: 231
diff changeset
1083 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1084 s->out_format = FMT_H263;
1644
835cf346975e h263 loop filter
michael
parents: 1641
diff changeset
1085 s->obmc= (avctx->flags & CODEC_FLAG_OBMC) ? 1:0;
336
c56b45669214 export delay info
michaelni
parents: 333
diff changeset
1086 avctx->delay=0;
924
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
1087 s->low_delay=1;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1088 break;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1089 case CODEC_ID_H263P:
986e461dc072 Initial revision
glantau
parents:
diff changeset
1090 s->out_format = FMT_H263;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1091 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
1092 /* Fx */
1644
835cf346975e h263 loop filter
michael
parents: 1641
diff changeset
1093 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
1094 s->h263_aic= (avctx->flags & CODEC_FLAG_H263P_AIC) ? 1:0;
1644
835cf346975e h263 loop filter
michael
parents: 1641
diff changeset
1095 s->modified_quant= s->h263_aic;
1637
7799582dc9b8 h263 alternative inter vlc support
michael
parents: 1633
diff changeset
1096 s->alt_inter_vlc= (avctx->flags & CODEC_FLAG_H263P_AIV) ? 1:0;
1644
835cf346975e h263 loop filter
michael
parents: 1641
diff changeset
1097 s->obmc= (avctx->flags & CODEC_FLAG_OBMC) ? 1:0;
835cf346975e h263 loop filter
michael
parents: 1641
diff changeset
1098 s->loop_filter= (avctx->flags & CODEC_FLAG_LOOP_FILTER) ? 1:0;
835cf346975e h263 loop filter
michael
parents: 1641
diff changeset
1099 s->unrestricted_mv= s->obmc || s->loop_filter || s->umvplus;
1661
4c9fd29f1606 h263 slice structured mode
michael
parents: 1659
diff changeset
1100 s->h263_slice_structured= (s->flags & CODEC_FLAG_H263P_SLICE_STRUCT) ? 1:0;
1644
835cf346975e h263 loop filter
michael
parents: 1641
diff changeset
1101
1095
c7604e6291c5 extended option for h263+ patch by (fixounet at free dot fr) with some minor modifications
michaelni
parents: 1094
diff changeset
1102 /* /Fx */
79
82e579c37bc3 Moved some H.263+ variables to MpegEncContext to be thread-safe.
pulento
parents: 78
diff changeset
1103 /* These are just to be sure */
336
c56b45669214 export delay info
michaelni
parents: 333
diff changeset
1104 avctx->delay=0;
924
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
1105 s->low_delay=1;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1106 break;
1353
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1344
diff changeset
1107 case CODEC_ID_FLV1:
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1344
diff changeset
1108 s->out_format = FMT_H263;
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1344
diff changeset
1109 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
1110 s->unrestricted_mv = 1;
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1344
diff changeset
1111 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
1112 avctx->delay=0;
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1344
diff changeset
1113 s->low_delay=1;
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1344
diff changeset
1114 break;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1115 case CODEC_ID_RV10:
986e461dc072 Initial revision
glantau
parents:
diff changeset
1116 s->out_format = FMT_H263;
336
c56b45669214 export delay info
michaelni
parents: 333
diff changeset
1117 avctx->delay=0;
924
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
1118 s->low_delay=1;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1119 break;
71
79be2c581c01 changed opendivx to mpeg4
glantau
parents: 64
diff changeset
1120 case CODEC_ID_MPEG4:
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1121 s->out_format = FMT_H263;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1122 s->h263_pred = 1;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1123 s->unrestricted_mv = 1;
924
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
1124 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
1125 avctx->delay= s->low_delay ? 0 : (s->max_b_frames + 1);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1126 break;
307
764aeec1320e msmpeg4v2 decoding (no encoding yet)
michaelni
parents: 302
diff changeset
1127 case CODEC_ID_MSMPEG4V1:
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1128 s->out_format = FMT_H263;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1129 s->h263_msmpeg4 = 1;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1130 s->h263_pred = 1;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1131 s->unrestricted_mv = 1;
307
764aeec1320e msmpeg4v2 decoding (no encoding yet)
michaelni
parents: 302
diff changeset
1132 s->msmpeg4_version= 1;
336
c56b45669214 export delay info
michaelni
parents: 333
diff changeset
1133 avctx->delay=0;
924
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
1134 s->low_delay=1;
307
764aeec1320e msmpeg4v2 decoding (no encoding yet)
michaelni
parents: 302
diff changeset
1135 break;
764aeec1320e msmpeg4v2 decoding (no encoding yet)
michaelni
parents: 302
diff changeset
1136 case CODEC_ID_MSMPEG4V2:
764aeec1320e msmpeg4v2 decoding (no encoding yet)
michaelni
parents: 302
diff changeset
1137 s->out_format = FMT_H263;
764aeec1320e msmpeg4v2 decoding (no encoding yet)
michaelni
parents: 302
diff changeset
1138 s->h263_msmpeg4 = 1;
764aeec1320e msmpeg4v2 decoding (no encoding yet)
michaelni
parents: 302
diff changeset
1139 s->h263_pred = 1;
764aeec1320e msmpeg4v2 decoding (no encoding yet)
michaelni
parents: 302
diff changeset
1140 s->unrestricted_mv = 1;
764aeec1320e msmpeg4v2 decoding (no encoding yet)
michaelni
parents: 302
diff changeset
1141 s->msmpeg4_version= 2;
336
c56b45669214 export delay info
michaelni
parents: 333
diff changeset
1142 avctx->delay=0;
924
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
1143 s->low_delay=1;
307
764aeec1320e msmpeg4v2 decoding (no encoding yet)
michaelni
parents: 302
diff changeset
1144 break;
764aeec1320e msmpeg4v2 decoding (no encoding yet)
michaelni
parents: 302
diff changeset
1145 case CODEC_ID_MSMPEG4V3:
764aeec1320e msmpeg4v2 decoding (no encoding yet)
michaelni
parents: 302
diff changeset
1146 s->out_format = FMT_H263;
764aeec1320e msmpeg4v2 decoding (no encoding yet)
michaelni
parents: 302
diff changeset
1147 s->h263_msmpeg4 = 1;
764aeec1320e msmpeg4v2 decoding (no encoding yet)
michaelni
parents: 302
diff changeset
1148 s->h263_pred = 1;
764aeec1320e msmpeg4v2 decoding (no encoding yet)
michaelni
parents: 302
diff changeset
1149 s->unrestricted_mv = 1;
764aeec1320e msmpeg4v2 decoding (no encoding yet)
michaelni
parents: 302
diff changeset
1150 s->msmpeg4_version= 3;
1163
0951691c4225 fixing msmpeg4v2 encoding
michaelni
parents: 1162
diff changeset
1151 s->flipflop_rounding=1;
336
c56b45669214 export delay info
michaelni
parents: 333
diff changeset
1152 avctx->delay=0;
924
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
1153 s->low_delay=1;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1154 break;
499
8b7a54d58549 wmv1 support
michaelni
parents: 487
diff changeset
1155 case CODEC_ID_WMV1:
8b7a54d58549 wmv1 support
michaelni
parents: 487
diff changeset
1156 s->out_format = FMT_H263;
8b7a54d58549 wmv1 support
michaelni
parents: 487
diff changeset
1157 s->h263_msmpeg4 = 1;
8b7a54d58549 wmv1 support
michaelni
parents: 487
diff changeset
1158 s->h263_pred = 1;
8b7a54d58549 wmv1 support
michaelni
parents: 487
diff changeset
1159 s->unrestricted_mv = 1;
8b7a54d58549 wmv1 support
michaelni
parents: 487
diff changeset
1160 s->msmpeg4_version= 4;
1163
0951691c4225 fixing msmpeg4v2 encoding
michaelni
parents: 1162
diff changeset
1161 s->flipflop_rounding=1;
499
8b7a54d58549 wmv1 support
michaelni
parents: 487
diff changeset
1162 avctx->delay=0;
924
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
1163 s->low_delay=1;
499
8b7a54d58549 wmv1 support
michaelni
parents: 487
diff changeset
1164 break;
8b7a54d58549 wmv1 support
michaelni
parents: 487
diff changeset
1165 case CODEC_ID_WMV2:
8b7a54d58549 wmv1 support
michaelni
parents: 487
diff changeset
1166 s->out_format = FMT_H263;
8b7a54d58549 wmv1 support
michaelni
parents: 487
diff changeset
1167 s->h263_msmpeg4 = 1;
8b7a54d58549 wmv1 support
michaelni
parents: 487
diff changeset
1168 s->h263_pred = 1;
8b7a54d58549 wmv1 support
michaelni
parents: 487
diff changeset
1169 s->unrestricted_mv = 1;
8b7a54d58549 wmv1 support
michaelni
parents: 487
diff changeset
1170 s->msmpeg4_version= 5;
1163
0951691c4225 fixing msmpeg4v2 encoding
michaelni
parents: 1162
diff changeset
1171 s->flipflop_rounding=1;
499
8b7a54d58549 wmv1 support
michaelni
parents: 487
diff changeset
1172 avctx->delay=0;
924
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
1173 s->low_delay=1;
499
8b7a54d58549 wmv1 support
michaelni
parents: 487
diff changeset
1174 break;
1042
a78f6f72d54e --disable-risky support
michaelni
parents: 1026
diff changeset
1175 #endif
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1176 default:
986e461dc072 Initial revision
glantau
parents:
diff changeset
1177 return -1;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1178 }
2042
87620c5e2b03 export low_delay for encoding too
michael
parents: 2025
diff changeset
1179
87620c5e2b03 export low_delay for encoding too
michael
parents: 2025
diff changeset
1180 avctx->has_b_frames= !s->low_delay;
1749
7b11032507e2 removing broken framerate conversation hack in mpeg1/2
michael
parents: 1742
diff changeset
1181
7
1d3ac9654178 added skip macroblock optimization (big perf win on black regions for example)
glantau
parents: 0
diff changeset
1182 s->encoding = 1;
1d3ac9654178 added skip macroblock optimization (big perf win on black regions for example)
glantau
parents: 0
diff changeset
1183
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1184 /* init */
986e461dc072 Initial revision
glantau
parents:
diff changeset
1185 if (MPV_common_init(s) < 0)
986e461dc072 Initial revision
glantau
parents:
diff changeset
1186 return -1;
1678
c962b8db3715 interlaced dct encoding fix
michael
parents: 1676
diff changeset
1187
c962b8db3715 interlaced dct encoding fix
michael
parents: 1676
diff changeset
1188 if(s->modified_quant)
c962b8db3715 interlaced dct encoding fix
michael
parents: 1676
diff changeset
1189 s->chroma_qscale_table= ff_h263_chroma_qscale_table;
c962b8db3715 interlaced dct encoding fix
michael
parents: 1676
diff changeset
1190 s->progressive_frame=
1708
dea5b2946999 interlaced motion estimation
michael
parents: 1707
diff changeset
1191 s->progressive_sequence= !(avctx->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME));
1799
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
1192 s->quant_precision=5;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1193
1729
a4a5e7521339 interlaced dct decision cleanup
michael
parents: 1723
diff changeset
1194 ff_set_cmp(&s->dsp, s->dsp.ildct_cmp, s->avctx->ildct_cmp);
a4a5e7521339 interlaced dct decision cleanup
michael
parents: 1723
diff changeset
1195
815
78accc54493b put a few large tables under #ifdef CONFIG_ENCODERS or dynamically allocate them
michaelni
parents: 814
diff changeset
1196 #ifdef CONFIG_ENCODERS
1042
a78f6f72d54e --disable-risky support
michaelni
parents: 1026
diff changeset
1197 #ifdef CONFIG_RISKY
706
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 704
diff changeset
1198 if (s->out_format == FMT_H263)
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 704
diff changeset
1199 h263_encode_init(s);
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 704
diff changeset
1200 if(s->msmpeg4_version)
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 704
diff changeset
1201 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
1202 #endif
1042
a78f6f72d54e --disable-risky support
michaelni
parents: 1026
diff changeset
1203 if (s->out_format == FMT_MPEG1)
a78f6f72d54e --disable-risky support
michaelni
parents: 1026
diff changeset
1204 ff_mpeg1_encode_init(s);
a78f6f72d54e --disable-risky support
michaelni
parents: 1026
diff changeset
1205 #endif
706
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 704
diff changeset
1206
1892
5ac49e7a1b8f init cleanup
michael
parents: 1885
diff changeset
1207 /* init q matrix */
60
35c1141e23d9 moved matrix init away from MPV_common_init()
glantau
parents: 57
diff changeset
1208 for(i=0;i<64;i++) {
1092
f59c3f66363b MpegEncContext.(i)dct_* -> DspContext.(i)dct_*
michaelni
parents: 1089
diff changeset
1209 int j= s->dsp.idct_permutation[i];
1042
a78f6f72d54e --disable-risky support
michaelni
parents: 1026
diff changeset
1210 #ifdef CONFIG_RISKY
599
b1a191202f96 mpeg4 mpeg quantizer encoding
michaelni
parents: 598
diff changeset
1211 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
1212 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
1213 s->inter_matrix[j] = ff_mpeg4_default_non_intra_matrix[i];
599
b1a191202f96 mpeg4 mpeg quantizer encoding
michaelni
parents: 598
diff changeset
1214 }else if(s->out_format == FMT_H263){
706
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 704
diff changeset
1215 s->intra_matrix[j] =
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 704
diff changeset
1216 s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i];
1042
a78f6f72d54e --disable-risky support
michaelni
parents: 1026
diff changeset
1217 }else
a78f6f72d54e --disable-risky support
michaelni
parents: 1026
diff changeset
1218 #endif
1421
340c90faa1dc mpeg2 encoding
michaelni
parents: 1416
diff changeset
1219 { /* mpeg1/2 */
706
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 704
diff changeset
1220 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
1221 s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i];
599
b1a191202f96 mpeg4 mpeg quantizer encoding
michaelni
parents: 598
diff changeset
1222 }
1411
c2e63cb94d06 custom quant matrix encoding support
michaelni
parents: 1402
diff changeset
1223 if(s->avctx->intra_matrix)
c2e63cb94d06 custom quant matrix encoding support
michaelni
parents: 1402
diff changeset
1224 s->intra_matrix[j] = s->avctx->intra_matrix[i];
c2e63cb94d06 custom quant matrix encoding support
michaelni
parents: 1402
diff changeset
1225 if(s->avctx->inter_matrix)
c2e63cb94d06 custom quant matrix encoding support
michaelni
parents: 1402
diff changeset
1226 s->inter_matrix[j] = s->avctx->inter_matrix[i];
344
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
1227 }
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
1228
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
1229 /* precompute matrix */
350
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 347
diff changeset
1230 /* for mjpeg, we do include qscale in the matrix */
344
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
1231 if (s->out_format != FMT_MJPEG) {
1579
039cb2296de2 make convert_matrix() independant of MpegEncContext
michael
parents: 1573
diff changeset
1232 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
1233 s->intra_matrix, s->intra_quant_bias, 1, 31);
1579
039cb2296de2 make convert_matrix() independant of MpegEncContext
michael
parents: 1573
diff changeset
1234 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
1235 s->inter_matrix, s->inter_quant_bias, 1, 31);
60
35c1141e23d9 moved matrix init away from MPV_common_init()
glantau
parents: 57
diff changeset
1236 }
35c1141e23d9 moved matrix init away from MPV_common_init()
glantau
parents: 57
diff changeset
1237
329
5cc47d0ba53e fixed ratecontrol & b-frames
michaelni
parents: 327
diff changeset
1238 if(ff_rate_control_init(s) < 0)
5cc47d0ba53e fixed ratecontrol & b-frames
michaelni
parents: 327
diff changeset
1239 return -1;
1892
5ac49e7a1b8f init cleanup
michael
parents: 1885
diff changeset
1240
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1241 return 0;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1242 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
1243
986e461dc072 Initial revision
glantau
parents:
diff changeset
1244 int MPV_encode_end(AVCodecContext *avctx)
986e461dc072 Initial revision
glantau
parents:
diff changeset
1245 {
986e461dc072 Initial revision
glantau
parents:
diff changeset
1246 MpegEncContext *s = avctx->priv_data;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1247
986e461dc072 Initial revision
glantau
parents:
diff changeset
1248 #ifdef STATS
986e461dc072 Initial revision
glantau
parents:
diff changeset
1249 print_stats();
986e461dc072 Initial revision
glantau
parents:
diff changeset
1250 #endif
329
5cc47d0ba53e fixed ratecontrol & b-frames
michaelni
parents: 327
diff changeset
1251
5cc47d0ba53e fixed ratecontrol & b-frames
michaelni
parents: 327
diff changeset
1252 ff_rate_control_uninit(s);
5cc47d0ba53e fixed ratecontrol & b-frames
michaelni
parents: 327
diff changeset
1253
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1254 MPV_common_end(s);
986e461dc072 Initial revision
glantau
parents:
diff changeset
1255 if (s->out_format == FMT_MJPEG)
986e461dc072 Initial revision
glantau
parents:
diff changeset
1256 mjpeg_close(s);
1458
40b69d238beb AVI stream header FCC / more reliable detection of old xvid files
michaelni
parents: 1451
diff changeset
1257
1424
39ebefd82728 fixing CODEC_FLAG_GLOBAL_HEADER
michaelni
parents: 1422
diff changeset
1258 av_freep(&avctx->extradata);
232
b640ec5948b0 - Now the ME is done for the entire picture when enconding, the
pulento
parents: 231
diff changeset
1259
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1260 return 0;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1261 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
1262
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
1263 #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
1264
1042
a78f6f72d54e --disable-risky support
michaelni
parents: 1026
diff changeset
1265 void init_rl(RLTable *rl)
a78f6f72d54e --disable-risky support
michaelni
parents: 1026
diff changeset
1266 {
1064
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1059
diff changeset
1267 int8_t max_level[MAX_RUN+1], max_run[MAX_LEVEL+1];
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1059
diff changeset
1268 uint8_t index_run[MAX_RUN+1];
1042
a78f6f72d54e --disable-risky support
michaelni
parents: 1026
diff changeset
1269 int last, run, level, start, end, i;
a78f6f72d54e --disable-risky support
michaelni
parents: 1026
diff changeset
1270
a78f6f72d54e --disable-risky support
michaelni
parents: 1026
diff changeset
1271 /* compute max_level[], max_run[] and index_run[] */
a78f6f72d54e --disable-risky support
michaelni
parents: 1026
diff changeset
1272 for(last=0;last<2;last++) {
a78f6f72d54e --disable-risky support
michaelni
parents: 1026
diff changeset
1273 if (last == 0) {
a78f6f72d54e --disable-risky support
michaelni
parents: 1026
diff changeset
1274 start = 0;
a78f6f72d54e --disable-risky support
michaelni
parents: 1026
diff changeset
1275 end = rl->last;
a78f6f72d54e --disable-risky support
michaelni
parents: 1026
diff changeset
1276 } else {
a78f6f72d54e --disable-risky support
michaelni
parents: 1026
diff changeset
1277 start = rl->last;
a78f6f72d54e --disable-risky support
michaelni
parents: 1026
diff changeset
1278 end = rl->n;
a78f6f72d54e --disable-risky support
michaelni
parents: 1026
diff changeset
1279 }
a78f6f72d54e --disable-risky support
michaelni
parents: 1026
diff changeset
1280
a78f6f72d54e --disable-risky support
michaelni
parents: 1026
diff changeset
1281 memset(max_level, 0, MAX_RUN + 1);
a78f6f72d54e --disable-risky support
michaelni
parents: 1026
diff changeset
1282 memset(max_run, 0, MAX_LEVEL + 1);
a78f6f72d54e --disable-risky support
michaelni
parents: 1026
diff changeset
1283 memset(index_run, rl->n, MAX_RUN + 1);
a78f6f72d54e --disable-risky support
michaelni
parents: 1026
diff changeset
1284 for(i=start;i<end;i++) {
a78f6f72d54e --disable-risky support
michaelni
parents: 1026
diff changeset
1285 run = rl->table_run[i];
a78f6f72d54e --disable-risky support
michaelni
parents: 1026
diff changeset
1286 level = rl->table_level[i];
a78f6f72d54e --disable-risky support
michaelni
parents: 1026
diff changeset
1287 if (index_run[run] == rl->n)
a78f6f72d54e --disable-risky support
michaelni
parents: 1026
diff changeset
1288 index_run[run] = i;
a78f6f72d54e --disable-risky support
michaelni
parents: 1026
diff changeset
1289 if (level > max_level[run])
a78f6f72d54e --disable-risky support
michaelni
parents: 1026
diff changeset
1290 max_level[run] = level;
a78f6f72d54e --disable-risky support
michaelni
parents: 1026
diff changeset
1291 if (run > max_run[level])
a78f6f72d54e --disable-risky support
michaelni
parents: 1026
diff changeset
1292 max_run[level] = run;
a78f6f72d54e --disable-risky support
michaelni
parents: 1026
diff changeset
1293 }
a78f6f72d54e --disable-risky support
michaelni
parents: 1026
diff changeset
1294 rl->max_level[last] = av_malloc(MAX_RUN + 1);
a78f6f72d54e --disable-risky support
michaelni
parents: 1026
diff changeset
1295 memcpy(rl->max_level[last], max_level, MAX_RUN + 1);
a78f6f72d54e --disable-risky support
michaelni
parents: 1026
diff changeset
1296 rl->max_run[last] = av_malloc(MAX_LEVEL + 1);
a78f6f72d54e --disable-risky support
michaelni
parents: 1026
diff changeset
1297 memcpy(rl->max_run[last], max_run, MAX_LEVEL + 1);
a78f6f72d54e --disable-risky support
michaelni
parents: 1026
diff changeset
1298 rl->index_run[last] = av_malloc(MAX_RUN + 1);
a78f6f72d54e --disable-risky support
michaelni
parents: 1026
diff changeset
1299 memcpy(rl->index_run[last], index_run, MAX_RUN + 1);
a78f6f72d54e --disable-risky support
michaelni
parents: 1026
diff changeset
1300 }
a78f6f72d54e --disable-risky support
michaelni
parents: 1026
diff changeset
1301 }
a78f6f72d54e --disable-risky support
michaelni
parents: 1026
diff changeset
1302
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1303 /* 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
1304 //FIXME check that this is ok for mpeg4 interlaced
1064
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1059
diff changeset
1305 static void draw_edges_c(uint8_t *buf, int wrap, int width, int height, int w)
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1306 {
1064
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1059
diff changeset
1307 uint8_t *ptr, *last_line;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1308 int i;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1309
986e461dc072 Initial revision
glantau
parents:
diff changeset
1310 last_line = buf + (height - 1) * wrap;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1311 for(i=0;i<w;i++) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
1312 /* top and bottom */
986e461dc072 Initial revision
glantau
parents:
diff changeset
1313 memcpy(buf - (i + 1) * wrap, buf, width);
986e461dc072 Initial revision
glantau
parents:
diff changeset
1314 memcpy(last_line + (i + 1) * wrap, last_line, width);
986e461dc072 Initial revision
glantau
parents:
diff changeset
1315 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
1316 /* left and right */
986e461dc072 Initial revision
glantau
parents:
diff changeset
1317 ptr = buf;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1318 for(i=0;i<height;i++) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
1319 memset(ptr - w, ptr[0], w);
986e461dc072 Initial revision
glantau
parents:
diff changeset
1320 memset(ptr + width, ptr[width-1], w);
986e461dc072 Initial revision
glantau
parents:
diff changeset
1321 ptr += wrap;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1322 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
1323 /* corners */
986e461dc072 Initial revision
glantau
parents:
diff changeset
1324 for(i=0;i<w;i++) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
1325 memset(buf - (i + 1) * wrap - w, buf[0], w); /* top left */
986e461dc072 Initial revision
glantau
parents:
diff changeset
1326 memset(buf - (i + 1) * wrap + width, buf[width-1], w); /* top right */
986e461dc072 Initial revision
glantau
parents:
diff changeset
1327 memset(last_line + (i + 1) * wrap - w, last_line[0], w); /* top left */
986e461dc072 Initial revision
glantau
parents:
diff changeset
1328 memset(last_line + (i + 1) * wrap + width, last_line[width-1], w); /* top right */
986e461dc072 Initial revision
glantau
parents:
diff changeset
1329 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
1330 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
1331
1586
3d1d0490e5a6 pts fix and related fixes
michael
parents: 1580
diff changeset
1332 int ff_find_unused_picture(MpegEncContext *s, int shared){
924
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
1333 int i;
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
1334
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
1335 if(shared){
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
1336 for(i=0; i<MAX_PICTURE_COUNT; i++){
1586
3d1d0490e5a6 pts fix and related fixes
michael
parents: 1580
diff changeset
1337 if(s->picture[i].data[0]==NULL && s->picture[i].type==0) return i;
924
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
1338 }
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
1339 }else{
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
1340 for(i=0; i<MAX_PICTURE_COUNT; i++){
1586
3d1d0490e5a6 pts fix and related fixes
michael
parents: 1580
diff changeset
1341 if(s->picture[i].data[0]==NULL && s->picture[i].type!=0) return i; //FIXME
924
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
1342 }
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
1343 for(i=0; i<MAX_PICTURE_COUNT; i++){
1586
3d1d0490e5a6 pts fix and related fixes
michael
parents: 1580
diff changeset
1344 if(s->picture[i].data[0]==NULL) return i;
924
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
1345 }
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
1346 }
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
1347
1586
3d1d0490e5a6 pts fix and related fixes
michael
parents: 1580
diff changeset
1348 assert(0);
3d1d0490e5a6 pts fix and related fixes
michael
parents: 1580
diff changeset
1349 return -1;
924
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
1350 }
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
1351
1597
4c9165372ab3 noise reduction of dct coefficients
michael
parents: 1586
diff changeset
1352 static void update_noise_reduction(MpegEncContext *s){
4c9165372ab3 noise reduction of dct coefficients
michael
parents: 1586
diff changeset
1353 int intra, i;
4c9165372ab3 noise reduction of dct coefficients
michael
parents: 1586
diff changeset
1354
4c9165372ab3 noise reduction of dct coefficients
michael
parents: 1586
diff changeset
1355 for(intra=0; intra<2; intra++){
4c9165372ab3 noise reduction of dct coefficients
michael
parents: 1586
diff changeset
1356 if(s->dct_count[intra] > (1<<16)){
4c9165372ab3 noise reduction of dct coefficients
michael
parents: 1586
diff changeset
1357 for(i=0; i<64; i++){
4c9165372ab3 noise reduction of dct coefficients
michael
parents: 1586
diff changeset
1358 s->dct_error_sum[intra][i] >>=1;
4c9165372ab3 noise reduction of dct coefficients
michael
parents: 1586
diff changeset
1359 }
4c9165372ab3 noise reduction of dct coefficients
michael
parents: 1586
diff changeset
1360 s->dct_count[intra] >>= 1;
4c9165372ab3 noise reduction of dct coefficients
michael
parents: 1586
diff changeset
1361 }
4c9165372ab3 noise reduction of dct coefficients
michael
parents: 1586
diff changeset
1362
4c9165372ab3 noise reduction of dct coefficients
michael
parents: 1586
diff changeset
1363 for(i=0; i<64; i++){
4c9165372ab3 noise reduction of dct coefficients
michael
parents: 1586
diff changeset
1364 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);
4c9165372ab3 noise reduction of dct coefficients
michael
parents: 1586
diff changeset
1365 }
4c9165372ab3 noise reduction of dct coefficients
michael
parents: 1586
diff changeset
1366 }
4c9165372ab3 noise reduction of dct coefficients
michael
parents: 1586
diff changeset
1367 }
4c9165372ab3 noise reduction of dct coefficients
michael
parents: 1586
diff changeset
1368
1586
3d1d0490e5a6 pts fix and related fixes
michael
parents: 1580
diff changeset
1369 /**
3d1d0490e5a6 pts fix and related fixes
michael
parents: 1580
diff changeset
1370 * generic function for encode/decode called after coding/decoding the header and before a frame is coded/decoded
3d1d0490e5a6 pts fix and related fixes
michael
parents: 1580
diff changeset
1371 */
771
d4cc92144266 handle direct rendering buffer allocation failure
michaelni
parents: 768
diff changeset
1372 int MPV_frame_start(MpegEncContext *s, AVCodecContext *avctx)
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1373 {
924
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
1374 int i;
925
7fccaa0d699d AVVideoFrame -> AVFrame
michaelni
parents: 924
diff changeset
1375 AVFrame *pic;
46
931417475f5b fixed mpeg1 first block bug (pb with black picture optimisation for B frames)
glantau
parents: 40
diff changeset
1376 s->mb_skiped = 0;
1168
5af9aeadbdc3 H264 decoder & demuxer
michaelni
parents: 1165
diff changeset
1377
1234
fc2a7eefa9cc svq3 decoder by anonymous
michaelni
parents: 1228
diff changeset
1378 assert(s->last_picture_ptr==NULL || s->out_format != FMT_H264 || s->codec_id == CODEC_ID_SVQ3);
1228
d63e0185a90f release buffer cleanup
michaelni
parents: 1225
diff changeset
1379
903
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
1380 /* mark&release old frames */
1944
a3f44c9168aa flv dropable p frame support
michael
parents: 1938
diff changeset
1381 if (s->pict_type != B_TYPE && s->last_picture_ptr && s->last_picture_ptr != s->next_picture_ptr && s->last_picture_ptr->data[0]) {
1138
e10e841c9bf0 field pic decoding cleanup
michaelni
parents: 1130
diff changeset
1382 avctx->release_buffer(avctx, (AVFrame*)s->last_picture_ptr);
903
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
1383
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
1384 /* release forgotten pictures */
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
1385 /* if(mpeg124/h263) */
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
1386 if(!s->encoding){
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
1387 for(i=0; i<MAX_PICTURE_COUNT; i++){
1138
e10e841c9bf0 field pic decoding cleanup
michaelni
parents: 1130
diff changeset
1388 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
1389 av_log(avctx, AV_LOG_ERROR, "releasing zombie picture\n");
925
7fccaa0d699d AVVideoFrame -> AVFrame
michaelni
parents: 924
diff changeset
1390 avctx->release_buffer(avctx, (AVFrame*)&s->picture[i]);
903
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
1391 }
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
1392 }
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
1393 }
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
1394 }
910
eb448df811be fixing files where the first frame isn a keyframe
michaelni
parents: 909
diff changeset
1395 alloc:
eb448df811be fixing files where the first frame isn a keyframe
michaelni
parents: 909
diff changeset
1396 if(!s->encoding){
1228
d63e0185a90f release buffer cleanup
michaelni
parents: 1225
diff changeset
1397 /* release non refernce frames */
d63e0185a90f release buffer cleanup
michaelni
parents: 1225
diff changeset
1398 for(i=0; i<MAX_PICTURE_COUNT; i++){
d63e0185a90f release buffer cleanup
michaelni
parents: 1225
diff changeset
1399 if(s->picture[i].data[0] && !s->picture[i].reference /*&& s->picture[i].type!=FF_BUFFER_TYPE_SHARED*/){
d63e0185a90f release buffer cleanup
michaelni
parents: 1225
diff changeset
1400 s->avctx->release_buffer(s->avctx, (AVFrame*)&s->picture[i]);
d63e0185a90f release buffer cleanup
michaelni
parents: 1225
diff changeset
1401 }
d63e0185a90f release buffer cleanup
michaelni
parents: 1225
diff changeset
1402 }
d63e0185a90f release buffer cleanup
michaelni
parents: 1225
diff changeset
1403
1586
3d1d0490e5a6 pts fix and related fixes
michael
parents: 1580
diff changeset
1404 if(s->current_picture_ptr && s->current_picture_ptr->data[0]==NULL)
3d1d0490e5a6 pts fix and related fixes
michael
parents: 1580
diff changeset
1405 pic= (AVFrame*)s->current_picture_ptr; //we allready have a unused image (maybe it was set before reading the header)
3d1d0490e5a6 pts fix and related fixes
michael
parents: 1580
diff changeset
1406 else{
3d1d0490e5a6 pts fix and related fixes
michael
parents: 1580
diff changeset
1407 i= ff_find_unused_picture(s, 0);
3d1d0490e5a6 pts fix and related fixes
michael
parents: 1580
diff changeset
1408 pic= (AVFrame*)&s->picture[i];
3d1d0490e5a6 pts fix and related fixes
michael
parents: 1580
diff changeset
1409 }
3d1d0490e5a6 pts fix and related fixes
michael
parents: 1580
diff changeset
1410
1944
a3f44c9168aa flv dropable p frame support
michael
parents: 1938
diff changeset
1411 pic->reference= s->pict_type != B_TYPE && !s->dropable ? 3 : 0;
1138
e10e841c9bf0 field pic decoding cleanup
michaelni
parents: 1130
diff changeset
1412
1705
954593137d37 picture number fixes
michael
parents: 1703
diff changeset
1413 pic->coded_picture_number= s->coded_picture_number++;
903
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
1414
1384
18cdce49339e make MPV_frame_start fail on get_buffer failer
iive
parents: 1381
diff changeset
1415 if( alloc_picture(s, (Picture*)pic, 0) < 0)
18cdce49339e make MPV_frame_start fail on get_buffer failer
iive
parents: 1381
diff changeset
1416 return -1;
903
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
1417
1586
3d1d0490e5a6 pts fix and related fixes
michael
parents: 1580
diff changeset
1418 s->current_picture_ptr= (Picture*)pic;
1658
d4637a0eaab1 export top_field_first & interlaced_frame
michael
parents: 1655
diff changeset
1419 s->current_picture_ptr->top_field_first= s->top_field_first; //FIXME use only the vars from current_pic
1659
3075fc11a974 AVFrame.interlaced_frame fixes
michael
parents: 1658
diff changeset
1420 s->current_picture_ptr->interlaced_frame= !s->progressive_frame && !s->progressive_sequence;
903
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
1421 }
456
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
1422
1173
86d5a33eaec8 pict_type & quality fix
michaelni
parents: 1168
diff changeset
1423 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
1424 // 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
1425 // 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
1426 s->current_picture_ptr->key_frame= s->pict_type == I_TYPE;
1173
86d5a33eaec8 pict_type & quality fix
michaelni
parents: 1168
diff changeset
1427
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
1428 copy_picture(&s->current_picture, s->current_picture_ptr);
1173
86d5a33eaec8 pict_type & quality fix
michaelni
parents: 1168
diff changeset
1429
1234
fc2a7eefa9cc svq3 decoder by anonymous
michaelni
parents: 1228
diff changeset
1430 if(s->out_format != FMT_H264 || s->codec_id == CODEC_ID_SVQ3){
903
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
1431 if (s->pict_type != B_TYPE) {
1138
e10e841c9bf0 field pic decoding cleanup
michaelni
parents: 1130
diff changeset
1432 s->last_picture_ptr= s->next_picture_ptr;
1944
a3f44c9168aa flv dropable p frame support
michael
parents: 1938
diff changeset
1433 if(!s->dropable)
a3f44c9168aa flv dropable p frame support
michael
parents: 1938
diff changeset
1434 s->next_picture_ptr= s->current_picture_ptr;
a3f44c9168aa flv dropable p frame support
michael
parents: 1938
diff changeset
1435 }
a3f44c9168aa flv dropable p frame support
michael
parents: 1938
diff changeset
1436 /* av_log(s->avctx, AV_LOG_DEBUG, "L%p N%p C%p L%p N%p C%p type:%d drop:%d\n", s->last_picture_ptr, s->next_picture_ptr,s->current_picture_ptr,
a3f44c9168aa flv dropable p frame support
michael
parents: 1938
diff changeset
1437 s->last_picture_ptr ? s->last_picture_ptr->data[0] : NULL,
a3f44c9168aa flv dropable p frame support
michael
parents: 1938
diff changeset
1438 s->next_picture_ptr ? s->next_picture_ptr->data[0] : NULL,
a3f44c9168aa flv dropable p frame support
michael
parents: 1938
diff changeset
1439 s->current_picture_ptr ? s->current_picture_ptr->data[0] : NULL,
a3f44c9168aa flv dropable p frame support
michael
parents: 1938
diff changeset
1440 s->pict_type, s->dropable);*/
1214
327c5a36dfe7 fixing mixed dr1 + internal buffers
michaelni
parents: 1189
diff changeset
1441
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
1442 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
1443 if(s->next_picture_ptr) copy_picture(&s->next_picture, s->next_picture_ptr);
1138
e10e841c9bf0 field pic decoding cleanup
michaelni
parents: 1130
diff changeset
1444
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
1445 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
1446 av_log(avctx, AV_LOG_ERROR, "warning: first frame is no keyframe\n");
1393
ba99a78bcb37 make the h263 decoder more error tolerant
michaelni
parents: 1389
diff changeset
1447 assert(s->pict_type != B_TYPE); //these should have been dropped if we dont have a reference
ba99a78bcb37 make the h263 decoder more error tolerant
michaelni
parents: 1389
diff changeset
1448 goto alloc;
ba99a78bcb37 make the h263 decoder more error tolerant
michaelni
parents: 1389
diff changeset
1449 }
ba99a78bcb37 make the h263 decoder more error tolerant
michaelni
parents: 1389
diff changeset
1450
ba99a78bcb37 make the h263 decoder more error tolerant
michaelni
parents: 1389
diff changeset
1451 assert(s->pict_type == I_TYPE || (s->last_picture_ptr && s->last_picture_ptr->data[0]));
ba99a78bcb37 make the h263 decoder more error tolerant
michaelni
parents: 1389
diff changeset
1452
1138
e10e841c9bf0 field pic decoding cleanup
michaelni
parents: 1130
diff changeset
1453 if(s->picture_structure!=PICT_FRAME){
e10e841c9bf0 field pic decoding cleanup
michaelni
parents: 1130
diff changeset
1454 int i;
e10e841c9bf0 field pic decoding cleanup
michaelni
parents: 1130
diff changeset
1455 for(i=0; i<4; i++){
e10e841c9bf0 field pic decoding cleanup
michaelni
parents: 1130
diff changeset
1456 if(s->picture_structure == PICT_BOTTOM_FIELD){
e10e841c9bf0 field pic decoding cleanup
michaelni
parents: 1130
diff changeset
1457 s->current_picture.data[i] += s->current_picture.linesize[i];
e10e841c9bf0 field pic decoding cleanup
michaelni
parents: 1130
diff changeset
1458 }
e10e841c9bf0 field pic decoding cleanup
michaelni
parents: 1130
diff changeset
1459 s->current_picture.linesize[i] *= 2;
e10e841c9bf0 field pic decoding cleanup
michaelni
parents: 1130
diff changeset
1460 s->last_picture.linesize[i] *=2;
e10e841c9bf0 field pic decoding cleanup
michaelni
parents: 1130
diff changeset
1461 s->next_picture.linesize[i] *=2;
e10e841c9bf0 field pic decoding cleanup
michaelni
parents: 1130
diff changeset
1462 }
553
18ad513d92fe direct rendering method 1 support
michaelni
parents: 549
diff changeset
1463 }
1168
5af9aeadbdc3 H264 decoder & demuxer
michaelni
parents: 1165
diff changeset
1464 }
903
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
1465
910
eb448df811be fixing files where the first frame isn a keyframe
michaelni
parents: 909
diff changeset
1466 s->hurry_up= s->avctx->hurry_up;
eb448df811be fixing files where the first frame isn a keyframe
michaelni
parents: 909
diff changeset
1467 s->error_resilience= avctx->error_resilience;
eb448df811be fixing files where the first frame isn a keyframe
michaelni
parents: 909
diff changeset
1468
591
d3f374218030 fixing mpeg4 mpeg quantizers
michaelni
parents: 588
diff changeset
1469 /* set dequantizer, we cant do it during init as it might change for mpeg4
d3f374218030 fixing mpeg4 mpeg quantizers
michaelni
parents: 588
diff changeset
1470 and we cant do it in the header decode as init isnt called for mpeg4 there yet */
1689
1a2db2073848 split intra / inter dequantization
michael
parents: 1688
diff changeset
1471 if(s->mpeg_quant || s->codec_id == CODEC_ID_MPEG2VIDEO){
1a2db2073848 split intra / inter dequantization
michael
parents: 1688
diff changeset
1472 s->dct_unquantize_intra = s->dct_unquantize_mpeg2_intra;
1a2db2073848 split intra / inter dequantization
michael
parents: 1688
diff changeset
1473 s->dct_unquantize_inter = s->dct_unquantize_mpeg2_inter;
1a2db2073848 split intra / inter dequantization
michael
parents: 1688
diff changeset
1474 }else if(s->out_format == FMT_H263){
1a2db2073848 split intra / inter dequantization
michael
parents: 1688
diff changeset
1475 s->dct_unquantize_intra = s->dct_unquantize_h263_intra;
1a2db2073848 split intra / inter dequantization
michael
parents: 1688
diff changeset
1476 s->dct_unquantize_inter = s->dct_unquantize_h263_inter;
2044
b6f2add2511e h261 decoder by (Maarten Daniels <maarten.daniels at student dot luc dot ac dot be>)
michael
parents: 2042
diff changeset
1477 }else if(s->out_format == FMT_H261){
b6f2add2511e h261 decoder by (Maarten Daniels <maarten.daniels at student dot luc dot ac dot be>)
michael
parents: 2042
diff changeset
1478 s->dct_unquantize_intra = s->dct_unquantize_h261_intra;
b6f2add2511e h261 decoder by (Maarten Daniels <maarten.daniels at student dot luc dot ac dot be>)
michael
parents: 2042
diff changeset
1479 s->dct_unquantize_inter = s->dct_unquantize_h261_inter;
1689
1a2db2073848 split intra / inter dequantization
michael
parents: 1688
diff changeset
1480 }else{
1a2db2073848 split intra / inter dequantization
michael
parents: 1688
diff changeset
1481 s->dct_unquantize_intra = s->dct_unquantize_mpeg1_intra;
1a2db2073848 split intra / inter dequantization
michael
parents: 1688
diff changeset
1482 s->dct_unquantize_inter = s->dct_unquantize_mpeg1_inter;
1a2db2073848 split intra / inter dequantization
michael
parents: 1688
diff changeset
1483 }
771
d4cc92144266 handle direct rendering buffer allocation failure
michaelni
parents: 768
diff changeset
1484
1597
4c9165372ab3 noise reduction of dct coefficients
michael
parents: 1586
diff changeset
1485 if(s->dct_error_sum){
4c9165372ab3 noise reduction of dct coefficients
michael
parents: 1586
diff changeset
1486 assert(s->avctx->noise_reduction && s->encoding);
4c9165372ab3 noise reduction of dct coefficients
michael
parents: 1586
diff changeset
1487
4c9165372ab3 noise reduction of dct coefficients
michael
parents: 1586
diff changeset
1488 update_noise_reduction(s);
4c9165372ab3 noise reduction of dct coefficients
michael
parents: 1586
diff changeset
1489 }
4c9165372ab3 noise reduction of dct coefficients
michael
parents: 1586
diff changeset
1490
1381
f07e17427140 initial XvMC support
iive
parents: 1373
diff changeset
1491 #ifdef HAVE_XVMC
f07e17427140 initial XvMC support
iive
parents: 1373
diff changeset
1492 if(s->avctx->xvmc_acceleration)
f07e17427140 initial XvMC support
iive
parents: 1373
diff changeset
1493 return XVMC_field_start(s, avctx);
f07e17427140 initial XvMC support
iive
parents: 1373
diff changeset
1494 #endif
771
d4cc92144266 handle direct rendering buffer allocation failure
michaelni
parents: 768
diff changeset
1495 return 0;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1496 }
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
1497
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1498 /* generic function for encode/decode called after a frame has been coded/decoded */
986e461dc072 Initial revision
glantau
parents:
diff changeset
1499 void MPV_frame_end(MpegEncContext *s)
986e461dc072 Initial revision
glantau
parents:
diff changeset
1500 {
903
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
1501 int i;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1502 /* draw edge for correct motion prediction if outside */
1381
f07e17427140 initial XvMC support
iive
parents: 1373
diff changeset
1503 #ifdef HAVE_XVMC
f07e17427140 initial XvMC support
iive
parents: 1373
diff changeset
1504 //just to make sure that all data is rendered.
f07e17427140 initial XvMC support
iive
parents: 1373
diff changeset
1505 if(s->avctx->xvmc_acceleration){
f07e17427140 initial XvMC support
iive
parents: 1373
diff changeset
1506 XVMC_field_end(s);
f07e17427140 initial XvMC support
iive
parents: 1373
diff changeset
1507 }else
f07e17427140 initial XvMC support
iive
parents: 1373
diff changeset
1508 #endif
1542
576861d6343a emu_edge checks simplification and avoid redundant checks for mpeg1/2 if emu_edge is set
michael
parents: 1539
diff changeset
1509 if(s->unrestricted_mv && s->pict_type != B_TYPE && !s->intra_only && !(s->flags&CODEC_FLAG_EMU_EDGE)) {
903
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
1510 draw_edges(s->current_picture.data[0], s->linesize , s->h_edge_pos , s->v_edge_pos , EDGE_WIDTH );
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
1511 draw_edges(s->current_picture.data[1], s->uvlinesize, s->h_edge_pos>>1, s->v_edge_pos>>1, EDGE_WIDTH/2);
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
1512 draw_edges(s->current_picture.data[2], s->uvlinesize, s->h_edge_pos>>1, s->v_edge_pos>>1, EDGE_WIDTH/2);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1513 }
207
6954f2830e4a (commit by michael)
arpi_esp
parents: 206
diff changeset
1514 emms_c();
329
5cc47d0ba53e fixed ratecontrol & b-frames
michaelni
parents: 327
diff changeset
1515
612
c0005de2be59 new ratecontrol code
michaelni
parents: 611
diff changeset
1516 s->last_pict_type = s->pict_type;
329
5cc47d0ba53e fixed ratecontrol & b-frames
michaelni
parents: 327
diff changeset
1517 if(s->pict_type!=B_TYPE){
5cc47d0ba53e fixed ratecontrol & b-frames
michaelni
parents: 327
diff changeset
1518 s->last_non_b_pict_type= s->pict_type;
5cc47d0ba53e fixed ratecontrol & b-frames
michaelni
parents: 327
diff changeset
1519 }
1138
e10e841c9bf0 field pic decoding cleanup
michaelni
parents: 1130
diff changeset
1520 #if 0
e10e841c9bf0 field pic decoding cleanup
michaelni
parents: 1130
diff changeset
1521 /* copy back current_picture variables */
903
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
1522 for(i=0; i<MAX_PICTURE_COUNT; i++){
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
1523 if(s->picture[i].data[0] == s->current_picture.data[0]){
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
1524 s->picture[i]= s->current_picture;
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
1525 break;
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
1526 }
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
1527 }
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
1528 assert(i<MAX_PICTURE_COUNT);
1138
e10e841c9bf0 field pic decoding cleanup
michaelni
parents: 1130
diff changeset
1529 #endif
903
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
1530
1228
d63e0185a90f release buffer cleanup
michaelni
parents: 1225
diff changeset
1531 if(s->encoding){
d63e0185a90f release buffer cleanup
michaelni
parents: 1225
diff changeset
1532 /* release non refernce frames */
d63e0185a90f release buffer cleanup
michaelni
parents: 1225
diff changeset
1533 for(i=0; i<MAX_PICTURE_COUNT; i++){
d63e0185a90f release buffer cleanup
michaelni
parents: 1225
diff changeset
1534 if(s->picture[i].data[0] && !s->picture[i].reference /*&& s->picture[i].type!=FF_BUFFER_TYPE_SHARED*/){
d63e0185a90f release buffer cleanup
michaelni
parents: 1225
diff changeset
1535 s->avctx->release_buffer(s->avctx, (AVFrame*)&s->picture[i]);
d63e0185a90f release buffer cleanup
michaelni
parents: 1225
diff changeset
1536 }
d63e0185a90f release buffer cleanup
michaelni
parents: 1225
diff changeset
1537 }
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
1538 }
1138
e10e841c9bf0 field pic decoding cleanup
michaelni
parents: 1130
diff changeset
1539 // clear copies, to avoid confusion
e10e841c9bf0 field pic decoding cleanup
michaelni
parents: 1130
diff changeset
1540 #if 0
e10e841c9bf0 field pic decoding cleanup
michaelni
parents: 1130
diff changeset
1541 memset(&s->last_picture, 0, sizeof(Picture));
e10e841c9bf0 field pic decoding cleanup
michaelni
parents: 1130
diff changeset
1542 memset(&s->next_picture, 0, sizeof(Picture));
e10e841c9bf0 field pic decoding cleanup
michaelni
parents: 1130
diff changeset
1543 memset(&s->current_picture, 0, sizeof(Picture));
e10e841c9bf0 field pic decoding cleanup
michaelni
parents: 1130
diff changeset
1544 #endif
903
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
1545 }
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
1546
1177
fea03d2c4946 simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents: 1173
diff changeset
1547 /**
1285
6e039762d5cb motion vector vissualization for mpeg1/2
michaelni
parents: 1273
diff changeset
1548 * draws an line from (ex, ey) -> (sx, sy).
6e039762d5cb motion vector vissualization for mpeg1/2
michaelni
parents: 1273
diff changeset
1549 * @param w width of the image
6e039762d5cb motion vector vissualization for mpeg1/2
michaelni
parents: 1273
diff changeset
1550 * @param h height of the image
6e039762d5cb motion vector vissualization for mpeg1/2
michaelni
parents: 1273
diff changeset
1551 * @param stride stride/linesize of the image
6e039762d5cb motion vector vissualization for mpeg1/2
michaelni
parents: 1273
diff changeset
1552 * @param color color of the arrow
6e039762d5cb motion vector vissualization for mpeg1/2
michaelni
parents: 1273
diff changeset
1553 */
6e039762d5cb motion vector vissualization for mpeg1/2
michaelni
parents: 1273
diff changeset
1554 static void draw_line(uint8_t *buf, int sx, int sy, int ex, int ey, int w, int h, int stride, int color){
1918
ea20f38b8d57 nicer looking arrows for the motion vector vissualization
michael
parents: 1916
diff changeset
1555 int t, x, y, fr, f;
1285
6e039762d5cb motion vector vissualization for mpeg1/2
michaelni
parents: 1273
diff changeset
1556
6e039762d5cb motion vector vissualization for mpeg1/2
michaelni
parents: 1273
diff changeset
1557 sx= clip(sx, 0, w-1);
6e039762d5cb motion vector vissualization for mpeg1/2
michaelni
parents: 1273
diff changeset
1558 sy= clip(sy, 0, h-1);
6e039762d5cb motion vector vissualization for mpeg1/2
michaelni
parents: 1273
diff changeset
1559 ex= clip(ex, 0, w-1);
6e039762d5cb motion vector vissualization for mpeg1/2
michaelni
parents: 1273
diff changeset
1560 ey= clip(ey, 0, h-1);
6e039762d5cb motion vector vissualization for mpeg1/2
michaelni
parents: 1273
diff changeset
1561
6e039762d5cb motion vector vissualization for mpeg1/2
michaelni
parents: 1273
diff changeset
1562 buf[sy*stride + sx]+= color;
6e039762d5cb motion vector vissualization for mpeg1/2
michaelni
parents: 1273
diff changeset
1563
6e039762d5cb motion vector vissualization for mpeg1/2
michaelni
parents: 1273
diff changeset
1564 if(ABS(ex - sx) > ABS(ey - sy)){
6e039762d5cb motion vector vissualization for mpeg1/2
michaelni
parents: 1273
diff changeset
1565 if(sx > ex){
6e039762d5cb motion vector vissualization for mpeg1/2
michaelni
parents: 1273
diff changeset
1566 t=sx; sx=ex; ex=t;
6e039762d5cb motion vector vissualization for mpeg1/2
michaelni
parents: 1273
diff changeset
1567 t=sy; sy=ey; ey=t;
6e039762d5cb motion vector vissualization for mpeg1/2
michaelni
parents: 1273
diff changeset
1568 }
6e039762d5cb motion vector vissualization for mpeg1/2
michaelni
parents: 1273
diff changeset
1569 buf+= sx + sy*stride;
6e039762d5cb motion vector vissualization for mpeg1/2
michaelni
parents: 1273
diff changeset
1570 ex-= sx;
6e039762d5cb motion vector vissualization for mpeg1/2
michaelni
parents: 1273
diff changeset
1571 f= ((ey-sy)<<16)/ex;
6e039762d5cb motion vector vissualization for mpeg1/2
michaelni
parents: 1273
diff changeset
1572 for(x= 0; x <= ex; x++){
1918
ea20f38b8d57 nicer looking arrows for the motion vector vissualization
michael
parents: 1916
diff changeset
1573 y = (x*f)>>16;
ea20f38b8d57 nicer looking arrows for the motion vector vissualization
michael
parents: 1916
diff changeset
1574 fr= (x*f)&0xFFFF;
ea20f38b8d57 nicer looking arrows for the motion vector vissualization
michael
parents: 1916
diff changeset
1575 buf[ y *stride + x]+= (color*(0x10000-fr))>>16;
ea20f38b8d57 nicer looking arrows for the motion vector vissualization
michael
parents: 1916
diff changeset
1576 buf[(y+1)*stride + x]+= (color* fr )>>16;
1285
6e039762d5cb motion vector vissualization for mpeg1/2
michaelni
parents: 1273
diff changeset
1577 }
6e039762d5cb motion vector vissualization for mpeg1/2
michaelni
parents: 1273
diff changeset
1578 }else{
6e039762d5cb motion vector vissualization for mpeg1/2
michaelni
parents: 1273
diff changeset
1579 if(sy > ey){
6e039762d5cb motion vector vissualization for mpeg1/2
michaelni
parents: 1273
diff changeset
1580 t=sx; sx=ex; ex=t;
6e039762d5cb motion vector vissualization for mpeg1/2
michaelni
parents: 1273
diff changeset
1581 t=sy; sy=ey; ey=t;
6e039762d5cb motion vector vissualization for mpeg1/2
michaelni
parents: 1273
diff changeset
1582 }
6e039762d5cb motion vector vissualization for mpeg1/2
michaelni
parents: 1273
diff changeset
1583 buf+= sx + sy*stride;
6e039762d5cb motion vector vissualization for mpeg1/2
michaelni
parents: 1273
diff changeset
1584 ey-= sy;
6e039762d5cb motion vector vissualization for mpeg1/2
michaelni
parents: 1273
diff changeset
1585 if(ey) f= ((ex-sx)<<16)/ey;
6e039762d5cb motion vector vissualization for mpeg1/2
michaelni
parents: 1273
diff changeset
1586 else f= 0;
6e039762d5cb motion vector vissualization for mpeg1/2
michaelni
parents: 1273
diff changeset
1587 for(y= 0; y <= ey; y++){
1918
ea20f38b8d57 nicer looking arrows for the motion vector vissualization
michael
parents: 1916
diff changeset
1588 x = (y*f)>>16;
ea20f38b8d57 nicer looking arrows for the motion vector vissualization
michael
parents: 1916
diff changeset
1589 fr= (y*f)&0xFFFF;
ea20f38b8d57 nicer looking arrows for the motion vector vissualization
michael
parents: 1916
diff changeset
1590 buf[y*stride + x ]+= (color*(0x10000-fr))>>16;;
ea20f38b8d57 nicer looking arrows for the motion vector vissualization
michael
parents: 1916
diff changeset
1591 buf[y*stride + x+1]+= (color* fr )>>16;;
1285
6e039762d5cb motion vector vissualization for mpeg1/2
michaelni
parents: 1273
diff changeset
1592 }
6e039762d5cb motion vector vissualization for mpeg1/2
michaelni
parents: 1273
diff changeset
1593 }
6e039762d5cb motion vector vissualization for mpeg1/2
michaelni
parents: 1273
diff changeset
1594 }
6e039762d5cb motion vector vissualization for mpeg1/2
michaelni
parents: 1273
diff changeset
1595
6e039762d5cb motion vector vissualization for mpeg1/2
michaelni
parents: 1273
diff changeset
1596 /**
6e039762d5cb motion vector vissualization for mpeg1/2
michaelni
parents: 1273
diff changeset
1597 * draws an arrow from (ex, ey) -> (sx, sy).
6e039762d5cb motion vector vissualization for mpeg1/2
michaelni
parents: 1273
diff changeset
1598 * @param w width of the image
6e039762d5cb motion vector vissualization for mpeg1/2
michaelni
parents: 1273
diff changeset
1599 * @param h height of the image
6e039762d5cb motion vector vissualization for mpeg1/2
michaelni
parents: 1273
diff changeset
1600 * @param stride stride/linesize of the image
6e039762d5cb motion vector vissualization for mpeg1/2
michaelni
parents: 1273
diff changeset
1601 * @param color color of the arrow
6e039762d5cb motion vector vissualization for mpeg1/2
michaelni
parents: 1273
diff changeset
1602 */
6e039762d5cb motion vector vissualization for mpeg1/2
michaelni
parents: 1273
diff changeset
1603 static void draw_arrow(uint8_t *buf, int sx, int sy, int ex, int ey, int w, int h, int stride, int color){
6e039762d5cb motion vector vissualization for mpeg1/2
michaelni
parents: 1273
diff changeset
1604 int dx,dy;
6e039762d5cb motion vector vissualization for mpeg1/2
michaelni
parents: 1273
diff changeset
1605
6e039762d5cb motion vector vissualization for mpeg1/2
michaelni
parents: 1273
diff changeset
1606 sx= clip(sx, -100, w+100);
6e039762d5cb motion vector vissualization for mpeg1/2
michaelni
parents: 1273
diff changeset
1607 sy= clip(sy, -100, h+100);
6e039762d5cb motion vector vissualization for mpeg1/2
michaelni
parents: 1273
diff changeset
1608 ex= clip(ex, -100, w+100);
6e039762d5cb motion vector vissualization for mpeg1/2
michaelni
parents: 1273
diff changeset
1609 ey= clip(ey, -100, h+100);
6e039762d5cb motion vector vissualization for mpeg1/2
michaelni
parents: 1273
diff changeset
1610
6e039762d5cb motion vector vissualization for mpeg1/2
michaelni
parents: 1273
diff changeset
1611 dx= ex - sx;
6e039762d5cb motion vector vissualization for mpeg1/2
michaelni
parents: 1273
diff changeset
1612 dy= ey - sy;
6e039762d5cb motion vector vissualization for mpeg1/2
michaelni
parents: 1273
diff changeset
1613
6e039762d5cb motion vector vissualization for mpeg1/2
michaelni
parents: 1273
diff changeset
1614 if(dx*dx + dy*dy > 3*3){
6e039762d5cb motion vector vissualization for mpeg1/2
michaelni
parents: 1273
diff changeset
1615 int rx= dx + dy;
6e039762d5cb motion vector vissualization for mpeg1/2
michaelni
parents: 1273
diff changeset
1616 int ry= -dx + dy;
6e039762d5cb motion vector vissualization for mpeg1/2
michaelni
parents: 1273
diff changeset
1617 int length= ff_sqrt((rx*rx + ry*ry)<<8);
6e039762d5cb motion vector vissualization for mpeg1/2
michaelni
parents: 1273
diff changeset
1618
6e039762d5cb motion vector vissualization for mpeg1/2
michaelni
parents: 1273
diff changeset
1619 //FIXME subpixel accuracy
6e039762d5cb motion vector vissualization for mpeg1/2
michaelni
parents: 1273
diff changeset
1620 rx= ROUNDED_DIV(rx*3<<4, length);
6e039762d5cb motion vector vissualization for mpeg1/2
michaelni
parents: 1273
diff changeset
1621 ry= ROUNDED_DIV(ry*3<<4, length);
6e039762d5cb motion vector vissualization for mpeg1/2
michaelni
parents: 1273
diff changeset
1622
6e039762d5cb motion vector vissualization for mpeg1/2
michaelni
parents: 1273
diff changeset
1623 draw_line(buf, sx, sy, sx + rx, sy + ry, w, h, stride, color);
6e039762d5cb motion vector vissualization for mpeg1/2
michaelni
parents: 1273
diff changeset
1624 draw_line(buf, sx, sy, sx - ry, sy + rx, w, h, stride, color);
6e039762d5cb motion vector vissualization for mpeg1/2
michaelni
parents: 1273
diff changeset
1625 }
6e039762d5cb motion vector vissualization for mpeg1/2
michaelni
parents: 1273
diff changeset
1626 draw_line(buf, sx, sy, ex, ey, w, h, stride, color);
6e039762d5cb motion vector vissualization for mpeg1/2
michaelni
parents: 1273
diff changeset
1627 }
6e039762d5cb motion vector vissualization for mpeg1/2
michaelni
parents: 1273
diff changeset
1628
6e039762d5cb motion vector vissualization for mpeg1/2
michaelni
parents: 1273
diff changeset
1629 /**
1177
fea03d2c4946 simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents: 1173
diff changeset
1630 * 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
1631 */
1706
3ba5c493db6f motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents: 1705
diff changeset
1632 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
1633
fea03d2c4946 simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents: 1173
diff changeset
1634 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
1635
fea03d2c4946 simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents: 1173
diff changeset
1636 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
1637 int x,y;
1706
3ba5c493db6f motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents: 1705
diff changeset
1638
3ba5c493db6f motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents: 1705
diff changeset
1639 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
1640 switch (pict->pict_type) {
3ba5c493db6f motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents: 1705
diff changeset
1641 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
1642 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
1643 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
1644 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
1645 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
1646 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
1647 }
1177
fea03d2c4946 simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents: 1173
diff changeset
1648 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
1649 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
1650 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
1651 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
1652 if(count>9) count=9;
1598
932d306bf1dc av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents: 1597
diff changeset
1653 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
1654 }
fea03d2c4946 simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents: 1173
diff changeset
1655 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
1656 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
1657 }
fea03d2c4946 simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents: 1173
diff changeset
1658 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
1659 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
1660 //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
1661 if(IS_PCM(mb_type))
1598
932d306bf1dc av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents: 1597
diff changeset
1662 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
1663 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
1664 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
1665 else if(IS_INTRA4x4(mb_type))
1598
932d306bf1dc av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents: 1597
diff changeset
1666 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
1667 else if(IS_INTRA16x16(mb_type))
1598
932d306bf1dc av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents: 1597
diff changeset
1668 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
1669 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
1670 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
1671 else if(IS_DIRECT(mb_type))
1598
932d306bf1dc av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents: 1597
diff changeset
1672 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
1673 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
1674 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
1675 else if(IS_GMC(mb_type))
1598
932d306bf1dc av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents: 1597
diff changeset
1676 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
1677 else if(IS_SKIP(mb_type))
1598
932d306bf1dc av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents: 1597
diff changeset
1678 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
1679 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
1680 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
1681 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
1682 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
1683 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
1684 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
1685 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
1686 }
fea03d2c4946 simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents: 1173
diff changeset
1687
fea03d2c4946 simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents: 1173
diff changeset
1688 //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
1689 if(IS_8X8(mb_type))
1598
932d306bf1dc av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents: 1597
diff changeset
1690 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
1691 else if(IS_16X8(mb_type))
1598
932d306bf1dc av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents: 1597
diff changeset
1692 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
1693 else if(IS_8X16(mb_type))
1598
932d306bf1dc av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents: 1597
diff changeset
1694 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
1695 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
1696 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
1697 else
1598
932d306bf1dc av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents: 1597
diff changeset
1698 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
1699
fea03d2c4946 simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents: 1173
diff changeset
1700
fea03d2c4946 simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents: 1173
diff changeset
1701 if(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
1702 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
1703 else
1598
932d306bf1dc av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents: 1597
diff changeset
1704 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
1705 }
1598
932d306bf1dc av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents: 1597
diff changeset
1706 // 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
1707 }
1598
932d306bf1dc av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents: 1597
diff changeset
1708 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
1709 }
fea03d2c4946 simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents: 1173
diff changeset
1710 }
1668
30746f429df6 move motion_val & mb_type to AVFrame patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents: 1662
diff changeset
1711
1706
3ba5c493db6f motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents: 1705
diff changeset
1712 if((s->avctx->debug&(FF_DEBUG_VIS_QP|FF_DEBUG_VIS_MB_TYPE)) || (s->avctx->debug_mv)){
1285
6e039762d5cb motion vector vissualization for mpeg1/2
michaelni
parents: 1273
diff changeset
1713 const int shift= 1 + s->quarter_sample;
6e039762d5cb motion vector vissualization for mpeg1/2
michaelni
parents: 1273
diff changeset
1714 int mb_y;
1706
3ba5c493db6f motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents: 1705
diff changeset
1715 uint8_t *ptr;
1707
027545a2fdbe 100000l
michael
parents: 1706
diff changeset
1716 int i;
1723
033d889d7c2c non YV12 vissualization fix by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents: 1722
diff changeset
1717 int h_chroma_shift, v_chroma_shift;
1285
6e039762d5cb motion vector vissualization for mpeg1/2
michaelni
parents: 1273
diff changeset
1718 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
1719
1723
033d889d7c2c non YV12 vissualization fix by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents: 1722
diff changeset
1720 avcodec_get_chroma_sub_sample(s->avctx->pix_fmt, &h_chroma_shift, &v_chroma_shift);
1706
3ba5c493db6f motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents: 1705
diff changeset
1721 for(i=0; i<3; i++){
1723
033d889d7c2c non YV12 vissualization fix by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents: 1722
diff changeset
1722 memcpy(s->visualization_buffer[i], pict->data[i], (i==0) ? pict->linesize[i]*s->height:pict->linesize[i]*s->height >> v_chroma_shift);
1706
3ba5c493db6f motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents: 1705
diff changeset
1723 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
1724 }
3ba5c493db6f motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents: 1705
diff changeset
1725 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
1726 ptr= pict->data[0];
1285
6e039762d5cb motion vector vissualization for mpeg1/2
michaelni
parents: 1273
diff changeset
1727
6e039762d5cb motion vector vissualization for mpeg1/2
michaelni
parents: 1273
diff changeset
1728 for(mb_y=0; mb_y<s->mb_height; mb_y++){
6e039762d5cb motion vector vissualization for mpeg1/2
michaelni
parents: 1273
diff changeset
1729 int mb_x;
6e039762d5cb motion vector vissualization for mpeg1/2
michaelni
parents: 1273
diff changeset
1730 for(mb_x=0; mb_x<s->mb_width; mb_x++){
6e039762d5cb motion vector vissualization for mpeg1/2
michaelni
parents: 1273
diff changeset
1731 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
1732 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
1733 int type;
3ba5c493db6f motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents: 1705
diff changeset
1734 for(type=0; type<3; type++){
2024
f65d87bfdd5a some of the warning fixes by (Michael Roitzsch <mroi at users dot sourceforge dot net>)
michael
parents: 2015
diff changeset
1735 int direction = 0;
1706
3ba5c493db6f motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents: 1705
diff changeset
1736 switch (type) {
3ba5c493db6f motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents: 1705
diff changeset
1737 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
1738 continue;
3ba5c493db6f motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents: 1705
diff changeset
1739 direction = 0;
3ba5c493db6f motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents: 1705
diff changeset
1740 break;
3ba5c493db6f motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents: 1705
diff changeset
1741 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
1742 continue;
3ba5c493db6f motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents: 1705
diff changeset
1743 direction = 0;
3ba5c493db6f motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents: 1705
diff changeset
1744 break;
3ba5c493db6f motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents: 1705
diff changeset
1745 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
1746 continue;
3ba5c493db6f motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents: 1705
diff changeset
1747 direction = 1;
3ba5c493db6f motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents: 1705
diff changeset
1748 break;
3ba5c493db6f motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents: 1705
diff changeset
1749 }
1712
5175116a97e8 dont show uninitalized motion vectors
michael
parents: 1711
diff changeset
1750 if(!USES_LIST(pict->mb_type[mb_index], direction))
5175116a97e8 dont show uninitalized motion vectors
michael
parents: 1711
diff changeset
1751 continue;
5175116a97e8 dont show uninitalized motion vectors
michael
parents: 1711
diff changeset
1752
1938
e2501e6e7ff7 unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents: 1918
diff changeset
1753 //FIXME for h264
1706
3ba5c493db6f motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents: 1705
diff changeset
1754 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
1755 int i;
3ba5c493db6f motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents: 1705
diff changeset
1756 for(i=0; i<4; i++){
1285
6e039762d5cb motion vector vissualization for mpeg1/2
michaelni
parents: 1273
diff changeset
1757 int sx= mb_x*16 + 4 + 8*(i&1);
6e039762d5cb motion vector vissualization for mpeg1/2
michaelni
parents: 1273
diff changeset
1758 int sy= mb_y*16 + 4 + 8*(i>>1);
1938
e2501e6e7ff7 unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents: 1918
diff changeset
1759 int xy= mb_x*2 + (i&1) + (mb_y*2 + (i>>1))*s->b8_stride;
1706
3ba5c493db6f motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents: 1705
diff changeset
1760 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
1761 int my= (pict->motion_val[direction][xy][1]>>shift) + sy;
1285
6e039762d5cb motion vector vissualization for mpeg1/2
michaelni
parents: 1273
diff changeset
1762 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
1763 }
3ba5c493db6f motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents: 1705
diff changeset
1764 }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
1765 int i;
3ba5c493db6f motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents: 1705
diff changeset
1766 for(i=0; i<2; i++){
1629
74685a0ec851 16x8 MV vissualization by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents: 1628
diff changeset
1767 int sx=mb_x*16 + 8;
74685a0ec851 16x8 MV vissualization by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents: 1628
diff changeset
1768 int sy=mb_y*16 + 4 + 8*i;
1938
e2501e6e7ff7 unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents: 1918
diff changeset
1769 int xy= mb_x*2 + (mb_y*2 + i)*s->b8_stride;
1947
b306574523ad fix y scale of mv vissualization of interlaced MVs
michael
parents: 1945
diff changeset
1770 int mx=(pict->motion_val[direction][xy][0]>>shift);
b306574523ad fix y scale of mv vissualization of interlaced MVs
michael
parents: 1945
diff changeset
1771 int my=(pict->motion_val[direction][xy][1]>>shift);
b306574523ad fix y scale of mv vissualization of interlaced MVs
michael
parents: 1945
diff changeset
1772
b306574523ad fix y scale of mv vissualization of interlaced MVs
michael
parents: 1945
diff changeset
1773 if(IS_INTERLACED(pict->mb_type[mb_index]))
b306574523ad fix y scale of mv vissualization of interlaced MVs
michael
parents: 1945
diff changeset
1774 my*=2;
b306574523ad fix y scale of mv vissualization of interlaced MVs
michael
parents: 1945
diff changeset
1775
b306574523ad fix y scale of mv vissualization of interlaced MVs
michael
parents: 1945
diff changeset
1776 draw_arrow(ptr, sx, sy, mx+sx, my+sy, 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
1777 }
3ba5c493db6f motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents: 1705
diff changeset
1778 }else{
3ba5c493db6f motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents: 1705
diff changeset
1779 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
1780 int sy= mb_y*16 + 8;
1938
e2501e6e7ff7 unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents: 1918
diff changeset
1781 int xy= mb_x*2 + mb_y*2*s->b8_stride;
1706
3ba5c493db6f motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents: 1705
diff changeset
1782 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
1783 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
1784 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
1785 }
1706
3ba5c493db6f motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents: 1705
diff changeset
1786 }
1685
cb09cf265a87 mb type & qp vissualization
michael
parents: 1684
diff changeset
1787 }
cb09cf265a87 mb type & qp vissualization
michael
parents: 1684
diff changeset
1788 if((s->avctx->debug&FF_DEBUG_VIS_QP) && pict->motion_val){
cb09cf265a87 mb type & qp vissualization
michael
parents: 1684
diff changeset
1789 uint64_t c= (pict->qscale_table[mb_index]*128/31) * 0x0101010101010101ULL;
cb09cf265a87 mb type & qp vissualization
michael
parents: 1684
diff changeset
1790 int y;
cb09cf265a87 mb type & qp vissualization
michael
parents: 1684
diff changeset
1791 for(y=0; y<8; y++){
cb09cf265a87 mb type & qp vissualization
michael
parents: 1684
diff changeset
1792 *(uint64_t*)(pict->data[1] + 8*mb_x + (8*mb_y + y)*pict->linesize[1])= c;
cb09cf265a87 mb type & qp vissualization
michael
parents: 1684
diff changeset
1793 *(uint64_t*)(pict->data[2] + 8*mb_x + (8*mb_y + y)*pict->linesize[2])= c;
cb09cf265a87 mb type & qp vissualization
michael
parents: 1684
diff changeset
1794 }
cb09cf265a87 mb type & qp vissualization
michael
parents: 1684
diff changeset
1795 }
cb09cf265a87 mb type & qp vissualization
michael
parents: 1684
diff changeset
1796 if((s->avctx->debug&FF_DEBUG_VIS_MB_TYPE) && pict->motion_val){
cb09cf265a87 mb type & qp vissualization
michael
parents: 1684
diff changeset
1797 int mb_type= pict->mb_type[mb_index];
cb09cf265a87 mb type & qp vissualization
michael
parents: 1684
diff changeset
1798 uint64_t u,v;
cb09cf265a87 mb type & qp vissualization
michael
parents: 1684
diff changeset
1799 int y;
cb09cf265a87 mb type & qp vissualization
michael
parents: 1684
diff changeset
1800 #define COLOR(theta, r)\
cb09cf265a87 mb type & qp vissualization
michael
parents: 1684
diff changeset
1801 u= (int)(128 + r*cos(theta*3.141592/180));\
cb09cf265a87 mb type & qp vissualization
michael
parents: 1684
diff changeset
1802 v= (int)(128 + r*sin(theta*3.141592/180));
cb09cf265a87 mb type & qp vissualization
michael
parents: 1684
diff changeset
1803
cb09cf265a87 mb type & qp vissualization
michael
parents: 1684
diff changeset
1804
cb09cf265a87 mb type & qp vissualization
michael
parents: 1684
diff changeset
1805 u=v=128;
cb09cf265a87 mb type & qp vissualization
michael
parents: 1684
diff changeset
1806 if(IS_PCM(mb_type)){
cb09cf265a87 mb type & qp vissualization
michael
parents: 1684
diff changeset
1807 COLOR(120,48)
cb09cf265a87 mb type & qp vissualization
michael
parents: 1684
diff changeset
1808 }else if((IS_INTRA(mb_type) && IS_ACPRED(mb_type)) || IS_INTRA16x16(mb_type)){
cb09cf265a87 mb type & qp vissualization
michael
parents: 1684
diff changeset
1809 COLOR(30,48)
cb09cf265a87 mb type & qp vissualization
michael
parents: 1684
diff changeset
1810 }else if(IS_INTRA4x4(mb_type)){
cb09cf265a87 mb type & qp vissualization
michael
parents: 1684
diff changeset
1811 COLOR(90,48)
cb09cf265a87 mb type & qp vissualization
michael
parents: 1684
diff changeset
1812 }else if(IS_DIRECT(mb_type) && IS_SKIP(mb_type)){
cb09cf265a87 mb type & qp vissualization
michael
parents: 1684
diff changeset
1813 // COLOR(120,48)
cb09cf265a87 mb type & qp vissualization
michael
parents: 1684
diff changeset
1814 }else if(IS_DIRECT(mb_type)){
cb09cf265a87 mb type & qp vissualization
michael
parents: 1684
diff changeset
1815 COLOR(150,48)
cb09cf265a87 mb type & qp vissualization
michael
parents: 1684
diff changeset
1816 }else if(IS_GMC(mb_type) && IS_SKIP(mb_type)){
cb09cf265a87 mb type & qp vissualization
michael
parents: 1684
diff changeset
1817 COLOR(170,48)
cb09cf265a87 mb type & qp vissualization
michael
parents: 1684
diff changeset
1818 }else if(IS_GMC(mb_type)){
cb09cf265a87 mb type & qp vissualization
michael
parents: 1684
diff changeset
1819 COLOR(190,48)
cb09cf265a87 mb type & qp vissualization
michael
parents: 1684
diff changeset
1820 }else if(IS_SKIP(mb_type)){
cb09cf265a87 mb type & qp vissualization
michael
parents: 1684
diff changeset
1821 // COLOR(180,48)
cb09cf265a87 mb type & qp vissualization
michael
parents: 1684
diff changeset
1822 }else if(!USES_LIST(mb_type, 1)){
cb09cf265a87 mb type & qp vissualization
michael
parents: 1684
diff changeset
1823 COLOR(240,48)
cb09cf265a87 mb type & qp vissualization
michael
parents: 1684
diff changeset
1824 }else if(!USES_LIST(mb_type, 0)){
cb09cf265a87 mb type & qp vissualization
michael
parents: 1684
diff changeset
1825 COLOR(0,48)
cb09cf265a87 mb type & qp vissualization
michael
parents: 1684
diff changeset
1826 }else{
cb09cf265a87 mb type & qp vissualization
michael
parents: 1684
diff changeset
1827 assert(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
cb09cf265a87 mb type & qp vissualization
michael
parents: 1684
diff changeset
1828 COLOR(300,48)
cb09cf265a87 mb type & qp vissualization
michael
parents: 1684
diff changeset
1829 }
cb09cf265a87 mb type & qp vissualization
michael
parents: 1684
diff changeset
1830
cb09cf265a87 mb type & qp vissualization
michael
parents: 1684
diff changeset
1831 u*= 0x0101010101010101ULL;
cb09cf265a87 mb type & qp vissualization
michael
parents: 1684
diff changeset
1832 v*= 0x0101010101010101ULL;
cb09cf265a87 mb type & qp vissualization
michael
parents: 1684
diff changeset
1833 for(y=0; y<8; y++){
cb09cf265a87 mb type & qp vissualization
michael
parents: 1684
diff changeset
1834 *(uint64_t*)(pict->data[1] + 8*mb_x + (8*mb_y + y)*pict->linesize[1])= u;
cb09cf265a87 mb type & qp vissualization
michael
parents: 1684
diff changeset
1835 *(uint64_t*)(pict->data[2] + 8*mb_x + (8*mb_y + y)*pict->linesize[2])= v;
cb09cf265a87 mb type & qp vissualization
michael
parents: 1684
diff changeset
1836 }
cb09cf265a87 mb type & qp vissualization
michael
parents: 1684
diff changeset
1837
cb09cf265a87 mb type & qp vissualization
michael
parents: 1684
diff changeset
1838 //segmentation
cb09cf265a87 mb type & qp vissualization
michael
parents: 1684
diff changeset
1839 if(IS_8X8(mb_type) || IS_16X8(mb_type)){
cb09cf265a87 mb type & qp vissualization
michael
parents: 1684
diff changeset
1840 *(uint64_t*)(pict->data[0] + 16*mb_x + 0 + (16*mb_y + 8)*pict->linesize[0])^= 0x8080808080808080ULL;
cb09cf265a87 mb type & qp vissualization
michael
parents: 1684
diff changeset
1841 *(uint64_t*)(pict->data[0] + 16*mb_x + 8 + (16*mb_y + 8)*pict->linesize[0])^= 0x8080808080808080ULL;
cb09cf265a87 mb type & qp vissualization
michael
parents: 1684
diff changeset
1842 }
cb09cf265a87 mb type & qp vissualization
michael
parents: 1684
diff changeset
1843 if(IS_8X8(mb_type) || IS_8X16(mb_type)){
cb09cf265a87 mb type & qp vissualization
michael
parents: 1684
diff changeset
1844 for(y=0; y<16; y++)
cb09cf265a87 mb type & qp vissualization
michael
parents: 1684
diff changeset
1845 pict->data[0][16*mb_x + 8 + (16*mb_y + y)*pict->linesize[0]]^= 0x80;
cb09cf265a87 mb type & qp vissualization
michael
parents: 1684
diff changeset
1846 }
cb09cf265a87 mb type & qp vissualization
michael
parents: 1684
diff changeset
1847
cb09cf265a87 mb type & qp vissualization
michael
parents: 1684
diff changeset
1848 if(IS_INTERLACED(mb_type) && s->codec_id == CODEC_ID_H264){
cb09cf265a87 mb type & qp vissualization
michael
parents: 1684
diff changeset
1849 // hmm
cb09cf265a87 mb type & qp vissualization
michael
parents: 1684
diff changeset
1850 }
1285
6e039762d5cb motion vector vissualization for mpeg1/2
michaelni
parents: 1273
diff changeset
1851 }
6e039762d5cb motion vector vissualization for mpeg1/2
michaelni
parents: 1273
diff changeset
1852 s->mbskip_table[mb_index]=0;
6e039762d5cb motion vector vissualization for mpeg1/2
michaelni
parents: 1273
diff changeset
1853 }
6e039762d5cb motion vector vissualization for mpeg1/2
michaelni
parents: 1273
diff changeset
1854 }
6e039762d5cb motion vector vissualization for mpeg1/2
michaelni
parents: 1273
diff changeset
1855 }
1177
fea03d2c4946 simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents: 1173
diff changeset
1856 }
fea03d2c4946 simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents: 1173
diff changeset
1857
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
1858 #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
1859
915
75ee49a4a516 fixing 2pass assert failure
michaelni
parents: 912
diff changeset
1860 static int get_sae(uint8_t *src, int ref, int stride){
75ee49a4a516 fixing 2pass assert failure
michaelni
parents: 912
diff changeset
1861 int x,y;
75ee49a4a516 fixing 2pass assert failure
michaelni
parents: 912
diff changeset
1862 int acc=0;
75ee49a4a516 fixing 2pass assert failure
michaelni
parents: 912
diff changeset
1863
75ee49a4a516 fixing 2pass assert failure
michaelni
parents: 912
diff changeset
1864 for(y=0; y<16; y++){
75ee49a4a516 fixing 2pass assert failure
michaelni
parents: 912
diff changeset
1865 for(x=0; x<16; x++){
75ee49a4a516 fixing 2pass assert failure
michaelni
parents: 912
diff changeset
1866 acc+= ABS(src[x+y*stride] - ref);
75ee49a4a516 fixing 2pass assert failure
michaelni
parents: 912
diff changeset
1867 }
75ee49a4a516 fixing 2pass assert failure
michaelni
parents: 912
diff changeset
1868 }
75ee49a4a516 fixing 2pass assert failure
michaelni
parents: 912
diff changeset
1869
75ee49a4a516 fixing 2pass assert failure
michaelni
parents: 912
diff changeset
1870 return acc;
75ee49a4a516 fixing 2pass assert failure
michaelni
parents: 912
diff changeset
1871 }
75ee49a4a516 fixing 2pass assert failure
michaelni
parents: 912
diff changeset
1872
75ee49a4a516 fixing 2pass assert failure
michaelni
parents: 912
diff changeset
1873 static int get_intra_count(MpegEncContext *s, uint8_t *src, uint8_t *ref, int stride){
75ee49a4a516 fixing 2pass assert failure
michaelni
parents: 912
diff changeset
1874 int x, y, w, h;
75ee49a4a516 fixing 2pass assert failure
michaelni
parents: 912
diff changeset
1875 int acc=0;
75ee49a4a516 fixing 2pass assert failure
michaelni
parents: 912
diff changeset
1876
75ee49a4a516 fixing 2pass assert failure
michaelni
parents: 912
diff changeset
1877 w= s->width &~15;
75ee49a4a516 fixing 2pass assert failure
michaelni
parents: 912
diff changeset
1878 h= s->height&~15;
75ee49a4a516 fixing 2pass assert failure
michaelni
parents: 912
diff changeset
1879
75ee49a4a516 fixing 2pass assert failure
michaelni
parents: 912
diff changeset
1880 for(y=0; y<h; y+=16){
75ee49a4a516 fixing 2pass assert failure
michaelni
parents: 912
diff changeset
1881 for(x=0; x<w; x+=16){
75ee49a4a516 fixing 2pass assert failure
michaelni
parents: 912
diff changeset
1882 int offset= x + y*stride;
1708
dea5b2946999 interlaced motion estimation
michael
parents: 1707
diff changeset
1883 int sad = s->dsp.sad[0](NULL, src + offset, ref + offset, stride, 16);
915
75ee49a4a516 fixing 2pass assert failure
michaelni
parents: 912
diff changeset
1884 int mean= (s->dsp.pix_sum(src + offset, stride) + 128)>>8;
75ee49a4a516 fixing 2pass assert failure
michaelni
parents: 912
diff changeset
1885 int sae = get_sae(src + offset, mean, stride);
75ee49a4a516 fixing 2pass assert failure
michaelni
parents: 912
diff changeset
1886
75ee49a4a516 fixing 2pass assert failure
michaelni
parents: 912
diff changeset
1887 acc+= sae + 500 < sad;
75ee49a4a516 fixing 2pass assert failure
michaelni
parents: 912
diff changeset
1888 }
75ee49a4a516 fixing 2pass assert failure
michaelni
parents: 912
diff changeset
1889 }
75ee49a4a516 fixing 2pass assert failure
michaelni
parents: 912
diff changeset
1890 return acc;
75ee49a4a516 fixing 2pass assert failure
michaelni
parents: 912
diff changeset
1891 }
75ee49a4a516 fixing 2pass assert failure
michaelni
parents: 912
diff changeset
1892
924
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
1893
925
7fccaa0d699d AVVideoFrame -> AVFrame
michaelni
parents: 924
diff changeset
1894 static int load_input_picture(MpegEncContext *s, AVFrame *pic_arg){
1373
b47a402bbe7f last frames & b frames encoding fix
michaelni
parents: 1370
diff changeset
1895 AVFrame *pic=NULL;
924
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
1896 int i;
903
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
1897 const int encoding_delay= s->max_b_frames;
924
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
1898 int direct=1;
1373
b47a402bbe7f last frames & b frames encoding fix
michaelni
parents: 1370
diff changeset
1899
b47a402bbe7f last frames & b frames encoding fix
michaelni
parents: 1370
diff changeset
1900 if(pic_arg){
924
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
1901 if(encoding_delay && !(s->flags&CODEC_FLAG_INPUT_PRESERVED)) direct=0;
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
1902 if(pic_arg->linesize[0] != s->linesize) direct=0;
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
1903 if(pic_arg->linesize[1] != s->uvlinesize) direct=0;
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
1904 if(pic_arg->linesize[2] != s->uvlinesize) direct=0;
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
1905
1598
932d306bf1dc av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents: 1597
diff changeset
1906 // av_log(AV_LOG_DEBUG, "%d %d %d %d\n",pic_arg->linesize[0], pic_arg->linesize[1], s->linesize, s->uvlinesize);
924
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
1907
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
1908 if(direct){
1586
3d1d0490e5a6 pts fix and related fixes
michael
parents: 1580
diff changeset
1909 i= ff_find_unused_picture(s, 1);
924
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
1910
925
7fccaa0d699d AVVideoFrame -> AVFrame
michaelni
parents: 924
diff changeset
1911 pic= (AVFrame*)&s->picture[i];
1168
5af9aeadbdc3 H264 decoder & demuxer
michaelni
parents: 1165
diff changeset
1912 pic->reference= 3;
903
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
1913
924
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
1914 for(i=0; i<4; i++){
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
1915 pic->data[i]= pic_arg->data[i];
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
1916 pic->linesize[i]= pic_arg->linesize[i];
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
1917 }
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
1918 alloc_picture(s, (Picture*)pic, 1);
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
1919 }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
1920 int offset= 16;
1586
3d1d0490e5a6 pts fix and related fixes
michael
parents: 1580
diff changeset
1921 i= ff_find_unused_picture(s, 0);
924
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
1922
925
7fccaa0d699d AVVideoFrame -> AVFrame
michaelni
parents: 924
diff changeset
1923 pic= (AVFrame*)&s->picture[i];
1168
5af9aeadbdc3 H264 decoder & demuxer
michaelni
parents: 1165
diff changeset
1924 pic->reference= 3;
924
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
1925
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
1926 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
1927
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
1928 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
1929 && 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
1930 && pic->data[2] + offset == pic_arg->data[2]){
924
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
1931 // empty
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
1932 }else{
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
1933 int h_chroma_shift, v_chroma_shift;
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
1934 avcodec_get_chroma_sub_sample(s->avctx->pix_fmt, &h_chroma_shift, &v_chroma_shift);
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
1935
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
1936 for(i=0; i<3; i++){
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
1937 int src_stride= pic_arg->linesize[i];
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
1938 int dst_stride= i ? s->uvlinesize : s->linesize;
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
1939 int h_shift= i ? h_chroma_shift : 0;
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
1940 int v_shift= i ? v_chroma_shift : 0;
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
1941 int w= s->width >>h_shift;
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
1942 int h= s->height>>v_shift;
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
1943 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
1944 uint8_t *dst= pic->data[i] + offset;
924
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
1945
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
1946 if(src_stride==dst_stride)
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
1947 memcpy(dst, src, src_stride*h);
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
1948 else{
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
1949 while(h--){
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
1950 memcpy(dst, src, w);
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
1951 dst += dst_stride;
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
1952 src += src_stride;
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
1953 }
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
1954 }
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
1955 }
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
1956 }
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
1957 }
1938
e2501e6e7ff7 unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents: 1918
diff changeset
1958 copy_picture_attributes(s, pic, pic_arg);
1702
fbab59f03144 10l (forgot to copy top_field_first flag)
michael
parents: 1697
diff changeset
1959
1705
954593137d37 picture number fixes
michael
parents: 1703
diff changeset
1960 pic->display_picture_number= s->input_picture_number++;
1831
cd2d7fcfab7a use AVFrame.pts=AV_NOPTS_VALUE instead of AVFrame.pts=0
michael
parents: 1829
diff changeset
1961 if(pic->pts != AV_NOPTS_VALUE){
1829
7ae26b6e197f set AVFrame.pts based upon framerate if its 0
michael
parents: 1827
diff changeset
1962 s->user_specified_pts= pic->pts;
7ae26b6e197f set AVFrame.pts based upon framerate if its 0
michael
parents: 1827
diff changeset
1963 }else{
7ae26b6e197f set AVFrame.pts based upon framerate if its 0
michael
parents: 1827
diff changeset
1964 if(s->user_specified_pts){
1831
cd2d7fcfab7a use AVFrame.pts=AV_NOPTS_VALUE instead of AVFrame.pts=0
michael
parents: 1829
diff changeset
1965 pic->pts= s->user_specified_pts + AV_TIME_BASE*(int64_t)s->avctx->frame_rate_base / s->avctx->frame_rate;
cd2d7fcfab7a use AVFrame.pts=AV_NOPTS_VALUE instead of AVFrame.pts=0
michael
parents: 1829
diff changeset
1966 av_log(s->avctx, AV_LOG_INFO, "Warning: AVFrame.pts=? trying to guess (%Ld)\n", pic->pts);
1829
7ae26b6e197f set AVFrame.pts based upon framerate if its 0
michael
parents: 1827
diff changeset
1967 }else{
1831
cd2d7fcfab7a use AVFrame.pts=AV_NOPTS_VALUE instead of AVFrame.pts=0
michael
parents: 1829
diff changeset
1968 pic->pts= av_rescale(pic->display_picture_number*(int64_t)s->avctx->frame_rate_base, AV_TIME_BASE, s->avctx->frame_rate);
1829
7ae26b6e197f set AVFrame.pts based upon framerate if its 0
michael
parents: 1827
diff changeset
1969 }
7ae26b6e197f set AVFrame.pts based upon framerate if its 0
michael
parents: 1827
diff changeset
1970 }
1373
b47a402bbe7f last frames & b frames encoding fix
michaelni
parents: 1370
diff changeset
1971 }
1829
7ae26b6e197f set AVFrame.pts based upon framerate if its 0
michael
parents: 1827
diff changeset
1972
903
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
1973 /* shift buffer entries */
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
1974 for(i=1; i<MAX_PICTURE_COUNT /*s->encoding_delay+1*/; i++)
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
1975 s->input_picture[i-1]= s->input_picture[i];
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
1976
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
1977 s->input_picture[encoding_delay]= (Picture*)pic;
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
1978
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
1979 return 0;
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
1980 }
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
1981
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
1982 static void select_input_picture(MpegEncContext *s){
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
1983 int i;
924
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
1984
903
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
1985 for(i=1; i<MAX_PICTURE_COUNT; i++)
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
1986 s->reordered_input_picture[i-1]= s->reordered_input_picture[i];
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
1987 s->reordered_input_picture[MAX_PICTURE_COUNT-1]= NULL;
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
1988
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
1989 /* set next picture types & ordering */
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
1990 if(s->reordered_input_picture[0]==NULL && s->input_picture[0]){
1138
e10e841c9bf0 field pic decoding cleanup
michaelni
parents: 1130
diff changeset
1991 if(/*s->picture_in_gop_number >= s->gop_size ||*/ s->next_picture_ptr==NULL || s->intra_only){
915
75ee49a4a516 fixing 2pass assert failure
michaelni
parents: 912
diff changeset
1992 s->reordered_input_picture[0]= s->input_picture[0];
75ee49a4a516 fixing 2pass assert failure
michaelni
parents: 912
diff changeset
1993 s->reordered_input_picture[0]->pict_type= I_TYPE;
1705
954593137d37 picture number fixes
michael
parents: 1703
diff changeset
1994 s->reordered_input_picture[0]->coded_picture_number= s->coded_picture_number++;
915
75ee49a4a516 fixing 2pass assert failure
michaelni
parents: 912
diff changeset
1995 }else{
75ee49a4a516 fixing 2pass assert failure
michaelni
parents: 912
diff changeset
1996 int b_frames;
75ee49a4a516 fixing 2pass assert failure
michaelni
parents: 912
diff changeset
1997
75ee49a4a516 fixing 2pass assert failure
michaelni
parents: 912
diff changeset
1998 if(s->flags&CODEC_FLAG_PASS2){
75ee49a4a516 fixing 2pass assert failure
michaelni
parents: 912
diff changeset
1999 for(i=0; i<s->max_b_frames+1; i++){
75ee49a4a516 fixing 2pass assert failure
michaelni
parents: 912
diff changeset
2000 int pict_num= s->input_picture[0]->display_picture_number + i;
75ee49a4a516 fixing 2pass assert failure
michaelni
parents: 912
diff changeset
2001 int pict_type= s->rc_context.entry[pict_num].new_pict_type;
75ee49a4a516 fixing 2pass assert failure
michaelni
parents: 912
diff changeset
2002 s->input_picture[i]->pict_type= pict_type;
75ee49a4a516 fixing 2pass assert failure
michaelni
parents: 912
diff changeset
2003
75ee49a4a516 fixing 2pass assert failure
michaelni
parents: 912
diff changeset
2004 if(i + 1 >= s->rc_context.num_entries) break;
75ee49a4a516 fixing 2pass assert failure
michaelni
parents: 912
diff changeset
2005 }
75ee49a4a516 fixing 2pass assert failure
michaelni
parents: 912
diff changeset
2006 }
924
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
2007
915
75ee49a4a516 fixing 2pass assert failure
michaelni
parents: 912
diff changeset
2008 if(s->input_picture[0]->pict_type){
75ee49a4a516 fixing 2pass assert failure
michaelni
parents: 912
diff changeset
2009 /* user selected pict_type */
909
8ae1e4c24e91 new PSNR code (now works with chroma, b frames, ...)
michaelni
parents: 903
diff changeset
2010 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
2011 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
2012 }
915
75ee49a4a516 fixing 2pass assert failure
michaelni
parents: 912
diff changeset
2013
909
8ae1e4c24e91 new PSNR code (now works with chroma, b frames, ...)
michaelni
parents: 903
diff changeset
2014 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
2015 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
2016 b_frames = s->max_b_frames;
8ae1e4c24e91 new PSNR code (now works with chroma, b frames, ...)
michaelni
parents: 903
diff changeset
2017 }
1687
cdc3d4106fb6 cleanup
michael
parents: 1686
diff changeset
2018 }else if(s->avctx->b_frame_strategy==0){
915
75ee49a4a516 fixing 2pass assert failure
michaelni
parents: 912
diff changeset
2019 b_frames= s->max_b_frames;
1373
b47a402bbe7f last frames & b frames encoding fix
michaelni
parents: 1370
diff changeset
2020 while(b_frames && !s->input_picture[b_frames]) b_frames--;
1687
cdc3d4106fb6 cleanup
michael
parents: 1686
diff changeset
2021 }else if(s->avctx->b_frame_strategy==1){
915
75ee49a4a516 fixing 2pass assert failure
michaelni
parents: 912
diff changeset
2022 for(i=1; i<s->max_b_frames+1; i++){
1373
b47a402bbe7f last frames & b frames encoding fix
michaelni
parents: 1370
diff changeset
2023 if(s->input_picture[i] && s->input_picture[i]->b_frame_score==0){
915
75ee49a4a516 fixing 2pass assert failure
michaelni
parents: 912
diff changeset
2024 s->input_picture[i]->b_frame_score=
924
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
2025 get_intra_count(s, s->input_picture[i ]->data[0],
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
2026 s->input_picture[i-1]->data[0], s->linesize) + 1;
915
75ee49a4a516 fixing 2pass assert failure
michaelni
parents: 912
diff changeset
2027 }
75ee49a4a516 fixing 2pass assert failure
michaelni
parents: 912
diff changeset
2028 }
75ee49a4a516 fixing 2pass assert failure
michaelni
parents: 912
diff changeset
2029 for(i=0; i<s->max_b_frames; i++){
1373
b47a402bbe7f last frames & b frames encoding fix
michaelni
parents: 1370
diff changeset
2030 if(s->input_picture[i]==NULL || s->input_picture[i]->b_frame_score - 1 > s->mb_num/40) break;
915
75ee49a4a516 fixing 2pass assert failure
michaelni
parents: 912
diff changeset
2031 }
75ee49a4a516 fixing 2pass assert failure
michaelni
parents: 912
diff changeset
2032
75ee49a4a516 fixing 2pass assert failure
michaelni
parents: 912
diff changeset
2033 b_frames= FFMAX(0, i-1);
909
8ae1e4c24e91 new PSNR code (now works with chroma, b frames, ...)
michaelni
parents: 903
diff changeset
2034
915
75ee49a4a516 fixing 2pass assert failure
michaelni
parents: 912
diff changeset
2035 /* reset scores */
75ee49a4a516 fixing 2pass assert failure
michaelni
parents: 912
diff changeset
2036 for(i=0; i<b_frames+1; i++){
75ee49a4a516 fixing 2pass assert failure
michaelni
parents: 912
diff changeset
2037 s->input_picture[i]->b_frame_score=0;
75ee49a4a516 fixing 2pass assert failure
michaelni
parents: 912
diff changeset
2038 }
75ee49a4a516 fixing 2pass assert failure
michaelni
parents: 912
diff changeset
2039 }else{
1598
932d306bf1dc av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents: 1597
diff changeset
2040 av_log(s->avctx, AV_LOG_ERROR, "illegal b frame strategy\n");
915
75ee49a4a516 fixing 2pass assert failure
michaelni
parents: 912
diff changeset
2041 b_frames=0;
909
8ae1e4c24e91 new PSNR code (now works with chroma, b frames, ...)
michaelni
parents: 903
diff changeset
2042 }
915
75ee49a4a516 fixing 2pass assert failure
michaelni
parents: 912
diff changeset
2043
75ee49a4a516 fixing 2pass assert failure
michaelni
parents: 912
diff changeset
2044 emms_c();
75ee49a4a516 fixing 2pass assert failure
michaelni
parents: 912
diff changeset
2045 //static int b_count=0;
75ee49a4a516 fixing 2pass assert failure
michaelni
parents: 912
diff changeset
2046 //b_count+= b_frames;
1598
932d306bf1dc av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents: 1597
diff changeset
2047 //av_log(s->avctx, AV_LOG_DEBUG, "b_frames: %d\n", b_count);
1754
bdf3927bf8c5 closed gop support & flags2 as all bits in flags are used
michael
parents: 1751
diff changeset
2048 if(s->picture_in_gop_number + b_frames >= s->gop_size){
bdf3927bf8c5 closed gop support & flags2 as all bits in flags are used
michael
parents: 1751
diff changeset
2049 if(s->flags & CODEC_FLAG_CLOSED_GOP)
bdf3927bf8c5 closed gop support & flags2 as all bits in flags are used
michael
parents: 1751
diff changeset
2050 b_frames=0;
bdf3927bf8c5 closed gop support & flags2 as all bits in flags are used
michael
parents: 1751
diff changeset
2051 s->input_picture[b_frames]->pict_type= I_TYPE;
bdf3927bf8c5 closed gop support & flags2 as all bits in flags are used
michael
parents: 1751
diff changeset
2052 }
bdf3927bf8c5 closed gop support & flags2 as all bits in flags are used
michael
parents: 1751
diff changeset
2053
bdf3927bf8c5 closed gop support & flags2 as all bits in flags are used
michael
parents: 1751
diff changeset
2054 if( (s->flags & CODEC_FLAG_CLOSED_GOP)
bdf3927bf8c5 closed gop support & flags2 as all bits in flags are used
michael
parents: 1751
diff changeset
2055 && b_frames
bdf3927bf8c5 closed gop support & flags2 as all bits in flags are used
michael
parents: 1751
diff changeset
2056 && s->input_picture[b_frames]->pict_type== I_TYPE)
bdf3927bf8c5 closed gop support & flags2 as all bits in flags are used
michael
parents: 1751
diff changeset
2057 b_frames--;
bdf3927bf8c5 closed gop support & flags2 as all bits in flags are used
michael
parents: 1751
diff changeset
2058
915
75ee49a4a516 fixing 2pass assert failure
michaelni
parents: 912
diff changeset
2059 s->reordered_input_picture[0]= s->input_picture[b_frames];
1754
bdf3927bf8c5 closed gop support & flags2 as all bits in flags are used
michael
parents: 1751
diff changeset
2060 if(s->reordered_input_picture[0]->pict_type != I_TYPE)
915
75ee49a4a516 fixing 2pass assert failure
michaelni
parents: 912
diff changeset
2061 s->reordered_input_picture[0]->pict_type= P_TYPE;
1705
954593137d37 picture number fixes
michael
parents: 1703
diff changeset
2062 s->reordered_input_picture[0]->coded_picture_number= s->coded_picture_number++;
915
75ee49a4a516 fixing 2pass assert failure
michaelni
parents: 912
diff changeset
2063 for(i=0; i<b_frames; i++){
75ee49a4a516 fixing 2pass assert failure
michaelni
parents: 912
diff changeset
2064 s->reordered_input_picture[i+1]= s->input_picture[i];
75ee49a4a516 fixing 2pass assert failure
michaelni
parents: 912
diff changeset
2065 s->reordered_input_picture[i+1]->pict_type= B_TYPE;
1705
954593137d37 picture number fixes
michael
parents: 1703
diff changeset
2066 s->reordered_input_picture[i+1]->coded_picture_number= s->coded_picture_number++;
903
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
2067 }
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
2068 }
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
2069 }
903
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
2070
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
2071 if(s->reordered_input_picture[0]){
1168
5af9aeadbdc3 H264 decoder & demuxer
michaelni
parents: 1165
diff changeset
2072 s->reordered_input_picture[0]->reference= s->reordered_input_picture[0]->pict_type!=B_TYPE ? 3 : 0;
1138
e10e841c9bf0 field pic decoding cleanup
michaelni
parents: 1130
diff changeset
2073
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
2074 copy_picture(&s->new_picture, s->reordered_input_picture[0]);
924
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
2075
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
2076 if(s->reordered_input_picture[0]->type == FF_BUFFER_TYPE_SHARED){
1138
e10e841c9bf0 field pic decoding cleanup
michaelni
parents: 1130
diff changeset
2077 // input is a shared pix, so we cant modifiy it -> alloc a new one & ensure that the shared one is reuseable
e10e841c9bf0 field pic decoding cleanup
michaelni
parents: 1130
diff changeset
2078
1586
3d1d0490e5a6 pts fix and related fixes
michael
parents: 1580
diff changeset
2079 int i= ff_find_unused_picture(s, 0);
924
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
2080 Picture *pic= &s->picture[i];
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
2081
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
2082 /* mark us unused / free shared pic */
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
2083 for(i=0; i<4; i++)
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
2084 s->reordered_input_picture[0]->data[i]= NULL;
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
2085 s->reordered_input_picture[0]->type= 0;
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
2086
1702
fbab59f03144 10l (forgot to copy top_field_first flag)
michael
parents: 1697
diff changeset
2087 pic->reference = s->reordered_input_picture[0]->reference;
924
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
2088
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
2089 alloc_picture(s, pic, 0);
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
2090
1955
5dafb10e0252 reuse motion vectors/mb types/field select values of the source video, if the SSE for a macroblock which is predicted with these values is below me_threshold
michael
parents: 1948
diff changeset
2091 copy_picture_attributes(s, (AVFrame*)pic, (AVFrame*)s->reordered_input_picture[0]);
5dafb10e0252 reuse motion vectors/mb types/field select values of the source video, if the SSE for a macroblock which is predicted with these values is below me_threshold
michael
parents: 1948
diff changeset
2092
1138
e10e841c9bf0 field pic decoding cleanup
michaelni
parents: 1130
diff changeset
2093 s->current_picture_ptr= pic;
924
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
2094 }else{
1138
e10e841c9bf0 field pic decoding cleanup
michaelni
parents: 1130
diff changeset
2095 // input is not a shared pix -> reuse buffer for current_pix
e10e841c9bf0 field pic decoding cleanup
michaelni
parents: 1130
diff changeset
2096
924
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
2097 assert( s->reordered_input_picture[0]->type==FF_BUFFER_TYPE_USER
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
2098 || s->reordered_input_picture[0]->type==FF_BUFFER_TYPE_INTERNAL);
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
2099
1138
e10e841c9bf0 field pic decoding cleanup
michaelni
parents: 1130
diff changeset
2100 s->current_picture_ptr= s->reordered_input_picture[0];
924
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
2101 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
2102 s->new_picture.data[i]+=16;
924
3814e9115672 cleanup / messup?
michaelni
parents: 915
diff changeset
2103 }
903
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
2104 }
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
2105 copy_picture(&s->current_picture, s->current_picture_ptr);
903
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
2106
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
2107 s->picture_number= s->new_picture.display_picture_number;
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
2108 //printf("dpn:%d\n", s->picture_number);
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
2109 }else{
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
2110 memset(&s->new_picture, 0, sizeof(Picture));
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
2111 }
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
2112 }
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
2113
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2114 int MPV_encode_picture(AVCodecContext *avctx,
986e461dc072 Initial revision
glantau
parents:
diff changeset
2115 unsigned char *buf, int buf_size, void *data)
986e461dc072 Initial revision
glantau
parents:
diff changeset
2116 {
986e461dc072 Initial revision
glantau
parents:
diff changeset
2117 MpegEncContext *s = avctx->priv_data;
925
7fccaa0d699d AVVideoFrame -> AVFrame
michaelni
parents: 924
diff changeset
2118 AVFrame *pic_arg = data;
1684
19e781619e3f stuffing to stay above min_bitrate
michael
parents: 1682
diff changeset
2119 int i, stuffing_count;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2120
1397
2e43c9bdc982 check input pix_fmt
michaelni
parents: 1396
diff changeset
2121 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
2122 av_log(avctx, AV_LOG_ERROR, "this codec supports only YUV420P\n");
1397
2e43c9bdc982 check input pix_fmt
michaelni
parents: 1396
diff changeset
2123 return -1;
2e43c9bdc982 check input pix_fmt
michaelni
parents: 1396
diff changeset
2124 }
2e43c9bdc982 check input pix_fmt
michaelni
parents: 1396
diff changeset
2125
1799
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
2126 for(i=0; i<avctx->thread_count; i++){
1838
8cdbb74c2f4b 10l (vdpart fix)
michael
parents: 1834
diff changeset
2127 int start_y= s->thread_context[i]->start_mb_y;
8cdbb74c2f4b 10l (vdpart fix)
michael
parents: 1834
diff changeset
2128 int end_y= s->thread_context[i]-> end_mb_y;
1799
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
2129 int h= s->mb_height;
1838
8cdbb74c2f4b 10l (vdpart fix)
michael
parents: 1834
diff changeset
2130 uint8_t *start= buf + buf_size*start_y/h;
8cdbb74c2f4b 10l (vdpart fix)
michael
parents: 1834
diff changeset
2131 uint8_t *end = buf + buf_size* end_y/h;
1799
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
2132
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
2133 init_put_bits(&s->thread_context[i]->pb, start, end - start);
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
2134 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2135
903
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
2136 s->picture_in_gop_number++;
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
2137
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
2138 load_input_picture(s, pic_arg);
329
5cc47d0ba53e fixed ratecontrol & b-frames
michaelni
parents: 327
diff changeset
2139
903
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
2140 select_input_picture(s);
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
2141
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
2142 /* output? */
903
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
2143 if(s->new_picture.data[0]){
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
2144 s->pict_type= s->new_picture.pict_type;
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
2145 //emms_c();
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
2146 //printf("qs:%f %f %d\n", s->new_picture.quality, s->current_picture.quality, s->qscale);
553
18ad513d92fe direct rendering method 1 support
michaelni
parents: 549
diff changeset
2147 MPV_frame_start(s, avctx);
286
91f7c38f5f37 statistics for 2-pass encoding
michaelni
parents: 281
diff changeset
2148
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
2149 encode_picture(s, s->picture_number);
652
c7647afc3ce5 set pict_type & key_frame on decoding too
michaelni
parents: 651
diff changeset
2150
376
ba9c3b8088c0 - pict_type exported to AVCodecContext
pulento
parents: 370
diff changeset
2151 avctx->real_pict_num = s->picture_number;
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
2152 avctx->header_bits = s->header_bits;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
2153 avctx->mv_bits = s->mv_bits;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
2154 avctx->misc_bits = s->misc_bits;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
2155 avctx->i_tex_bits = s->i_tex_bits;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
2156 avctx->p_tex_bits = s->p_tex_bits;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
2157 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
2158 avctx->p_count = s->mb_num - s->i_count - s->skip_count; //FIXME f/b_count in avctx
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
2159 avctx->skip_count = s->skip_count;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2160
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
2161 MPV_frame_end(s);
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
2162
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
2163 if (s->out_format == FMT_MJPEG)
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
2164 mjpeg_picture_trailer(s);
329
5cc47d0ba53e fixed ratecontrol & b-frames
michaelni
parents: 327
diff changeset
2165
5cc47d0ba53e fixed ratecontrol & b-frames
michaelni
parents: 327
diff changeset
2166 if(s->flags&CODEC_FLAG_PASS1)
5cc47d0ba53e fixed ratecontrol & b-frames
michaelni
parents: 327
diff changeset
2167 ff_write_pass1_stats(s);
1138
e10e841c9bf0 field pic decoding cleanup
michaelni
parents: 1130
diff changeset
2168
e10e841c9bf0 field pic decoding cleanup
michaelni
parents: 1130
diff changeset
2169 for(i=0; i<4; i++){
e10e841c9bf0 field pic decoding cleanup
michaelni
parents: 1130
diff changeset
2170 avctx->error[i] += s->current_picture_ptr->error[i];
e10e841c9bf0 field pic decoding cleanup
michaelni
parents: 1130
diff changeset
2171 }
1766
95c7b69f37f3 b frames + cbr fix
michael
parents: 1760
diff changeset
2172
1684
19e781619e3f stuffing to stay above min_bitrate
michael
parents: 1682
diff changeset
2173 flush_put_bits(&s->pb);
1801
3f26dfb3eba4 replace a few pbBufPtr() by put_bits_count(), one of them was actually wrong
michael
parents: 1799
diff changeset
2174 s->frame_bits = put_bits_count(&s->pb);
1766
95c7b69f37f3 b frames + cbr fix
michael
parents: 1760
diff changeset
2175
95c7b69f37f3 b frames + cbr fix
michael
parents: 1760
diff changeset
2176 stuffing_count= ff_vbv_update(s, s->frame_bits);
95c7b69f37f3 b frames + cbr fix
michael
parents: 1760
diff changeset
2177 if(stuffing_count){
95c7b69f37f3 b frames + cbr fix
michael
parents: 1760
diff changeset
2178 switch(s->codec_id){
95c7b69f37f3 b frames + cbr fix
michael
parents: 1760
diff changeset
2179 case CODEC_ID_MPEG1VIDEO:
95c7b69f37f3 b frames + cbr fix
michael
parents: 1760
diff changeset
2180 case CODEC_ID_MPEG2VIDEO:
95c7b69f37f3 b frames + cbr fix
michael
parents: 1760
diff changeset
2181 while(stuffing_count--){
95c7b69f37f3 b frames + cbr fix
michael
parents: 1760
diff changeset
2182 put_bits(&s->pb, 8, 0);
95c7b69f37f3 b frames + cbr fix
michael
parents: 1760
diff changeset
2183 }
95c7b69f37f3 b frames + cbr fix
michael
parents: 1760
diff changeset
2184 break;
95c7b69f37f3 b frames + cbr fix
michael
parents: 1760
diff changeset
2185 case CODEC_ID_MPEG4:
95c7b69f37f3 b frames + cbr fix
michael
parents: 1760
diff changeset
2186 put_bits(&s->pb, 16, 0);
95c7b69f37f3 b frames + cbr fix
michael
parents: 1760
diff changeset
2187 put_bits(&s->pb, 16, 0x1C3);
95c7b69f37f3 b frames + cbr fix
michael
parents: 1760
diff changeset
2188 stuffing_count -= 4;
95c7b69f37f3 b frames + cbr fix
michael
parents: 1760
diff changeset
2189 while(stuffing_count--){
95c7b69f37f3 b frames + cbr fix
michael
parents: 1760
diff changeset
2190 put_bits(&s->pb, 8, 0xFF);
95c7b69f37f3 b frames + cbr fix
michael
parents: 1760
diff changeset
2191 }
95c7b69f37f3 b frames + cbr fix
michael
parents: 1760
diff changeset
2192 break;
95c7b69f37f3 b frames + cbr fix
michael
parents: 1760
diff changeset
2193 default:
95c7b69f37f3 b frames + cbr fix
michael
parents: 1760
diff changeset
2194 av_log(s->avctx, AV_LOG_ERROR, "vbv buffer overflow\n");
95c7b69f37f3 b frames + cbr fix
michael
parents: 1760
diff changeset
2195 }
95c7b69f37f3 b frames + cbr fix
michael
parents: 1760
diff changeset
2196 flush_put_bits(&s->pb);
1801
3f26dfb3eba4 replace a few pbBufPtr() by put_bits_count(), one of them was actually wrong
michael
parents: 1799
diff changeset
2197 s->frame_bits = put_bits_count(&s->pb);
1766
95c7b69f37f3 b frames + cbr fix
michael
parents: 1760
diff changeset
2198 }
95c7b69f37f3 b frames + cbr fix
michael
parents: 1760
diff changeset
2199
95c7b69f37f3 b frames + cbr fix
michael
parents: 1760
diff changeset
2200 /* update mpeg1/2 vbv_delay for CBR */
1907
7ff22288289e huge vbv buffer size + CBR fix
michael
parents: 1904
diff changeset
2201 if(s->avctx->rc_max_rate && s->avctx->rc_min_rate == s->avctx->rc_max_rate && s->out_format == FMT_MPEG1
7ff22288289e huge vbv buffer size + CBR fix
michael
parents: 1904
diff changeset
2202 && 90000LL * (avctx->rc_buffer_size-1) <= s->avctx->rc_max_rate*0xFFFFLL){
1766
95c7b69f37f3 b frames + cbr fix
michael
parents: 1760
diff changeset
2203 int vbv_delay;
95c7b69f37f3 b frames + cbr fix
michael
parents: 1760
diff changeset
2204
95c7b69f37f3 b frames + cbr fix
michael
parents: 1760
diff changeset
2205 assert(s->repeat_first_field==0);
95c7b69f37f3 b frames + cbr fix
michael
parents: 1760
diff changeset
2206
95c7b69f37f3 b frames + cbr fix
michael
parents: 1760
diff changeset
2207 vbv_delay= lrintf(90000 * s->rc_context.buffer_index / s->avctx->rc_max_rate);
95c7b69f37f3 b frames + cbr fix
michael
parents: 1760
diff changeset
2208 assert(vbv_delay < 0xFFFF);
95c7b69f37f3 b frames + cbr fix
michael
parents: 1760
diff changeset
2209
95c7b69f37f3 b frames + cbr fix
michael
parents: 1760
diff changeset
2210 s->vbv_delay_ptr[0] &= 0xF8;
95c7b69f37f3 b frames + cbr fix
michael
parents: 1760
diff changeset
2211 s->vbv_delay_ptr[0] |= vbv_delay>>13;
95c7b69f37f3 b frames + cbr fix
michael
parents: 1760
diff changeset
2212 s->vbv_delay_ptr[1] = vbv_delay>>5;
95c7b69f37f3 b frames + cbr fix
michael
parents: 1760
diff changeset
2213 s->vbv_delay_ptr[2] &= 0x07;
95c7b69f37f3 b frames + cbr fix
michael
parents: 1760
diff changeset
2214 s->vbv_delay_ptr[2] |= vbv_delay<<3;
95c7b69f37f3 b frames + cbr fix
michael
parents: 1760
diff changeset
2215 }
95c7b69f37f3 b frames + cbr fix
michael
parents: 1760
diff changeset
2216 s->total_bits += s->frame_bits;
95c7b69f37f3 b frames + cbr fix
michael
parents: 1760
diff changeset
2217 avctx->frame_bits = s->frame_bits;
95c7b69f37f3 b frames + cbr fix
michael
parents: 1760
diff changeset
2218 }else{
95c7b69f37f3 b frames + cbr fix
michael
parents: 1760
diff changeset
2219 assert((pbBufPtr(&s->pb) == s->pb.buf));
95c7b69f37f3 b frames + cbr fix
michael
parents: 1760
diff changeset
2220 s->frame_bits=0;
1684
19e781619e3f stuffing to stay above min_bitrate
michael
parents: 1682
diff changeset
2221 }
1766
95c7b69f37f3 b frames + cbr fix
michael
parents: 1760
diff changeset
2222 assert((s->frame_bits&7)==0);
909
8ae1e4c24e91 new PSNR code (now works with chroma, b frames, ...)
michaelni
parents: 903
diff changeset
2223
1684
19e781619e3f stuffing to stay above min_bitrate
michael
parents: 1682
diff changeset
2224 return s->frame_bits/8;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2225 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
2226
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
2227 #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
2228
255
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
2229 static inline void gmc1_motion(MpegEncContext *s,
1064
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1059
diff changeset
2230 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
1842
0d82db458a3c interlaced mpeg4 + edge emu fix (fixes decoding of mermaid.avi)
michael
parents: 1838
diff changeset
2231 uint8_t **ref_picture)
255
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
2232 {
1064
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1059
diff changeset
2233 uint8_t *ptr;
556
762c67fd4078 uvlinesize
michaelni
parents: 554
diff changeset
2234 int offset, src_x, src_y, linesize, uvlinesize;
255
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
2235 int motion_x, motion_y;
566
c376a0b290cf fixing gmc with emu edges
michaelni
parents: 565
diff changeset
2236 int emu=0;
255
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
2237
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
2238 motion_x= s->sprite_offset[0][0];
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
2239 motion_y= s->sprite_offset[0][1];
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
2240 src_x = s->mb_x * 16 + (motion_x >> (s->sprite_warping_accuracy+1));
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
2241 src_y = s->mb_y * 16 + (motion_y >> (s->sprite_warping_accuracy+1));
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
2242 motion_x<<=(3-s->sprite_warping_accuracy);
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
2243 motion_y<<=(3-s->sprite_warping_accuracy);
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
2244 src_x = clip(src_x, -16, s->width);
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
2245 if (src_x == s->width)
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
2246 motion_x =0;
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
2247 src_y = clip(src_y, -16, s->height);
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
2248 if (src_y == s->height)
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
2249 motion_y =0;
753
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 745
diff changeset
2250
255
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
2251 linesize = s->linesize;
556
762c67fd4078 uvlinesize
michaelni
parents: 554
diff changeset
2252 uvlinesize = s->uvlinesize;
753
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 745
diff changeset
2253
1842
0d82db458a3c interlaced mpeg4 + edge emu fix (fixes decoding of mermaid.avi)
michael
parents: 1838
diff changeset
2254 ptr = ref_picture[0] + (src_y * linesize) + src_x;
0d82db458a3c interlaced mpeg4 + edge emu fix (fixes decoding of mermaid.avi)
michael
parents: 1838
diff changeset
2255
566
c376a0b290cf fixing gmc with emu edges
michaelni
parents: 565
diff changeset
2256 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
2257 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
2258 || (unsigned)src_y >= s->v_edge_pos - 17){
1317
26c44d2433c1 make ff_emulated_edge_mc() independant of MpegEncContext
michaelni
parents: 1315
diff changeset
2259 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
c376a0b290cf fixing gmc with emu edges
michaelni
parents: 565
diff changeset
2260 ptr= s->edge_emu_buffer;
c376a0b290cf fixing gmc with emu edges
michaelni
parents: 565
diff changeset
2261 }
c376a0b290cf fixing gmc with emu edges
michaelni
parents: 565
diff changeset
2262 }
753
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 745
diff changeset
2263
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 745
diff changeset
2264 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
2265 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
2266 s->dsp.gmc1(dest_y+8, ptr+8, linesize, 16, motion_x&15, motion_y&15, 128 - s->no_rounding);
753
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 745
diff changeset
2267 }else{
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 745
diff changeset
2268 int dxy;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 745
diff changeset
2269
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 745
diff changeset
2270 dxy= ((motion_x>>3)&1) | ((motion_y>>2)&2);
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 745
diff changeset
2271 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
2272 s->dsp.put_no_rnd_pixels_tab[0][dxy](dest_y, ptr, linesize, 16);
753
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 745
diff changeset
2273 }else{
853
eacc2dd8fd9d * using DSPContext - so each codec could use its local (sub)set of CPU extension
kabi
parents: 847
diff changeset
2274 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
2275 }
753
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 745
diff changeset
2276 }
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 745
diff changeset
2277
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 745
diff changeset
2278 if(s->flags&CODEC_FLAG_GRAY) return;
255
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
2279
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
2280 motion_x= s->sprite_offset[1][0];
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
2281 motion_y= s->sprite_offset[1][1];
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
2282 src_x = s->mb_x * 8 + (motion_x >> (s->sprite_warping_accuracy+1));
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
2283 src_y = s->mb_y * 8 + (motion_y >> (s->sprite_warping_accuracy+1));
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
2284 motion_x<<=(3-s->sprite_warping_accuracy);
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
2285 motion_y<<=(3-s->sprite_warping_accuracy);
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
2286 src_x = clip(src_x, -8, s->width>>1);
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
2287 if (src_x == s->width>>1)
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
2288 motion_x =0;
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
2289 src_y = clip(src_y, -8, s->height>>1);
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
2290 if (src_y == s->height>>1)
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
2291 motion_y =0;
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
2292
1842
0d82db458a3c interlaced mpeg4 + edge emu fix (fixes decoding of mermaid.avi)
michael
parents: 1838
diff changeset
2293 offset = (src_y * uvlinesize) + src_x;
255
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
2294 ptr = ref_picture[1] + offset;
1002
e89b11e07ee7 gmc1 segfault fix (found by kabi)
michaelni
parents: 998
diff changeset
2295 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
2296 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
2297 || (unsigned)src_y >= (s->v_edge_pos>>1) - 9){
1317
26c44d2433c1 make ff_emulated_edge_mc() independant of MpegEncContext
michaelni
parents: 1315
diff changeset
2298 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
e89b11e07ee7 gmc1 segfault fix (found by kabi)
michaelni
parents: 998
diff changeset
2299 ptr= s->edge_emu_buffer;
e89b11e07ee7 gmc1 segfault fix (found by kabi)
michaelni
parents: 998
diff changeset
2300 emu=1;
e89b11e07ee7 gmc1 segfault fix (found by kabi)
michaelni
parents: 998
diff changeset
2301 }
566
c376a0b290cf fixing gmc with emu edges
michaelni
parents: 565
diff changeset
2302 }
1842
0d82db458a3c interlaced mpeg4 + edge emu fix (fixes decoding of mermaid.avi)
michael
parents: 1838
diff changeset
2303 s->dsp.gmc1(dest_cb, ptr, uvlinesize, 8, motion_x&15, motion_y&15, 128 - s->no_rounding);
566
c376a0b290cf fixing gmc with emu edges
michaelni
parents: 565
diff changeset
2304
255
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
2305 ptr = ref_picture[2] + offset;
566
c376a0b290cf fixing gmc with emu edges
michaelni
parents: 565
diff changeset
2306 if(emu){
1317
26c44d2433c1 make ff_emulated_edge_mc() independant of MpegEncContext
michaelni
parents: 1315
diff changeset
2307 ff_emulated_edge_mc(s->edge_emu_buffer, ptr, uvlinesize, 9, 9, src_x, src_y, s->h_edge_pos>>1, s->v_edge_pos>>1);
566
c376a0b290cf fixing gmc with emu edges
michaelni
parents: 565
diff changeset
2308 ptr= s->edge_emu_buffer;
c376a0b290cf fixing gmc with emu edges
michaelni
parents: 565
diff changeset
2309 }
1842
0d82db458a3c interlaced mpeg4 + edge emu fix (fixes decoding of mermaid.avi)
michael
parents: 1838
diff changeset
2310 s->dsp.gmc1(dest_cr, ptr, uvlinesize, 8, motion_x&15, motion_y&15, 128 - s->no_rounding);
255
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
2311
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
2312 return;
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
2313 }
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
2314
753
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 745
diff changeset
2315 static inline void gmc_motion(MpegEncContext *s,
1064
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1059
diff changeset
2316 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
1842
0d82db458a3c interlaced mpeg4 + edge emu fix (fixes decoding of mermaid.avi)
michael
parents: 1838
diff changeset
2317 uint8_t **ref_picture)
753
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 745
diff changeset
2318 {
1064
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1059
diff changeset
2319 uint8_t *ptr;
753
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 745
diff changeset
2320 int linesize, uvlinesize;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 745
diff changeset
2321 const int a= s->sprite_warping_accuracy;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 745
diff changeset
2322 int ox, oy;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 745
diff changeset
2323
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 745
diff changeset
2324 linesize = s->linesize;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 745
diff changeset
2325 uvlinesize = s->uvlinesize;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 745
diff changeset
2326
1842
0d82db458a3c interlaced mpeg4 + edge emu fix (fixes decoding of mermaid.avi)
michael
parents: 1838
diff changeset
2327 ptr = ref_picture[0];
0d82db458a3c interlaced mpeg4 + edge emu fix (fixes decoding of mermaid.avi)
michael
parents: 1838
diff changeset
2328
753
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 745
diff changeset
2329 ox= s->sprite_offset[0][0] + s->sprite_delta[0][0]*s->mb_x*16 + s->sprite_delta[0][1]*s->mb_y*16;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 745
diff changeset
2330 oy= s->sprite_offset[0][1] + s->sprite_delta[1][0]*s->mb_x*16 + s->sprite_delta[1][1]*s->mb_y*16;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 745
diff changeset
2331
853
eacc2dd8fd9d * using DSPContext - so each codec could use its local (sub)set of CPU extension
kabi
parents: 847
diff changeset
2332 s->dsp.gmc(dest_y, ptr, linesize, 16,
753
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 745
diff changeset
2333 ox,
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 745
diff changeset
2334 oy,
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 745
diff changeset
2335 s->sprite_delta[0][0], s->sprite_delta[0][1],
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 745
diff changeset
2336 s->sprite_delta[1][0], s->sprite_delta[1][1],
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 745
diff changeset
2337 a+1, (1<<(2*a+1)) - s->no_rounding,
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 745
diff changeset
2338 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
2339 s->dsp.gmc(dest_y+8, ptr, linesize, 16,
753
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 745
diff changeset
2340 ox + s->sprite_delta[0][0]*8,
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 745
diff changeset
2341 oy + s->sprite_delta[1][0]*8,
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 745
diff changeset
2342 s->sprite_delta[0][0], s->sprite_delta[0][1],
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 745
diff changeset
2343 s->sprite_delta[1][0], s->sprite_delta[1][1],
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 745
diff changeset
2344 a+1, (1<<(2*a+1)) - s->no_rounding,
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 745
diff changeset
2345 s->h_edge_pos, s->v_edge_pos);
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 745
diff changeset
2346
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 745
diff changeset
2347 if(s->flags&CODEC_FLAG_GRAY) return;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 745
diff changeset
2348
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 745
diff changeset
2349 ox= s->sprite_offset[1][0] + s->sprite_delta[0][0]*s->mb_x*8 + s->sprite_delta[0][1]*s->mb_y*8;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 745
diff changeset
2350 oy= s->sprite_offset[1][1] + s->sprite_delta[1][0]*s->mb_x*8 + s->sprite_delta[1][1]*s->mb_y*8;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 745
diff changeset
2351
1842
0d82db458a3c interlaced mpeg4 + edge emu fix (fixes decoding of mermaid.avi)
michael
parents: 1838
diff changeset
2352 ptr = ref_picture[1];
853
eacc2dd8fd9d * using DSPContext - so each codec could use its local (sub)set of CPU extension
kabi
parents: 847
diff changeset
2353 s->dsp.gmc(dest_cb, ptr, uvlinesize, 8,
753
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 745
diff changeset
2354 ox,
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 745
diff changeset
2355 oy,
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 745
diff changeset
2356 s->sprite_delta[0][0], s->sprite_delta[0][1],
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 745
diff changeset
2357 s->sprite_delta[1][0], s->sprite_delta[1][1],
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 745
diff changeset
2358 a+1, (1<<(2*a+1)) - s->no_rounding,
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 745
diff changeset
2359 s->h_edge_pos>>1, s->v_edge_pos>>1);
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 745
diff changeset
2360
1842
0d82db458a3c interlaced mpeg4 + edge emu fix (fixes decoding of mermaid.avi)
michael
parents: 1838
diff changeset
2361 ptr = ref_picture[2];
853
eacc2dd8fd9d * using DSPContext - so each codec could use its local (sub)set of CPU extension
kabi
parents: 847
diff changeset
2362 s->dsp.gmc(dest_cr, ptr, uvlinesize, 8,
753
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 745
diff changeset
2363 ox,
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 745
diff changeset
2364 oy,
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 745
diff changeset
2365 s->sprite_delta[0][0], s->sprite_delta[0][1],
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 745
diff changeset
2366 s->sprite_delta[1][0], s->sprite_delta[1][1],
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 745
diff changeset
2367 a+1, (1<<(2*a+1)) - s->no_rounding,
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 745
diff changeset
2368 s->h_edge_pos>>1, s->v_edge_pos>>1);
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 745
diff changeset
2369 }
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 745
diff changeset
2370
1317
26c44d2433c1 make ff_emulated_edge_mc() independant of MpegEncContext
michaelni
parents: 1315
diff changeset
2371 /**
26c44d2433c1 make ff_emulated_edge_mc() independant of MpegEncContext
michaelni
parents: 1315
diff changeset
2372 * 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
2373 * @param buf destination buffer
26c44d2433c1 make ff_emulated_edge_mc() independant of MpegEncContext
michaelni
parents: 1315
diff changeset
2374 * @param src source buffer
26c44d2433c1 make ff_emulated_edge_mc() independant of MpegEncContext
michaelni
parents: 1315
diff changeset
2375 * @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
2376 * @param block_w width of block
26c44d2433c1 make ff_emulated_edge_mc() independant of MpegEncContext
michaelni
parents: 1315
diff changeset
2377 * @param block_h height of block
26c44d2433c1 make ff_emulated_edge_mc() independant of MpegEncContext
michaelni
parents: 1315
diff changeset
2378 * @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
2379 * @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
2380 * @param w width of the source buffer
26c44d2433c1 make ff_emulated_edge_mc() independant of MpegEncContext
michaelni
parents: 1315
diff changeset
2381 * @param h height of the source buffer
26c44d2433c1 make ff_emulated_edge_mc() independant of MpegEncContext
michaelni
parents: 1315
diff changeset
2382 */
26c44d2433c1 make ff_emulated_edge_mc() independant of MpegEncContext
michaelni
parents: 1315
diff changeset
2383 void ff_emulated_edge_mc(uint8_t *buf, uint8_t *src, int linesize, int block_w, int block_h,
553
18ad513d92fe direct rendering method 1 support
michaelni
parents: 549
diff changeset
2384 int src_x, int src_y, int w, int h){
18ad513d92fe direct rendering method 1 support
michaelni
parents: 549
diff changeset
2385 int x, y;
18ad513d92fe direct rendering method 1 support
michaelni
parents: 549
diff changeset
2386 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
2387
553
18ad513d92fe direct rendering method 1 support
michaelni
parents: 549
diff changeset
2388 if(src_y>= h){
18ad513d92fe direct rendering method 1 support
michaelni
parents: 549
diff changeset
2389 src+= (h-1-src_y)*linesize;
18ad513d92fe direct rendering method 1 support
michaelni
parents: 549
diff changeset
2390 src_y=h-1;
554
3eb6fe38019a 4mv & qpel edge emu
michaelni
parents: 553
diff changeset
2391 }else if(src_y<=-block_h){
3eb6fe38019a 4mv & qpel edge emu
michaelni
parents: 553
diff changeset
2392 src+= (1-block_h-src_y)*linesize;
3eb6fe38019a 4mv & qpel edge emu
michaelni
parents: 553
diff changeset
2393 src_y=1-block_h;
553
18ad513d92fe direct rendering method 1 support
michaelni
parents: 549
diff changeset
2394 }
18ad513d92fe direct rendering method 1 support
michaelni
parents: 549
diff changeset
2395 if(src_x>= w){
18ad513d92fe direct rendering method 1 support
michaelni
parents: 549
diff changeset
2396 src+= (w-1-src_x);
18ad513d92fe direct rendering method 1 support
michaelni
parents: 549
diff changeset
2397 src_x=w-1;
554
3eb6fe38019a 4mv & qpel edge emu
michaelni
parents: 553
diff changeset
2398 }else if(src_x<=-block_w){
3eb6fe38019a 4mv & qpel edge emu
michaelni
parents: 553
diff changeset
2399 src+= (1-block_w-src_x);
3eb6fe38019a 4mv & qpel edge emu
michaelni
parents: 553
diff changeset
2400 src_x=1-block_w;
553
18ad513d92fe direct rendering method 1 support
michaelni
parents: 549
diff changeset
2401 }
18ad513d92fe direct rendering method 1 support
michaelni
parents: 549
diff changeset
2402
847
f3c369b8ddca reversing header game
michaelni
parents: 843
diff changeset
2403 start_y= FFMAX(0, -src_y);
f3c369b8ddca reversing header game
michaelni
parents: 843
diff changeset
2404 start_x= FFMAX(0, -src_x);
f3c369b8ddca reversing header game
michaelni
parents: 843
diff changeset
2405 end_y= FFMIN(block_h, h-src_y);
f3c369b8ddca reversing header game
michaelni
parents: 843
diff changeset
2406 end_x= FFMIN(block_w, w-src_x);
566
c376a0b290cf fixing gmc with emu edges
michaelni
parents: 565
diff changeset
2407
553
18ad513d92fe direct rendering method 1 support
michaelni
parents: 549
diff changeset
2408 // copy existing part
18ad513d92fe direct rendering method 1 support
michaelni
parents: 549
diff changeset
2409 for(y=start_y; y<end_y; y++){
18ad513d92fe direct rendering method 1 support
michaelni
parents: 549
diff changeset
2410 for(x=start_x; x<end_x; x++){
18ad513d92fe direct rendering method 1 support
michaelni
parents: 549
diff changeset
2411 buf[x + y*linesize]= src[x + y*linesize];
18ad513d92fe direct rendering method 1 support
michaelni
parents: 549
diff changeset
2412 }
18ad513d92fe direct rendering method 1 support
michaelni
parents: 549
diff changeset
2413 }
18ad513d92fe direct rendering method 1 support
michaelni
parents: 549
diff changeset
2414
18ad513d92fe direct rendering method 1 support
michaelni
parents: 549
diff changeset
2415 //top
18ad513d92fe direct rendering method 1 support
michaelni
parents: 549
diff changeset
2416 for(y=0; y<start_y; y++){
18ad513d92fe direct rendering method 1 support
michaelni
parents: 549
diff changeset
2417 for(x=start_x; x<end_x; x++){
18ad513d92fe direct rendering method 1 support
michaelni
parents: 549
diff changeset
2418 buf[x + y*linesize]= buf[x + start_y*linesize];
18ad513d92fe direct rendering method 1 support
michaelni
parents: 549
diff changeset
2419 }
18ad513d92fe direct rendering method 1 support
michaelni
parents: 549
diff changeset
2420 }
18ad513d92fe direct rendering method 1 support
michaelni
parents: 549
diff changeset
2421
18ad513d92fe direct rendering method 1 support
michaelni
parents: 549
diff changeset
2422 //bottom
18ad513d92fe direct rendering method 1 support
michaelni
parents: 549
diff changeset
2423 for(y=end_y; y<block_h; y++){
18ad513d92fe direct rendering method 1 support
michaelni
parents: 549
diff changeset
2424 for(x=start_x; x<end_x; x++){
18ad513d92fe direct rendering method 1 support
michaelni
parents: 549
diff changeset
2425 buf[x + y*linesize]= buf[x + (end_y-1)*linesize];
18ad513d92fe direct rendering method 1 support
michaelni
parents: 549
diff changeset
2426 }
18ad513d92fe direct rendering method 1 support
michaelni
parents: 549
diff changeset
2427 }
18ad513d92fe direct rendering method 1 support
michaelni
parents: 549
diff changeset
2428
18ad513d92fe direct rendering method 1 support
michaelni
parents: 549
diff changeset
2429 for(y=0; y<block_h; y++){
18ad513d92fe direct rendering method 1 support
michaelni
parents: 549
diff changeset
2430 //left
18ad513d92fe direct rendering method 1 support
michaelni
parents: 549
diff changeset
2431 for(x=0; x<start_x; x++){
18ad513d92fe direct rendering method 1 support
michaelni
parents: 549
diff changeset
2432 buf[x + y*linesize]= buf[start_x + y*linesize];
18ad513d92fe direct rendering method 1 support
michaelni
parents: 549
diff changeset
2433 }
18ad513d92fe direct rendering method 1 support
michaelni
parents: 549
diff changeset
2434
18ad513d92fe direct rendering method 1 support
michaelni
parents: 549
diff changeset
2435 //right
18ad513d92fe direct rendering method 1 support
michaelni
parents: 549
diff changeset
2436 for(x=end_x; x<block_w; x++){
18ad513d92fe direct rendering method 1 support
michaelni
parents: 549
diff changeset
2437 buf[x + y*linesize]= buf[end_x - 1 + y*linesize];
18ad513d92fe direct rendering method 1 support
michaelni
parents: 549
diff changeset
2438 }
18ad513d92fe direct rendering method 1 support
michaelni
parents: 549
diff changeset
2439 }
18ad513d92fe direct rendering method 1 support
michaelni
parents: 549
diff changeset
2440 }
18ad513d92fe direct rendering method 1 support
michaelni
parents: 549
diff changeset
2441
1633
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1632
diff changeset
2442 static inline int hpel_motion(MpegEncContext *s,
1842
0d82db458a3c interlaced mpeg4 + edge emu fix (fixes decoding of mermaid.avi)
michael
parents: 1838
diff changeset
2443 uint8_t *dest, uint8_t *src,
0d82db458a3c interlaced mpeg4 + edge emu fix (fixes decoding of mermaid.avi)
michael
parents: 1838
diff changeset
2444 int field_based, int field_select,
1633
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1632
diff changeset
2445 int src_x, int src_y,
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1632
diff changeset
2446 int width, int height, int stride,
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1632
diff changeset
2447 int h_edge_pos, int v_edge_pos,
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1632
diff changeset
2448 int w, int h, op_pixels_func *pix_op,
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1632
diff changeset
2449 int motion_x, int motion_y)
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1632
diff changeset
2450 {
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1632
diff changeset
2451 int dxy;
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1632
diff changeset
2452 int emu=0;
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1632
diff changeset
2453
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1632
diff changeset
2454 dxy = ((motion_y & 1) << 1) | (motion_x & 1);
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1632
diff changeset
2455 src_x += motion_x >> 1;
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1632
diff changeset
2456 src_y += motion_y >> 1;
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1632
diff changeset
2457
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1632
diff changeset
2458 /* WARNING: do no forget half pels */
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1632
diff changeset
2459 src_x = clip(src_x, -16, width); //FIXME unneeded for emu?
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1632
diff changeset
2460 if (src_x == width)
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1632
diff changeset
2461 dxy &= ~1;
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1632
diff changeset
2462 src_y = clip(src_y, -16, height);
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1632
diff changeset
2463 if (src_y == height)
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1632
diff changeset
2464 dxy &= ~2;
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1632
diff changeset
2465 src += src_y * stride + src_x;
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1632
diff changeset
2466
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1632
diff changeset
2467 if(s->unrestricted_mv && (s->flags&CODEC_FLAG_EMU_EDGE)){
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1632
diff changeset
2468 if( (unsigned)src_x > h_edge_pos - (motion_x&1) - w
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1632
diff changeset
2469 || (unsigned)src_y > v_edge_pos - (motion_y&1) - h){
1842
0d82db458a3c interlaced mpeg4 + edge emu fix (fixes decoding of mermaid.avi)
michael
parents: 1838
diff changeset
2470 ff_emulated_edge_mc(s->edge_emu_buffer, src, s->linesize, w+1, (h+1)<<field_based,
0d82db458a3c interlaced mpeg4 + edge emu fix (fixes decoding of mermaid.avi)
michael
parents: 1838
diff changeset
2471 src_x, src_y<<field_based, h_edge_pos, s->v_edge_pos);
1633
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1632
diff changeset
2472 src= s->edge_emu_buffer;
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1632
diff changeset
2473 emu=1;
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1632
diff changeset
2474 }
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1632
diff changeset
2475 }
1842
0d82db458a3c interlaced mpeg4 + edge emu fix (fixes decoding of mermaid.avi)
michael
parents: 1838
diff changeset
2476 if(field_select)
0d82db458a3c interlaced mpeg4 + edge emu fix (fixes decoding of mermaid.avi)
michael
parents: 1838
diff changeset
2477 src += s->linesize;
1633
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1632
diff changeset
2478 pix_op[dxy](dest, src, stride, h);
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1632
diff changeset
2479 return emu;
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1632
diff changeset
2480 }
553
18ad513d92fe direct rendering method 1 support
michaelni
parents: 549
diff changeset
2481
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2482 /* apply one mpeg motion vector to the three components */
2074
2faafe7a3db6 mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents: 2066
diff changeset
2483 static always_inline void mpeg_motion(MpegEncContext *s,
1064
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1059
diff changeset
2484 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
1842
0d82db458a3c interlaced mpeg4 + edge emu fix (fixes decoding of mermaid.avi)
michael
parents: 1838
diff changeset
2485 int field_based, int bottom_field, int field_select,
0d82db458a3c interlaced mpeg4 + edge emu fix (fixes decoding of mermaid.avi)
michael
parents: 1838
diff changeset
2486 uint8_t **ref_picture, op_pixels_func (*pix_op)[4],
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2487 int motion_x, int motion_y, int h)
986e461dc072 Initial revision
glantau
parents:
diff changeset
2488 {
1846
cea4f1a80059 optimizing/cleanup of mpeg/qpel_motion()
michael
parents: 1843
diff changeset
2489 uint8_t *ptr_y, *ptr_cb, *ptr_cr;
cea4f1a80059 optimizing/cleanup of mpeg/qpel_motion()
michael
parents: 1843
diff changeset
2490 int dxy, uvdxy, mx, my, src_x, src_y, uvsrc_x, uvsrc_y, v_edge_pos, uvlinesize, linesize;
1842
0d82db458a3c interlaced mpeg4 + edge emu fix (fixes decoding of mermaid.avi)
michael
parents: 1838
diff changeset
2491
651
45e8f39fda50 put/avg_pixels16
michaelni
parents: 650
diff changeset
2492 #if 0
255
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
2493 if(s->quarter_sample)
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
2494 {
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
2495 motion_x>>=1;
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
2496 motion_y>>=1;
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
2497 }
651
45e8f39fda50 put/avg_pixels16
michaelni
parents: 650
diff changeset
2498 #endif
1633
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1632
diff changeset
2499
582
5132a4ee50cd different edge positions fixed with edge emu / dr1
michaelni
parents: 575
diff changeset
2500 v_edge_pos = s->v_edge_pos >> field_based;
1846
cea4f1a80059 optimizing/cleanup of mpeg/qpel_motion()
michael
parents: 1843
diff changeset
2501 linesize = s->current_picture.linesize[0] << field_based;
1138
e10e841c9bf0 field pic decoding cleanup
michaelni
parents: 1130
diff changeset
2502 uvlinesize = s->current_picture.linesize[1] << field_based;
1633
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1632
diff changeset
2503
1846
cea4f1a80059 optimizing/cleanup of mpeg/qpel_motion()
michael
parents: 1843
diff changeset
2504 dxy = ((motion_y & 1) << 1) | (motion_x & 1);
cea4f1a80059 optimizing/cleanup of mpeg/qpel_motion()
michael
parents: 1843
diff changeset
2505 src_x = s->mb_x* 16 + (motion_x >> 1);
2074
2faafe7a3db6 mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents: 2066
diff changeset
2506 src_y =(s->mb_y<<(4-field_based)) + (motion_y >> 1);
485
20108840b0e5 grayscale only decoding
michaelni
parents: 481
diff changeset
2507
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2508 if (s->out_format == FMT_H263) {
1916
f2d134308a70 interlaced chroma MC divx-bug workaround
michael
parents: 1907
diff changeset
2509 if((s->workaround_bugs & FF_BUG_HPEL_CHROMA) && field_based){
f2d134308a70 interlaced chroma MC divx-bug workaround
michael
parents: 1907
diff changeset
2510 mx = (motion_x>>1)|(motion_x&1);
f2d134308a70 interlaced chroma MC divx-bug workaround
michael
parents: 1907
diff changeset
2511 my = motion_y >>1;
f2d134308a70 interlaced chroma MC divx-bug workaround
michael
parents: 1907
diff changeset
2512 uvdxy = ((my & 1) << 1) | (mx & 1);
f2d134308a70 interlaced chroma MC divx-bug workaround
michael
parents: 1907
diff changeset
2513 uvsrc_x = s->mb_x* 8 + (mx >> 1);
2074
2faafe7a3db6 mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents: 2066
diff changeset
2514 uvsrc_y = (s->mb_y<<(3-field_based)) + (my >> 1);
1916
f2d134308a70 interlaced chroma MC divx-bug workaround
michael
parents: 1907
diff changeset
2515 }else{
f2d134308a70 interlaced chroma MC divx-bug workaround
michael
parents: 1907
diff changeset
2516 uvdxy = dxy | (motion_y & 2) | ((motion_x & 2) >> 1);
f2d134308a70 interlaced chroma MC divx-bug workaround
michael
parents: 1907
diff changeset
2517 uvsrc_x = src_x>>1;
f2d134308a70 interlaced chroma MC divx-bug workaround
michael
parents: 1907
diff changeset
2518 uvsrc_y = src_y>>1;
f2d134308a70 interlaced chroma MC divx-bug workaround
michael
parents: 1907
diff changeset
2519 }
2044
b6f2add2511e h261 decoder by (Maarten Daniels <maarten.daniels at student dot luc dot ac dot be>)
michael
parents: 2042
diff changeset
2520 }else if(s->out_format == FMT_H261){//even chroma mv's are full pel in H261
b6f2add2511e h261 decoder by (Maarten Daniels <maarten.daniels at student dot luc dot ac dot be>)
michael
parents: 2042
diff changeset
2521 mx = motion_x / 4;
b6f2add2511e h261 decoder by (Maarten Daniels <maarten.daniels at student dot luc dot ac dot be>)
michael
parents: 2042
diff changeset
2522 my = motion_y / 4;
b6f2add2511e h261 decoder by (Maarten Daniels <maarten.daniels at student dot luc dot ac dot be>)
michael
parents: 2042
diff changeset
2523 uvdxy = 0;
b6f2add2511e h261 decoder by (Maarten Daniels <maarten.daniels at student dot luc dot ac dot be>)
michael
parents: 2042
diff changeset
2524 uvsrc_x = s->mb_x*8 + mx;
b6f2add2511e h261 decoder by (Maarten Daniels <maarten.daniels at student dot luc dot ac dot be>)
michael
parents: 2042
diff changeset
2525 uvsrc_y = s->mb_y*8 + my;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2526 } else {
2074
2faafe7a3db6 mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents: 2066
diff changeset
2527 if(s->chroma_y_shift){
2faafe7a3db6 mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents: 2066
diff changeset
2528 mx = motion_x / 2;
2faafe7a3db6 mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents: 2066
diff changeset
2529 my = motion_y / 2;
2faafe7a3db6 mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents: 2066
diff changeset
2530 uvdxy = ((my & 1) << 1) | (mx & 1);
2faafe7a3db6 mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents: 2066
diff changeset
2531 uvsrc_x = s->mb_x* 8 + (mx >> 1);
2faafe7a3db6 mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents: 2066
diff changeset
2532 uvsrc_y = (s->mb_y<<(3-field_based)) + (my >> 1);
2faafe7a3db6 mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents: 2066
diff changeset
2533 } else {
2faafe7a3db6 mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents: 2066
diff changeset
2534 if(s->chroma_x_shift){
2faafe7a3db6 mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents: 2066
diff changeset
2535 //Chroma422
2faafe7a3db6 mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents: 2066
diff changeset
2536 mx = motion_x / 2;
2faafe7a3db6 mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents: 2066
diff changeset
2537 uvdxy = ((motion_y & 1) << 1) | (mx & 1);
2faafe7a3db6 mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents: 2066
diff changeset
2538 uvsrc_x = s->mb_x* 8 + (mx >> 1);
2faafe7a3db6 mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents: 2066
diff changeset
2539 uvsrc_y = src_y;
2faafe7a3db6 mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents: 2066
diff changeset
2540 } else {
2faafe7a3db6 mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents: 2066
diff changeset
2541 //Chroma444
2faafe7a3db6 mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents: 2066
diff changeset
2542 uvdxy = dxy;
2faafe7a3db6 mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents: 2066
diff changeset
2543 uvsrc_x = src_x;
2faafe7a3db6 mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents: 2066
diff changeset
2544 uvsrc_y = src_y;
2faafe7a3db6 mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents: 2066
diff changeset
2545 }
2faafe7a3db6 mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents: 2066
diff changeset
2546 }
1846
cea4f1a80059 optimizing/cleanup of mpeg/qpel_motion()
michael
parents: 1843
diff changeset
2547 }
cea4f1a80059 optimizing/cleanup of mpeg/qpel_motion()
michael
parents: 1843
diff changeset
2548
cea4f1a80059 optimizing/cleanup of mpeg/qpel_motion()
michael
parents: 1843
diff changeset
2549 ptr_y = ref_picture[0] + src_y * linesize + src_x;
cea4f1a80059 optimizing/cleanup of mpeg/qpel_motion()
michael
parents: 1843
diff changeset
2550 ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x;
cea4f1a80059 optimizing/cleanup of mpeg/qpel_motion()
michael
parents: 1843
diff changeset
2551 ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x;
cea4f1a80059 optimizing/cleanup of mpeg/qpel_motion()
michael
parents: 1843
diff changeset
2552
cea4f1a80059 optimizing/cleanup of mpeg/qpel_motion()
michael
parents: 1843
diff changeset
2553 if( (unsigned)src_x > s->h_edge_pos - (motion_x&1) - 16
cea4f1a80059 optimizing/cleanup of mpeg/qpel_motion()
michael
parents: 1843
diff changeset
2554 || (unsigned)src_y > v_edge_pos - (motion_y&1) - h){
2074
2faafe7a3db6 mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents: 2066
diff changeset
2555 if(s->codec_id == CODEC_ID_MPEG2VIDEO ||
2faafe7a3db6 mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents: 2066
diff changeset
2556 s->codec_id == CODEC_ID_MPEG1VIDEO){
2faafe7a3db6 mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents: 2066
diff changeset
2557 av_log(s->avctx,AV_LOG_DEBUG,"MPEG motion vector out of boundary\n");
2faafe7a3db6 mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents: 2066
diff changeset
2558 return ;
2faafe7a3db6 mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents: 2066
diff changeset
2559 }
1846
cea4f1a80059 optimizing/cleanup of mpeg/qpel_motion()
michael
parents: 1843
diff changeset
2560 ff_emulated_edge_mc(s->edge_emu_buffer, ptr_y, s->linesize, 17, 17+field_based,
cea4f1a80059 optimizing/cleanup of mpeg/qpel_motion()
michael
parents: 1843
diff changeset
2561 src_x, src_y<<field_based, s->h_edge_pos, s->v_edge_pos);
cea4f1a80059 optimizing/cleanup of mpeg/qpel_motion()
michael
parents: 1843
diff changeset
2562 ptr_y = s->edge_emu_buffer;
cea4f1a80059 optimizing/cleanup of mpeg/qpel_motion()
michael
parents: 1843
diff changeset
2563 if(!(s->flags&CODEC_FLAG_GRAY)){
1874
michael
parents: 1863
diff changeset
2564 uint8_t *uvbuf= s->edge_emu_buffer+18*s->linesize;
1846
cea4f1a80059 optimizing/cleanup of mpeg/qpel_motion()
michael
parents: 1843
diff changeset
2565 ff_emulated_edge_mc(uvbuf , ptr_cb, s->uvlinesize, 9, 9+field_based,
cea4f1a80059 optimizing/cleanup of mpeg/qpel_motion()
michael
parents: 1843
diff changeset
2566 uvsrc_x, uvsrc_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
cea4f1a80059 optimizing/cleanup of mpeg/qpel_motion()
michael
parents: 1843
diff changeset
2567 ff_emulated_edge_mc(uvbuf+16, ptr_cr, s->uvlinesize, 9, 9+field_based,
cea4f1a80059 optimizing/cleanup of mpeg/qpel_motion()
michael
parents: 1843
diff changeset
2568 uvsrc_x, uvsrc_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
cea4f1a80059 optimizing/cleanup of mpeg/qpel_motion()
michael
parents: 1843
diff changeset
2569 ptr_cb= uvbuf;
cea4f1a80059 optimizing/cleanup of mpeg/qpel_motion()
michael
parents: 1843
diff changeset
2570 ptr_cr= uvbuf+16;
cea4f1a80059 optimizing/cleanup of mpeg/qpel_motion()
michael
parents: 1843
diff changeset
2571 }
cea4f1a80059 optimizing/cleanup of mpeg/qpel_motion()
michael
parents: 1843
diff changeset
2572 }
cea4f1a80059 optimizing/cleanup of mpeg/qpel_motion()
michael
parents: 1843
diff changeset
2573
cea4f1a80059 optimizing/cleanup of mpeg/qpel_motion()
michael
parents: 1843
diff changeset
2574 if(bottom_field){ //FIXME use this for field pix too instead of the obnoxious hack which changes picture.data
cea4f1a80059 optimizing/cleanup of mpeg/qpel_motion()
michael
parents: 1843
diff changeset
2575 dest_y += s->linesize;
cea4f1a80059 optimizing/cleanup of mpeg/qpel_motion()
michael
parents: 1843
diff changeset
2576 dest_cb+= s->uvlinesize;
cea4f1a80059 optimizing/cleanup of mpeg/qpel_motion()
michael
parents: 1843
diff changeset
2577 dest_cr+= s->uvlinesize;
cea4f1a80059 optimizing/cleanup of mpeg/qpel_motion()
michael
parents: 1843
diff changeset
2578 }
cea4f1a80059 optimizing/cleanup of mpeg/qpel_motion()
michael
parents: 1843
diff changeset
2579
cea4f1a80059 optimizing/cleanup of mpeg/qpel_motion()
michael
parents: 1843
diff changeset
2580 if(field_select){
cea4f1a80059 optimizing/cleanup of mpeg/qpel_motion()
michael
parents: 1843
diff changeset
2581 ptr_y += s->linesize;
cea4f1a80059 optimizing/cleanup of mpeg/qpel_motion()
michael
parents: 1843
diff changeset
2582 ptr_cb+= s->uvlinesize;
cea4f1a80059 optimizing/cleanup of mpeg/qpel_motion()
michael
parents: 1843
diff changeset
2583 ptr_cr+= s->uvlinesize;
cea4f1a80059 optimizing/cleanup of mpeg/qpel_motion()
michael
parents: 1843
diff changeset
2584 }
cea4f1a80059 optimizing/cleanup of mpeg/qpel_motion()
michael
parents: 1843
diff changeset
2585
cea4f1a80059 optimizing/cleanup of mpeg/qpel_motion()
michael
parents: 1843
diff changeset
2586 pix_op[0][dxy](dest_y, ptr_y, linesize, h);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2587
1846
cea4f1a80059 optimizing/cleanup of mpeg/qpel_motion()
michael
parents: 1843
diff changeset
2588 if(!(s->flags&CODEC_FLAG_GRAY)){
2074
2faafe7a3db6 mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents: 2066
diff changeset
2589 pix_op[s->chroma_x_shift][uvdxy](dest_cb, ptr_cb, uvlinesize, h >> s->chroma_y_shift);
2faafe7a3db6 mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents: 2066
diff changeset
2590 pix_op[s->chroma_x_shift][uvdxy](dest_cr, ptr_cr, uvlinesize, h >> s->chroma_y_shift);
1846
cea4f1a80059 optimizing/cleanup of mpeg/qpel_motion()
michael
parents: 1843
diff changeset
2591 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2592 }
1633
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1632
diff changeset
2593 //FIXME move to dsputil, avg variant, 16x16 version
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1632
diff changeset
2594 static inline void put_obmc(uint8_t *dst, uint8_t *src[5], int stride){
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1632
diff changeset
2595 int x;
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1632
diff changeset
2596 uint8_t * const top = src[1];
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1632
diff changeset
2597 uint8_t * const left = src[2];
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1632
diff changeset
2598 uint8_t * const mid = src[0];
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1632
diff changeset
2599 uint8_t * const right = src[3];
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1632
diff changeset
2600 uint8_t * const bottom= src[4];
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1632
diff changeset
2601 #define OBMC_FILTER(x, t, l, m, r, b)\
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1632
diff changeset
2602 dst[x]= (t*top[x] + l*left[x] + m*mid[x] + r*right[x] + b*bottom[x] + 4)>>3
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1632
diff changeset
2603 #define OBMC_FILTER4(x, t, l, m, r, b)\
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1632
diff changeset
2604 OBMC_FILTER(x , t, l, m, r, b);\
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1632
diff changeset
2605 OBMC_FILTER(x+1 , t, l, m, r, b);\
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1632
diff changeset
2606 OBMC_FILTER(x +stride, t, l, m, r, b);\
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1632
diff changeset
2607 OBMC_FILTER(x+1+stride, t, l, m, r, b);
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1632
diff changeset
2608
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1632
diff changeset
2609 x=0;
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1632
diff changeset
2610 OBMC_FILTER (x , 2, 2, 4, 0, 0);
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1632
diff changeset
2611 OBMC_FILTER (x+1, 2, 1, 5, 0, 0);
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1632
diff changeset
2612 OBMC_FILTER4(x+2, 2, 1, 5, 0, 0);
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1632
diff changeset
2613 OBMC_FILTER4(x+4, 2, 0, 5, 1, 0);
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1632
diff changeset
2614 OBMC_FILTER (x+6, 2, 0, 5, 1, 0);
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1632
diff changeset
2615 OBMC_FILTER (x+7, 2, 0, 4, 2, 0);
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1632
diff changeset
2616 x+= stride;
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1632
diff changeset
2617 OBMC_FILTER (x , 1, 2, 5, 0, 0);
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1632
diff changeset
2618 OBMC_FILTER (x+1, 1, 2, 5, 0, 0);
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1632
diff changeset
2619 OBMC_FILTER (x+6, 1, 0, 5, 2, 0);
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1632
diff changeset
2620 OBMC_FILTER (x+7, 1, 0, 5, 2, 0);
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1632
diff changeset
2621 x+= stride;
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1632
diff changeset
2622 OBMC_FILTER4(x , 1, 2, 5, 0, 0);
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1632
diff changeset
2623 OBMC_FILTER4(x+2, 1, 1, 6, 0, 0);
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1632
diff changeset
2624 OBMC_FILTER4(x+4, 1, 0, 6, 1, 0);
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1632
diff changeset
2625 OBMC_FILTER4(x+6, 1, 0, 5, 2, 0);
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1632
diff changeset
2626 x+= 2*stride;
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1632
diff changeset
2627 OBMC_FILTER4(x , 0, 2, 5, 0, 1);
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1632
diff changeset
2628 OBMC_FILTER4(x+2, 0, 1, 6, 0, 1);
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1632
diff changeset
2629 OBMC_FILTER4(x+4, 0, 0, 6, 1, 1);
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1632
diff changeset
2630 OBMC_FILTER4(x+6, 0, 0, 5, 2, 1);
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1632
diff changeset
2631 x+= 2*stride;
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1632
diff changeset
2632 OBMC_FILTER (x , 0, 2, 5, 0, 1);
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1632
diff changeset
2633 OBMC_FILTER (x+1, 0, 2, 5, 0, 1);
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1632
diff changeset
2634 OBMC_FILTER4(x+2, 0, 1, 5, 0, 2);
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1632
diff changeset
2635 OBMC_FILTER4(x+4, 0, 0, 5, 1, 2);
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1632
diff changeset
2636 OBMC_FILTER (x+6, 0, 0, 5, 2, 1);
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1632
diff changeset
2637 OBMC_FILTER (x+7, 0, 0, 5, 2, 1);
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1632
diff changeset
2638 x+= stride;
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1632
diff changeset
2639 OBMC_FILTER (x , 0, 2, 4, 0, 2);
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1632
diff changeset
2640 OBMC_FILTER (x+1, 0, 1, 5, 0, 2);
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1632
diff changeset
2641 OBMC_FILTER (x+6, 0, 0, 5, 1, 2);
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1632
diff changeset
2642 OBMC_FILTER (x+7, 0, 0, 4, 2, 2);
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1632
diff changeset
2643 }
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1632
diff changeset
2644
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1632
diff changeset
2645 /* obmc for 1 8x8 luma block */
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1632
diff changeset
2646 static inline void obmc_motion(MpegEncContext *s,
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1632
diff changeset
2647 uint8_t *dest, uint8_t *src,
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1632
diff changeset
2648 int src_x, int src_y,
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1632
diff changeset
2649 op_pixels_func *pix_op,
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1632
diff changeset
2650 int16_t mv[5][2]/* mid top left right bottom*/)
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1632
diff changeset
2651 #define MID 0
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1632
diff changeset
2652 {
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1632
diff changeset
2653 int i;
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1632
diff changeset
2654 uint8_t *ptr[5];
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1632
diff changeset
2655
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1632
diff changeset
2656 assert(s->quarter_sample==0);
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1632
diff changeset
2657
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1632
diff changeset
2658 for(i=0; i<5; i++){
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1632
diff changeset
2659 if(i && mv[i][0]==mv[MID][0] && mv[i][1]==mv[MID][1]){
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1632
diff changeset
2660 ptr[i]= ptr[MID];
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1632
diff changeset
2661 }else{
1799
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
2662 ptr[i]= s->obmc_scratchpad + 8*(i&1) + s->linesize*8*(i>>1);
1842
0d82db458a3c interlaced mpeg4 + edge emu fix (fixes decoding of mermaid.avi)
michael
parents: 1838
diff changeset
2663 hpel_motion(s, ptr[i], src, 0, 0,
1633
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1632
diff changeset
2664 src_x, src_y,
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1632
diff changeset
2665 s->width, s->height, s->linesize,
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1632
diff changeset
2666 s->h_edge_pos, s->v_edge_pos,
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1632
diff changeset
2667 8, 8, pix_op,
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1632
diff changeset
2668 mv[i][0], mv[i][1]);
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1632
diff changeset
2669 }
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1632
diff changeset
2670 }
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1632
diff changeset
2671
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1632
diff changeset
2672 put_obmc(dest, ptr, s->linesize);
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1632
diff changeset
2673 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2674
255
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
2675 static inline void qpel_motion(MpegEncContext *s,
1064
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1059
diff changeset
2676 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
1842
0d82db458a3c interlaced mpeg4 + edge emu fix (fixes decoding of mermaid.avi)
michael
parents: 1838
diff changeset
2677 int field_based, int bottom_field, int field_select,
0d82db458a3c interlaced mpeg4 + edge emu fix (fixes decoding of mermaid.avi)
michael
parents: 1838
diff changeset
2678 uint8_t **ref_picture, op_pixels_func (*pix_op)[4],
651
45e8f39fda50 put/avg_pixels16
michaelni
parents: 650
diff changeset
2679 qpel_mc_func (*qpix_op)[16],
255
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
2680 int motion_x, int motion_y, int h)
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
2681 {
1846
cea4f1a80059 optimizing/cleanup of mpeg/qpel_motion()
michael
parents: 1843
diff changeset
2682 uint8_t *ptr_y, *ptr_cb, *ptr_cr;
cea4f1a80059 optimizing/cleanup of mpeg/qpel_motion()
michael
parents: 1843
diff changeset
2683 int dxy, uvdxy, mx, my, src_x, src_y, uvsrc_x, uvsrc_y, v_edge_pos, linesize, uvlinesize;
1842
0d82db458a3c interlaced mpeg4 + edge emu fix (fixes decoding of mermaid.avi)
michael
parents: 1838
diff changeset
2684
255
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
2685 dxy = ((motion_y & 3) << 2) | (motion_x & 3);
1846
cea4f1a80059 optimizing/cleanup of mpeg/qpel_motion()
michael
parents: 1843
diff changeset
2686 src_x = s->mb_x * 16 + (motion_x >> 2);
255
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
2687 src_y = s->mb_y * (16 >> field_based) + (motion_y >> 2);
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
2688
582
5132a4ee50cd different edge positions fixed with edge emu / dr1
michaelni
parents: 575
diff changeset
2689 v_edge_pos = s->v_edge_pos >> field_based;
255
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
2690 linesize = s->linesize << field_based;
671
3f2e5a282f61 interlaced qpel mpeg4 fixed
michaelni
parents: 664
diff changeset
2691 uvlinesize = s->uvlinesize << field_based;
554
3eb6fe38019a 4mv & qpel edge emu
michaelni
parents: 553
diff changeset
2692
671
3f2e5a282f61 interlaced qpel mpeg4 fixed
michaelni
parents: 664
diff changeset
2693 if(field_based){
3f2e5a282f61 interlaced qpel mpeg4 fixed
michaelni
parents: 664
diff changeset
2694 mx= motion_x/2;
3f2e5a282f61 interlaced qpel mpeg4 fixed
michaelni
parents: 664
diff changeset
2695 my= motion_y>>1;
1048
75a659fae7e0 divx503 decoding fix
michaelni
parents: 1042
diff changeset
2696 }else if(s->workaround_bugs&FF_BUG_QPEL_CHROMA2){
75a659fae7e0 divx503 decoding fix
michaelni
parents: 1042
diff changeset
2697 static const int rtab[8]= {0,0,1,1,0,0,0,1};
75a659fae7e0 divx503 decoding fix
michaelni
parents: 1042
diff changeset
2698 mx= (motion_x>>1) + rtab[motion_x&7];
75a659fae7e0 divx503 decoding fix
michaelni
parents: 1042
diff changeset
2699 my= (motion_y>>1) + rtab[motion_y&7];
760
e858fe220ce0 xvid qpel bug workaround
michaelni
parents: 756
diff changeset
2700 }else if(s->workaround_bugs&FF_BUG_QPEL_CHROMA){
671
3f2e5a282f61 interlaced qpel mpeg4 fixed
michaelni
parents: 664
diff changeset
2701 mx= (motion_x>>1)|(motion_x&1);
3f2e5a282f61 interlaced qpel mpeg4 fixed
michaelni
parents: 664
diff changeset
2702 my= (motion_y>>1)|(motion_y&1);
3f2e5a282f61 interlaced qpel mpeg4 fixed
michaelni
parents: 664
diff changeset
2703 }else{
3f2e5a282f61 interlaced qpel mpeg4 fixed
michaelni
parents: 664
diff changeset
2704 mx= motion_x/2;
3f2e5a282f61 interlaced qpel mpeg4 fixed
michaelni
parents: 664
diff changeset
2705 my= motion_y/2;
3f2e5a282f61 interlaced qpel mpeg4 fixed
michaelni
parents: 664
diff changeset
2706 }
3f2e5a282f61 interlaced qpel mpeg4 fixed
michaelni
parents: 664
diff changeset
2707 mx= (mx>>1)|(mx&1);
3f2e5a282f61 interlaced qpel mpeg4 fixed
michaelni
parents: 664
diff changeset
2708 my= (my>>1)|(my&1);
1048
75a659fae7e0 divx503 decoding fix
michaelni
parents: 1042
diff changeset
2709
1846
cea4f1a80059 optimizing/cleanup of mpeg/qpel_motion()
michael
parents: 1843
diff changeset
2710 uvdxy= (mx&1) | ((my&1)<<1);
671
3f2e5a282f61 interlaced qpel mpeg4 fixed
michaelni
parents: 664
diff changeset
2711 mx>>=1;
3f2e5a282f61 interlaced qpel mpeg4 fixed
michaelni
parents: 664
diff changeset
2712 my>>=1;
255
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
2713
1846
cea4f1a80059 optimizing/cleanup of mpeg/qpel_motion()
michael
parents: 1843
diff changeset
2714 uvsrc_x = s->mb_x * 8 + mx;
cea4f1a80059 optimizing/cleanup of mpeg/qpel_motion()
michael
parents: 1843
diff changeset
2715 uvsrc_y = s->mb_y * (8 >> field_based) + my;
cea4f1a80059 optimizing/cleanup of mpeg/qpel_motion()
michael
parents: 1843
diff changeset
2716
cea4f1a80059 optimizing/cleanup of mpeg/qpel_motion()
michael
parents: 1843
diff changeset
2717 ptr_y = ref_picture[0] + src_y * linesize + src_x;
cea4f1a80059 optimizing/cleanup of mpeg/qpel_motion()
michael
parents: 1843
diff changeset
2718 ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x;
cea4f1a80059 optimizing/cleanup of mpeg/qpel_motion()
michael
parents: 1843
diff changeset
2719 ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x;
cea4f1a80059 optimizing/cleanup of mpeg/qpel_motion()
michael
parents: 1843
diff changeset
2720
cea4f1a80059 optimizing/cleanup of mpeg/qpel_motion()
michael
parents: 1843
diff changeset
2721 if( (unsigned)src_x > s->h_edge_pos - (motion_x&3) - 16
cea4f1a80059 optimizing/cleanup of mpeg/qpel_motion()
michael
parents: 1843
diff changeset
2722 || (unsigned)src_y > v_edge_pos - (motion_y&3) - h ){
cea4f1a80059 optimizing/cleanup of mpeg/qpel_motion()
michael
parents: 1843
diff changeset
2723 ff_emulated_edge_mc(s->edge_emu_buffer, ptr_y, s->linesize, 17, 17+field_based,
cea4f1a80059 optimizing/cleanup of mpeg/qpel_motion()
michael
parents: 1843
diff changeset
2724 src_x, src_y<<field_based, s->h_edge_pos, s->v_edge_pos);
cea4f1a80059 optimizing/cleanup of mpeg/qpel_motion()
michael
parents: 1843
diff changeset
2725 ptr_y= s->edge_emu_buffer;
cea4f1a80059 optimizing/cleanup of mpeg/qpel_motion()
michael
parents: 1843
diff changeset
2726 if(!(s->flags&CODEC_FLAG_GRAY)){
1874
michael
parents: 1863
diff changeset
2727 uint8_t *uvbuf= s->edge_emu_buffer + 18*s->linesize;
1846
cea4f1a80059 optimizing/cleanup of mpeg/qpel_motion()
michael
parents: 1843
diff changeset
2728 ff_emulated_edge_mc(uvbuf, ptr_cb, s->uvlinesize, 9, 9 + field_based,
cea4f1a80059 optimizing/cleanup of mpeg/qpel_motion()
michael
parents: 1843
diff changeset
2729 uvsrc_x, uvsrc_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
cea4f1a80059 optimizing/cleanup of mpeg/qpel_motion()
michael
parents: 1843
diff changeset
2730 ff_emulated_edge_mc(uvbuf + 16, ptr_cr, s->uvlinesize, 9, 9 + field_based,
cea4f1a80059 optimizing/cleanup of mpeg/qpel_motion()
michael
parents: 1843
diff changeset
2731 uvsrc_x, uvsrc_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
cea4f1a80059 optimizing/cleanup of mpeg/qpel_motion()
michael
parents: 1843
diff changeset
2732 ptr_cb= uvbuf;
cea4f1a80059 optimizing/cleanup of mpeg/qpel_motion()
michael
parents: 1843
diff changeset
2733 ptr_cr= uvbuf + 16;
cea4f1a80059 optimizing/cleanup of mpeg/qpel_motion()
michael
parents: 1843
diff changeset
2734 }
cea4f1a80059 optimizing/cleanup of mpeg/qpel_motion()
michael
parents: 1843
diff changeset
2735 }
cea4f1a80059 optimizing/cleanup of mpeg/qpel_motion()
michael
parents: 1843
diff changeset
2736
cea4f1a80059 optimizing/cleanup of mpeg/qpel_motion()
michael
parents: 1843
diff changeset
2737 if(!field_based)
cea4f1a80059 optimizing/cleanup of mpeg/qpel_motion()
michael
parents: 1843
diff changeset
2738 qpix_op[0][dxy](dest_y, ptr_y, linesize);
cea4f1a80059 optimizing/cleanup of mpeg/qpel_motion()
michael
parents: 1843
diff changeset
2739 else{
cea4f1a80059 optimizing/cleanup of mpeg/qpel_motion()
michael
parents: 1843
diff changeset
2740 if(bottom_field){
cea4f1a80059 optimizing/cleanup of mpeg/qpel_motion()
michael
parents: 1843
diff changeset
2741 dest_y += s->linesize;
cea4f1a80059 optimizing/cleanup of mpeg/qpel_motion()
michael
parents: 1843
diff changeset
2742 dest_cb+= s->uvlinesize;
cea4f1a80059 optimizing/cleanup of mpeg/qpel_motion()
michael
parents: 1843
diff changeset
2743 dest_cr+= s->uvlinesize;
cea4f1a80059 optimizing/cleanup of mpeg/qpel_motion()
michael
parents: 1843
diff changeset
2744 }
cea4f1a80059 optimizing/cleanup of mpeg/qpel_motion()
michael
parents: 1843
diff changeset
2745
cea4f1a80059 optimizing/cleanup of mpeg/qpel_motion()
michael
parents: 1843
diff changeset
2746 if(field_select){
cea4f1a80059 optimizing/cleanup of mpeg/qpel_motion()
michael
parents: 1843
diff changeset
2747 ptr_y += s->linesize;
cea4f1a80059 optimizing/cleanup of mpeg/qpel_motion()
michael
parents: 1843
diff changeset
2748 ptr_cb += s->uvlinesize;
cea4f1a80059 optimizing/cleanup of mpeg/qpel_motion()
michael
parents: 1843
diff changeset
2749 ptr_cr += s->uvlinesize;
cea4f1a80059 optimizing/cleanup of mpeg/qpel_motion()
michael
parents: 1843
diff changeset
2750 }
cea4f1a80059 optimizing/cleanup of mpeg/qpel_motion()
michael
parents: 1843
diff changeset
2751 //damn interlaced mode
cea4f1a80059 optimizing/cleanup of mpeg/qpel_motion()
michael
parents: 1843
diff changeset
2752 //FIXME boundary mirroring is not exactly correct here
cea4f1a80059 optimizing/cleanup of mpeg/qpel_motion()
michael
parents: 1843
diff changeset
2753 qpix_op[1][dxy](dest_y , ptr_y , linesize);
cea4f1a80059 optimizing/cleanup of mpeg/qpel_motion()
michael
parents: 1843
diff changeset
2754 qpix_op[1][dxy](dest_y+8, ptr_y+8, linesize);
cea4f1a80059 optimizing/cleanup of mpeg/qpel_motion()
michael
parents: 1843
diff changeset
2755 }
cea4f1a80059 optimizing/cleanup of mpeg/qpel_motion()
michael
parents: 1843
diff changeset
2756 if(!(s->flags&CODEC_FLAG_GRAY)){
cea4f1a80059 optimizing/cleanup of mpeg/qpel_motion()
michael
parents: 1843
diff changeset
2757 pix_op[1][uvdxy](dest_cr, ptr_cr, uvlinesize, h >> 1);
cea4f1a80059 optimizing/cleanup of mpeg/qpel_motion()
michael
parents: 1843
diff changeset
2758 pix_op[1][uvdxy](dest_cb, ptr_cb, uvlinesize, h >> 1);
cea4f1a80059 optimizing/cleanup of mpeg/qpel_motion()
michael
parents: 1843
diff changeset
2759 }
255
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
2760 }
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
2761
1013
5d4c95f323d0 finetuneing thresholds/factors
michaelni
parents: 1011
diff changeset
2762 inline int ff_h263_round_chroma(int x){
5d4c95f323d0 finetuneing thresholds/factors
michaelni
parents: 1011
diff changeset
2763 if (x >= 0)
5d4c95f323d0 finetuneing thresholds/factors
michaelni
parents: 1011
diff changeset
2764 return (h263_chroma_roundtab[x & 0xf] + ((x >> 3) & ~1));
5d4c95f323d0 finetuneing thresholds/factors
michaelni
parents: 1011
diff changeset
2765 else {
5d4c95f323d0 finetuneing thresholds/factors
michaelni
parents: 1011
diff changeset
2766 x = -x;
5d4c95f323d0 finetuneing thresholds/factors
michaelni
parents: 1011
diff changeset
2767 return -(h263_chroma_roundtab[x & 0xf] + ((x >> 3) & ~1));
5d4c95f323d0 finetuneing thresholds/factors
michaelni
parents: 1011
diff changeset
2768 }
5d4c95f323d0 finetuneing thresholds/factors
michaelni
parents: 1011
diff changeset
2769 }
255
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
2770
1225
michaelni
parents: 1218
diff changeset
2771 /**
1633
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1632
diff changeset
2772 * h263 chorma 4mv motion compensation.
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1632
diff changeset
2773 */
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1632
diff changeset
2774 static inline void chroma_4mv_motion(MpegEncContext *s,
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1632
diff changeset
2775 uint8_t *dest_cb, uint8_t *dest_cr,
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1632
diff changeset
2776 uint8_t **ref_picture,
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1632
diff changeset
2777 op_pixels_func *pix_op,
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1632
diff changeset
2778 int mx, int my){
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1632
diff changeset
2779 int dxy, emu=0, src_x, src_y, offset;
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1632
diff changeset
2780 uint8_t *ptr;
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1632
diff changeset
2781
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1632
diff changeset
2782 /* In case of 8X8, we construct a single chroma motion vector
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1632
diff changeset
2783 with a special rounding */
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1632
diff changeset
2784 mx= ff_h263_round_chroma(mx);
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1632
diff changeset
2785 my= ff_h263_round_chroma(my);
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1632
diff changeset
2786
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1632
diff changeset
2787 dxy = ((my & 1) << 1) | (mx & 1);
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1632
diff changeset
2788 mx >>= 1;
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1632
diff changeset
2789 my >>= 1;
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1632
diff changeset
2790
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1632
diff changeset
2791 src_x = s->mb_x * 8 + mx;
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1632
diff changeset
2792 src_y = s->mb_y * 8 + my;
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1632
diff changeset
2793 src_x = clip(src_x, -8, s->width/2);
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1632
diff changeset
2794 if (src_x == s->width/2)
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1632
diff changeset
2795 dxy &= ~1;
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1632
diff changeset
2796 src_y = clip(src_y, -8, s->height/2);
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1632
diff changeset
2797 if (src_y == s->height/2)
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1632
diff changeset
2798 dxy &= ~2;
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1632
diff changeset
2799
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1632
diff changeset
2800 offset = (src_y * (s->uvlinesize)) + src_x;
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1632
diff changeset
2801 ptr = ref_picture[1] + offset;
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1632
diff changeset
2802 if(s->flags&CODEC_FLAG_EMU_EDGE){
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1632
diff changeset
2803 if( (unsigned)src_x > (s->h_edge_pos>>1) - (dxy &1) - 8
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1632
diff changeset
2804 || (unsigned)src_y > (s->v_edge_pos>>1) - (dxy>>1) - 8){
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1632
diff changeset
2805 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);
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1632
diff changeset
2806 ptr= s->edge_emu_buffer;
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1632
diff changeset
2807 emu=1;
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1632
diff changeset
2808 }
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1632
diff changeset
2809 }
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1632
diff changeset
2810 pix_op[dxy](dest_cb, ptr, s->uvlinesize, 8);
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1632
diff changeset
2811
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1632
diff changeset
2812 ptr = ref_picture[2] + offset;
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1632
diff changeset
2813 if(emu){
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1632
diff changeset
2814 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);
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1632
diff changeset
2815 ptr= s->edge_emu_buffer;
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1632
diff changeset
2816 }
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1632
diff changeset
2817 pix_op[dxy](dest_cr, ptr, s->uvlinesize, 8);
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1632
diff changeset
2818 }
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1632
diff changeset
2819
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1632
diff changeset
2820 /**
1225
michaelni
parents: 1218
diff changeset
2821 * motion compesation of a single macroblock
michaelni
parents: 1218
diff changeset
2822 * @param s context
michaelni
parents: 1218
diff changeset
2823 * @param dest_y luma destination pointer
michaelni
parents: 1218
diff changeset
2824 * @param dest_cb chroma cb/u destination pointer
michaelni
parents: 1218
diff changeset
2825 * @param dest_cr chroma cr/v destination pointer
michaelni
parents: 1218
diff changeset
2826 * @param dir direction (0->forward, 1->backward)
michaelni
parents: 1218
diff changeset
2827 * @param ref_picture array[3] of pointers to the 3 planes of the reference picture
michaelni
parents: 1218
diff changeset
2828 * @param pic_op halfpel motion compensation function (average or put normally)
michaelni
parents: 1218
diff changeset
2829 * @param pic_op qpel motion compensation function (average or put normally)
michaelni
parents: 1218
diff changeset
2830 * the motion vectors are taken from s->mv and the MV type from s->mv_type
michaelni
parents: 1218
diff changeset
2831 */
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2832 static inline void MPV_motion(MpegEncContext *s,
1064
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1059
diff changeset
2833 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1059
diff changeset
2834 int dir, uint8_t **ref_picture,
651
45e8f39fda50 put/avg_pixels16
michaelni
parents: 650
diff changeset
2835 op_pixels_func (*pix_op)[4], qpel_mc_func (*qpix_op)[16])
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2836 {
1633
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1632
diff changeset
2837 int dxy, mx, my, src_x, src_y, motion_x, motion_y;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2838 int mb_x, mb_y, i;
1064
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1059
diff changeset
2839 uint8_t *ptr, *dest;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2840
986e461dc072 Initial revision
glantau
parents:
diff changeset
2841 mb_x = s->mb_x;
986e461dc072 Initial revision
glantau
parents:
diff changeset
2842 mb_y = s->mb_y;
986e461dc072 Initial revision
glantau
parents:
diff changeset
2843
1655
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
2844 if(s->obmc && s->pict_type != B_TYPE){
1633
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1632
diff changeset
2845 int16_t mv_cache[4][4][2];
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1632
diff changeset
2846 const int xy= s->mb_x + s->mb_y*s->mb_stride;
1938
e2501e6e7ff7 unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents: 1918
diff changeset
2847 const int mot_stride= s->b8_stride;
e2501e6e7ff7 unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents: 1918
diff changeset
2848 const int mot_xy= mb_x*2 + mb_y*2*mot_stride;
1633
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1632
diff changeset
2849
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1632
diff changeset
2850 assert(!s->mb_skiped);
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1632
diff changeset
2851
1668
30746f429df6 move motion_val & mb_type to AVFrame patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents: 1662
diff changeset
2852 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
2853 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
2854 memcpy(mv_cache[3][1], s->current_picture.motion_val[0][mot_xy+mot_stride], sizeof(int16_t)*4);
1633
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1632
diff changeset
2855
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1632
diff changeset
2856 if(mb_y==0 || IS_INTRA(s->current_picture.mb_type[xy-s->mb_stride])){
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1632
diff changeset
2857 memcpy(mv_cache[0][1], mv_cache[1][1], sizeof(int16_t)*4);
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1632
diff changeset
2858 }else{
1668
30746f429df6 move motion_val & mb_type to AVFrame patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents: 1662
diff changeset
2859 memcpy(mv_cache[0][1], s->current_picture.motion_val[0][mot_xy-mot_stride], sizeof(int16_t)*4);
1633
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1632
diff changeset
2860 }
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1632
diff changeset
2861
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1632
diff changeset
2862 if(mb_x==0 || IS_INTRA(s->current_picture.mb_type[xy-1])){
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1632
diff changeset
2863 *(int32_t*)mv_cache[1][0]= *(int32_t*)mv_cache[1][1];
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1632
diff changeset
2864 *(int32_t*)mv_cache[2][0]= *(int32_t*)mv_cache[2][1];
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1632
diff changeset
2865 }else{
1668
30746f429df6 move motion_val & mb_type to AVFrame patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents: 1662
diff changeset
2866 *(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
2867 *(int32_t*)mv_cache[2][0]= *(int32_t*)s->current_picture.motion_val[0][mot_xy-1+mot_stride];
1633
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1632
diff changeset
2868 }
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1632
diff changeset
2869
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1632
diff changeset
2870 if(mb_x+1>=s->mb_width || IS_INTRA(s->current_picture.mb_type[xy+1])){
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1632
diff changeset
2871 *(int32_t*)mv_cache[1][3]= *(int32_t*)mv_cache[1][2];
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1632
diff changeset
2872 *(int32_t*)mv_cache[2][3]= *(int32_t*)mv_cache[2][2];
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1632
diff changeset
2873 }else{
1668
30746f429df6 move motion_val & mb_type to AVFrame patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents: 1662
diff changeset
2874 *(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
2875 *(int32_t*)mv_cache[2][3]= *(int32_t*)s->current_picture.motion_val[0][mot_xy+2+mot_stride];
1633
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1632
diff changeset
2876 }
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1632
diff changeset
2877
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1632
diff changeset
2878 mx = 0;
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1632
diff changeset
2879 my = 0;
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1632
diff changeset
2880 for(i=0;i<4;i++) {
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1632
diff changeset
2881 const int x= (i&1)+1;
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1632
diff changeset
2882 const int y= (i>>1)+1;
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1632
diff changeset
2883 int16_t mv[5][2]= {
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1632
diff changeset
2884 {mv_cache[y][x ][0], mv_cache[y][x ][1]},
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1632
diff changeset
2885 {mv_cache[y-1][x][0], mv_cache[y-1][x][1]},
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1632
diff changeset
2886 {mv_cache[y][x-1][0], mv_cache[y][x-1][1]},
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1632
diff changeset
2887 {mv_cache[y][x+1][0], mv_cache[y][x+1][1]},
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1632
diff changeset
2888 {mv_cache[y+1][x][0], mv_cache[y+1][x][1]}};
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1632
diff changeset
2889 //FIXME cleanup
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1632
diff changeset
2890 obmc_motion(s, dest_y + ((i & 1) * 8) + (i >> 1) * 8 * s->linesize,
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1632
diff changeset
2891 ref_picture[0],
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1632
diff changeset
2892 mb_x * 16 + (i & 1) * 8, mb_y * 16 + (i >>1) * 8,
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1632
diff changeset
2893 pix_op[1],
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1632
diff changeset
2894 mv);
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1632
diff changeset
2895
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1632
diff changeset
2896 mx += mv[0][0];
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1632
diff changeset
2897 my += mv[0][1];
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1632
diff changeset
2898 }
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1632
diff changeset
2899 if(!(s->flags&CODEC_FLAG_GRAY))
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1632
diff changeset
2900 chroma_4mv_motion(s, dest_cb, dest_cr, ref_picture, pix_op[1], mx, my);
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1632
diff changeset
2901
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1632
diff changeset
2902 return;
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1632
diff changeset
2903 }
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1632
diff changeset
2904
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2905 switch(s->mv_type) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
2906 case MV_TYPE_16X16:
1042
a78f6f72d54e --disable-risky support
michaelni
parents: 1026
diff changeset
2907 #ifdef CONFIG_RISKY
255
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
2908 if(s->mcsel){
753
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 745
diff changeset
2909 if(s->real_sprite_warping_points==1){
1842
0d82db458a3c interlaced mpeg4 + edge emu fix (fixes decoding of mermaid.avi)
michael
parents: 1838
diff changeset
2910 gmc1_motion(s, dest_y, dest_cb, dest_cr,
0d82db458a3c interlaced mpeg4 + edge emu fix (fixes decoding of mermaid.avi)
michael
parents: 1838
diff changeset
2911 ref_picture);
753
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 745
diff changeset
2912 }else{
1842
0d82db458a3c interlaced mpeg4 + edge emu fix (fixes decoding of mermaid.avi)
michael
parents: 1838
diff changeset
2913 gmc_motion(s, dest_y, dest_cb, dest_cr,
0d82db458a3c interlaced mpeg4 + edge emu fix (fixes decoding of mermaid.avi)
michael
parents: 1838
diff changeset
2914 ref_picture);
753
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 745
diff changeset
2915 }
651
45e8f39fda50 put/avg_pixels16
michaelni
parents: 650
diff changeset
2916 }else if(s->quarter_sample){
1842
0d82db458a3c interlaced mpeg4 + edge emu fix (fixes decoding of mermaid.avi)
michael
parents: 1838
diff changeset
2917 qpel_motion(s, dest_y, dest_cb, dest_cr,
0d82db458a3c interlaced mpeg4 + edge emu fix (fixes decoding of mermaid.avi)
michael
parents: 1838
diff changeset
2918 0, 0, 0,
0d82db458a3c interlaced mpeg4 + edge emu fix (fixes decoding of mermaid.avi)
michael
parents: 1838
diff changeset
2919 ref_picture, pix_op, qpix_op,
255
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
2920 s->mv[dir][0][0], s->mv[dir][0][1], 16);
936
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2921 }else if(s->mspel){
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2922 ff_mspel_motion(s, dest_y, dest_cb, dest_cr,
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2923 ref_picture, pix_op,
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2924 s->mv[dir][0][0], s->mv[dir][0][1], 16);
1042
a78f6f72d54e --disable-risky support
michaelni
parents: 1026
diff changeset
2925 }else
a78f6f72d54e --disable-risky support
michaelni
parents: 1026
diff changeset
2926 #endif
a78f6f72d54e --disable-risky support
michaelni
parents: 1026
diff changeset
2927 {
1842
0d82db458a3c interlaced mpeg4 + edge emu fix (fixes decoding of mermaid.avi)
michael
parents: 1838
diff changeset
2928 mpeg_motion(s, dest_y, dest_cb, dest_cr,
0d82db458a3c interlaced mpeg4 + edge emu fix (fixes decoding of mermaid.avi)
michael
parents: 1838
diff changeset
2929 0, 0, 0,
0d82db458a3c interlaced mpeg4 + edge emu fix (fixes decoding of mermaid.avi)
michael
parents: 1838
diff changeset
2930 ref_picture, pix_op,
255
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
2931 s->mv[dir][0][0], s->mv[dir][0][1], 16);
db20b987c32d divx5-gmc support
michaelni
parents: 252
diff changeset
2932 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2933 break;
986e461dc072 Initial revision
glantau
parents:
diff changeset
2934 case MV_TYPE_8X8:
673
242f0f7d8c15 fixing qpel 4mv
michaelni
parents: 671
diff changeset
2935 mx = 0;
242f0f7d8c15 fixing qpel 4mv
michaelni
parents: 671
diff changeset
2936 my = 0;
242f0f7d8c15 fixing qpel 4mv
michaelni
parents: 671
diff changeset
2937 if(s->quarter_sample){
242f0f7d8c15 fixing qpel 4mv
michaelni
parents: 671
diff changeset
2938 for(i=0;i<4;i++) {
242f0f7d8c15 fixing qpel 4mv
michaelni
parents: 671
diff changeset
2939 motion_x = s->mv[dir][i][0];
242f0f7d8c15 fixing qpel 4mv
michaelni
parents: 671
diff changeset
2940 motion_y = s->mv[dir][i][1];
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2941
673
242f0f7d8c15 fixing qpel 4mv
michaelni
parents: 671
diff changeset
2942 dxy = ((motion_y & 3) << 2) | (motion_x & 3);
242f0f7d8c15 fixing qpel 4mv
michaelni
parents: 671
diff changeset
2943 src_x = mb_x * 16 + (motion_x >> 2) + (i & 1) * 8;
242f0f7d8c15 fixing qpel 4mv
michaelni
parents: 671
diff changeset
2944 src_y = mb_y * 16 + (motion_y >> 2) + (i >>1) * 8;
242f0f7d8c15 fixing qpel 4mv
michaelni
parents: 671
diff changeset
2945
242f0f7d8c15 fixing qpel 4mv
michaelni
parents: 671
diff changeset
2946 /* WARNING: do no forget half pels */
242f0f7d8c15 fixing qpel 4mv
michaelni
parents: 671
diff changeset
2947 src_x = clip(src_x, -16, s->width);
242f0f7d8c15 fixing qpel 4mv
michaelni
parents: 671
diff changeset
2948 if (src_x == s->width)
242f0f7d8c15 fixing qpel 4mv
michaelni
parents: 671
diff changeset
2949 dxy &= ~3;
242f0f7d8c15 fixing qpel 4mv
michaelni
parents: 671
diff changeset
2950 src_y = clip(src_y, -16, s->height);
242f0f7d8c15 fixing qpel 4mv
michaelni
parents: 671
diff changeset
2951 if (src_y == s->height)
242f0f7d8c15 fixing qpel 4mv
michaelni
parents: 671
diff changeset
2952 dxy &= ~12;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2953
673
242f0f7d8c15 fixing qpel 4mv
michaelni
parents: 671
diff changeset
2954 ptr = ref_picture[0] + (src_y * s->linesize) + (src_x);
242f0f7d8c15 fixing qpel 4mv
michaelni
parents: 671
diff changeset
2955 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
2956 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
2957 || (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
2958 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
242f0f7d8c15 fixing qpel 4mv
michaelni
parents: 671
diff changeset
2959 ptr= s->edge_emu_buffer;
242f0f7d8c15 fixing qpel 4mv
michaelni
parents: 671
diff changeset
2960 }
242f0f7d8c15 fixing qpel 4mv
michaelni
parents: 671
diff changeset
2961 }
242f0f7d8c15 fixing qpel 4mv
michaelni
parents: 671
diff changeset
2962 dest = dest_y + ((i & 1) * 8) + (i >> 1) * 8 * s->linesize;
242f0f7d8c15 fixing qpel 4mv
michaelni
parents: 671
diff changeset
2963 qpix_op[1][dxy](dest, ptr, s->linesize);
242f0f7d8c15 fixing qpel 4mv
michaelni
parents: 671
diff changeset
2964
242f0f7d8c15 fixing qpel 4mv
michaelni
parents: 671
diff changeset
2965 mx += s->mv[dir][i][0]/2;
242f0f7d8c15 fixing qpel 4mv
michaelni
parents: 671
diff changeset
2966 my += s->mv[dir][i][1]/2;
242f0f7d8c15 fixing qpel 4mv
michaelni
parents: 671
diff changeset
2967 }
242f0f7d8c15 fixing qpel 4mv
michaelni
parents: 671
diff changeset
2968 }else{
242f0f7d8c15 fixing qpel 4mv
michaelni
parents: 671
diff changeset
2969 for(i=0;i<4;i++) {
1633
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1632
diff changeset
2970 hpel_motion(s, dest_y + ((i & 1) * 8) + (i >> 1) * 8 * s->linesize,
1842
0d82db458a3c interlaced mpeg4 + edge emu fix (fixes decoding of mermaid.avi)
michael
parents: 1838
diff changeset
2971 ref_picture[0], 0, 0,
1633
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1632
diff changeset
2972 mb_x * 16 + (i & 1) * 8, mb_y * 16 + (i >>1) * 8,
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1632
diff changeset
2973 s->width, s->height, s->linesize,
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1632
diff changeset
2974 s->h_edge_pos, s->v_edge_pos,
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1632
diff changeset
2975 8, 8, pix_op[1],
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1632
diff changeset
2976 s->mv[dir][i][0], s->mv[dir][i][1]);
673
242f0f7d8c15 fixing qpel 4mv
michaelni
parents: 671
diff changeset
2977
242f0f7d8c15 fixing qpel 4mv
michaelni
parents: 671
diff changeset
2978 mx += s->mv[dir][i][0];
242f0f7d8c15 fixing qpel 4mv
michaelni
parents: 671
diff changeset
2979 my += s->mv[dir][i][1];
554
3eb6fe38019a 4mv & qpel edge emu
michaelni
parents: 553
diff changeset
2980 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2981 }
673
242f0f7d8c15 fixing qpel 4mv
michaelni
parents: 671
diff changeset
2982
1633
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1632
diff changeset
2983 if(!(s->flags&CODEC_FLAG_GRAY))
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1632
diff changeset
2984 chroma_4mv_motion(s, dest_cb, dest_cr, ref_picture, pix_op[1], mx, my);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2985 break;
986e461dc072 Initial revision
glantau
parents:
diff changeset
2986 case MV_TYPE_FIELD:
986e461dc072 Initial revision
glantau
parents:
diff changeset
2987 if (s->picture_structure == PICT_FRAME) {
671
3f2e5a282f61 interlaced qpel mpeg4 fixed
michaelni
parents: 664
diff changeset
2988 if(s->quarter_sample){
1843
2b488cb389b6 simplify MPV_motion()
michael
parents: 1842
diff changeset
2989 for(i=0; i<2; i++){
2b488cb389b6 simplify MPV_motion()
michael
parents: 1842
diff changeset
2990 qpel_motion(s, dest_y, dest_cb, dest_cr,
2b488cb389b6 simplify MPV_motion()
michael
parents: 1842
diff changeset
2991 1, i, s->field_select[dir][i],
2b488cb389b6 simplify MPV_motion()
michael
parents: 1842
diff changeset
2992 ref_picture, pix_op, qpix_op,
2b488cb389b6 simplify MPV_motion()
michael
parents: 1842
diff changeset
2993 s->mv[dir][i][0], s->mv[dir][i][1], 8);
2b488cb389b6 simplify MPV_motion()
michael
parents: 1842
diff changeset
2994 }
671
3f2e5a282f61 interlaced qpel mpeg4 fixed
michaelni
parents: 664
diff changeset
2995 }else{
3f2e5a282f61 interlaced qpel mpeg4 fixed
michaelni
parents: 664
diff changeset
2996 /* top field */
1842
0d82db458a3c interlaced mpeg4 + edge emu fix (fixes decoding of mermaid.avi)
michael
parents: 1838
diff changeset
2997 mpeg_motion(s, dest_y, dest_cb, dest_cr,
0d82db458a3c interlaced mpeg4 + edge emu fix (fixes decoding of mermaid.avi)
michael
parents: 1838
diff changeset
2998 1, 0, s->field_select[dir][0],
0d82db458a3c interlaced mpeg4 + edge emu fix (fixes decoding of mermaid.avi)
michael
parents: 1838
diff changeset
2999 ref_picture, pix_op,
671
3f2e5a282f61 interlaced qpel mpeg4 fixed
michaelni
parents: 664
diff changeset
3000 s->mv[dir][0][0], s->mv[dir][0][1], 8);
3f2e5a282f61 interlaced qpel mpeg4 fixed
michaelni
parents: 664
diff changeset
3001 /* bottom field */
1842
0d82db458a3c interlaced mpeg4 + edge emu fix (fixes decoding of mermaid.avi)
michael
parents: 1838
diff changeset
3002 mpeg_motion(s, dest_y, dest_cb, dest_cr,
0d82db458a3c interlaced mpeg4 + edge emu fix (fixes decoding of mermaid.avi)
michael
parents: 1838
diff changeset
3003 1, 1, s->field_select[dir][1],
0d82db458a3c interlaced mpeg4 + edge emu fix (fixes decoding of mermaid.avi)
michael
parents: 1838
diff changeset
3004 ref_picture, pix_op,
671
3f2e5a282f61 interlaced qpel mpeg4 fixed
michaelni
parents: 664
diff changeset
3005 s->mv[dir][1][0], s->mv[dir][1][1], 8);
3f2e5a282f61 interlaced qpel mpeg4 fixed
michaelni
parents: 664
diff changeset
3006 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3007 } else {
1842
0d82db458a3c interlaced mpeg4 + edge emu fix (fixes decoding of mermaid.avi)
michael
parents: 1838
diff changeset
3008 if(s->picture_structure != s->field_select[dir][0] + 1 && s->pict_type != B_TYPE && !s->first_field){
0d82db458a3c interlaced mpeg4 + edge emu fix (fixes decoding of mermaid.avi)
michael
parents: 1838
diff changeset
3009 ref_picture= s->current_picture_ptr->data;
1096
5e6e505d8997 field picture decoding support (16x16 MC blocks only as i dont have any samples which use other modes ...)
michaelni
parents: 1095
diff changeset
3010 }
5e6e505d8997 field picture decoding support (16x16 MC blocks only as i dont have any samples which use other modes ...)
michaelni
parents: 1095
diff changeset
3011
1842
0d82db458a3c interlaced mpeg4 + edge emu fix (fixes decoding of mermaid.avi)
michael
parents: 1838
diff changeset
3012 mpeg_motion(s, dest_y, dest_cb, dest_cr,
0d82db458a3c interlaced mpeg4 + edge emu fix (fixes decoding of mermaid.avi)
michael
parents: 1838
diff changeset
3013 0, 0, s->field_select[dir][0],
0d82db458a3c interlaced mpeg4 + edge emu fix (fixes decoding of mermaid.avi)
michael
parents: 1838
diff changeset
3014 ref_picture, pix_op,
1096
5e6e505d8997 field picture decoding support (16x16 MC blocks only as i dont have any samples which use other modes ...)
michaelni
parents: 1095
diff changeset
3015 s->mv[dir][0][0], s->mv[dir][0][1], 16);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3016 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
3017 break;
1843
2b488cb389b6 simplify MPV_motion()
michael
parents: 1842
diff changeset
3018 case MV_TYPE_16X8:
2b488cb389b6 simplify MPV_motion()
michael
parents: 1842
diff changeset
3019 for(i=0; i<2; i++){
2b488cb389b6 simplify MPV_motion()
michael
parents: 1842
diff changeset
3020 uint8_t ** ref2picture;
2b488cb389b6 simplify MPV_motion()
michael
parents: 1842
diff changeset
3021
2b488cb389b6 simplify MPV_motion()
michael
parents: 1842
diff changeset
3022 if(s->picture_structure == s->field_select[dir][i] + 1 || s->pict_type == B_TYPE || s->first_field){
1339
338a2f6e6402 Mpeg2 16x8 Patch by ("Ivan Kalvachev" <ivan at cacad dot com>)
michaelni
parents: 1328
diff changeset
3023 ref2picture= ref_picture;
338a2f6e6402 Mpeg2 16x8 Patch by ("Ivan Kalvachev" <ivan at cacad dot com>)
michaelni
parents: 1328
diff changeset
3024 }else{
1842
0d82db458a3c interlaced mpeg4 + edge emu fix (fixes decoding of mermaid.avi)
michael
parents: 1838
diff changeset
3025 ref2picture= s->current_picture_ptr->data;
1339
338a2f6e6402 Mpeg2 16x8 Patch by ("Ivan Kalvachev" <ivan at cacad dot com>)
michaelni
parents: 1328
diff changeset
3026 }
338a2f6e6402 Mpeg2 16x8 Patch by ("Ivan Kalvachev" <ivan at cacad dot com>)
michaelni
parents: 1328
diff changeset
3027
1842
0d82db458a3c interlaced mpeg4 + edge emu fix (fixes decoding of mermaid.avi)
michael
parents: 1838
diff changeset
3028 mpeg_motion(s, dest_y, dest_cb, dest_cr,
1843
2b488cb389b6 simplify MPV_motion()
michael
parents: 1842
diff changeset
3029 0, 0, s->field_select[dir][i],
1842
0d82db458a3c interlaced mpeg4 + edge emu fix (fixes decoding of mermaid.avi)
michael
parents: 1838
diff changeset
3030 ref2picture, pix_op,
1843
2b488cb389b6 simplify MPV_motion()
michael
parents: 1842
diff changeset
3031 s->mv[dir][i][0], s->mv[dir][i][1] + 16*i, 8);
2b488cb389b6 simplify MPV_motion()
michael
parents: 1842
diff changeset
3032
2b488cb389b6 simplify MPV_motion()
michael
parents: 1842
diff changeset
3033 dest_y += 16*s->linesize;
2074
2faafe7a3db6 mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents: 2066
diff changeset
3034 dest_cb+= (16>>s->chroma_y_shift)*s->uvlinesize;
2faafe7a3db6 mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents: 2066
diff changeset
3035 dest_cr+= (16>>s->chroma_y_shift)*s->uvlinesize;
1843
2b488cb389b6 simplify MPV_motion()
michael
parents: 1842
diff changeset
3036 }
1339
338a2f6e6402 Mpeg2 16x8 Patch by ("Ivan Kalvachev" <ivan at cacad dot com>)
michaelni
parents: 1328
diff changeset
3037 break;
1326
6cdd3b8f4fd3 DMV support patch by ("Ivan Kalvachev" <ivan at cacad dot com>)
michaelni
parents: 1317
diff changeset
3038 case MV_TYPE_DMV:
6cdd3b8f4fd3 DMV support patch by ("Ivan Kalvachev" <ivan at cacad dot com>)
michaelni
parents: 1317
diff changeset
3039 if(s->picture_structure == PICT_FRAME){
1843
2b488cb389b6 simplify MPV_motion()
michael
parents: 1842
diff changeset
3040 for(i=0; i<2; i++){
2b488cb389b6 simplify MPV_motion()
michael
parents: 1842
diff changeset
3041 int j;
2b488cb389b6 simplify MPV_motion()
michael
parents: 1842
diff changeset
3042 for(j=0; j<2; j++){
2b488cb389b6 simplify MPV_motion()
michael
parents: 1842
diff changeset
3043 mpeg_motion(s, dest_y, dest_cb, dest_cr,
2b488cb389b6 simplify MPV_motion()
michael
parents: 1842
diff changeset
3044 1, j, j^i,
2b488cb389b6 simplify MPV_motion()
michael
parents: 1842
diff changeset
3045 ref_picture, pix_op,
2b488cb389b6 simplify MPV_motion()
michael
parents: 1842
diff changeset
3046 s->mv[dir][2*i + j][0], s->mv[dir][2*i + j][1], 8);
2b488cb389b6 simplify MPV_motion()
michael
parents: 1842
diff changeset
3047 }
2b488cb389b6 simplify MPV_motion()
michael
parents: 1842
diff changeset
3048 pix_op = s->dsp.avg_pixels_tab;
2b488cb389b6 simplify MPV_motion()
michael
parents: 1842
diff changeset
3049 }
1326
6cdd3b8f4fd3 DMV support patch by ("Ivan Kalvachev" <ivan at cacad dot com>)
michaelni
parents: 1317
diff changeset
3050 }else{
1843
2b488cb389b6 simplify MPV_motion()
michael
parents: 1842
diff changeset
3051 for(i=0; i<2; i++){
2b488cb389b6 simplify MPV_motion()
michael
parents: 1842
diff changeset
3052 mpeg_motion(s, dest_y, dest_cb, dest_cr,
2b488cb389b6 simplify MPV_motion()
michael
parents: 1842
diff changeset
3053 0, 0, s->picture_structure != i+1,
2b488cb389b6 simplify MPV_motion()
michael
parents: 1842
diff changeset
3054 ref_picture, pix_op,
2b488cb389b6 simplify MPV_motion()
michael
parents: 1842
diff changeset
3055 s->mv[dir][2*i][0],s->mv[dir][2*i][1],16);
2b488cb389b6 simplify MPV_motion()
michael
parents: 1842
diff changeset
3056
2b488cb389b6 simplify MPV_motion()
michael
parents: 1842
diff changeset
3057 // after put we make avg of the same block
2b488cb389b6 simplify MPV_motion()
michael
parents: 1842
diff changeset
3058 pix_op=s->dsp.avg_pixels_tab;
2b488cb389b6 simplify MPV_motion()
michael
parents: 1842
diff changeset
3059
2b488cb389b6 simplify MPV_motion()
michael
parents: 1842
diff changeset
3060 //opposite parity is always in the same frame if this is second field
2b488cb389b6 simplify MPV_motion()
michael
parents: 1842
diff changeset
3061 if(!s->first_field){
2b488cb389b6 simplify MPV_motion()
michael
parents: 1842
diff changeset
3062 ref_picture = s->current_picture_ptr->data;
2b488cb389b6 simplify MPV_motion()
michael
parents: 1842
diff changeset
3063 }
1842
0d82db458a3c interlaced mpeg4 + edge emu fix (fixes decoding of mermaid.avi)
michael
parents: 1838
diff changeset
3064 }
1326
6cdd3b8f4fd3 DMV support patch by ("Ivan Kalvachev" <ivan at cacad dot com>)
michaelni
parents: 1317
diff changeset
3065 }
6cdd3b8f4fd3 DMV support patch by ("Ivan Kalvachev" <ivan at cacad dot com>)
michaelni
parents: 1317
diff changeset
3066 break;
1633
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1632
diff changeset
3067 default: assert(0);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3068 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
3069 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
3070
986e461dc072 Initial revision
glantau
parents:
diff changeset
3071
986e461dc072 Initial revision
glantau
parents:
diff changeset
3072 /* put block[] to dest[] */
986e461dc072 Initial revision
glantau
parents:
diff changeset
3073 static inline void put_dct(MpegEncContext *s,
1651
ccf7c96a630f h263 modified quantization fix
michael
parents: 1644
diff changeset
3074 DCTELEM *block, int i, uint8_t *dest, int line_size, int qscale)
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3075 {
1689
1a2db2073848 split intra / inter dequantization
michael
parents: 1688
diff changeset
3076 s->dct_unquantize_intra(s, block, i, qscale);
1092
f59c3f66363b MpegEncContext.(i)dct_* -> DspContext.(i)dct_*
michaelni
parents: 1089
diff changeset
3077 s->dsp.idct_put (dest, line_size, block);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3078 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
3079
986e461dc072 Initial revision
glantau
parents:
diff changeset
3080 /* add block[] to dest[] */
986e461dc072 Initial revision
glantau
parents:
diff changeset
3081 static inline void add_dct(MpegEncContext *s,
1064
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1059
diff changeset
3082 DCTELEM *block, int i, uint8_t *dest, int line_size)
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3083 {
986e461dc072 Initial revision
glantau
parents:
diff changeset
3084 if (s->block_last_index[i] >= 0) {
1092
f59c3f66363b MpegEncContext.(i)dct_* -> DspContext.(i)dct_*
michaelni
parents: 1089
diff changeset
3085 s->dsp.idct_add (dest, line_size, block);
481
29a7e17d19dd optimizing MPV_decode_mb
michaelni
parents: 478
diff changeset
3086 }
29a7e17d19dd optimizing MPV_decode_mb
michaelni
parents: 478
diff changeset
3087 }
29a7e17d19dd optimizing MPV_decode_mb
michaelni
parents: 478
diff changeset
3088
29a7e17d19dd optimizing MPV_decode_mb
michaelni
parents: 478
diff changeset
3089 static inline void add_dequant_dct(MpegEncContext *s,
1644
835cf346975e h263 loop filter
michael
parents: 1641
diff changeset
3090 DCTELEM *block, int i, uint8_t *dest, int line_size, int qscale)
481
29a7e17d19dd optimizing MPV_decode_mb
michaelni
parents: 478
diff changeset
3091 {
29a7e17d19dd optimizing MPV_decode_mb
michaelni
parents: 478
diff changeset
3092 if (s->block_last_index[i] >= 0) {
1689
1a2db2073848 split intra / inter dequantization
michael
parents: 1688
diff changeset
3093 s->dct_unquantize_inter(s, block, i, qscale);
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
3094
1092
f59c3f66363b MpegEncContext.(i)dct_* -> DspContext.(i)dct_*
michaelni
parents: 1089
diff changeset
3095 s->dsp.idct_add (dest, line_size, block);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3096 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
3097 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
3098
456
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
3099 /**
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
3100 * cleans dc, ac, coded_block for the current non intra MB
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
3101 */
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
3102 void ff_clean_intra_table_entries(MpegEncContext *s)
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
3103 {
1938
e2501e6e7ff7 unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents: 1918
diff changeset
3104 int wrap = s->b8_stride;
456
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
3105 int xy = s->block_index[0];
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
3106
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
3107 s->dc_val[0][xy ] =
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
3108 s->dc_val[0][xy + 1 ] =
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
3109 s->dc_val[0][xy + wrap] =
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
3110 s->dc_val[0][xy + 1 + wrap] = 1024;
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
3111 /* ac pred */
1064
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1059
diff changeset
3112 memset(s->ac_val[0][xy ], 0, 32 * sizeof(int16_t));
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1059
diff changeset
3113 memset(s->ac_val[0][xy + wrap], 0, 32 * sizeof(int16_t));
456
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
3114 if (s->msmpeg4_version>=3) {
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
3115 s->coded_block[xy ] =
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
3116 s->coded_block[xy + 1 ] =
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
3117 s->coded_block[xy + wrap] =
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
3118 s->coded_block[xy + 1 + wrap] = 0;
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
3119 }
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
3120 /* chroma */
1938
e2501e6e7ff7 unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents: 1918
diff changeset
3121 wrap = s->mb_stride;
e2501e6e7ff7 unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents: 1918
diff changeset
3122 xy = s->mb_x + s->mb_y * wrap;
456
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
3123 s->dc_val[1][xy] =
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
3124 s->dc_val[2][xy] = 1024;
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
3125 /* ac pred */
1064
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1059
diff changeset
3126 memset(s->ac_val[1][xy], 0, 16 * sizeof(int16_t));
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1059
diff changeset
3127 memset(s->ac_val[2][xy], 0, 16 * sizeof(int16_t));
456
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
3128
1938
e2501e6e7ff7 unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents: 1918
diff changeset
3129 s->mbintra_table[xy]= 0;
456
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
3130 }
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
3131
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3132 /* generic function called after a macroblock has been parsed by the
986e461dc072 Initial revision
glantau
parents:
diff changeset
3133 decoder or after it has been encoded by the encoder.
986e461dc072 Initial revision
glantau
parents:
diff changeset
3134
986e461dc072 Initial revision
glantau
parents:
diff changeset
3135 Important variables used:
986e461dc072 Initial revision
glantau
parents:
diff changeset
3136 s->mb_intra : true if intra macroblock
986e461dc072 Initial revision
glantau
parents:
diff changeset
3137 s->mv_dir : motion vector direction
986e461dc072 Initial revision
glantau
parents:
diff changeset
3138 s->mv_type : motion vector type
986e461dc072 Initial revision
glantau
parents:
diff changeset
3139 s->mv : motion vector
986e461dc072 Initial revision
glantau
parents:
diff changeset
3140 s->interlaced_dct : true if interlaced dct used (mpeg2)
986e461dc072 Initial revision
glantau
parents:
diff changeset
3141 */
2074
2faafe7a3db6 mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents: 2066
diff changeset
3142 void MPV_decode_mb(MpegEncContext *s, DCTELEM block[12][64])
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3143 {
244
3860331a1ecb * eliminating duplicated code from MPV_common_end
kabi
parents: 239
diff changeset
3144 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
3145 const int mb_xy = s->mb_y * s->mb_stride + s->mb_x;
1381
f07e17427140 initial XvMC support
iive
parents: 1373
diff changeset
3146 #ifdef HAVE_XVMC
f07e17427140 initial XvMC support
iive
parents: 1373
diff changeset
3147 if(s->avctx->xvmc_acceleration){
1580
628bf341e099 XvMC speedup by removing one memcpy and doing MB packing
iive
parents: 1579
diff changeset
3148 XVMC_decode_mb(s);//xvmc uses pblocks
1381
f07e17427140 initial XvMC support
iive
parents: 1373
diff changeset
3149 return;
f07e17427140 initial XvMC support
iive
parents: 1373
diff changeset
3150 }
f07e17427140 initial XvMC support
iive
parents: 1373
diff changeset
3151 #endif
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3152
986e461dc072 Initial revision
glantau
parents:
diff changeset
3153 mb_x = s->mb_x;
986e461dc072 Initial revision
glantau
parents:
diff changeset
3154 mb_y = s->mb_y;
986e461dc072 Initial revision
glantau
parents:
diff changeset
3155
1833
ba27ce284d07 export DCT coefficients patch by (Wolfgang Hesseler <wolfgang.hesseler at imk dot fraunhofer dot de>)
michael
parents: 1831
diff changeset
3156 if(s->avctx->debug&FF_DEBUG_DCT_COEFF) {
ba27ce284d07 export DCT coefficients patch by (Wolfgang Hesseler <wolfgang.hesseler at imk dot fraunhofer dot de>)
michael
parents: 1831
diff changeset
3157 /* save DCT coefficients */
ba27ce284d07 export DCT coefficients patch by (Wolfgang Hesseler <wolfgang.hesseler at imk dot fraunhofer dot de>)
michael
parents: 1831
diff changeset
3158 int i,j;
ba27ce284d07 export DCT coefficients patch by (Wolfgang Hesseler <wolfgang.hesseler at imk dot fraunhofer dot de>)
michael
parents: 1831
diff changeset
3159 DCTELEM *dct = &s->current_picture.dct_coeff[mb_xy*64*6];
ba27ce284d07 export DCT coefficients patch by (Wolfgang Hesseler <wolfgang.hesseler at imk dot fraunhofer dot de>)
michael
parents: 1831
diff changeset
3160 for(i=0; i<6; i++)
ba27ce284d07 export DCT coefficients patch by (Wolfgang Hesseler <wolfgang.hesseler at imk dot fraunhofer dot de>)
michael
parents: 1831
diff changeset
3161 for(j=0; j<64; j++)
ba27ce284d07 export DCT coefficients patch by (Wolfgang Hesseler <wolfgang.hesseler at imk dot fraunhofer dot de>)
michael
parents: 1831
diff changeset
3162 *dct++ = block[i][s->dsp.idct_permutation[j]];
ba27ce284d07 export DCT coefficients patch by (Wolfgang Hesseler <wolfgang.hesseler at imk dot fraunhofer dot de>)
michael
parents: 1831
diff changeset
3163 }
ba27ce284d07 export DCT coefficients patch by (Wolfgang Hesseler <wolfgang.hesseler at imk dot fraunhofer dot de>)
michael
parents: 1831
diff changeset
3164
903
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
3165 s->current_picture.qscale_table[mb_xy]= s->qscale;
108
1e4a4af694d1 exporting qscale data for postprocessing (for MPlayer)
arpi_esp
parents: 79
diff changeset
3166
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3167 /* update DC predictors for P macroblocks */
986e461dc072 Initial revision
glantau
parents:
diff changeset
3168 if (!s->mb_intra) {
249
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
3169 if (s->h263_pred || s->h263_aic) {
481
29a7e17d19dd optimizing MPV_decode_mb
michaelni
parents: 478
diff changeset
3170 if(s->mbintra_table[mb_xy])
456
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
3171 ff_clean_intra_table_entries(s);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3172 } else {
456
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
3173 s->last_dc[0] =
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
3174 s->last_dc[1] =
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3175 s->last_dc[2] = 128 << s->intra_dc_precision;
986e461dc072 Initial revision
glantau
parents:
diff changeset
3176 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
3177 }
249
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
3178 else if (s->h263_pred || s->h263_aic)
481
29a7e17d19dd optimizing MPV_decode_mb
michaelni
parents: 478
diff changeset
3179 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
3180
909
8ae1e4c24e91 new PSNR code (now works with chroma, b frames, ...)
michaelni
parents: 903
diff changeset
3181 if ((s->flags&CODEC_FLAG_PSNR) || !(s->encoding && (s->intra_only || s->pict_type==B_TYPE))) { //FIXME precalc
1064
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1059
diff changeset
3182 uint8_t *dest_y, *dest_cb, *dest_cr;
481
29a7e17d19dd optimizing MPV_decode_mb
michaelni
parents: 478
diff changeset
3183 int dct_linesize, dct_offset;
651
45e8f39fda50 put/avg_pixels16
michaelni
parents: 650
diff changeset
3184 op_pixels_func (*op_pix)[4];
45e8f39fda50 put/avg_pixels16
michaelni
parents: 650
diff changeset
3185 qpel_mc_func (*op_qpix)[16];
1138
e10e841c9bf0 field pic decoding cleanup
michaelni
parents: 1130
diff changeset
3186 const int linesize= s->current_picture.linesize[0]; //not s->linesize as this woulnd be wrong for field pics
e10e841c9bf0 field pic decoding cleanup
michaelni
parents: 1130
diff changeset
3187 const int uvlinesize= s->current_picture.linesize[1];
1632
4c0469b79010 dont read from b frames if draw_horiz_band==NULL
michael
parents: 1629
diff changeset
3188 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
3189
903
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
3190 /* avoid copy if macroblock skipped in last frame too */
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
3191 /* skip only during decoding as we might trash the buffers during encoding a bit */
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
3192 if(!s->encoding){
1064
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1059
diff changeset
3193 uint8_t *mbskip_ptr = &s->mbskip_table[mb_xy];
903
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
3194 const int age= s->current_picture.age;
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
3195
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
3196 assert(age);
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
3197
7
1d3ac9654178 added skip macroblock optimization (big perf win on black regions for example)
glantau
parents: 0
diff changeset
3198 if (s->mb_skiped) {
903
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
3199 s->mb_skiped= 0;
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
3200 assert(s->pict_type!=I_TYPE);
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
3201
556
762c67fd4078 uvlinesize
michaelni
parents: 554
diff changeset
3202 (*mbskip_ptr) ++; /* indicate that this time we skiped it */
762c67fd4078 uvlinesize
michaelni
parents: 554
diff changeset
3203 if(*mbskip_ptr >99) *mbskip_ptr= 99;
762c67fd4078 uvlinesize
michaelni
parents: 554
diff changeset
3204
903
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
3205 /* 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
3206 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
3207 return;
903
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
3208 }
1021
2d7c9f5738de trying to fix mb skip bug in mpeg1/2 if slices are not used
michaelni
parents: 1014
diff changeset
3209 } 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
3210 (*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
3211 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
3212 } else{
7
1d3ac9654178 added skip macroblock optimization (big perf win on black regions for example)
glantau
parents: 0
diff changeset
3213 *mbskip_ptr = 0; /* not skipped */
1d3ac9654178 added skip macroblock optimization (big perf win on black regions for example)
glantau
parents: 0
diff changeset
3214 }
717
6cba3b6196f0 optimization
michaelni
parents: 711
diff changeset
3215 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3216
2074
2faafe7a3db6 mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents: 2066
diff changeset
3217 dct_linesize = linesize << s->interlaced_dct;
2faafe7a3db6 mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents: 2066
diff changeset
3218 dct_offset =(s->interlaced_dct)? linesize : linesize*8;
2faafe7a3db6 mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents: 2066
diff changeset
3219
1632
4c0469b79010 dont read from b frames if draw_horiz_band==NULL
michael
parents: 1629
diff changeset
3220 if(readable){
4c0469b79010 dont read from b frames if draw_horiz_band==NULL
michael
parents: 1629
diff changeset
3221 dest_y= s->dest[0];
4c0469b79010 dont read from b frames if draw_horiz_band==NULL
michael
parents: 1629
diff changeset
3222 dest_cb= s->dest[1];
4c0469b79010 dont read from b frames if draw_horiz_band==NULL
michael
parents: 1629
diff changeset
3223 dest_cr= s->dest[2];
4c0469b79010 dont read from b frames if draw_horiz_band==NULL
michael
parents: 1629
diff changeset
3224 }else{
1799
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
3225 dest_y = s->b_scratchpad;
1834
41c324b09fcc 100l (field picture decoding fix)
michael
parents: 1833
diff changeset
3226 dest_cb= s->b_scratchpad+16*linesize;
2074
2faafe7a3db6 mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents: 2066
diff changeset
3227 dest_cr= s->b_scratchpad+32*linesize;
1632
4c0469b79010 dont read from b frames if draw_horiz_band==NULL
michael
parents: 1629
diff changeset
3228 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3229 if (!s->mb_intra) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
3230 /* motion handling */
456
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
3231 /* decoding or more than one mb_type (MC was allready done otherwise) */
1389
da0b3a50d209 rate distortion mb decision support
michaelni
parents: 1384
diff changeset
3232 if(!s->encoding){
327
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 326
diff changeset
3233 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
3234 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
3235 op_qpix= s->dsp.put_qpel_pixels_tab;
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
3236 }else{
853
eacc2dd8fd9d * using DSPContext - so each codec could use its local (sub)set of CPU extension
kabi
parents: 847
diff changeset
3237 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
3238 op_qpix= s->dsp.put_no_rnd_qpel_pixels_tab;
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
3239 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3240
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
3241 if (s->mv_dir & MV_DIR_FORWARD) {
903
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
3242 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
3243 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
3244 op_qpix= s->dsp.avg_qpel_pixels_tab;
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
3245 }
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
3246 if (s->mv_dir & MV_DIR_BACKWARD) {
903
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
3247 MPV_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.data, op_pix, op_qpix);
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
3248 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3249 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
3250
481
29a7e17d19dd optimizing MPV_decode_mb
michaelni
parents: 478
diff changeset
3251 /* skip dequant / idct if we are really late ;) */
814
8f31ed5bacd1 dont call emms_c() for each MB
michaelni
parents: 813
diff changeset
3252 if(s->hurry_up>1) return;
481
29a7e17d19dd optimizing MPV_decode_mb
michaelni
parents: 478
diff changeset
3253
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3254 /* add dct residue */
1421
340c90faa1dc mpeg2 encoding
michaelni
parents: 1416
diff changeset
3255 if(s->encoding || !( s->h263_msmpeg4 || s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO
711
dcbcf9676c9f optimizing mpeg1_decode_block()
michaelni
parents: 709
diff changeset
3256 || (s->codec_id==CODEC_ID_MPEG4 && !s->mpeg_quant))){
1644
835cf346975e h263 loop filter
michael
parents: 1641
diff changeset
3257 add_dequant_dct(s, block[0], 0, dest_y, dct_linesize, s->qscale);
835cf346975e h263 loop filter
michael
parents: 1641
diff changeset
3258 add_dequant_dct(s, block[1], 1, dest_y + 8, dct_linesize, s->qscale);
835cf346975e h263 loop filter
michael
parents: 1641
diff changeset
3259 add_dequant_dct(s, block[2], 2, dest_y + dct_offset, dct_linesize, s->qscale);
835cf346975e h263 loop filter
michael
parents: 1641
diff changeset
3260 add_dequant_dct(s, block[3], 3, dest_y + dct_offset + 8, dct_linesize, s->qscale);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3261
485
20108840b0e5 grayscale only decoding
michaelni
parents: 481
diff changeset
3262 if(!(s->flags&CODEC_FLAG_GRAY)){
1644
835cf346975e h263 loop filter
michael
parents: 1641
diff changeset
3263 add_dequant_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale);
835cf346975e h263 loop filter
michael
parents: 1641
diff changeset
3264 add_dequant_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale);
485
20108840b0e5 grayscale only decoding
michaelni
parents: 481
diff changeset
3265 }
936
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
3266 } else if(s->codec_id != CODEC_ID_WMV2){
481
29a7e17d19dd optimizing MPV_decode_mb
michaelni
parents: 478
diff changeset
3267 add_dct(s, block[0], 0, dest_y, dct_linesize);
29a7e17d19dd optimizing MPV_decode_mb
michaelni
parents: 478
diff changeset
3268 add_dct(s, block[1], 1, dest_y + 8, dct_linesize);
29a7e17d19dd optimizing MPV_decode_mb
michaelni
parents: 478
diff changeset
3269 add_dct(s, block[2], 2, dest_y + dct_offset, dct_linesize);
29a7e17d19dd optimizing MPV_decode_mb
michaelni
parents: 478
diff changeset
3270 add_dct(s, block[3], 3, dest_y + dct_offset + 8, dct_linesize);
29a7e17d19dd optimizing MPV_decode_mb
michaelni
parents: 478
diff changeset
3271
485
20108840b0e5 grayscale only decoding
michaelni
parents: 481
diff changeset
3272 if(!(s->flags&CODEC_FLAG_GRAY)){
2074
2faafe7a3db6 mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents: 2066
diff changeset
3273 if(s->chroma_y_shift){//Chroma420
2faafe7a3db6 mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents: 2066
diff changeset
3274 add_dct(s, block[4], 4, dest_cb, uvlinesize);
2faafe7a3db6 mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents: 2066
diff changeset
3275 add_dct(s, block[5], 5, dest_cr, uvlinesize);
2faafe7a3db6 mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents: 2066
diff changeset
3276 }else{
2faafe7a3db6 mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents: 2066
diff changeset
3277 //chroma422
2faafe7a3db6 mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents: 2066
diff changeset
3278 dct_linesize = uvlinesize << s->interlaced_dct;
2faafe7a3db6 mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents: 2066
diff changeset
3279 dct_offset =(s->interlaced_dct)? uvlinesize : uvlinesize*8;
2faafe7a3db6 mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents: 2066
diff changeset
3280
2faafe7a3db6 mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents: 2066
diff changeset
3281 add_dct(s, block[4], 4, dest_cb, dct_linesize);
2faafe7a3db6 mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents: 2066
diff changeset
3282 add_dct(s, block[5], 5, dest_cr, dct_linesize);
2faafe7a3db6 mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents: 2066
diff changeset
3283 add_dct(s, block[6], 6, dest_cb+dct_offset, dct_linesize);
2faafe7a3db6 mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents: 2066
diff changeset
3284 add_dct(s, block[7], 7, dest_cr+dct_offset, dct_linesize);
2faafe7a3db6 mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents: 2066
diff changeset
3285 if(!s->chroma_x_shift){//Chroma444
2faafe7a3db6 mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents: 2066
diff changeset
3286 add_dct(s, block[8], 8, dest_cb+8, dct_linesize);
2faafe7a3db6 mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents: 2066
diff changeset
3287 add_dct(s, block[9], 9, dest_cr+8, dct_linesize);
2faafe7a3db6 mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents: 2066
diff changeset
3288 add_dct(s, block[10], 10, dest_cb+8+dct_offset, dct_linesize);
2faafe7a3db6 mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents: 2066
diff changeset
3289 add_dct(s, block[11], 11, dest_cr+8+dct_offset, dct_linesize);
2faafe7a3db6 mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents: 2066
diff changeset
3290 }
2faafe7a3db6 mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents: 2066
diff changeset
3291 }
2faafe7a3db6 mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents: 2066
diff changeset
3292 }//fi gray
2faafe7a3db6 mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents: 2066
diff changeset
3293 }
1042
a78f6f72d54e --disable-risky support
michaelni
parents: 1026
diff changeset
3294 #ifdef CONFIG_RISKY
a78f6f72d54e --disable-risky support
michaelni
parents: 1026
diff changeset
3295 else{
936
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
3296 ff_wmv2_add_mb(s, block, dest_y, dest_cb, dest_cr);
481
29a7e17d19dd optimizing MPV_decode_mb
michaelni
parents: 478
diff changeset
3297 }
1042
a78f6f72d54e --disable-risky support
michaelni
parents: 1026
diff changeset
3298 #endif
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3299 } else {
986e461dc072 Initial revision
glantau
parents:
diff changeset
3300 /* dct only in intra block */
1421
340c90faa1dc mpeg2 encoding
michaelni
parents: 1416
diff changeset
3301 if(s->encoding || !(s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO)){
1651
ccf7c96a630f h263 modified quantization fix
michael
parents: 1644
diff changeset
3302 put_dct(s, block[0], 0, dest_y, dct_linesize, s->qscale);
ccf7c96a630f h263 modified quantization fix
michael
parents: 1644
diff changeset
3303 put_dct(s, block[1], 1, dest_y + 8, dct_linesize, s->qscale);
ccf7c96a630f h263 modified quantization fix
michael
parents: 1644
diff changeset
3304 put_dct(s, block[2], 2, dest_y + dct_offset, dct_linesize, s->qscale);
ccf7c96a630f h263 modified quantization fix
michael
parents: 1644
diff changeset
3305 put_dct(s, block[3], 3, dest_y + dct_offset + 8, dct_linesize, s->qscale);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3306
711
dcbcf9676c9f optimizing mpeg1_decode_block()
michaelni
parents: 709
diff changeset
3307 if(!(s->flags&CODEC_FLAG_GRAY)){
1651
ccf7c96a630f h263 modified quantization fix
michael
parents: 1644
diff changeset
3308 put_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale);
ccf7c96a630f h263 modified quantization fix
michael
parents: 1644
diff changeset
3309 put_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale);
711
dcbcf9676c9f optimizing mpeg1_decode_block()
michaelni
parents: 709
diff changeset
3310 }
dcbcf9676c9f optimizing mpeg1_decode_block()
michaelni
parents: 709
diff changeset
3311 }else{
1092
f59c3f66363b MpegEncContext.(i)dct_* -> DspContext.(i)dct_*
michaelni
parents: 1089
diff changeset
3312 s->dsp.idct_put(dest_y , dct_linesize, block[0]);
f59c3f66363b MpegEncContext.(i)dct_* -> DspContext.(i)dct_*
michaelni
parents: 1089
diff changeset
3313 s->dsp.idct_put(dest_y + 8, dct_linesize, block[1]);
f59c3f66363b MpegEncContext.(i)dct_* -> DspContext.(i)dct_*
michaelni
parents: 1089
diff changeset
3314 s->dsp.idct_put(dest_y + dct_offset , dct_linesize, block[2]);
f59c3f66363b MpegEncContext.(i)dct_* -> DspContext.(i)dct_*
michaelni
parents: 1089
diff changeset
3315 s->dsp.idct_put(dest_y + dct_offset + 8, dct_linesize, block[3]);
711
dcbcf9676c9f optimizing mpeg1_decode_block()
michaelni
parents: 709
diff changeset
3316
dcbcf9676c9f optimizing mpeg1_decode_block()
michaelni
parents: 709
diff changeset
3317 if(!(s->flags&CODEC_FLAG_GRAY)){
2074
2faafe7a3db6 mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents: 2066
diff changeset
3318 if(s->chroma_y_shift){
2faafe7a3db6 mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents: 2066
diff changeset
3319 s->dsp.idct_put(dest_cb, uvlinesize, block[4]);
2faafe7a3db6 mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents: 2066
diff changeset
3320 s->dsp.idct_put(dest_cr, uvlinesize, block[5]);
2faafe7a3db6 mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents: 2066
diff changeset
3321 }else{
2faafe7a3db6 mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents: 2066
diff changeset
3322
2faafe7a3db6 mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents: 2066
diff changeset
3323 dct_linesize = uvlinesize << s->interlaced_dct;
2faafe7a3db6 mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents: 2066
diff changeset
3324 dct_offset =(s->interlaced_dct)? uvlinesize : uvlinesize*8;
2faafe7a3db6 mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents: 2066
diff changeset
3325
2faafe7a3db6 mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents: 2066
diff changeset
3326 s->dsp.idct_put(dest_cb, dct_linesize, block[4]);
2faafe7a3db6 mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents: 2066
diff changeset
3327 s->dsp.idct_put(dest_cr, dct_linesize, block[5]);
2faafe7a3db6 mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents: 2066
diff changeset
3328 s->dsp.idct_put(dest_cb + dct_offset, dct_linesize, block[6]);
2faafe7a3db6 mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents: 2066
diff changeset
3329 s->dsp.idct_put(dest_cr + dct_offset, dct_linesize, block[7]);
2faafe7a3db6 mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents: 2066
diff changeset
3330 if(!s->chroma_x_shift){//Chroma444
2faafe7a3db6 mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents: 2066
diff changeset
3331 s->dsp.idct_put(dest_cb + 8, dct_linesize, block[8]);
2faafe7a3db6 mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents: 2066
diff changeset
3332 s->dsp.idct_put(dest_cr + 8, dct_linesize, block[9]);
2faafe7a3db6 mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents: 2066
diff changeset
3333 s->dsp.idct_put(dest_cb + 8 + dct_offset, dct_linesize, block[10]);
2faafe7a3db6 mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents: 2066
diff changeset
3334 s->dsp.idct_put(dest_cr + 8 + dct_offset, dct_linesize, block[11]);
2faafe7a3db6 mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents: 2066
diff changeset
3335 }
2faafe7a3db6 mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents: 2066
diff changeset
3336 }
2faafe7a3db6 mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents: 2066
diff changeset
3337 }//gray
485
20108840b0e5 grayscale only decoding
michaelni
parents: 481
diff changeset
3338 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3339 }
1632
4c0469b79010 dont read from b frames if draw_horiz_band==NULL
michael
parents: 1629
diff changeset
3340 if(!readable){
4c0469b79010 dont read from b frames if draw_horiz_band==NULL
michael
parents: 1629
diff changeset
3341 s->dsp.put_pixels_tab[0][0](s->dest[0], dest_y , linesize,16);
2074
2faafe7a3db6 mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents: 2066
diff changeset
3342 s->dsp.put_pixels_tab[s->chroma_x_shift][0](s->dest[1], dest_cb, uvlinesize,16 >> s->chroma_y_shift);
2faafe7a3db6 mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents: 2066
diff changeset
3343 s->dsp.put_pixels_tab[s->chroma_x_shift][0](s->dest[2], dest_cr, uvlinesize,16 >> s->chroma_y_shift);
1632
4c0469b79010 dont read from b frames if draw_horiz_band==NULL
michael
parents: 1629
diff changeset
3344 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3345 }
294
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 292
diff changeset
3346 }
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 292
diff changeset
3347
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
3348 #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
3349
605
40874804a5af same dc skip behavior for chroma & luma elimination, its confusing otherwise imho
michaelni
parents: 604
diff changeset
3350 static inline void dct_single_coeff_elimination(MpegEncContext *s, int n, int threshold)
456
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
3351 {
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
3352 static const char tab[64]=
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
3353 {3,2,2,1,1,1,1,1,
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
3354 1,1,1,1,1,1,1,1,
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
3355 1,1,1,1,1,1,1,1,
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
3356 0,0,0,0,0,0,0,0,
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
3357 0,0,0,0,0,0,0,0,
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
3358 0,0,0,0,0,0,0,0,
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
3359 0,0,0,0,0,0,0,0,
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
3360 0,0,0,0,0,0,0,0};
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
3361 int score=0;
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
3362 int run=0;
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
3363 int i;
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
3364 DCTELEM *block= s->block[n];
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
3365 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
3366 int skip_dc;
456
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
3367
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
3368 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
3369 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
3370 threshold= -threshold;
605
40874804a5af same dc skip behavior for chroma & luma elimination, its confusing otherwise imho
michaelni
parents: 604
diff changeset
3371 }else
40874804a5af same dc skip behavior for chroma & luma elimination, its confusing otherwise imho
michaelni
parents: 604
diff changeset
3372 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
3373
456
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
3374 /* are all which we could set to zero are allready zero? */
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
3375 if(last_index<=skip_dc - 1) return;
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
3376
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
3377 for(i=0; i<=last_index; i++){
706
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 704
diff changeset
3378 const int j = s->intra_scantable.permutated[i];
456
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
3379 const int level = ABS(block[j]);
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
3380 if(level==1){
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
3381 if(skip_dc && i==0) continue;
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
3382 score+= tab[run];
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
3383 run=0;
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
3384 }else if(level>1){
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
3385 return;
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
3386 }else{
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
3387 run++;
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
3388 }
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
3389 }
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
3390 if(score >= threshold) return;
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
3391 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
3392 const int j = s->intra_scantable.permutated[i];
456
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
3393 block[j]=0;
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
3394 }
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
3395 if(block[0]) s->block_last_index[n]= 0;
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
3396 else s->block_last_index[n]= -1;
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
3397 }
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
3398
344
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
3399 static inline void clip_coeffs(MpegEncContext *s, DCTELEM *block, int last_index)
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
3400 {
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
3401 int i;
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
3402 const int maxlevel= s->max_qcoeff;
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
3403 const int minlevel= s->min_qcoeff;
1722
7e040c2a86e4 warn the user if we had to clip some dct coefficient due to a crappy format which doenst support the whole needed range (msmpeg4/wmv mostly but mpeg1 too to a lesser extend)
michael
parents: 1719
diff changeset
3404 int overflow=0;
706
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 704
diff changeset
3405
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 704
diff changeset
3406 if(s->mb_intra){
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 704
diff changeset
3407 i=1; //skip clipping of intra dc
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 704
diff changeset
3408 }else
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 704
diff changeset
3409 i=0;
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 704
diff changeset
3410
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 704
diff changeset
3411 for(;i<=last_index; i++){
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 704
diff changeset
3412 const int j= s->intra_scantable.permutated[i];
344
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
3413 int level = block[j];
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
3414
1722
7e040c2a86e4 warn the user if we had to clip some dct coefficient due to a crappy format which doenst support the whole needed range (msmpeg4/wmv mostly but mpeg1 too to a lesser extend)
michael
parents: 1719
diff changeset
3415 if (level>maxlevel){
7e040c2a86e4 warn the user if we had to clip some dct coefficient due to a crappy format which doenst support the whole needed range (msmpeg4/wmv mostly but mpeg1 too to a lesser extend)
michael
parents: 1719
diff changeset
3416 level=maxlevel;
7e040c2a86e4 warn the user if we had to clip some dct coefficient due to a crappy format which doenst support the whole needed range (msmpeg4/wmv mostly but mpeg1 too to a lesser extend)
michael
parents: 1719
diff changeset
3417 overflow++;
7e040c2a86e4 warn the user if we had to clip some dct coefficient due to a crappy format which doenst support the whole needed range (msmpeg4/wmv mostly but mpeg1 too to a lesser extend)
michael
parents: 1719
diff changeset
3418 }else if(level<minlevel){
7e040c2a86e4 warn the user if we had to clip some dct coefficient due to a crappy format which doenst support the whole needed range (msmpeg4/wmv mostly but mpeg1 too to a lesser extend)
michael
parents: 1719
diff changeset
3419 level=minlevel;
7e040c2a86e4 warn the user if we had to clip some dct coefficient due to a crappy format which doenst support the whole needed range (msmpeg4/wmv mostly but mpeg1 too to a lesser extend)
michael
parents: 1719
diff changeset
3420 overflow++;
7e040c2a86e4 warn the user if we had to clip some dct coefficient due to a crappy format which doenst support the whole needed range (msmpeg4/wmv mostly but mpeg1 too to a lesser extend)
michael
parents: 1719
diff changeset
3421 }
7e040c2a86e4 warn the user if we had to clip some dct coefficient due to a crappy format which doenst support the whole needed range (msmpeg4/wmv mostly but mpeg1 too to a lesser extend)
michael
parents: 1719
diff changeset
3422
344
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
3423 block[j]= level;
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
3424 }
1722
7e040c2a86e4 warn the user if we had to clip some dct coefficient due to a crappy format which doenst support the whole needed range (msmpeg4/wmv mostly but mpeg1 too to a lesser extend)
michael
parents: 1719
diff changeset
3425
7e040c2a86e4 warn the user if we had to clip some dct coefficient due to a crappy format which doenst support the whole needed range (msmpeg4/wmv mostly but mpeg1 too to a lesser extend)
michael
parents: 1719
diff changeset
3426 if(overflow && s->avctx->mb_decision == FF_MB_DECISION_SIMPLE)
7e040c2a86e4 warn the user if we had to clip some dct coefficient due to a crappy format which doenst support the whole needed range (msmpeg4/wmv mostly but mpeg1 too to a lesser extend)
michael
parents: 1719
diff changeset
3427 av_log(s->avctx, AV_LOG_INFO, "warning, cliping %d dct coefficents to %d..%d\n", overflow, minlevel, maxlevel);
344
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
3428 }
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
3429
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
3430 #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
3431
1098
b7f267d168b7 mpeg2 field pictures + sliced mode (doesnt work with mplayer though, dunno why)
michaelni
parents: 1096
diff changeset
3432 /**
b7f267d168b7 mpeg2 field pictures + sliced mode (doesnt work with mplayer though, dunno why)
michaelni
parents: 1096
diff changeset
3433 *
b7f267d168b7 mpeg2 field pictures + sliced mode (doesnt work with mplayer though, dunno why)
michaelni
parents: 1096
diff changeset
3434 * @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
3435 */
b7f267d168b7 mpeg2 field pictures + sliced mode (doesnt work with mplayer though, dunno why)
michaelni
parents: 1096
diff changeset
3436 void ff_draw_horiz_band(MpegEncContext *s, int y, int h){
1368
0fd38b711f06 AVCodec.flush()
michaelni
parents: 1354
diff changeset
3437 if (s->avctx->draw_horiz_band) {
1370
45d761c387cd default for slices is display order again
michaelni
parents: 1369
diff changeset
3438 AVFrame *src;
1368
0fd38b711f06 AVCodec.flush()
michaelni
parents: 1354
diff changeset
3439 int offset[4];
1370
45d761c387cd default for slices is display order again
michaelni
parents: 1369
diff changeset
3440
45d761c387cd default for slices is display order again
michaelni
parents: 1369
diff changeset
3441 if(s->picture_structure != PICT_FRAME){
45d761c387cd default for slices is display order again
michaelni
parents: 1369
diff changeset
3442 h <<= 1;
45d761c387cd default for slices is display order again
michaelni
parents: 1369
diff changeset
3443 y <<= 1;
45d761c387cd default for slices is display order again
michaelni
parents: 1369
diff changeset
3444 if(s->first_field && !(s->avctx->slice_flags&SLICE_FLAG_ALLOW_FIELD)) return;
45d761c387cd default for slices is display order again
michaelni
parents: 1369
diff changeset
3445 }
45d761c387cd default for slices is display order again
michaelni
parents: 1369
diff changeset
3446
1098
b7f267d168b7 mpeg2 field pictures + sliced mode (doesnt work with mplayer though, dunno why)
michaelni
parents: 1096
diff changeset
3447 h= FFMIN(h, s->height - y);
b7f267d168b7 mpeg2 field pictures + sliced mode (doesnt work with mplayer though, dunno why)
michaelni
parents: 1096
diff changeset
3448
1370
45d761c387cd default for slices is display order again
michaelni
parents: 1369
diff changeset
3449 if(s->pict_type==B_TYPE || s->low_delay || (s->avctx->slice_flags&SLICE_FLAG_CODED_ORDER))
45d761c387cd default for slices is display order again
michaelni
parents: 1369
diff changeset
3450 src= (AVFrame*)s->current_picture_ptr;
45d761c387cd default for slices is display order again
michaelni
parents: 1369
diff changeset
3451 else if(s->last_picture_ptr)
45d761c387cd default for slices is display order again
michaelni
parents: 1369
diff changeset
3452 src= (AVFrame*)s->last_picture_ptr;
45d761c387cd default for slices is display order again
michaelni
parents: 1369
diff changeset
3453 else
45d761c387cd default for slices is display order again
michaelni
parents: 1369
diff changeset
3454 return;
45d761c387cd default for slices is display order again
michaelni
parents: 1369
diff changeset
3455
1369
8a150a66d2d9 svq3 b frame slices fix
michaelni
parents: 1368
diff changeset
3456 if(s->pict_type==B_TYPE && s->picture_structure == PICT_FRAME && s->out_format != FMT_H264){
1368
0fd38b711f06 AVCodec.flush()
michaelni
parents: 1354
diff changeset
3457 offset[0]=
0fd38b711f06 AVCodec.flush()
michaelni
parents: 1354
diff changeset
3458 offset[1]=
0fd38b711f06 AVCodec.flush()
michaelni
parents: 1354
diff changeset
3459 offset[2]=
0fd38b711f06 AVCodec.flush()
michaelni
parents: 1354
diff changeset
3460 offset[3]= 0;
0fd38b711f06 AVCodec.flush()
michaelni
parents: 1354
diff changeset
3461 }else{
0fd38b711f06 AVCodec.flush()
michaelni
parents: 1354
diff changeset
3462 offset[0]= y * s->linesize;;
0fd38b711f06 AVCodec.flush()
michaelni
parents: 1354
diff changeset
3463 offset[1]=
2074
2faafe7a3db6 mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents: 2066
diff changeset
3464 offset[2]= (y >> s->chroma_y_shift) * s->uvlinesize;
1368
0fd38b711f06 AVCodec.flush()
michaelni
parents: 1354
diff changeset
3465 offset[3]= 0;
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 731
diff changeset
3466 }
1368
0fd38b711f06 AVCodec.flush()
michaelni
parents: 1354
diff changeset
3467
813
dfaa1c45bd27 cleanup
michaelni
parents: 809
diff changeset
3468 emms_c();
dfaa1c45bd27 cleanup
michaelni
parents: 809
diff changeset
3469
1370
45d761c387cd default for slices is display order again
michaelni
parents: 1369
diff changeset
3470 s->avctx->draw_horiz_band(s->avctx, src, offset,
45d761c387cd default for slices is display order again
michaelni
parents: 1369
diff changeset
3471 y, s->picture_structure, h);
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 731
diff changeset
3472 }
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 731
diff changeset
3473 }
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 731
diff changeset
3474
1389
da0b3a50d209 rate distortion mb decision support
michaelni
parents: 1384
diff changeset
3475 void ff_init_block_index(MpegEncContext *s){ //FIXME maybe rename
da0b3a50d209 rate distortion mb decision support
michaelni
parents: 1384
diff changeset
3476 const int linesize= s->current_picture.linesize[0]; //not s->linesize as this woulnd be wrong for field pics
da0b3a50d209 rate distortion mb decision support
michaelni
parents: 1384
diff changeset
3477 const int uvlinesize= s->current_picture.linesize[1];
da0b3a50d209 rate distortion mb decision support
michaelni
parents: 1384
diff changeset
3478
1938
e2501e6e7ff7 unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents: 1918
diff changeset
3479 s->block_index[0]= s->b8_stride*(s->mb_y*2 ) - 2 + s->mb_x*2;
e2501e6e7ff7 unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents: 1918
diff changeset
3480 s->block_index[1]= s->b8_stride*(s->mb_y*2 ) - 1 + s->mb_x*2;
e2501e6e7ff7 unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents: 1918
diff changeset
3481 s->block_index[2]= s->b8_stride*(s->mb_y*2 + 1) - 2 + s->mb_x*2;
e2501e6e7ff7 unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents: 1918
diff changeset
3482 s->block_index[3]= s->b8_stride*(s->mb_y*2 + 1) - 1 + s->mb_x*2;
e2501e6e7ff7 unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents: 1918
diff changeset
3483 s->block_index[4]= s->mb_stride*(s->mb_y + 1) + s->b8_stride*s->mb_height*2 + s->mb_x - 1;
e2501e6e7ff7 unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents: 1918
diff changeset
3484 s->block_index[5]= s->mb_stride*(s->mb_y + s->mb_height + 2) + s->b8_stride*s->mb_height*2 + s->mb_x - 1;
2074
2faafe7a3db6 mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents: 2066
diff changeset
3485 //block_index is not used by mpeg2, so it is not affected by chroma_format
2faafe7a3db6 mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents: 2066
diff changeset
3486
2168
f3f5dabef677 minor optimization
michael
parents: 2165
diff changeset
3487 s->dest[0] = s->current_picture.data[0] + ((s->mb_x - 1) << 4);
f3f5dabef677 minor optimization
michael
parents: 2165
diff changeset
3488 s->dest[1] = s->current_picture.data[1] + ((s->mb_x - 1) << (4 - s->chroma_x_shift));
f3f5dabef677 minor optimization
michael
parents: 2165
diff changeset
3489 s->dest[2] = s->current_picture.data[2] + ((s->mb_x - 1) << (4 - s->chroma_x_shift));
f3f5dabef677 minor optimization
michael
parents: 2165
diff changeset
3490
2074
2faafe7a3db6 mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents: 2066
diff changeset
3491 if(!(s->pict_type==B_TYPE && s->avctx->draw_horiz_band && s->picture_structure==PICT_FRAME))
2faafe7a3db6 mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents: 2066
diff changeset
3492 {
2168
f3f5dabef677 minor optimization
michael
parents: 2165
diff changeset
3493 s->dest[0] += s->mb_y * linesize << 4;
f3f5dabef677 minor optimization
michael
parents: 2165
diff changeset
3494 s->dest[1] += s->mb_y * uvlinesize << (4 - s->chroma_y_shift);
f3f5dabef677 minor optimization
michael
parents: 2165
diff changeset
3495 s->dest[2] += s->mb_y * uvlinesize << (4 - s->chroma_y_shift);
2074
2faafe7a3db6 mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents: 2066
diff changeset
3496 }
1389
da0b3a50d209 rate distortion mb decision support
michaelni
parents: 1384
diff changeset
3497 }
da0b3a50d209 rate distortion mb decision support
michaelni
parents: 1384
diff changeset
3498
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
3499 #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
3500
1777
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
3501 static void get_vissual_weight(int16_t *weight, uint8_t *ptr, int stride){
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
3502 int x, y;
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
3503 //FIXME optimize
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
3504 for(y=0; y<8; y++){
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
3505 for(x=0; x<8; x++){
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
3506 int x2, y2;
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
3507 int sum=0;
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
3508 int sqr=0;
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
3509 int count=0;
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
3510
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
3511 for(y2= FFMAX(y-1, 0); y2 < FFMIN(8, y+2); y2++){
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
3512 for(x2= FFMAX(x-1, 0); x2 < FFMIN(8, x+2); x2++){
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
3513 int v= ptr[x2 + y2*stride];
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
3514 sum += v;
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
3515 sqr += v*v;
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
3516 count++;
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
3517 }
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
3518 }
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
3519 weight[x + 8*y]= (36*ff_sqrt(count*sqr - sum*sum)) / count;
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
3520 }
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
3521 }
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
3522 }
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
3523
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
3524 static void encode_mb(MpegEncContext *s, int motion_x, int motion_y)
294
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 292
diff changeset
3525 {
1777
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
3526 int16_t weight[6][64];
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
3527 DCTELEM orig[6][64];
294
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 292
diff changeset
3528 const int mb_x= s->mb_x;
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 292
diff changeset
3529 const int mb_y= s->mb_y;
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 292
diff changeset
3530 int i;
456
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
3531 int skip_dct[6];
697
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
3532 int dct_offset = s->linesize*8; //default for progressive frames
1778
34466835920f simplify
michael
parents: 1777
diff changeset
3533 uint8_t *ptr_y, *ptr_cb, *ptr_cr;
34466835920f simplify
michael
parents: 1777
diff changeset
3534 int wrap_y, wrap_c;
697
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
3535
456
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
3536 for(i=0; i<6; i++) skip_dct[i]=0;
690
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 673
diff changeset
3537
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 673
diff changeset
3538 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
3539 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
3540 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
3541
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
3542 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
3543 update_qscale(s);
1616
13a20c0594f2 rate distored optimal lambda->qp support
michael
parents: 1601
diff changeset
3544
13a20c0594f2 rate distored optimal lambda->qp support
michael
parents: 1601
diff changeset
3545 if(!(s->flags&CODEC_FLAG_QP_RD)){
13a20c0594f2 rate distored optimal lambda->qp support
michael
parents: 1601
diff changeset
3546 s->dquant= s->qscale - last_qp;
13a20c0594f2 rate distored optimal lambda->qp support
michael
parents: 1601
diff changeset
3547
1805
5dd5b2052f5b mpeg4 b frame + adaptive quantization assertion failure fix
michael
parents: 1804
diff changeset
3548 if(s->out_format==FMT_H263){
1616
13a20c0594f2 rate distored optimal lambda->qp support
michael
parents: 1601
diff changeset
3549 s->dquant= clip(s->dquant, -2, 2); //FIXME RD
697
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
3550
1805
5dd5b2052f5b mpeg4 b frame + adaptive quantization assertion failure fix
michael
parents: 1804
diff changeset
3551 if(s->codec_id==CODEC_ID_MPEG4){
5dd5b2052f5b mpeg4 b frame + adaptive quantization assertion failure fix
michael
parents: 1804
diff changeset
3552 if(!s->mb_intra){
5dd5b2052f5b mpeg4 b frame + adaptive quantization assertion failure fix
michael
parents: 1804
diff changeset
3553 if(s->pict_type == B_TYPE){
5dd5b2052f5b mpeg4 b frame + adaptive quantization assertion failure fix
michael
parents: 1804
diff changeset
3554 if(s->dquant&1)
5dd5b2052f5b mpeg4 b frame + adaptive quantization assertion failure fix
michael
parents: 1804
diff changeset
3555 s->dquant= (s->dquant/2)*2;
5dd5b2052f5b mpeg4 b frame + adaptive quantization assertion failure fix
michael
parents: 1804
diff changeset
3556 if(s->mv_dir&MV_DIRECT)
5dd5b2052f5b mpeg4 b frame + adaptive quantization assertion failure fix
michael
parents: 1804
diff changeset
3557 s->dquant= 0;
5dd5b2052f5b mpeg4 b frame + adaptive quantization assertion failure fix
michael
parents: 1804
diff changeset
3558 }
5dd5b2052f5b mpeg4 b frame + adaptive quantization assertion failure fix
michael
parents: 1804
diff changeset
3559 if(s->mv_type==MV_TYPE_8X8)
5dd5b2052f5b mpeg4 b frame + adaptive quantization assertion failure fix
michael
parents: 1804
diff changeset
3560 s->dquant=0;
5dd5b2052f5b mpeg4 b frame + adaptive quantization assertion failure fix
michael
parents: 1804
diff changeset
3561 }
1616
13a20c0594f2 rate distored optimal lambda->qp support
michael
parents: 1601
diff changeset
3562 }
690
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 673
diff changeset
3563 }
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 673
diff changeset
3564 }
1652
834922115010 cleanup
michael
parents: 1651
diff changeset
3565 ff_set_qscale(s, last_qp + s->dquant);
2054
06d6a6bade18 qscale + qprd fix
michael
parents: 2053
diff changeset
3566 }else if(s->flags&CODEC_FLAG_QP_RD)
06d6a6bade18 qscale + qprd fix
michael
parents: 2053
diff changeset
3567 ff_set_qscale(s, s->qscale + s->dquant);
294
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 292
diff changeset
3568
1778
34466835920f simplify
michael
parents: 1777
diff changeset
3569 wrap_y = s->linesize;
34466835920f simplify
michael
parents: 1777
diff changeset
3570 wrap_c = s->uvlinesize;
34466835920f simplify
michael
parents: 1777
diff changeset
3571 ptr_y = s->new_picture.data[0] + (mb_y * 16 * wrap_y) + mb_x * 16;
34466835920f simplify
michael
parents: 1777
diff changeset
3572 ptr_cb = s->new_picture.data[1] + (mb_y * 8 * wrap_c) + mb_x * 8;
34466835920f simplify
michael
parents: 1777
diff changeset
3573 ptr_cr = s->new_picture.data[2] + (mb_y * 8 * wrap_c) + mb_x * 8;
34466835920f simplify
michael
parents: 1777
diff changeset
3574
34466835920f simplify
michael
parents: 1777
diff changeset
3575 if(mb_x*16+16 > s->width || mb_y*16+16 > s->height){
2165
5ca07515a309 10l (dont store 2 different things at the same place ...)
michael
parents: 2132
diff changeset
3576 uint8_t *ebuf= s->edge_emu_buffer + 32;
5ca07515a309 10l (dont store 2 different things at the same place ...)
michael
parents: 2132
diff changeset
3577 ff_emulated_edge_mc(ebuf , ptr_y , wrap_y,16,16,mb_x*16,mb_y*16, s->width , s->height);
5ca07515a309 10l (dont store 2 different things at the same place ...)
michael
parents: 2132
diff changeset
3578 ptr_y= ebuf;
5ca07515a309 10l (dont store 2 different things at the same place ...)
michael
parents: 2132
diff changeset
3579 ff_emulated_edge_mc(ebuf+18*wrap_y , ptr_cb, wrap_c, 8, 8, mb_x*8, mb_y*8, s->width>>1, s->height>>1);
5ca07515a309 10l (dont store 2 different things at the same place ...)
michael
parents: 2132
diff changeset
3580 ptr_cb= ebuf+18*wrap_y;
5ca07515a309 10l (dont store 2 different things at the same place ...)
michael
parents: 2132
diff changeset
3581 ff_emulated_edge_mc(ebuf+18*wrap_y+8, ptr_cr, wrap_c, 8, 8, mb_x*8, mb_y*8, s->width>>1, s->height>>1);
5ca07515a309 10l (dont store 2 different things at the same place ...)
michael
parents: 2132
diff changeset
3582 ptr_cr= ebuf+18*wrap_y+8;
1778
34466835920f simplify
michael
parents: 1777
diff changeset
3583 }
34466835920f simplify
michael
parents: 1777
diff changeset
3584
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
3585 if (s->mb_intra) {
697
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
3586 if(s->flags&CODEC_FLAG_INTERLACED_DCT){
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
3587 int progressive_score, interlaced_score;
1708
dea5b2946999 interlaced motion estimation
michael
parents: 1707
diff changeset
3588
1729
a4a5e7521339 interlaced dct decision cleanup
michael
parents: 1723
diff changeset
3589 s->interlaced_dct=0;
1777
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
3590 progressive_score= s->dsp.ildct_cmp[4](s, ptr_y , NULL, wrap_y, 8)
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
3591 +s->dsp.ildct_cmp[4](s, ptr_y + wrap_y*8, NULL, wrap_y, 8) - 400;
1729
a4a5e7521339 interlaced dct decision cleanup
michael
parents: 1723
diff changeset
3592
a4a5e7521339 interlaced dct decision cleanup
michael
parents: 1723
diff changeset
3593 if(progressive_score > 0){
1777
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
3594 interlaced_score = s->dsp.ildct_cmp[4](s, ptr_y , NULL, wrap_y*2, 8)
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
3595 +s->dsp.ildct_cmp[4](s, ptr_y + wrap_y , NULL, wrap_y*2, 8);
1729
a4a5e7521339 interlaced dct decision cleanup
michael
parents: 1723
diff changeset
3596 if(progressive_score > interlaced_score){
a4a5e7521339 interlaced dct decision cleanup
michael
parents: 1723
diff changeset
3597 s->interlaced_dct=1;
697
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
3598
1729
a4a5e7521339 interlaced dct decision cleanup
michael
parents: 1723
diff changeset
3599 dct_offset= wrap_y;
a4a5e7521339 interlaced dct decision cleanup
michael
parents: 1723
diff changeset
3600 wrap_y<<=1;
a4a5e7521339 interlaced dct decision cleanup
michael
parents: 1723
diff changeset
3601 }
a4a5e7521339 interlaced dct decision cleanup
michael
parents: 1723
diff changeset
3602 }
697
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
3603 }
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
3604
1777
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
3605 s->dsp.get_pixels(s->block[0], ptr_y , wrap_y);
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
3606 s->dsp.get_pixels(s->block[1], ptr_y + 8, wrap_y);
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
3607 s->dsp.get_pixels(s->block[2], ptr_y + dct_offset , wrap_y);
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
3608 s->dsp.get_pixels(s->block[3], ptr_y + dct_offset + 8, wrap_y);
294
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 292
diff changeset
3609
487
cee02f2f4a5a grayscale only encoding
michaelni
parents: 485
diff changeset
3610 if(s->flags&CODEC_FLAG_GRAY){
cee02f2f4a5a grayscale only encoding
michaelni
parents: 485
diff changeset
3611 skip_dct[4]= 1;
cee02f2f4a5a grayscale only encoding
michaelni
parents: 485
diff changeset
3612 skip_dct[5]= 1;
cee02f2f4a5a grayscale only encoding
michaelni
parents: 485
diff changeset
3613 }else{
1777
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
3614 s->dsp.get_pixels(s->block[4], ptr_cb, wrap_c);
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
3615 s->dsp.get_pixels(s->block[5], ptr_cr, wrap_c);
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
3616 }
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
3617 }else{
651
45e8f39fda50 put/avg_pixels16
michaelni
parents: 650
diff changeset
3618 op_pixels_func (*op_pix)[4];
45e8f39fda50 put/avg_pixels16
michaelni
parents: 650
diff changeset
3619 qpel_mc_func (*op_qpix)[16];
1064
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1059
diff changeset
3620 uint8_t *dest_y, *dest_cb, *dest_cr;
294
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 292
diff changeset
3621
1389
da0b3a50d209 rate distortion mb decision support
michaelni
parents: 1384
diff changeset
3622 dest_y = s->dest[0];
da0b3a50d209 rate distortion mb decision support
michaelni
parents: 1384
diff changeset
3623 dest_cb = s->dest[1];
da0b3a50d209 rate distortion mb decision support
michaelni
parents: 1384
diff changeset
3624 dest_cr = s->dest[2];
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
3625
327
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 326
diff changeset
3626 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
3627 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
3628 op_qpix= s->dsp.put_qpel_pixels_tab;
295
6622b0fd036c mpeg4 4MV encoding
michaelni
parents: 294
diff changeset
3629 }else{
853
eacc2dd8fd9d * using DSPContext - so each codec could use its local (sub)set of CPU extension
kabi
parents: 847
diff changeset
3630 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
3631 op_qpix= s->dsp.put_no_rnd_qpel_pixels_tab;
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
3632 }
295
6622b0fd036c mpeg4 4MV encoding
michaelni
parents: 294
diff changeset
3633
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
3634 if (s->mv_dir & MV_DIR_FORWARD) {
903
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
3635 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
3636 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
3637 op_qpix= s->dsp.avg_qpel_pixels_tab;
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
3638 }
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
3639 if (s->mv_dir & MV_DIR_BACKWARD) {
903
22ee74da2cd3 cleanup
michaelni
parents: 899
diff changeset
3640 MPV_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.data, op_pix, op_qpix);
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
3641 }
295
6622b0fd036c mpeg4 4MV encoding
michaelni
parents: 294
diff changeset
3642
697
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
3643 if(s->flags&CODEC_FLAG_INTERLACED_DCT){
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
3644 int progressive_score, interlaced_score;
1729
a4a5e7521339 interlaced dct decision cleanup
michael
parents: 1723
diff changeset
3645
a4a5e7521339 interlaced dct decision cleanup
michael
parents: 1723
diff changeset
3646 s->interlaced_dct=0;
a4a5e7521339 interlaced dct decision cleanup
michael
parents: 1723
diff changeset
3647 progressive_score= s->dsp.ildct_cmp[0](s, dest_y , ptr_y , wrap_y, 8)
a4a5e7521339 interlaced dct decision cleanup
michael
parents: 1723
diff changeset
3648 +s->dsp.ildct_cmp[0](s, dest_y + wrap_y*8, ptr_y + wrap_y*8, wrap_y, 8) - 400;
697
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
3649
1729
a4a5e7521339 interlaced dct decision cleanup
michael
parents: 1723
diff changeset
3650 if(s->avctx->ildct_cmp == FF_CMP_VSSE) progressive_score -= 400;
a4a5e7521339 interlaced dct decision cleanup
michael
parents: 1723
diff changeset
3651
a4a5e7521339 interlaced dct decision cleanup
michael
parents: 1723
diff changeset
3652 if(progressive_score>0){
a4a5e7521339 interlaced dct decision cleanup
michael
parents: 1723
diff changeset
3653 interlaced_score = s->dsp.ildct_cmp[0](s, dest_y , ptr_y , wrap_y*2, 8)
a4a5e7521339 interlaced dct decision cleanup
michael
parents: 1723
diff changeset
3654 +s->dsp.ildct_cmp[0](s, dest_y + wrap_y , ptr_y + wrap_y , wrap_y*2, 8);
697
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
3655
1729
a4a5e7521339 interlaced dct decision cleanup
michael
parents: 1723
diff changeset
3656 if(progressive_score > interlaced_score){
a4a5e7521339 interlaced dct decision cleanup
michael
parents: 1723
diff changeset
3657 s->interlaced_dct=1;
a4a5e7521339 interlaced dct decision cleanup
michael
parents: 1723
diff changeset
3658
a4a5e7521339 interlaced dct decision cleanup
michael
parents: 1723
diff changeset
3659 dct_offset= wrap_y;
a4a5e7521339 interlaced dct decision cleanup
michael
parents: 1723
diff changeset
3660 wrap_y<<=1;
a4a5e7521339 interlaced dct decision cleanup
michael
parents: 1723
diff changeset
3661 }
a4a5e7521339 interlaced dct decision cleanup
michael
parents: 1723
diff changeset
3662 }
697
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
3663 }
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
3664
853
eacc2dd8fd9d * using DSPContext - so each codec could use its local (sub)set of CPU extension
kabi
parents: 847
diff changeset
3665 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
3666 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
3667 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
3668 s->dsp.diff_pixels(s->block[3], ptr_y + dct_offset + 8, dest_y + dct_offset + 8, wrap_y);
487
cee02f2f4a5a grayscale only encoding
michaelni
parents: 485
diff changeset
3669
cee02f2f4a5a grayscale only encoding
michaelni
parents: 485
diff changeset
3670 if(s->flags&CODEC_FLAG_GRAY){
cee02f2f4a5a grayscale only encoding
michaelni
parents: 485
diff changeset
3671 skip_dct[4]= 1;
cee02f2f4a5a grayscale only encoding
michaelni
parents: 485
diff changeset
3672 skip_dct[5]= 1;
cee02f2f4a5a grayscale only encoding
michaelni
parents: 485
diff changeset
3673 }else{
853
eacc2dd8fd9d * using DSPContext - so each codec could use its local (sub)set of CPU extension
kabi
parents: 847
diff changeset
3674 s->dsp.diff_pixels(s->block[4], ptr_cb, dest_cb, wrap_c);
eacc2dd8fd9d * using DSPContext - so each codec could use its local (sub)set of CPU extension
kabi
parents: 847
diff changeset
3675 s->dsp.diff_pixels(s->block[5], ptr_cr, dest_cr, wrap_c);
487
cee02f2f4a5a grayscale only encoding
michaelni
parents: 485
diff changeset
3676 }
456
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
3677 /* 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
3678 if(s->current_picture.mc_mb_var[s->mb_stride*mb_y+ mb_x]<2*s->qscale*s->qscale){
697
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
3679 //FIXME optimize
1708
dea5b2946999 interlaced motion estimation
michael
parents: 1707
diff changeset
3680 if(s->dsp.sad[1](NULL, ptr_y , dest_y , wrap_y, 8) < 20*s->qscale) skip_dct[0]= 1;
dea5b2946999 interlaced motion estimation
michael
parents: 1707
diff changeset
3681 if(s->dsp.sad[1](NULL, ptr_y + 8, dest_y + 8, wrap_y, 8) < 20*s->qscale) skip_dct[1]= 1;
dea5b2946999 interlaced motion estimation
michael
parents: 1707
diff changeset
3682 if(s->dsp.sad[1](NULL, ptr_y +dct_offset , dest_y +dct_offset , wrap_y, 8) < 20*s->qscale) skip_dct[2]= 1;
dea5b2946999 interlaced motion estimation
michael
parents: 1707
diff changeset
3683 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;
dea5b2946999 interlaced motion estimation
michael
parents: 1707
diff changeset
3684 if(s->dsp.sad[1](NULL, ptr_cb , dest_cb , wrap_c, 8) < 20*s->qscale) skip_dct[4]= 1;
dea5b2946999 interlaced motion estimation
michael
parents: 1707
diff changeset
3685 if(s->dsp.sad[1](NULL, ptr_cr , dest_cr , wrap_c, 8) < 20*s->qscale) skip_dct[5]= 1;
456
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
3686 }
1778
34466835920f simplify
michael
parents: 1777
diff changeset
3687 }
34466835920f simplify
michael
parents: 1777
diff changeset
3688
34466835920f simplify
michael
parents: 1777
diff changeset
3689 if(s->avctx->quantizer_noise_shaping){
34466835920f simplify
michael
parents: 1777
diff changeset
3690 if(!skip_dct[0]) get_vissual_weight(weight[0], ptr_y , wrap_y);
34466835920f simplify
michael
parents: 1777
diff changeset
3691 if(!skip_dct[1]) get_vissual_weight(weight[1], ptr_y + 8, wrap_y);
34466835920f simplify
michael
parents: 1777
diff changeset
3692 if(!skip_dct[2]) get_vissual_weight(weight[2], ptr_y + dct_offset , wrap_y);
34466835920f simplify
michael
parents: 1777
diff changeset
3693 if(!skip_dct[3]) get_vissual_weight(weight[3], ptr_y + dct_offset + 8, wrap_y);
34466835920f simplify
michael
parents: 1777
diff changeset
3694 if(!skip_dct[4]) get_vissual_weight(weight[4], ptr_cb , wrap_c);
34466835920f simplify
michael
parents: 1777
diff changeset
3695 if(!skip_dct[5]) get_vissual_weight(weight[5], ptr_cr , wrap_c);
34466835920f simplify
michael
parents: 1777
diff changeset
3696 memcpy(orig[0], s->block[0], sizeof(DCTELEM)*64*6);
294
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 292
diff changeset
3697 }
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 292
diff changeset
3698
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 292
diff changeset
3699 /* DCT & quantize */
1778
34466835920f simplify
michael
parents: 1777
diff changeset
3700 assert(s->out_format!=FMT_MJPEG || s->qscale==8);
34466835920f simplify
michael
parents: 1777
diff changeset
3701 {
344
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
3702 for(i=0;i<6;i++) {
456
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
3703 if(!skip_dct[i]){
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
3704 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
3705 s->block_last_index[i] = s->dct_quantize(s, s->block[i], i, s->qscale, &overflow);
344
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
3706 // 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
3707 // 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
3708 // of improve it. Just INTRADC clipping deserves changes in quantizer
456
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
3709 if (overflow) clip_coeffs(s, s->block[i], s->block_last_index[i]);
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
3710 }else
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
3711 s->block_last_index[i]= -1;
344
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
3712 }
1777
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
3713 if(s->avctx->quantizer_noise_shaping){
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
3714 for(i=0;i<6;i++) {
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
3715 if(!skip_dct[i]){
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
3716 s->block_last_index[i] = dct_quantize_refine(s, s->block[i], weight[i], orig[i], i, s->qscale);
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
3717 }
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
3718 }
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
3719 }
1490
0355f2b3519a rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents: 1480
diff changeset
3720
456
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
3721 if(s->luma_elim_threshold && !s->mb_intra)
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
3722 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
3723 dct_single_coeff_elimination(s, i, s->luma_elim_threshold);
456
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
3724 if(s->chroma_elim_threshold && !s->mb_intra)
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
3725 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
3726 dct_single_coeff_elimination(s, i, s->chroma_elim_threshold);
1497
37e16bd36d2c rd cbp + single coeff elimination fix
michaelni
parents: 1494
diff changeset
3727
37e16bd36d2c rd cbp + single coeff elimination fix
michaelni
parents: 1494
diff changeset
3728 if(s->flags & CODEC_FLAG_CBP_RD){
37e16bd36d2c rd cbp + single coeff elimination fix
michaelni
parents: 1494
diff changeset
3729 for(i=0;i<6;i++) {
37e16bd36d2c rd cbp + single coeff elimination fix
michaelni
parents: 1494
diff changeset
3730 if(s->block_last_index[i] == -1)
37e16bd36d2c rd cbp + single coeff elimination fix
michaelni
parents: 1494
diff changeset
3731 s->coded_score[i]= INT_MAX/256;
37e16bd36d2c rd cbp + single coeff elimination fix
michaelni
parents: 1494
diff changeset
3732 }
37e16bd36d2c rd cbp + single coeff elimination fix
michaelni
parents: 1494
diff changeset
3733 }
294
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 292
diff changeset
3734 }
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 292
diff changeset
3735
487
cee02f2f4a5a grayscale only encoding
michaelni
parents: 485
diff changeset
3736 if((s->flags&CODEC_FLAG_GRAY) && s->mb_intra){
cee02f2f4a5a grayscale only encoding
michaelni
parents: 485
diff changeset
3737 s->block_last_index[4]=
cee02f2f4a5a grayscale only encoding
michaelni
parents: 485
diff changeset
3738 s->block_last_index[5]= 0;
cee02f2f4a5a grayscale only encoding
michaelni
parents: 485
diff changeset
3739 s->block[4][0]=
1011
michaelni
parents: 1007
diff changeset
3740 s->block[5][0]= (1024 + s->c_dc_scale/2)/ s->c_dc_scale;
487
cee02f2f4a5a grayscale only encoding
michaelni
parents: 485
diff changeset
3741 }
cee02f2f4a5a grayscale only encoding
michaelni
parents: 485
diff changeset
3742
1708
dea5b2946999 interlaced motion estimation
michael
parents: 1707
diff changeset
3743 //non c quantize code returns incorrect block_last_index FIXME
dea5b2946999 interlaced motion estimation
michael
parents: 1707
diff changeset
3744 if(s->alternate_scan && s->dct_quantize != dct_quantize_c){
dea5b2946999 interlaced motion estimation
michael
parents: 1707
diff changeset
3745 for(i=0; i<6; i++){
dea5b2946999 interlaced motion estimation
michael
parents: 1707
diff changeset
3746 int j;
dea5b2946999 interlaced motion estimation
michael
parents: 1707
diff changeset
3747 if(s->block_last_index[i]>0){
dea5b2946999 interlaced motion estimation
michael
parents: 1707
diff changeset
3748 for(j=63; j>0; j--){
dea5b2946999 interlaced motion estimation
michael
parents: 1707
diff changeset
3749 if(s->block[i][ s->intra_scantable.permutated[j] ]) break;
dea5b2946999 interlaced motion estimation
michael
parents: 1707
diff changeset
3750 }
dea5b2946999 interlaced motion estimation
michael
parents: 1707
diff changeset
3751 s->block_last_index[i]= j;
dea5b2946999 interlaced motion estimation
michael
parents: 1707
diff changeset
3752 }
dea5b2946999 interlaced motion estimation
michael
parents: 1707
diff changeset
3753 }
dea5b2946999 interlaced motion estimation
michael
parents: 1707
diff changeset
3754 }
dea5b2946999 interlaced motion estimation
michael
parents: 1707
diff changeset
3755
294
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 292
diff changeset
3756 /* huffman encode */
936
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
3757 switch(s->codec_id){ //FIXME funct ptr could be slightly faster
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
3758 case CODEC_ID_MPEG1VIDEO:
1421
340c90faa1dc mpeg2 encoding
michaelni
parents: 1416
diff changeset
3759 case CODEC_ID_MPEG2VIDEO:
936
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
3760 mpeg1_encode_mb(s, s->block, motion_x, motion_y); break;
1042
a78f6f72d54e --disable-risky support
michaelni
parents: 1026
diff changeset
3761 #ifdef CONFIG_RISKY
936
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
3762 case CODEC_ID_MPEG4:
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
3763 mpeg4_encode_mb(s, s->block, motion_x, motion_y); break;
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
3764 case CODEC_ID_MSMPEG4V2:
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
3765 case CODEC_ID_MSMPEG4V3:
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
3766 case CODEC_ID_WMV1:
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
3767 msmpeg4_encode_mb(s, s->block, motion_x, motion_y); break;
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
3768 case CODEC_ID_WMV2:
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
3769 ff_wmv2_encode_mb(s, s->block, motion_x, motion_y); break;
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
3770 case CODEC_ID_H263:
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
3771 case CODEC_ID_H263P:
1353
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1344
diff changeset
3772 case CODEC_ID_FLV1:
936
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
3773 case CODEC_ID_RV10:
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
3774 h263_encode_mb(s, s->block, motion_x, motion_y); break;
1042
a78f6f72d54e --disable-risky support
michaelni
parents: 1026
diff changeset
3775 #endif
a78f6f72d54e --disable-risky support
michaelni
parents: 1026
diff changeset
3776 case CODEC_ID_MJPEG:
a78f6f72d54e --disable-risky support
michaelni
parents: 1026
diff changeset
3777 mjpeg_encode_mb(s, s->block); break;
936
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
3778 default:
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
3779 assert(0);
294
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 292
diff changeset
3780 }
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 292
diff changeset
3781 }
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 292
diff changeset
3782
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
3783 #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
3784
1368
0fd38b711f06 AVCodec.flush()
michaelni
parents: 1354
diff changeset
3785 void ff_mpeg_flush(AVCodecContext *avctx){
0fd38b711f06 AVCodec.flush()
michaelni
parents: 1354
diff changeset
3786 int i;
0fd38b711f06 AVCodec.flush()
michaelni
parents: 1354
diff changeset
3787 MpegEncContext *s = avctx->priv_data;
0fd38b711f06 AVCodec.flush()
michaelni
parents: 1354
diff changeset
3788
1751
3f1125adbc84 avcodec_flush_buffers() fix
michael
parents: 1749
diff changeset
3789 if(s==NULL || s->picture==NULL)
3f1125adbc84 avcodec_flush_buffers() fix
michael
parents: 1749
diff changeset
3790 return;
3f1125adbc84 avcodec_flush_buffers() fix
michael
parents: 1749
diff changeset
3791
1368
0fd38b711f06 AVCodec.flush()
michaelni
parents: 1354
diff changeset
3792 for(i=0; i<MAX_PICTURE_COUNT; i++){
0fd38b711f06 AVCodec.flush()
michaelni
parents: 1354
diff changeset
3793 if(s->picture[i].data[0] && ( s->picture[i].type == FF_BUFFER_TYPE_INTERNAL
0fd38b711f06 AVCodec.flush()
michaelni
parents: 1354
diff changeset
3794 || s->picture[i].type == FF_BUFFER_TYPE_USER))
0fd38b711f06 AVCodec.flush()
michaelni
parents: 1354
diff changeset
3795 avctx->release_buffer(avctx, (AVFrame*)&s->picture[i]);
0fd38b711f06 AVCodec.flush()
michaelni
parents: 1354
diff changeset
3796 }
1601
a70c07e13e8e flush fix (untested)
michael
parents: 1599
diff changeset
3797 s->current_picture_ptr = s->last_picture_ptr = s->next_picture_ptr = NULL;
1395
b2ac20ff1458 clear bitstream buffers in AVCodec.flush()
michaelni
parents: 1393
diff changeset
3798
b2ac20ff1458 clear bitstream buffers in AVCodec.flush()
michaelni
parents: 1393
diff changeset
3799 s->parse_context.state= -1;
b2ac20ff1458 clear bitstream buffers in AVCodec.flush()
michaelni
parents: 1393
diff changeset
3800 s->parse_context.frame_start_found= 0;
b2ac20ff1458 clear bitstream buffers in AVCodec.flush()
michaelni
parents: 1393
diff changeset
3801 s->parse_context.overread= 0;
b2ac20ff1458 clear bitstream buffers in AVCodec.flush()
michaelni
parents: 1393
diff changeset
3802 s->parse_context.overread_index= 0;
b2ac20ff1458 clear bitstream buffers in AVCodec.flush()
michaelni
parents: 1393
diff changeset
3803 s->parse_context.index= 0;
b2ac20ff1458 clear bitstream buffers in AVCodec.flush()
michaelni
parents: 1393
diff changeset
3804 s->parse_context.last_index= 0;
1851
07a4c1c4b929 100l (divx5 b frame + seeking + flush fix)
michael
parents: 1848
diff changeset
3805 s->bitstream_buffer_size=0;
1368
0fd38b711f06 AVCodec.flush()
michaelni
parents: 1354
diff changeset
3806 }
0fd38b711f06 AVCodec.flush()
michaelni
parents: 1354
diff changeset
3807
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
3808 #ifdef CONFIG_ENCODERS
1064
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1059
diff changeset
3809 void ff_copy_bits(PutBitContext *pb, uint8_t *src, int length)
294
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 292
diff changeset
3810 {
1810
fc6b38b5dd40 noise reduction with threads bugfix
michael
parents: 1805
diff changeset
3811 const uint16_t *srcw= (uint16_t*)src;
1799
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
3812 int words= length>>4;
326
6ebb8680885d fixing hq mode with mpeg1 and 2-pass
michaelni
parents: 325
diff changeset
3813 int bits= length&15;
6ebb8680885d fixing hq mode with mpeg1 and 2-pass
michaelni
parents: 325
diff changeset
3814 int i;
6ebb8680885d fixing hq mode with mpeg1 and 2-pass
michaelni
parents: 325
diff changeset
3815
456
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
3816 if(length==0) return;
1799
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
3817
1803
f100993b9b5a ff_copy_bits() optimization
michael
parents: 1802
diff changeset
3818 if(words < 16){
f100993b9b5a ff_copy_bits() optimization
michael
parents: 1802
diff changeset
3819 for(i=0; i<words; i++) put_bits(pb, 16, be2me_16(srcw[i]));
f100993b9b5a ff_copy_bits() optimization
michael
parents: 1802
diff changeset
3820 }else if(put_bits_count(pb)&7){
f100993b9b5a ff_copy_bits() optimization
michael
parents: 1802
diff changeset
3821 for(i=0; i<words; i++) put_bits(pb, 16, be2me_16(srcw[i]));
1802
e91dbb5b1a8d activate the memcpy special case for the byte aligned case in ff_copy_bits(), wasnt working before because of a incorrectly used pbBufPtr()
michael
parents: 1801
diff changeset
3822 }else{
1803
f100993b9b5a ff_copy_bits() optimization
michael
parents: 1802
diff changeset
3823 for(i=0; put_bits_count(pb)&31; i++)
f100993b9b5a ff_copy_bits() optimization
michael
parents: 1802
diff changeset
3824 put_bits(pb, 8, src[i]);
1799
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
3825 flush_put_bits(pb);
1803
f100993b9b5a ff_copy_bits() optimization
michael
parents: 1802
diff changeset
3826 memcpy(pbBufPtr(pb), src+i, 2*words-i);
f100993b9b5a ff_copy_bits() optimization
michael
parents: 1802
diff changeset
3827 skip_put_bytes(pb, 2*words-i);
1802
e91dbb5b1a8d activate the memcpy special case for the byte aligned case in ff_copy_bits(), wasnt working before because of a incorrectly used pbBufPtr()
michael
parents: 1801
diff changeset
3828 }
1799
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
3829
1803
f100993b9b5a ff_copy_bits() optimization
michael
parents: 1802
diff changeset
3830 put_bits(pb, bits, be2me_16(srcw[words])>>(16-bits));
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3831 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
3832
456
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
3833 static inline void copy_context_before_encode(MpegEncContext *d, MpegEncContext *s, int type){
326
6ebb8680885d fixing hq mode with mpeg1 and 2-pass
michaelni
parents: 325
diff changeset
3834 int i;
6ebb8680885d fixing hq mode with mpeg1 and 2-pass
michaelni
parents: 325
diff changeset
3835
6ebb8680885d fixing hq mode with mpeg1 and 2-pass
michaelni
parents: 325
diff changeset
3836 memcpy(d->last_mv, s->last_mv, 2*2*2*sizeof(int)); //FIXME is memcpy faster then a loop?
6ebb8680885d fixing hq mode with mpeg1 and 2-pass
michaelni
parents: 325
diff changeset
3837
6ebb8680885d fixing hq mode with mpeg1 and 2-pass
michaelni
parents: 325
diff changeset
3838 /* mpeg1 */
1160
9a5c29575902 mpeg1 slice encoding support
michaelni
parents: 1159
diff changeset
3839 d->mb_skip_run= s->mb_skip_run;
326
6ebb8680885d fixing hq mode with mpeg1 and 2-pass
michaelni
parents: 325
diff changeset
3840 for(i=0; i<3; i++)
6ebb8680885d fixing hq mode with mpeg1 and 2-pass
michaelni
parents: 325
diff changeset
3841 d->last_dc[i]= s->last_dc[i];
6ebb8680885d fixing hq mode with mpeg1 and 2-pass
michaelni
parents: 325
diff changeset
3842
6ebb8680885d fixing hq mode with mpeg1 and 2-pass
michaelni
parents: 325
diff changeset
3843 /* statistics */
6ebb8680885d fixing hq mode with mpeg1 and 2-pass
michaelni
parents: 325
diff changeset
3844 d->mv_bits= s->mv_bits;
6ebb8680885d fixing hq mode with mpeg1 and 2-pass
michaelni
parents: 325
diff changeset
3845 d->i_tex_bits= s->i_tex_bits;
6ebb8680885d fixing hq mode with mpeg1 and 2-pass
michaelni
parents: 325
diff changeset
3846 d->p_tex_bits= s->p_tex_bits;
6ebb8680885d fixing hq mode with mpeg1 and 2-pass
michaelni
parents: 325
diff changeset
3847 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
3848 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
3849 d->b_count= s->b_count;
326
6ebb8680885d fixing hq mode with mpeg1 and 2-pass
michaelni
parents: 325
diff changeset
3850 d->skip_count= s->skip_count;
6ebb8680885d fixing hq mode with mpeg1 and 2-pass
michaelni
parents: 325
diff changeset
3851 d->misc_bits= s->misc_bits;
329
5cc47d0ba53e fixed ratecontrol & b-frames
michaelni
parents: 327
diff changeset
3852 d->last_bits= 0;
327
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 326
diff changeset
3853
1389
da0b3a50d209 rate distortion mb decision support
michaelni
parents: 1384
diff changeset
3854 d->mb_skiped= 0;
912
4a1e6bb1f41c fixing hq + adaptive quant
michaelni
parents: 910
diff changeset
3855 d->qscale= s->qscale;
1616
13a20c0594f2 rate distored optimal lambda->qp support
michael
parents: 1601
diff changeset
3856 d->dquant= s->dquant;
326
6ebb8680885d fixing hq mode with mpeg1 and 2-pass
michaelni
parents: 325
diff changeset
3857 }
6ebb8680885d fixing hq mode with mpeg1 and 2-pass
michaelni
parents: 325
diff changeset
3858
456
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
3859 static inline void copy_context_after_encode(MpegEncContext *d, MpegEncContext *s, int type){
326
6ebb8680885d fixing hq mode with mpeg1 and 2-pass
michaelni
parents: 325
diff changeset
3860 int i;
6ebb8680885d fixing hq mode with mpeg1 and 2-pass
michaelni
parents: 325
diff changeset
3861
6ebb8680885d fixing hq mode with mpeg1 and 2-pass
michaelni
parents: 325
diff changeset
3862 memcpy(d->mv, s->mv, 2*4*2*sizeof(int));
6ebb8680885d fixing hq mode with mpeg1 and 2-pass
michaelni
parents: 325
diff changeset
3863 memcpy(d->last_mv, s->last_mv, 2*2*2*sizeof(int)); //FIXME is memcpy faster then a loop?
6ebb8680885d fixing hq mode with mpeg1 and 2-pass
michaelni
parents: 325
diff changeset
3864
6ebb8680885d fixing hq mode with mpeg1 and 2-pass
michaelni
parents: 325
diff changeset
3865 /* mpeg1 */
1160
9a5c29575902 mpeg1 slice encoding support
michaelni
parents: 1159
diff changeset
3866 d->mb_skip_run= s->mb_skip_run;
326
6ebb8680885d fixing hq mode with mpeg1 and 2-pass
michaelni
parents: 325
diff changeset
3867 for(i=0; i<3; i++)
6ebb8680885d fixing hq mode with mpeg1 and 2-pass
michaelni
parents: 325
diff changeset
3868 d->last_dc[i]= s->last_dc[i];
6ebb8680885d fixing hq mode with mpeg1 and 2-pass
michaelni
parents: 325
diff changeset
3869
6ebb8680885d fixing hq mode with mpeg1 and 2-pass
michaelni
parents: 325
diff changeset
3870 /* statistics */
6ebb8680885d fixing hq mode with mpeg1 and 2-pass
michaelni
parents: 325
diff changeset
3871 d->mv_bits= s->mv_bits;
6ebb8680885d fixing hq mode with mpeg1 and 2-pass
michaelni
parents: 325
diff changeset
3872 d->i_tex_bits= s->i_tex_bits;
6ebb8680885d fixing hq mode with mpeg1 and 2-pass
michaelni
parents: 325
diff changeset
3873 d->p_tex_bits= s->p_tex_bits;
6ebb8680885d fixing hq mode with mpeg1 and 2-pass
michaelni
parents: 325
diff changeset
3874 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
3875 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
3876 d->b_count= s->b_count;
326
6ebb8680885d fixing hq mode with mpeg1 and 2-pass
michaelni
parents: 325
diff changeset
3877 d->skip_count= s->skip_count;
6ebb8680885d fixing hq mode with mpeg1 and 2-pass
michaelni
parents: 325
diff changeset
3878 d->misc_bits= s->misc_bits;
6ebb8680885d fixing hq mode with mpeg1 and 2-pass
michaelni
parents: 325
diff changeset
3879
6ebb8680885d fixing hq mode with mpeg1 and 2-pass
michaelni
parents: 325
diff changeset
3880 d->mb_intra= s->mb_intra;
327
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 326
diff changeset
3881 d->mb_skiped= s->mb_skiped;
326
6ebb8680885d fixing hq mode with mpeg1 and 2-pass
michaelni
parents: 325
diff changeset
3882 d->mv_type= s->mv_type;
6ebb8680885d fixing hq mode with mpeg1 and 2-pass
michaelni
parents: 325
diff changeset
3883 d->mv_dir= s->mv_dir;
6ebb8680885d fixing hq mode with mpeg1 and 2-pass
michaelni
parents: 325
diff changeset
3884 d->pb= s->pb;
456
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
3885 if(s->data_partitioning){
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
3886 d->pb2= s->pb2;
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
3887 d->tex_pb= s->tex_pb;
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
3888 }
326
6ebb8680885d fixing hq mode with mpeg1 and 2-pass
michaelni
parents: 325
diff changeset
3889 d->block= s->block;
6ebb8680885d fixing hq mode with mpeg1 and 2-pass
michaelni
parents: 325
diff changeset
3890 for(i=0; i<6; i++)
6ebb8680885d fixing hq mode with mpeg1 and 2-pass
michaelni
parents: 325
diff changeset
3891 d->block_last_index[i]= s->block_last_index[i];
755
d17846a6c164 fixing interlaced dct + hq mode
michaelni
parents: 754
diff changeset
3892 d->interlaced_dct= s->interlaced_dct;
912
4a1e6bb1f41c fixing hq + adaptive quant
michaelni
parents: 910
diff changeset
3893 d->qscale= s->qscale;
326
6ebb8680885d fixing hq mode with mpeg1 and 2-pass
michaelni
parents: 325
diff changeset
3894 }
6ebb8680885d fixing hq mode with mpeg1 and 2-pass
michaelni
parents: 325
diff changeset
3895
456
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
3896 static inline void encode_mb_hq(MpegEncContext *s, MpegEncContext *backup, MpegEncContext *best, int type,
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
3897 PutBitContext pb[2], PutBitContext pb2[2], PutBitContext tex_pb[2],
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
3898 int *dmin, int *next_block, int motion_x, int motion_y)
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
3899 {
1389
da0b3a50d209 rate distortion mb decision support
michaelni
parents: 1384
diff changeset
3900 int score;
da0b3a50d209 rate distortion mb decision support
michaelni
parents: 1384
diff changeset
3901 uint8_t *dest_backup[3];
456
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
3902
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
3903 copy_context_before_encode(s, backup, type);
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
3904
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
3905 s->block= s->blocks[*next_block];
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
3906 s->pb= pb[*next_block];
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
3907 if(s->data_partitioning){
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
3908 s->pb2 = pb2 [*next_block];
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
3909 s->tex_pb= tex_pb[*next_block];
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
3910 }
1389
da0b3a50d209 rate distortion mb decision support
michaelni
parents: 1384
diff changeset
3911
da0b3a50d209 rate distortion mb decision support
michaelni
parents: 1384
diff changeset
3912 if(*next_block){
da0b3a50d209 rate distortion mb decision support
michaelni
parents: 1384
diff changeset
3913 memcpy(dest_backup, s->dest, sizeof(s->dest));
1799
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
3914 s->dest[0] = s->rd_scratchpad;
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
3915 s->dest[1] = s->rd_scratchpad + 16*s->linesize;
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
3916 s->dest[2] = s->rd_scratchpad + 16*s->linesize + 8;
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
3917 assert(s->linesize >= 32); //FIXME
1389
da0b3a50d209 rate distortion mb decision support
michaelni
parents: 1384
diff changeset
3918 }
456
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
3919
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
3920 encode_mb(s, motion_x, motion_y);
1389
da0b3a50d209 rate distortion mb decision support
michaelni
parents: 1384
diff changeset
3921
1786
b7340afa261a get_bit_count -> put_bits_count
alex
parents: 1785
diff changeset
3922 score= put_bits_count(&s->pb);
456
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
3923 if(s->data_partitioning){
1786
b7340afa261a get_bit_count -> put_bits_count
alex
parents: 1785
diff changeset
3924 score+= put_bits_count(&s->pb2);
b7340afa261a get_bit_count -> put_bits_count
alex
parents: 1785
diff changeset
3925 score+= put_bits_count(&s->tex_pb);
456
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
3926 }
1389
da0b3a50d209 rate distortion mb decision support
michaelni
parents: 1384
diff changeset
3927
da0b3a50d209 rate distortion mb decision support
michaelni
parents: 1384
diff changeset
3928 if(s->avctx->mb_decision == FF_MB_DECISION_RD){
da0b3a50d209 rate distortion mb decision support
michaelni
parents: 1384
diff changeset
3929 MPV_decode_mb(s, s->block);
da0b3a50d209 rate distortion mb decision support
michaelni
parents: 1384
diff changeset
3930
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
3931 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
3932 score += sse_mb(s) << FF_LAMBDA_SHIFT;
1389
da0b3a50d209 rate distortion mb decision support
michaelni
parents: 1384
diff changeset
3933 }
da0b3a50d209 rate distortion mb decision support
michaelni
parents: 1384
diff changeset
3934
da0b3a50d209 rate distortion mb decision support
michaelni
parents: 1384
diff changeset
3935 if(*next_block){
da0b3a50d209 rate distortion mb decision support
michaelni
parents: 1384
diff changeset
3936 memcpy(s->dest, dest_backup, sizeof(s->dest));
da0b3a50d209 rate distortion mb decision support
michaelni
parents: 1384
diff changeset
3937 }
da0b3a50d209 rate distortion mb decision support
michaelni
parents: 1384
diff changeset
3938
da0b3a50d209 rate distortion mb decision support
michaelni
parents: 1384
diff changeset
3939 if(score<*dmin){
da0b3a50d209 rate distortion mb decision support
michaelni
parents: 1384
diff changeset
3940 *dmin= score;
456
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
3941 *next_block^=1;
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
3942
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
3943 copy_context_after_encode(best, s, type);
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
3944 }
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
3945 }
909
8ae1e4c24e91 new PSNR code (now works with chroma, b frames, ...)
michaelni
parents: 903
diff changeset
3946
1389
da0b3a50d209 rate distortion mb decision support
michaelni
parents: 1384
diff changeset
3947 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
3948 uint32_t *sq = squareTbl + 256;
8ae1e4c24e91 new PSNR code (now works with chroma, b frames, ...)
michaelni
parents: 903
diff changeset
3949 int acc=0;
8ae1e4c24e91 new PSNR code (now works with chroma, b frames, ...)
michaelni
parents: 903
diff changeset
3950 int x,y;
8ae1e4c24e91 new PSNR code (now works with chroma, b frames, ...)
michaelni
parents: 903
diff changeset
3951
8ae1e4c24e91 new PSNR code (now works with chroma, b frames, ...)
michaelni
parents: 903
diff changeset
3952 if(w==16 && h==16)
1708
dea5b2946999 interlaced motion estimation
michael
parents: 1707
diff changeset
3953 return s->dsp.sse[0](NULL, src1, src2, stride, 16);
936
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
3954 else if(w==8 && h==8)
1708
dea5b2946999 interlaced motion estimation
michael
parents: 1707
diff changeset
3955 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
3956
8ae1e4c24e91 new PSNR code (now works with chroma, b frames, ...)
michaelni
parents: 903
diff changeset
3957 for(y=0; y<h; y++){
8ae1e4c24e91 new PSNR code (now works with chroma, b frames, ...)
michaelni
parents: 903
diff changeset
3958 for(x=0; x<w; x++){
8ae1e4c24e91 new PSNR code (now works with chroma, b frames, ...)
michaelni
parents: 903
diff changeset
3959 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
3960 }
8ae1e4c24e91 new PSNR code (now works with chroma, b frames, ...)
michaelni
parents: 903
diff changeset
3961 }
936
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
3962
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
3963 assert(acc>=0);
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
3964
909
8ae1e4c24e91 new PSNR code (now works with chroma, b frames, ...)
michaelni
parents: 903
diff changeset
3965 return acc;
8ae1e4c24e91 new PSNR code (now works with chroma, b frames, ...)
michaelni
parents: 903
diff changeset
3966 }
326
6ebb8680885d fixing hq mode with mpeg1 and 2-pass
michaelni
parents: 325
diff changeset
3967
1389
da0b3a50d209 rate distortion mb decision support
michaelni
parents: 1384
diff changeset
3968 static int sse_mb(MpegEncContext *s){
da0b3a50d209 rate distortion mb decision support
michaelni
parents: 1384
diff changeset
3969 int w= 16;
da0b3a50d209 rate distortion mb decision support
michaelni
parents: 1384
diff changeset
3970 int h= 16;
da0b3a50d209 rate distortion mb decision support
michaelni
parents: 1384
diff changeset
3971
da0b3a50d209 rate distortion mb decision support
michaelni
parents: 1384
diff changeset
3972 if(s->mb_x*16 + 16 > s->width ) w= s->width - s->mb_x*16;
da0b3a50d209 rate distortion mb decision support
michaelni
parents: 1384
diff changeset
3973 if(s->mb_y*16 + 16 > s->height) h= s->height- s->mb_y*16;
da0b3a50d209 rate distortion mb decision support
michaelni
parents: 1384
diff changeset
3974
da0b3a50d209 rate distortion mb decision support
michaelni
parents: 1384
diff changeset
3975 if(w==16 && h==16)
2065
9e4bebc39ade noise preserving sum of squares comparission function
michael
parents: 2063
diff changeset
3976 if(s->avctx->mb_cmp == FF_CMP_NSSE){
2066
4bfb146e701b nsse weight
michael
parents: 2065
diff changeset
3977 return s->dsp.nsse[0](s, s->new_picture.data[0] + s->mb_x*16 + s->mb_y*s->linesize*16, s->dest[0], s->linesize, 16)
4bfb146e701b nsse weight
michael
parents: 2065
diff changeset
3978 +s->dsp.nsse[1](s, s->new_picture.data[1] + s->mb_x*8 + s->mb_y*s->uvlinesize*8,s->dest[1], s->uvlinesize, 8)
4bfb146e701b nsse weight
michael
parents: 2065
diff changeset
3979 +s->dsp.nsse[1](s, s->new_picture.data[2] + s->mb_x*8 + s->mb_y*s->uvlinesize*8,s->dest[2], s->uvlinesize, 8);
2065
9e4bebc39ade noise preserving sum of squares comparission function
michael
parents: 2063
diff changeset
3980 }else{
1708
dea5b2946999 interlaced motion estimation
michael
parents: 1707
diff changeset
3981 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)
dea5b2946999 interlaced motion estimation
michael
parents: 1707
diff changeset
3982 +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)
dea5b2946999 interlaced motion estimation
michael
parents: 1707
diff changeset
3983 +s->dsp.sse[1](NULL, s->new_picture.data[2] + s->mb_x*8 + s->mb_y*s->uvlinesize*8,s->dest[2], s->uvlinesize, 8);
2065
9e4bebc39ade noise preserving sum of squares comparission function
michael
parents: 2063
diff changeset
3984 }
1389
da0b3a50d209 rate distortion mb decision support
michaelni
parents: 1384
diff changeset
3985 else
da0b3a50d209 rate distortion mb decision support
michaelni
parents: 1384
diff changeset
3986 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)
da0b3a50d209 rate distortion mb decision support
michaelni
parents: 1384
diff changeset
3987 +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)
da0b3a50d209 rate distortion mb decision support
michaelni
parents: 1384
diff changeset
3988 +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);
da0b3a50d209 rate distortion mb decision support
michaelni
parents: 1384
diff changeset
3989 }
da0b3a50d209 rate distortion mb decision support
michaelni
parents: 1384
diff changeset
3990
1799
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
3991 static int pre_estimate_motion_thread(AVCodecContext *c, void *arg){
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
3992 MpegEncContext *s= arg;
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
3993
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
3994
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
3995 s->me.pre_pass=1;
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
3996 s->me.dia_size= s->avctx->pre_dia_size;
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
3997 s->first_slice_line=1;
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
3998 for(s->mb_y= s->end_mb_y-1; s->mb_y >= s->start_mb_y; s->mb_y--) {
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
3999 for(s->mb_x=s->mb_width-1; s->mb_x >=0 ;s->mb_x--) {
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4000 ff_pre_estimate_p_frame_motion(s, s->mb_x, s->mb_y);
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4001 }
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4002 s->first_slice_line=0;
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4003 }
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4004
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4005 s->me.pre_pass=0;
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4006
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4007 return 0;
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4008 }
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4009
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4010 static int estimate_motion_thread(AVCodecContext *c, void *arg){
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4011 MpegEncContext *s= arg;
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4012
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4013 s->me.dia_size= s->avctx->dia_size;
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4014 s->first_slice_line=1;
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4015 for(s->mb_y= s->start_mb_y; s->mb_y < s->end_mb_y; s->mb_y++) {
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4016 s->mb_x=0; //for block init below
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4017 ff_init_block_index(s);
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4018 for(s->mb_x=0; s->mb_x < s->mb_width; s->mb_x++) {
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4019 s->block_index[0]+=2;
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4020 s->block_index[1]+=2;
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4021 s->block_index[2]+=2;
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4022 s->block_index[3]+=2;
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4023
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4024 /* compute motion vector & mb_type and store in context */
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4025 if(s->pict_type==B_TYPE)
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4026 ff_estimate_b_frame_motion(s, s->mb_x, s->mb_y);
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4027 else
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4028 ff_estimate_p_frame_motion(s, s->mb_x, s->mb_y);
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4029 }
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4030 s->first_slice_line=0;
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4031 }
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4032 return 0;
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4033 }
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4034
1804
cc0a15943a87 multithreaded spatial complexity calculation for i frames
michael
parents: 1803
diff changeset
4035 static int mb_var_thread(AVCodecContext *c, void *arg){
cc0a15943a87 multithreaded spatial complexity calculation for i frames
michael
parents: 1803
diff changeset
4036 MpegEncContext *s= arg;
cc0a15943a87 multithreaded spatial complexity calculation for i frames
michael
parents: 1803
diff changeset
4037 int mb_x, mb_y;
cc0a15943a87 multithreaded spatial complexity calculation for i frames
michael
parents: 1803
diff changeset
4038
cc0a15943a87 multithreaded spatial complexity calculation for i frames
michael
parents: 1803
diff changeset
4039 for(mb_y=s->start_mb_y; mb_y < s->end_mb_y; mb_y++) {
cc0a15943a87 multithreaded spatial complexity calculation for i frames
michael
parents: 1803
diff changeset
4040 for(mb_x=0; mb_x < s->mb_width; mb_x++) {
cc0a15943a87 multithreaded spatial complexity calculation for i frames
michael
parents: 1803
diff changeset
4041 int xx = mb_x * 16;
cc0a15943a87 multithreaded spatial complexity calculation for i frames
michael
parents: 1803
diff changeset
4042 int yy = mb_y * 16;
cc0a15943a87 multithreaded spatial complexity calculation for i frames
michael
parents: 1803
diff changeset
4043 uint8_t *pix = s->new_picture.data[0] + (yy * s->linesize) + xx;
cc0a15943a87 multithreaded spatial complexity calculation for i frames
michael
parents: 1803
diff changeset
4044 int varc;
cc0a15943a87 multithreaded spatial complexity calculation for i frames
michael
parents: 1803
diff changeset
4045 int sum = s->dsp.pix_sum(pix, s->linesize);
cc0a15943a87 multithreaded spatial complexity calculation for i frames
michael
parents: 1803
diff changeset
4046
cc0a15943a87 multithreaded spatial complexity calculation for i frames
michael
parents: 1803
diff changeset
4047 varc = (s->dsp.pix_norm1(pix, s->linesize) - (((unsigned)(sum*sum))>>8) + 500 + 128)>>8;
cc0a15943a87 multithreaded spatial complexity calculation for i frames
michael
parents: 1803
diff changeset
4048
cc0a15943a87 multithreaded spatial complexity calculation for i frames
michael
parents: 1803
diff changeset
4049 s->current_picture.mb_var [s->mb_stride * mb_y + mb_x] = varc;
cc0a15943a87 multithreaded spatial complexity calculation for i frames
michael
parents: 1803
diff changeset
4050 s->current_picture.mb_mean[s->mb_stride * mb_y + mb_x] = (sum+128)>>8;
2015
3ab8f3e2ae6a moving motion estimation specific variables from MpegEncContext -> MotionEstContext
michael
parents: 1994
diff changeset
4051 s->me.mb_var_sum_temp += varc;
1804
cc0a15943a87 multithreaded spatial complexity calculation for i frames
michael
parents: 1803
diff changeset
4052 }
cc0a15943a87 multithreaded spatial complexity calculation for i frames
michael
parents: 1803
diff changeset
4053 }
1805
5dd5b2052f5b mpeg4 b frame + adaptive quantization assertion failure fix
michael
parents: 1804
diff changeset
4054 return 0;
1804
cc0a15943a87 multithreaded spatial complexity calculation for i frames
michael
parents: 1803
diff changeset
4055 }
cc0a15943a87 multithreaded spatial complexity calculation for i frames
michael
parents: 1803
diff changeset
4056
1799
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4057 static void write_slice_end(MpegEncContext *s){
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4058 if(s->codec_id==CODEC_ID_MPEG4){
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4059 if(s->partitioned_frame){
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4060 ff_mpeg4_merge_partitions(s);
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4061 }
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4062
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4063 ff_mpeg4_stuffing(&s->pb);
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4064 }else if(s->out_format == FMT_MJPEG){
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4065 ff_mjpeg_stuffing(&s->pb);
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4066 }
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4067
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4068 align_put_bits(&s->pb);
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4069 flush_put_bits(&s->pb);
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4070 }
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4071
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4072 static int encode_thread(AVCodecContext *c, void *arg){
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4073 MpegEncContext *s= arg;
766
8d36b35a7e6e slice encoding cleanup
michaelni
parents: 764
diff changeset
4074 int mb_x, mb_y, pdif = 0;
1708
dea5b2946999 interlaced motion estimation
michael
parents: 1707
diff changeset
4075 int i, j;
326
6ebb8680885d fixing hq mode with mpeg1 and 2-pass
michaelni
parents: 325
diff changeset
4076 MpegEncContext best_s, backup_s;
1064
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1059
diff changeset
4077 uint8_t bit_buf[2][3000];
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1059
diff changeset
4078 uint8_t bit_buf2[2][3000];
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1059
diff changeset
4079 uint8_t bit_buf_tex[2][3000];
456
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
4080 PutBitContext pb[2], pb2[2], tex_pb[2];
1799
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4081 //printf("%d->%d\n", s->resync_mb_y, s->end_mb_y);
456
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
4082
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
4083 for(i=0; i<2; i++){
1522
79dddc5cd990 removed the obsolete and unused parameters of init_put_bits
alex
parents: 1505
diff changeset
4084 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
4085 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
4086 init_put_bits(&tex_pb[i], bit_buf_tex[i], 3000);
456
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
4087 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4088
1786
b7340afa261a get_bit_count -> put_bits_count
alex
parents: 1785
diff changeset
4089 s->last_bits= put_bits_count(&s->pb);
286
91f7c38f5f37 statistics for 2-pass encoding
michaelni
parents: 281
diff changeset
4090 s->mv_bits=0;
91f7c38f5f37 statistics for 2-pass encoding
michaelni
parents: 281
diff changeset
4091 s->misc_bits=0;
91f7c38f5f37 statistics for 2-pass encoding
michaelni
parents: 281
diff changeset
4092 s->i_tex_bits=0;
91f7c38f5f37 statistics for 2-pass encoding
michaelni
parents: 281
diff changeset
4093 s->p_tex_bits=0;
91f7c38f5f37 statistics for 2-pass encoding
michaelni
parents: 281
diff changeset
4094 s->i_count=0;
656
e47fa3e3f2d5 statistics for forw & back p-MBs instead of just one counter for both
michaelni
parents: 652
diff changeset
4095 s->f_count=0;
e47fa3e3f2d5 statistics for forw & back p-MBs instead of just one counter for both
michaelni
parents: 652
diff changeset
4096 s->b_count=0;
286
91f7c38f5f37 statistics for 2-pass encoding
michaelni
parents: 281
diff changeset
4097 s->skip_count=0;
91f7c38f5f37 statistics for 2-pass encoding
michaelni
parents: 281
diff changeset
4098
909
8ae1e4c24e91 new PSNR code (now works with chroma, b frames, ...)
michaelni
parents: 903
diff changeset
4099 for(i=0; i<3; i++){
8ae1e4c24e91 new PSNR code (now works with chroma, b frames, ...)
michaelni
parents: 903
diff changeset
4100 /* init last dc values */
8ae1e4c24e91 new PSNR code (now works with chroma, b frames, ...)
michaelni
parents: 903
diff changeset
4101 /* note: quant matrix value (8) is implied here */
1992
938e47c809b0 intra_dc_precission>0 encoding support
michael
parents: 1991
diff changeset
4102 s->last_dc[i] = 128 << s->intra_dc_precision;
909
8ae1e4c24e91 new PSNR code (now works with chroma, b frames, ...)
michaelni
parents: 903
diff changeset
4103
1148
michaelni
parents: 1141
diff changeset
4104 s->current_picture_ptr->error[i] = 0;
909
8ae1e4c24e91 new PSNR code (now works with chroma, b frames, ...)
michaelni
parents: 903
diff changeset
4105 }
1160
9a5c29575902 mpeg1 slice encoding support
michaelni
parents: 1159
diff changeset
4106 s->mb_skip_run = 0;
1708
dea5b2946999 interlaced motion estimation
michael
parents: 1707
diff changeset
4107 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
4108
e5a9dbf597d4 mpeg1 bframe encoding patch by (Rapha«³l LEGRAND) with some modifications by me
michaelni
parents: 1048
diff changeset
4109 s->last_mv_dir = 0;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4110
1042
a78f6f72d54e --disable-risky support
michaelni
parents: 1026
diff changeset
4111 #ifdef CONFIG_RISKY
1353
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1344
diff changeset
4112 switch(s->codec_id){
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1344
diff changeset
4113 case CODEC_ID_H263:
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1344
diff changeset
4114 case CODEC_ID_H263P:
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1344
diff changeset
4115 case CODEC_ID_FLV1:
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 731
diff changeset
4116 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
4117 break;
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1344
diff changeset
4118 case CODEC_ID_MPEG4:
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1344
diff changeset
4119 if(s->partitioned_frame)
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1344
diff changeset
4120 ff_mpeg4_init_partitions(s);
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1344
diff changeset
4121 break;
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1344
diff changeset
4122 }
1042
a78f6f72d54e --disable-risky support
michaelni
parents: 1026
diff changeset
4123 #endif
456
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
4124
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
4125 s->resync_mb_x=0;
1799
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4126 s->resync_mb_y=0;
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 731
diff changeset
4127 s->first_slice_line = 1;
766
8d36b35a7e6e slice encoding cleanup
michaelni
parents: 764
diff changeset
4128 s->ptr_lastgob = s->pb.buf;
1799
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4129 for(mb_y= s->start_mb_y; mb_y < s->end_mb_y; mb_y++) {
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4130 // printf("row %d at %X\n", s->mb_y, (int)s);
1389
da0b3a50d209 rate distortion mb decision support
michaelni
parents: 1384
diff changeset
4131 s->mb_x=0;
da0b3a50d209 rate distortion mb decision support
michaelni
parents: 1384
diff changeset
4132 s->mb_y= mb_y;
da0b3a50d209 rate distortion mb decision support
michaelni
parents: 1384
diff changeset
4133
1652
834922115010 cleanup
michael
parents: 1651
diff changeset
4134 ff_set_qscale(s, s->qscale);
1389
da0b3a50d209 rate distortion mb decision support
michaelni
parents: 1384
diff changeset
4135 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
4136
232
b640ec5948b0 - Now the ME is done for the entire picture when enconding, the
pulento
parents: 231
diff changeset
4137 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
4138 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
4139 int mb_type= s->mb_type[xy];
456
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
4140 // int d;
1389
da0b3a50d209 rate distortion mb decision support
michaelni
parents: 1384
diff changeset
4141 int dmin= INT_MAX;
1708
dea5b2946999 interlaced motion estimation
michael
parents: 1707
diff changeset
4142 int dir;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4143
232
b640ec5948b0 - Now the ME is done for the entire picture when enconding, the
pulento
parents: 231
diff changeset
4144 s->mb_x = mb_x;
1389
da0b3a50d209 rate distortion mb decision support
michaelni
parents: 1384
diff changeset
4145 ff_update_block_index(s);
456
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
4146
766
8d36b35a7e6e slice encoding cleanup
michaelni
parents: 764
diff changeset
4147 /* write gob / video packet header */
1042
a78f6f72d54e --disable-risky support
michaelni
parents: 1026
diff changeset
4148 #ifdef CONFIG_RISKY
1661
4c9fd29f1606 h263 slice structured mode
michael
parents: 1659
diff changeset
4149 if(s->rtp_mode){
766
8d36b35a7e6e slice encoding cleanup
michaelni
parents: 764
diff changeset
4150 int current_packet_size, is_gob_start;
8d36b35a7e6e slice encoding cleanup
michaelni
parents: 764
diff changeset
4151
1801
3f26dfb3eba4 replace a few pbBufPtr() by put_bits_count(), one of them was actually wrong
michael
parents: 1799
diff changeset
4152 current_packet_size= ((put_bits_count(&s->pb)+7)>>3) - (s->ptr_lastgob - s->pb.buf);
1661
4c9fd29f1606 h263 slice structured mode
michael
parents: 1659
diff changeset
4153
4c9fd29f1606 h263 slice structured mode
michael
parents: 1659
diff changeset
4154 is_gob_start= s->avctx->rtp_payload_size && current_packet_size >= s->avctx->rtp_payload_size && mb_y + mb_x>0;
4c9fd29f1606 h263 slice structured mode
michael
parents: 1659
diff changeset
4155
1799
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4156 if(s->start_mb_y == mb_y && mb_y > 0 && mb_x==0) is_gob_start=1;
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4157
1661
4c9fd29f1606 h263 slice structured mode
michael
parents: 1659
diff changeset
4158 switch(s->codec_id){
4c9fd29f1606 h263 slice structured mode
michael
parents: 1659
diff changeset
4159 case CODEC_ID_H263:
4c9fd29f1606 h263 slice structured mode
michael
parents: 1659
diff changeset
4160 case CODEC_ID_H263P:
4c9fd29f1606 h263 slice structured mode
michael
parents: 1659
diff changeset
4161 if(!s->h263_slice_structured)
4c9fd29f1606 h263 slice structured mode
michael
parents: 1659
diff changeset
4162 if(s->mb_x || s->mb_y%s->gob_index) is_gob_start=0;
4c9fd29f1606 h263 slice structured mode
michael
parents: 1659
diff changeset
4163 break;
4c9fd29f1606 h263 slice structured mode
michael
parents: 1659
diff changeset
4164 case CODEC_ID_MPEG2VIDEO:
4c9fd29f1606 h263 slice structured mode
michael
parents: 1659
diff changeset
4165 if(s->mb_x==0 && s->mb_y!=0) is_gob_start=1;
4c9fd29f1606 h263 slice structured mode
michael
parents: 1659
diff changeset
4166 case CODEC_ID_MPEG1VIDEO:
4c9fd29f1606 h263 slice structured mode
michael
parents: 1659
diff changeset
4167 if(s->mb_skip_run) is_gob_start=0;
4c9fd29f1606 h263 slice structured mode
michael
parents: 1659
diff changeset
4168 break;
4c9fd29f1606 h263 slice structured mode
michael
parents: 1659
diff changeset
4169 }
1799
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4170
1661
4c9fd29f1606 h263 slice structured mode
michael
parents: 1659
diff changeset
4171 if(is_gob_start){
1799
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4172 if(s->start_mb_y != mb_y || mb_x!=0){
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4173 write_slice_end(s);
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4174
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4175 if(s->codec_id==CODEC_ID_MPEG4 && s->partitioned_frame){
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4176 ff_mpeg4_init_partitions(s);
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4177 }
1661
4c9fd29f1606 h263 slice structured mode
michael
parents: 1659
diff changeset
4178 }
4c9fd29f1606 h263 slice structured mode
michael
parents: 1659
diff changeset
4179
1786
b7340afa261a get_bit_count -> put_bits_count
alex
parents: 1785
diff changeset
4180 assert((put_bits_count(&s->pb)&7) == 0);
1661
4c9fd29f1606 h263 slice structured mode
michael
parents: 1659
diff changeset
4181 current_packet_size= pbBufPtr(&s->pb) - s->ptr_lastgob;
1688
04b759af8bd4 error concealment regression test
michael
parents: 1687
diff changeset
4182
04b759af8bd4 error concealment regression test
michael
parents: 1687
diff changeset
4183 if(s->avctx->error_rate && s->resync_mb_x + s->resync_mb_y > 0){
1786
b7340afa261a get_bit_count -> put_bits_count
alex
parents: 1785
diff changeset
4184 int r= put_bits_count(&s->pb)/8 + s->picture_number + s->codec_id + s->mb_x + s->mb_y;
1688
04b759af8bd4 error concealment regression test
michael
parents: 1687
diff changeset
4185 int d= 100 / s->avctx->error_rate;
04b759af8bd4 error concealment regression test
michael
parents: 1687
diff changeset
4186 if(r % d == 0){
04b759af8bd4 error concealment regression test
michael
parents: 1687
diff changeset
4187 current_packet_size=0;
04b759af8bd4 error concealment regression test
michael
parents: 1687
diff changeset
4188 #ifndef ALT_BITSTREAM_WRITER
04b759af8bd4 error concealment regression test
michael
parents: 1687
diff changeset
4189 s->pb.buf_ptr= s->ptr_lastgob;
04b759af8bd4 error concealment regression test
michael
parents: 1687
diff changeset
4190 #endif
04b759af8bd4 error concealment regression test
michael
parents: 1687
diff changeset
4191 assert(pbBufPtr(&s->pb) == s->ptr_lastgob);
04b759af8bd4 error concealment regression test
michael
parents: 1687
diff changeset
4192 }
04b759af8bd4 error concealment regression test
michael
parents: 1687
diff changeset
4193 }
1661
4c9fd29f1606 h263 slice structured mode
michael
parents: 1659
diff changeset
4194
4c9fd29f1606 h263 slice structured mode
michael
parents: 1659
diff changeset
4195 if (s->avctx->rtp_callback)
2025
591233f22963 rtp callback context patch by ("Chris Flerackers" <cflerackers at androme dot be>)
michael
parents: 2024
diff changeset
4196 s->avctx->rtp_callback(s->avctx, s->ptr_lastgob, current_packet_size, 0);
1661
4c9fd29f1606 h263 slice structured mode
michael
parents: 1659
diff changeset
4197
4c9fd29f1606 h263 slice structured mode
michael
parents: 1659
diff changeset
4198 switch(s->codec_id){
4c9fd29f1606 h263 slice structured mode
michael
parents: 1659
diff changeset
4199 case CODEC_ID_MPEG4:
456
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
4200 ff_mpeg4_encode_video_packet_header(s);
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
4201 ff_mpeg4_clean_buffers(s);
1661
4c9fd29f1606 h263 slice structured mode
michael
parents: 1659
diff changeset
4202 break;
4c9fd29f1606 h263 slice structured mode
michael
parents: 1659
diff changeset
4203 case CODEC_ID_MPEG1VIDEO:
4c9fd29f1606 h263 slice structured mode
michael
parents: 1659
diff changeset
4204 case CODEC_ID_MPEG2VIDEO:
1421
340c90faa1dc mpeg2 encoding
michaelni
parents: 1416
diff changeset
4205 ff_mpeg1_encode_slice_header(s);
340c90faa1dc mpeg2 encoding
michaelni
parents: 1416
diff changeset
4206 ff_mpeg1_clean_buffers(s);
1661
4c9fd29f1606 h263 slice structured mode
michael
parents: 1659
diff changeset
4207 break;
4c9fd29f1606 h263 slice structured mode
michael
parents: 1659
diff changeset
4208 case CODEC_ID_H263:
4c9fd29f1606 h263 slice structured mode
michael
parents: 1659
diff changeset
4209 case CODEC_ID_H263P:
4c9fd29f1606 h263 slice structured mode
michael
parents: 1659
diff changeset
4210 h263_encode_gob_header(s, mb_y);
4c9fd29f1606 h263 slice structured mode
michael
parents: 1659
diff changeset
4211 break;
1160
9a5c29575902 mpeg1 slice encoding support
michaelni
parents: 1159
diff changeset
4212 }
1661
4c9fd29f1606 h263 slice structured mode
michael
parents: 1659
diff changeset
4213
4c9fd29f1606 h263 slice structured mode
michael
parents: 1659
diff changeset
4214 if(s->flags&CODEC_FLAG_PASS1){
1786
b7340afa261a get_bit_count -> put_bits_count
alex
parents: 1785
diff changeset
4215 int bits= put_bits_count(&s->pb);
1661
4c9fd29f1606 h263 slice structured mode
michael
parents: 1659
diff changeset
4216 s->misc_bits+= bits - s->last_bits;
4c9fd29f1606 h263 slice structured mode
michael
parents: 1659
diff changeset
4217 s->last_bits= bits;
766
8d36b35a7e6e slice encoding cleanup
michaelni
parents: 764
diff changeset
4218 }
1661
4c9fd29f1606 h263 slice structured mode
michael
parents: 1659
diff changeset
4219
1662
64c370fe6e88 slice flush / position fix
michael
parents: 1661
diff changeset
4220 s->ptr_lastgob += current_packet_size;
456
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
4221 s->first_slice_line=1;
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
4222 s->resync_mb_x=mb_x;
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
4223 s->resync_mb_y=mb_y;
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
4224 }
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 731
diff changeset
4225 }
1042
a78f6f72d54e --disable-risky support
michaelni
parents: 1026
diff changeset
4226 #endif
456
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
4227
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 731
diff changeset
4228 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
4229 && 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
4230 s->first_slice_line=0;
456
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
4231 }
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
4232
1389
da0b3a50d209 rate distortion mb decision support
michaelni
parents: 1384
diff changeset
4233 s->mb_skiped=0;
1616
13a20c0594f2 rate distored optimal lambda->qp support
michael
parents: 1601
diff changeset
4234 s->dquant=0; //only for QP_RD
13a20c0594f2 rate distored optimal lambda->qp support
michael
parents: 1601
diff changeset
4235
13a20c0594f2 rate distored optimal lambda->qp support
michael
parents: 1601
diff changeset
4236 if(mb_type & (mb_type-1) || (s->flags & CODEC_FLAG_QP_RD)){ // more than 1 MB type possible
327
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 326
diff changeset
4237 int next_block=0;
456
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
4238 int pb_bits_count, pb2_bits_count, tex_pb_bits_count;
326
6ebb8680885d fixing hq mode with mpeg1 and 2-pass
michaelni
parents: 325
diff changeset
4239
6ebb8680885d fixing hq mode with mpeg1 and 2-pass
michaelni
parents: 325
diff changeset
4240 copy_context_before_encode(&backup_s, s, -1);
456
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
4241 backup_s.pb= s->pb;
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
4242 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
4243 best_s.partitioned_frame= s->partitioned_frame;
456
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
4244 if(s->data_partitioning){
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
4245 backup_s.pb2= s->pb2;
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
4246 backup_s.tex_pb= s->tex_pb;
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
4247 }
326
6ebb8680885d fixing hq mode with mpeg1 and 2-pass
michaelni
parents: 325
diff changeset
4248
1708
dea5b2946999 interlaced motion estimation
michael
parents: 1707
diff changeset
4249 if(mb_type&CANDIDATE_MB_TYPE_INTER){
327
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 326
diff changeset
4250 s->mv_dir = MV_DIR_FORWARD;
295
6622b0fd036c mpeg4 4MV encoding
michaelni
parents: 294
diff changeset
4251 s->mv_type = MV_TYPE_16X16;
294
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 292
diff changeset
4252 s->mb_intra= 0;
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
4253 s->mv[0][0][0] = s->p_mv_table[xy][0];
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
4254 s->mv[0][0][1] = s->p_mv_table[xy][1];
1708
dea5b2946999 interlaced motion estimation
michael
parents: 1707
diff changeset
4255 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER, pb, pb2, tex_pb,
456
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
4256 &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4257 }
1708
dea5b2946999 interlaced motion estimation
michael
parents: 1707
diff changeset
4258 if(mb_type&CANDIDATE_MB_TYPE_INTER_I){
dea5b2946999 interlaced motion estimation
michael
parents: 1707
diff changeset
4259 s->mv_dir = MV_DIR_FORWARD;
dea5b2946999 interlaced motion estimation
michael
parents: 1707
diff changeset
4260 s->mv_type = MV_TYPE_FIELD;
dea5b2946999 interlaced motion estimation
michael
parents: 1707
diff changeset
4261 s->mb_intra= 0;
dea5b2946999 interlaced motion estimation
michael
parents: 1707
diff changeset
4262 for(i=0; i<2; i++){
dea5b2946999 interlaced motion estimation
michael
parents: 1707
diff changeset
4263 j= s->field_select[0][i] = s->p_field_select_table[i][xy];
dea5b2946999 interlaced motion estimation
michael
parents: 1707
diff changeset
4264 s->mv[0][i][0] = s->p_field_mv_table[i][j][xy][0];
dea5b2946999 interlaced motion estimation
michael
parents: 1707
diff changeset
4265 s->mv[0][i][1] = s->p_field_mv_table[i][j][xy][1];
dea5b2946999 interlaced motion estimation
michael
parents: 1707
diff changeset
4266 }
dea5b2946999 interlaced motion estimation
michael
parents: 1707
diff changeset
4267 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER_I, pb, pb2, tex_pb,
dea5b2946999 interlaced motion estimation
michael
parents: 1707
diff changeset
4268 &dmin, &next_block, 0, 0);
dea5b2946999 interlaced motion estimation
michael
parents: 1707
diff changeset
4269 }
dea5b2946999 interlaced motion estimation
michael
parents: 1707
diff changeset
4270 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
4271 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
4272 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
4273 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
4274 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
4275 s->mv[0][0][1] = 0;
1708
dea5b2946999 interlaced motion estimation
michael
parents: 1707
diff changeset
4276 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
4277 &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
4278 }
1708
dea5b2946999 interlaced motion estimation
michael
parents: 1707
diff changeset
4279 if(mb_type&CANDIDATE_MB_TYPE_INTER4V){
327
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 326
diff changeset
4280 s->mv_dir = MV_DIR_FORWARD;
295
6622b0fd036c mpeg4 4MV encoding
michaelni
parents: 294
diff changeset
4281 s->mv_type = MV_TYPE_8X8;
6622b0fd036c mpeg4 4MV encoding
michaelni
parents: 294
diff changeset
4282 s->mb_intra= 0;
6622b0fd036c mpeg4 4MV encoding
michaelni
parents: 294
diff changeset
4283 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
4284 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
4285 s->mv[0][i][1] = s->current_picture.motion_val[0][s->block_index[i]][1];
295
6622b0fd036c mpeg4 4MV encoding
michaelni
parents: 294
diff changeset
4286 }
1708
dea5b2946999 interlaced motion estimation
michael
parents: 1707
diff changeset
4287 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER4V, pb, pb2, tex_pb,
456
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
4288 &dmin, &next_block, 0, 0);
327
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 326
diff changeset
4289 }
1708
dea5b2946999 interlaced motion estimation
michael
parents: 1707
diff changeset
4290 if(mb_type&CANDIDATE_MB_TYPE_FORWARD){
327
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 326
diff changeset
4291 s->mv_dir = MV_DIR_FORWARD;
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 326
diff changeset
4292 s->mv_type = MV_TYPE_16X16;
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 326
diff changeset
4293 s->mb_intra= 0;
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 326
diff changeset
4294 s->mv[0][0][0] = s->b_forw_mv_table[xy][0];
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 326
diff changeset
4295 s->mv[0][0][1] = s->b_forw_mv_table[xy][1];
1708
dea5b2946999 interlaced motion estimation
michael
parents: 1707
diff changeset
4296 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_FORWARD, pb, pb2, tex_pb,
456
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
4297 &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
327
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 326
diff changeset
4298 }
1708
dea5b2946999 interlaced motion estimation
michael
parents: 1707
diff changeset
4299 if(mb_type&CANDIDATE_MB_TYPE_BACKWARD){
327
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 326
diff changeset
4300 s->mv_dir = MV_DIR_BACKWARD;
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 326
diff changeset
4301 s->mv_type = MV_TYPE_16X16;
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 326
diff changeset
4302 s->mb_intra= 0;
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 326
diff changeset
4303 s->mv[1][0][0] = s->b_back_mv_table[xy][0];
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 326
diff changeset
4304 s->mv[1][0][1] = s->b_back_mv_table[xy][1];
1708
dea5b2946999 interlaced motion estimation
michael
parents: 1707
diff changeset
4305 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BACKWARD, pb, pb2, tex_pb,
456
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
4306 &dmin, &next_block, s->mv[1][0][0], s->mv[1][0][1]);
327
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 326
diff changeset
4307 }
1708
dea5b2946999 interlaced motion estimation
michael
parents: 1707
diff changeset
4308 if(mb_type&CANDIDATE_MB_TYPE_BIDIR){
327
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 326
diff changeset
4309 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 326
diff changeset
4310 s->mv_type = MV_TYPE_16X16;
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 326
diff changeset
4311 s->mb_intra= 0;
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 326
diff changeset
4312 s->mv[0][0][0] = s->b_bidir_forw_mv_table[xy][0];
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 326
diff changeset
4313 s->mv[0][0][1] = s->b_bidir_forw_mv_table[xy][1];
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 326
diff changeset
4314 s->mv[1][0][0] = s->b_bidir_back_mv_table[xy][0];
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 326
diff changeset
4315 s->mv[1][0][1] = s->b_bidir_back_mv_table[xy][1];
1708
dea5b2946999 interlaced motion estimation
michael
parents: 1707
diff changeset
4316 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BIDIR, pb, pb2, tex_pb,
456
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
4317 &dmin, &next_block, 0, 0);
327
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 326
diff changeset
4318 }
1708
dea5b2946999 interlaced motion estimation
michael
parents: 1707
diff changeset
4319 if(mb_type&CANDIDATE_MB_TYPE_DIRECT){
936
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
4320 int mx= s->b_direct_mv_table[xy][0];
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
4321 int my= s->b_direct_mv_table[xy][1];
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
4322
327
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 326
diff changeset
4323 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 326
diff changeset
4324 s->mb_intra= 0;
1042
a78f6f72d54e --disable-risky support
michaelni
parents: 1026
diff changeset
4325 #ifdef CONFIG_RISKY
936
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
4326 ff_mpeg4_set_direct_mv(s, mx, my);
1042
a78f6f72d54e --disable-risky support
michaelni
parents: 1026
diff changeset
4327 #endif
1708
dea5b2946999 interlaced motion estimation
michael
parents: 1707
diff changeset
4328 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_DIRECT, pb, pb2, tex_pb,
936
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
4329 &dmin, &next_block, mx, my);
295
6622b0fd036c mpeg4 4MV encoding
michaelni
parents: 294
diff changeset
4330 }
1708
dea5b2946999 interlaced motion estimation
michael
parents: 1707
diff changeset
4331 if(mb_type&CANDIDATE_MB_TYPE_FORWARD_I){
dea5b2946999 interlaced motion estimation
michael
parents: 1707
diff changeset
4332 s->mv_dir = MV_DIR_FORWARD;
dea5b2946999 interlaced motion estimation
michael
parents: 1707
diff changeset
4333 s->mv_type = MV_TYPE_FIELD;
dea5b2946999 interlaced motion estimation
michael
parents: 1707
diff changeset
4334 s->mb_intra= 0;
dea5b2946999 interlaced motion estimation
michael
parents: 1707
diff changeset
4335 for(i=0; i<2; i++){
dea5b2946999 interlaced motion estimation
michael
parents: 1707
diff changeset
4336 j= s->field_select[0][i] = s->b_field_select_table[0][i][xy];
dea5b2946999 interlaced motion estimation
michael
parents: 1707
diff changeset
4337 s->mv[0][i][0] = s->b_field_mv_table[0][i][j][xy][0];
dea5b2946999 interlaced motion estimation
michael
parents: 1707
diff changeset
4338 s->mv[0][i][1] = s->b_field_mv_table[0][i][j][xy][1];
dea5b2946999 interlaced motion estimation
michael
parents: 1707
diff changeset
4339 }
dea5b2946999 interlaced motion estimation
michael
parents: 1707
diff changeset
4340 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_FORWARD_I, pb, pb2, tex_pb,
dea5b2946999 interlaced motion estimation
michael
parents: 1707
diff changeset
4341 &dmin, &next_block, 0, 0);
dea5b2946999 interlaced motion estimation
michael
parents: 1707
diff changeset
4342 }
dea5b2946999 interlaced motion estimation
michael
parents: 1707
diff changeset
4343 if(mb_type&CANDIDATE_MB_TYPE_BACKWARD_I){
dea5b2946999 interlaced motion estimation
michael
parents: 1707
diff changeset
4344 s->mv_dir = MV_DIR_BACKWARD;
dea5b2946999 interlaced motion estimation
michael
parents: 1707
diff changeset
4345 s->mv_type = MV_TYPE_FIELD;
dea5b2946999 interlaced motion estimation
michael
parents: 1707
diff changeset
4346 s->mb_intra= 0;
dea5b2946999 interlaced motion estimation
michael
parents: 1707
diff changeset
4347 for(i=0; i<2; i++){
dea5b2946999 interlaced motion estimation
michael
parents: 1707
diff changeset
4348 j= s->field_select[1][i] = s->b_field_select_table[1][i][xy];
dea5b2946999 interlaced motion estimation
michael
parents: 1707
diff changeset
4349 s->mv[1][i][0] = s->b_field_mv_table[1][i][j][xy][0];
dea5b2946999 interlaced motion estimation
michael
parents: 1707
diff changeset
4350 s->mv[1][i][1] = s->b_field_mv_table[1][i][j][xy][1];
dea5b2946999 interlaced motion estimation
michael
parents: 1707
diff changeset
4351 }
dea5b2946999 interlaced motion estimation
michael
parents: 1707
diff changeset
4352 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BACKWARD_I, pb, pb2, tex_pb,
dea5b2946999 interlaced motion estimation
michael
parents: 1707
diff changeset
4353 &dmin, &next_block, 0, 0);
dea5b2946999 interlaced motion estimation
michael
parents: 1707
diff changeset
4354 }
dea5b2946999 interlaced motion estimation
michael
parents: 1707
diff changeset
4355 if(mb_type&CANDIDATE_MB_TYPE_BIDIR_I){
dea5b2946999 interlaced motion estimation
michael
parents: 1707
diff changeset
4356 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
dea5b2946999 interlaced motion estimation
michael
parents: 1707
diff changeset
4357 s->mv_type = MV_TYPE_FIELD;
dea5b2946999 interlaced motion estimation
michael
parents: 1707
diff changeset
4358 s->mb_intra= 0;
dea5b2946999 interlaced motion estimation
michael
parents: 1707
diff changeset
4359 for(dir=0; dir<2; dir++){
dea5b2946999 interlaced motion estimation
michael
parents: 1707
diff changeset
4360 for(i=0; i<2; i++){
dea5b2946999 interlaced motion estimation
michael
parents: 1707
diff changeset
4361 j= s->field_select[dir][i] = s->b_field_select_table[dir][i][xy];
dea5b2946999 interlaced motion estimation
michael
parents: 1707
diff changeset
4362 s->mv[dir][i][0] = s->b_field_mv_table[dir][i][j][xy][0];
dea5b2946999 interlaced motion estimation
michael
parents: 1707
diff changeset
4363 s->mv[dir][i][1] = s->b_field_mv_table[dir][i][j][xy][1];
dea5b2946999 interlaced motion estimation
michael
parents: 1707
diff changeset
4364 }
dea5b2946999 interlaced motion estimation
michael
parents: 1707
diff changeset
4365 }
dea5b2946999 interlaced motion estimation
michael
parents: 1707
diff changeset
4366 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BIDIR_I, pb, pb2, tex_pb,
dea5b2946999 interlaced motion estimation
michael
parents: 1707
diff changeset
4367 &dmin, &next_block, 0, 0);
dea5b2946999 interlaced motion estimation
michael
parents: 1707
diff changeset
4368 }
dea5b2946999 interlaced motion estimation
michael
parents: 1707
diff changeset
4369 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
4370 s->mv_dir = 0;
295
6622b0fd036c mpeg4 4MV encoding
michaelni
parents: 294
diff changeset
4371 s->mv_type = MV_TYPE_16X16;
294
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 292
diff changeset
4372 s->mb_intra= 1;
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 292
diff changeset
4373 s->mv[0][0][0] = 0;
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 292
diff changeset
4374 s->mv[0][0][1] = 0;
1708
dea5b2946999 interlaced motion estimation
michael
parents: 1707
diff changeset
4375 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTRA, pb, pb2, tex_pb,
456
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
4376 &dmin, &next_block, 0, 0);
1389
da0b3a50d209 rate distortion mb decision support
michaelni
parents: 1384
diff changeset
4377 if(s->h263_pred || s->h263_aic){
da0b3a50d209 rate distortion mb decision support
michaelni
parents: 1384
diff changeset
4378 if(best_s.mb_intra)
da0b3a50d209 rate distortion mb decision support
michaelni
parents: 1384
diff changeset
4379 s->mbintra_table[mb_x + mb_y*s->mb_stride]=1;
da0b3a50d209 rate distortion mb decision support
michaelni
parents: 1384
diff changeset
4380 else
da0b3a50d209 rate distortion mb decision support
michaelni
parents: 1384
diff changeset
4381 ff_clean_intra_table_entries(s); //old mode?
da0b3a50d209 rate distortion mb decision support
michaelni
parents: 1384
diff changeset
4382 }
295
6622b0fd036c mpeg4 4MV encoding
michaelni
parents: 294
diff changeset
4383 }
1616
13a20c0594f2 rate distored optimal lambda->qp support
michael
parents: 1601
diff changeset
4384
13a20c0594f2 rate distored optimal lambda->qp support
michael
parents: 1601
diff changeset
4385 if(s->flags & CODEC_FLAG_QP_RD){
13a20c0594f2 rate distored optimal lambda->qp support
michael
parents: 1601
diff changeset
4386 if(best_s.mv_type==MV_TYPE_16X16 && !(best_s.mv_dir&MV_DIRECT)){
13a20c0594f2 rate distored optimal lambda->qp support
michael
parents: 1601
diff changeset
4387 const int last_qp= backup_s.qscale;
13a20c0594f2 rate distored optimal lambda->qp support
michael
parents: 1601
diff changeset
4388 int dquant, dir, qp, dc[6];
1617
8b31f3a3e9fa ac prediction with rate distorted qp fix
michael
parents: 1616
diff changeset
4389 DCTELEM ac[6][16];
1623
1dd437affd27 qprd with b frames fix
michael
parents: 1622
diff changeset
4390 const int mvdir= (best_s.mv_dir&MV_DIR_BACKWARD) ? 1 : 0;
1616
13a20c0594f2 rate distored optimal lambda->qp support
michael
parents: 1601
diff changeset
4391
13a20c0594f2 rate distored optimal lambda->qp support
michael
parents: 1601
diff changeset
4392 assert(backup_s.dquant == 0);
13a20c0594f2 rate distored optimal lambda->qp support
michael
parents: 1601
diff changeset
4393
13a20c0594f2 rate distored optimal lambda->qp support
michael
parents: 1601
diff changeset
4394 //FIXME intra
13a20c0594f2 rate distored optimal lambda->qp support
michael
parents: 1601
diff changeset
4395 s->mv_dir= best_s.mv_dir;
13a20c0594f2 rate distored optimal lambda->qp support
michael
parents: 1601
diff changeset
4396 s->mv_type = MV_TYPE_16X16;
13a20c0594f2 rate distored optimal lambda->qp support
michael
parents: 1601
diff changeset
4397 s->mb_intra= best_s.mb_intra;
13a20c0594f2 rate distored optimal lambda->qp support
michael
parents: 1601
diff changeset
4398 s->mv[0][0][0] = best_s.mv[0][0][0];
13a20c0594f2 rate distored optimal lambda->qp support
michael
parents: 1601
diff changeset
4399 s->mv[0][0][1] = best_s.mv[0][0][1];
13a20c0594f2 rate distored optimal lambda->qp support
michael
parents: 1601
diff changeset
4400 s->mv[1][0][0] = best_s.mv[1][0][0];
13a20c0594f2 rate distored optimal lambda->qp support
michael
parents: 1601
diff changeset
4401 s->mv[1][0][1] = best_s.mv[1][0][1];
13a20c0594f2 rate distored optimal lambda->qp support
michael
parents: 1601
diff changeset
4402
13a20c0594f2 rate distored optimal lambda->qp support
michael
parents: 1601
diff changeset
4403 dir= s->pict_type == B_TYPE ? 2 : 1;
1623
1dd437affd27 qprd with b frames fix
michael
parents: 1622
diff changeset
4404 if(last_qp + dir > s->avctx->qmax) dir= -dir;
1616
13a20c0594f2 rate distored optimal lambda->qp support
michael
parents: 1601
diff changeset
4405 for(dquant= dir; dquant<=2 && dquant>=-2; dquant += dir){
13a20c0594f2 rate distored optimal lambda->qp support
michael
parents: 1601
diff changeset
4406 qp= last_qp + dquant;
13a20c0594f2 rate distored optimal lambda->qp support
michael
parents: 1601
diff changeset
4407 if(qp < s->avctx->qmin || qp > s->avctx->qmax)
13a20c0594f2 rate distored optimal lambda->qp support
michael
parents: 1601
diff changeset
4408 break;
13a20c0594f2 rate distored optimal lambda->qp support
michael
parents: 1601
diff changeset
4409 backup_s.dquant= dquant;
1617
8b31f3a3e9fa ac prediction with rate distorted qp fix
michael
parents: 1616
diff changeset
4410 if(s->mb_intra){
8b31f3a3e9fa ac prediction with rate distorted qp fix
michael
parents: 1616
diff changeset
4411 for(i=0; i<6; i++){
8b31f3a3e9fa ac prediction with rate distorted qp fix
michael
parents: 1616
diff changeset
4412 dc[i]= s->dc_val[0][ s->block_index[i] ];
8b31f3a3e9fa ac prediction with rate distorted qp fix
michael
parents: 1616
diff changeset
4413 memcpy(ac[i], s->ac_val[0][s->block_index[i]], sizeof(DCTELEM)*16);
8b31f3a3e9fa ac prediction with rate distorted qp fix
michael
parents: 1616
diff changeset
4414 }
1616
13a20c0594f2 rate distored optimal lambda->qp support
michael
parents: 1601
diff changeset
4415 }
1617
8b31f3a3e9fa ac prediction with rate distorted qp fix
michael
parents: 1616
diff changeset
4416
1708
dea5b2946999 interlaced motion estimation
michael
parents: 1707
diff changeset
4417 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER /* wrong but unused */, pb, pb2, tex_pb,
1623
1dd437affd27 qprd with b frames fix
michael
parents: 1622
diff changeset
4418 &dmin, &next_block, s->mv[mvdir][0][0], s->mv[mvdir][0][1]);
1616
13a20c0594f2 rate distored optimal lambda->qp support
michael
parents: 1601
diff changeset
4419 if(best_s.qscale != qp){
1617
8b31f3a3e9fa ac prediction with rate distorted qp fix
michael
parents: 1616
diff changeset
4420 if(s->mb_intra){
8b31f3a3e9fa ac prediction with rate distorted qp fix
michael
parents: 1616
diff changeset
4421 for(i=0; i<6; i++){
8b31f3a3e9fa ac prediction with rate distorted qp fix
michael
parents: 1616
diff changeset
4422 s->dc_val[0][ s->block_index[i] ]= dc[i];
8b31f3a3e9fa ac prediction with rate distorted qp fix
michael
parents: 1616
diff changeset
4423 memcpy(s->ac_val[0][s->block_index[i]], ac[i], sizeof(DCTELEM)*16);
8b31f3a3e9fa ac prediction with rate distorted qp fix
michael
parents: 1616
diff changeset
4424 }
1616
13a20c0594f2 rate distored optimal lambda->qp support
michael
parents: 1601
diff changeset
4425 }
13a20c0594f2 rate distored optimal lambda->qp support
michael
parents: 1601
diff changeset
4426 if(dir > 0 && dquant==dir){
13a20c0594f2 rate distored optimal lambda->qp support
michael
parents: 1601
diff changeset
4427 dquant= 0;
13a20c0594f2 rate distored optimal lambda->qp support
michael
parents: 1601
diff changeset
4428 dir= -dir;
13a20c0594f2 rate distored optimal lambda->qp support
michael
parents: 1601
diff changeset
4429 }else
13a20c0594f2 rate distored optimal lambda->qp support
michael
parents: 1601
diff changeset
4430 break;
13a20c0594f2 rate distored optimal lambda->qp support
michael
parents: 1601
diff changeset
4431 }
13a20c0594f2 rate distored optimal lambda->qp support
michael
parents: 1601
diff changeset
4432 }
13a20c0594f2 rate distored optimal lambda->qp support
michael
parents: 1601
diff changeset
4433 qp= best_s.qscale;
13a20c0594f2 rate distored optimal lambda->qp support
michael
parents: 1601
diff changeset
4434 s->current_picture.qscale_table[xy]= qp;
13a20c0594f2 rate distored optimal lambda->qp support
michael
parents: 1601
diff changeset
4435 }
13a20c0594f2 rate distored optimal lambda->qp support
michael
parents: 1601
diff changeset
4436 }
13a20c0594f2 rate distored optimal lambda->qp support
michael
parents: 1601
diff changeset
4437
326
6ebb8680885d fixing hq mode with mpeg1 and 2-pass
michaelni
parents: 325
diff changeset
4438 copy_context_after_encode(s, &best_s, -1);
456
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
4439
1786
b7340afa261a get_bit_count -> put_bits_count
alex
parents: 1785
diff changeset
4440 pb_bits_count= put_bits_count(&s->pb);
456
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
4441 flush_put_bits(&s->pb);
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
4442 ff_copy_bits(&backup_s.pb, bit_buf[next_block^1], pb_bits_count);
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
4443 s->pb= backup_s.pb;
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
4444
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
4445 if(s->data_partitioning){
1786
b7340afa261a get_bit_count -> put_bits_count
alex
parents: 1785
diff changeset
4446 pb2_bits_count= put_bits_count(&s->pb2);
456
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
4447 flush_put_bits(&s->pb2);
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
4448 ff_copy_bits(&backup_s.pb2, bit_buf2[next_block^1], pb2_bits_count);
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
4449 s->pb2= backup_s.pb2;
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
4450
1786
b7340afa261a get_bit_count -> put_bits_count
alex
parents: 1785
diff changeset
4451 tex_pb_bits_count= put_bits_count(&s->tex_pb);
456
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
4452 flush_put_bits(&s->tex_pb);
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
4453 ff_copy_bits(&backup_s.tex_pb, bit_buf_tex[next_block^1], tex_pb_bits_count);
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
4454 s->tex_pb= backup_s.tex_pb;
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
4455 }
1786
b7340afa261a get_bit_count -> put_bits_count
alex
parents: 1785
diff changeset
4456 s->last_bits= put_bits_count(&s->pb);
1451
62c16edd18c6 --disable-risky fix by (Luca Abeni <lucabe72 at email dot it>)
michaelni
parents: 1444
diff changeset
4457
62c16edd18c6 --disable-risky fix by (Luca Abeni <lucabe72 at email dot it>)
michaelni
parents: 1444
diff changeset
4458 #ifdef CONFIG_RISKY
1389
da0b3a50d209 rate distortion mb decision support
michaelni
parents: 1384
diff changeset
4459 if (s->out_format == FMT_H263 && s->pict_type!=B_TYPE)
da0b3a50d209 rate distortion mb decision support
michaelni
parents: 1384
diff changeset
4460 ff_h263_update_motion_val(s);
1451
62c16edd18c6 --disable-risky fix by (Luca Abeni <lucabe72 at email dot it>)
michaelni
parents: 1444
diff changeset
4461 #endif
1389
da0b3a50d209 rate distortion mb decision support
michaelni
parents: 1384
diff changeset
4462
1799
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4463 if(next_block==0){ //FIXME 16 vs linesize16
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4464 s->dsp.put_pixels_tab[0][0](s->dest[0], s->rd_scratchpad , s->linesize ,16);
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4465 s->dsp.put_pixels_tab[1][0](s->dest[1], s->rd_scratchpad + 16*s->linesize , s->uvlinesize, 8);
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4466 s->dsp.put_pixels_tab[1][0](s->dest[2], s->rd_scratchpad + 16*s->linesize + 8, s->uvlinesize, 8);
1389
da0b3a50d209 rate distortion mb decision support
michaelni
parents: 1384
diff changeset
4467 }
da0b3a50d209 rate distortion mb decision support
michaelni
parents: 1384
diff changeset
4468
da0b3a50d209 rate distortion mb decision support
michaelni
parents: 1384
diff changeset
4469 if(s->avctx->mb_decision == FF_MB_DECISION_BITS)
da0b3a50d209 rate distortion mb decision support
michaelni
parents: 1384
diff changeset
4470 MPV_decode_mb(s, s->block);
294
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 292
diff changeset
4471 } else {
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
4472 int motion_x, motion_y;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
4473 s->mv_type=MV_TYPE_16X16;
294
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 292
diff changeset
4474 // only one MB-Type possible
1013
5d4c95f323d0 finetuneing thresholds/factors
michaelni
parents: 1011
diff changeset
4475
327
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 326
diff changeset
4476 switch(mb_type){
1708
dea5b2946999 interlaced motion estimation
michael
parents: 1707
diff changeset
4477 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
4478 s->mv_dir = 0;
294
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 292
diff changeset
4479 s->mb_intra= 1;
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
4480 motion_x= s->mv[0][0][0] = 0;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
4481 motion_y= s->mv[0][0][1] = 0;
327
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 326
diff changeset
4482 break;
1708
dea5b2946999 interlaced motion estimation
michael
parents: 1707
diff changeset
4483 case CANDIDATE_MB_TYPE_INTER:
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
4484 s->mv_dir = MV_DIR_FORWARD;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
4485 s->mb_intra= 0;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
4486 motion_x= s->mv[0][0][0] = s->p_mv_table[xy][0];
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
4487 motion_y= s->mv[0][0][1] = s->p_mv_table[xy][1];
327
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 326
diff changeset
4488 break;
1708
dea5b2946999 interlaced motion estimation
michael
parents: 1707
diff changeset
4489 case CANDIDATE_MB_TYPE_INTER_I:
dea5b2946999 interlaced motion estimation
michael
parents: 1707
diff changeset
4490 s->mv_dir = MV_DIR_FORWARD;
dea5b2946999 interlaced motion estimation
michael
parents: 1707
diff changeset
4491 s->mv_type = MV_TYPE_FIELD;
dea5b2946999 interlaced motion estimation
michael
parents: 1707
diff changeset
4492 s->mb_intra= 0;
dea5b2946999 interlaced motion estimation
michael
parents: 1707
diff changeset
4493 for(i=0; i<2; i++){
dea5b2946999 interlaced motion estimation
michael
parents: 1707
diff changeset
4494 j= s->field_select[0][i] = s->p_field_select_table[i][xy];
dea5b2946999 interlaced motion estimation
michael
parents: 1707
diff changeset
4495 s->mv[0][i][0] = s->p_field_mv_table[i][j][xy][0];
dea5b2946999 interlaced motion estimation
michael
parents: 1707
diff changeset
4496 s->mv[0][i][1] = s->p_field_mv_table[i][j][xy][1];
dea5b2946999 interlaced motion estimation
michael
parents: 1707
diff changeset
4497 }
dea5b2946999 interlaced motion estimation
michael
parents: 1707
diff changeset
4498 motion_x = motion_y = 0;
dea5b2946999 interlaced motion estimation
michael
parents: 1707
diff changeset
4499 break;
dea5b2946999 interlaced motion estimation
michael
parents: 1707
diff changeset
4500 case CANDIDATE_MB_TYPE_INTER4V:
456
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
4501 s->mv_dir = MV_DIR_FORWARD;
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
4502 s->mv_type = MV_TYPE_8X8;
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
4503 s->mb_intra= 0;
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
4504 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
4505 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
4506 s->mv[0][i][1] = s->current_picture.motion_val[0][s->block_index[i]][1];
456
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
4507 }
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
4508 motion_x= motion_y= 0;
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
4509 break;
1708
dea5b2946999 interlaced motion estimation
michael
parents: 1707
diff changeset
4510 case CANDIDATE_MB_TYPE_DIRECT:
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
4511 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
4512 s->mb_intra= 0;
327
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 326
diff changeset
4513 motion_x=s->b_direct_mv_table[xy][0];
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 326
diff changeset
4514 motion_y=s->b_direct_mv_table[xy][1];
1042
a78f6f72d54e --disable-risky support
michaelni
parents: 1026
diff changeset
4515 #ifdef CONFIG_RISKY
936
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
4516 ff_mpeg4_set_direct_mv(s, motion_x, motion_y);
1042
a78f6f72d54e --disable-risky support
michaelni
parents: 1026
diff changeset
4517 #endif
327
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 326
diff changeset
4518 break;
1708
dea5b2946999 interlaced motion estimation
michael
parents: 1707
diff changeset
4519 case CANDIDATE_MB_TYPE_BIDIR:
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
4520 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
294
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 292
diff changeset
4521 s->mb_intra= 0;
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
4522 motion_x=0;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
4523 motion_y=0;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
4524 s->mv[0][0][0] = s->b_bidir_forw_mv_table[xy][0];
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
4525 s->mv[0][0][1] = s->b_bidir_forw_mv_table[xy][1];
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
4526 s->mv[1][0][0] = s->b_bidir_back_mv_table[xy][0];
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
4527 s->mv[1][0][1] = s->b_bidir_back_mv_table[xy][1];
327
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 326
diff changeset
4528 break;
1708
dea5b2946999 interlaced motion estimation
michael
parents: 1707
diff changeset
4529 case CANDIDATE_MB_TYPE_BACKWARD:
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
4530 s->mv_dir = MV_DIR_BACKWARD;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
4531 s->mb_intra= 0;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
4532 motion_x= s->mv[1][0][0] = s->b_back_mv_table[xy][0];
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
4533 motion_y= s->mv[1][0][1] = s->b_back_mv_table[xy][1];
327
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 326
diff changeset
4534 break;
1708
dea5b2946999 interlaced motion estimation
michael
parents: 1707
diff changeset
4535 case CANDIDATE_MB_TYPE_FORWARD:
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
4536 s->mv_dir = MV_DIR_FORWARD;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
4537 s->mb_intra= 0;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
4538 motion_x= s->mv[0][0][0] = s->b_forw_mv_table[xy][0];
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
4539 motion_y= s->mv[0][0][1] = s->b_forw_mv_table[xy][1];
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
4540 // printf(" %d %d ", motion_x, motion_y);
327
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 326
diff changeset
4541 break;
1708
dea5b2946999 interlaced motion estimation
michael
parents: 1707
diff changeset
4542 case CANDIDATE_MB_TYPE_FORWARD_I:
dea5b2946999 interlaced motion estimation
michael
parents: 1707
diff changeset
4543 s->mv_dir = MV_DIR_FORWARD;
dea5b2946999 interlaced motion estimation
michael
parents: 1707
diff changeset
4544 s->mv_type = MV_TYPE_FIELD;
dea5b2946999 interlaced motion estimation
michael
parents: 1707
diff changeset
4545 s->mb_intra= 0;
dea5b2946999 interlaced motion estimation
michael
parents: 1707
diff changeset
4546 for(i=0; i<2; i++){
dea5b2946999 interlaced motion estimation
michael
parents: 1707
diff changeset
4547 j= s->field_select[0][i] = s->b_field_select_table[0][i][xy];
dea5b2946999 interlaced motion estimation
michael
parents: 1707
diff changeset
4548 s->mv[0][i][0] = s->b_field_mv_table[0][i][j][xy][0];
dea5b2946999 interlaced motion estimation
michael
parents: 1707
diff changeset
4549 s->mv[0][i][1] = s->b_field_mv_table[0][i][j][xy][1];
dea5b2946999 interlaced motion estimation
michael
parents: 1707
diff changeset
4550 }
dea5b2946999 interlaced motion estimation
michael
parents: 1707
diff changeset
4551 motion_x=motion_y=0;
dea5b2946999 interlaced motion estimation
michael
parents: 1707
diff changeset
4552 break;
dea5b2946999 interlaced motion estimation
michael
parents: 1707
diff changeset
4553 case CANDIDATE_MB_TYPE_BACKWARD_I:
dea5b2946999 interlaced motion estimation
michael
parents: 1707
diff changeset
4554 s->mv_dir = MV_DIR_BACKWARD;
dea5b2946999 interlaced motion estimation
michael
parents: 1707
diff changeset
4555 s->mv_type = MV_TYPE_FIELD;
dea5b2946999 interlaced motion estimation
michael
parents: 1707
diff changeset
4556 s->mb_intra= 0;
dea5b2946999 interlaced motion estimation
michael
parents: 1707
diff changeset
4557 for(i=0; i<2; i++){
dea5b2946999 interlaced motion estimation
michael
parents: 1707
diff changeset
4558 j= s->field_select[1][i] = s->b_field_select_table[1][i][xy];
dea5b2946999 interlaced motion estimation
michael
parents: 1707
diff changeset
4559 s->mv[1][i][0] = s->b_field_mv_table[1][i][j][xy][0];
dea5b2946999 interlaced motion estimation
michael
parents: 1707
diff changeset
4560 s->mv[1][i][1] = s->b_field_mv_table[1][i][j][xy][1];
dea5b2946999 interlaced motion estimation
michael
parents: 1707
diff changeset
4561 }
dea5b2946999 interlaced motion estimation
michael
parents: 1707
diff changeset
4562 motion_x=motion_y=0;
dea5b2946999 interlaced motion estimation
michael
parents: 1707
diff changeset
4563 break;
dea5b2946999 interlaced motion estimation
michael
parents: 1707
diff changeset
4564 case CANDIDATE_MB_TYPE_BIDIR_I:
dea5b2946999 interlaced motion estimation
michael
parents: 1707
diff changeset
4565 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
dea5b2946999 interlaced motion estimation
michael
parents: 1707
diff changeset
4566 s->mv_type = MV_TYPE_FIELD;
dea5b2946999 interlaced motion estimation
michael
parents: 1707
diff changeset
4567 s->mb_intra= 0;
dea5b2946999 interlaced motion estimation
michael
parents: 1707
diff changeset
4568 for(dir=0; dir<2; dir++){
dea5b2946999 interlaced motion estimation
michael
parents: 1707
diff changeset
4569 for(i=0; i<2; i++){
dea5b2946999 interlaced motion estimation
michael
parents: 1707
diff changeset
4570 j= s->field_select[dir][i] = s->b_field_select_table[dir][i][xy];
dea5b2946999 interlaced motion estimation
michael
parents: 1707
diff changeset
4571 s->mv[dir][i][0] = s->b_field_mv_table[dir][i][j][xy][0];
dea5b2946999 interlaced motion estimation
michael
parents: 1707
diff changeset
4572 s->mv[dir][i][1] = s->b_field_mv_table[dir][i][j][xy][1];
dea5b2946999 interlaced motion estimation
michael
parents: 1707
diff changeset
4573 }
dea5b2946999 interlaced motion estimation
michael
parents: 1707
diff changeset
4574 }
dea5b2946999 interlaced motion estimation
michael
parents: 1707
diff changeset
4575 motion_x=motion_y=0;
dea5b2946999 interlaced motion estimation
michael
parents: 1707
diff changeset
4576 break;
327
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 326
diff changeset
4577 default:
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
4578 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
4579 av_log(s->avctx, AV_LOG_ERROR, "illegal MB type\n");
294
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 292
diff changeset
4580 }
1051
e5a9dbf597d4 mpeg1 bframe encoding patch by (Rapha«³l LEGRAND) with some modifications by me
michaelni
parents: 1048
diff changeset
4581
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 321
diff changeset
4582 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
4583
e5a9dbf597d4 mpeg1 bframe encoding patch by (Rapha«³l LEGRAND) with some modifications by me
michaelni
parents: 1048
diff changeset
4584 // RAL: Update last macrobloc type
e5a9dbf597d4 mpeg1 bframe encoding patch by (Rapha«³l LEGRAND) with some modifications by me
michaelni
parents: 1048
diff changeset
4585 s->last_mv_dir = s->mv_dir;
1389
da0b3a50d209 rate distortion mb decision support
michaelni
parents: 1384
diff changeset
4586
1451
62c16edd18c6 --disable-risky fix by (Luca Abeni <lucabe72 at email dot it>)
michaelni
parents: 1444
diff changeset
4587 #ifdef CONFIG_RISKY
1389
da0b3a50d209 rate distortion mb decision support
michaelni
parents: 1384
diff changeset
4588 if (s->out_format == FMT_H263 && s->pict_type!=B_TYPE)
da0b3a50d209 rate distortion mb decision support
michaelni
parents: 1384
diff changeset
4589 ff_h263_update_motion_val(s);
1451
62c16edd18c6 --disable-risky fix by (Luca Abeni <lucabe72 at email dot it>)
michaelni
parents: 1444
diff changeset
4590 #endif
62c16edd18c6 --disable-risky fix by (Luca Abeni <lucabe72 at email dot it>)
michaelni
parents: 1444
diff changeset
4591
1389
da0b3a50d209 rate distortion mb decision support
michaelni
parents: 1384
diff changeset
4592 MPV_decode_mb(s, s->block);
248
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 244
diff changeset
4593 }
1051
e5a9dbf597d4 mpeg1 bframe encoding patch by (Rapha«³l LEGRAND) with some modifications by me
michaelni
parents: 1048
diff changeset
4594
327
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 326
diff changeset
4595 /* clean the MV table in IPS frames for direct mode in B frames */
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 326
diff changeset
4596 if(s->mb_intra /* && I,P,S_TYPE */){
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 326
diff changeset
4597 s->p_mv_table[xy][0]=0;
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 326
diff changeset
4598 s->p_mv_table[xy][1]=0;
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 326
diff changeset
4599 }
909
8ae1e4c24e91 new PSNR code (now works with chroma, b frames, ...)
michaelni
parents: 903
diff changeset
4600
8ae1e4c24e91 new PSNR code (now works with chroma, b frames, ...)
michaelni
parents: 903
diff changeset
4601 if(s->flags&CODEC_FLAG_PSNR){
8ae1e4c24e91 new PSNR code (now works with chroma, b frames, ...)
michaelni
parents: 903
diff changeset
4602 int w= 16;
8ae1e4c24e91 new PSNR code (now works with chroma, b frames, ...)
michaelni
parents: 903
diff changeset
4603 int h= 16;
8ae1e4c24e91 new PSNR code (now works with chroma, b frames, ...)
michaelni
parents: 903
diff changeset
4604
8ae1e4c24e91 new PSNR code (now works with chroma, b frames, ...)
michaelni
parents: 903
diff changeset
4605 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
4606 if(s->mb_y*16 + 16 > s->height) h= s->height- s->mb_y*16;
936
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
4607
1148
michaelni
parents: 1141
diff changeset
4608 s->current_picture_ptr->error[0] += sse(
1389
da0b3a50d209 rate distortion mb decision support
michaelni
parents: 1384
diff changeset
4609 s, s->new_picture.data[0] + s->mb_x*16 + s->mb_y*s->linesize*16,
da0b3a50d209 rate distortion mb decision support
michaelni
parents: 1384
diff changeset
4610 s->dest[0], w, h, s->linesize);
1148
michaelni
parents: 1141
diff changeset
4611 s->current_picture_ptr->error[1] += sse(
1389
da0b3a50d209 rate distortion mb decision support
michaelni
parents: 1384
diff changeset
4612 s, s->new_picture.data[1] + s->mb_x*8 + s->mb_y*s->uvlinesize*8,
da0b3a50d209 rate distortion mb decision support
michaelni
parents: 1384
diff changeset
4613 s->dest[1], w>>1, h>>1, s->uvlinesize);
1148
michaelni
parents: 1141
diff changeset
4614 s->current_picture_ptr->error[2] += sse(
1389
da0b3a50d209 rate distortion mb decision support
michaelni
parents: 1384
diff changeset
4615 s, s->new_picture .data[2] + s->mb_x*8 + s->mb_y*s->uvlinesize*8,
da0b3a50d209 rate distortion mb decision support
michaelni
parents: 1384
diff changeset
4616 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
4617 }
1644
835cf346975e h263 loop filter
michael
parents: 1641
diff changeset
4618 if(s->loop_filter)
835cf346975e h263 loop filter
michael
parents: 1641
diff changeset
4619 ff_h263_loop_filter(s);
1786
b7340afa261a get_bit_count -> put_bits_count
alex
parents: 1785
diff changeset
4620 //printf("MB %d %d bits\n", s->mb_x+s->mb_y*s->mb_stride, put_bits_count(&s->pb));
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4621 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
4622 }
286
91f7c38f5f37 statistics for 2-pass encoding
michaelni
parents: 281
diff changeset
4623
1042
a78f6f72d54e --disable-risky support
michaelni
parents: 1026
diff changeset
4624 #ifdef CONFIG_RISKY
1799
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4625 //not beautifull here but we must write it before flushing so it has to be here
456
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
4626 if (s->msmpeg4_version && s->msmpeg4_version<4 && s->pict_type == I_TYPE)
208
2eb04d6be309 (commit by michael)
arpi_esp
parents: 207
diff changeset
4627 msmpeg4_encode_ext_header(s);
1042
a78f6f72d54e --disable-risky support
michaelni
parents: 1026
diff changeset
4628 #endif
456
c006ee838856 single coefficient elimination
michaelni
parents: 429
diff changeset
4629
1799
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4630 write_slice_end(s);
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4631
231
840cd25bf259 - Fixes on RTP and GOB headers for H.263.
pulento
parents: 230
diff changeset
4632 /* Send the last GOB if RTP */
1661
4c9fd29f1606 h263 slice structured mode
michael
parents: 1659
diff changeset
4633 if (s->avctx->rtp_callback) {
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
4634 pdif = pbBufPtr(&s->pb) - s->ptr_lastgob;
231
840cd25bf259 - Fixes on RTP and GOB headers for H.263.
pulento
parents: 230
diff changeset
4635 /* Call the RTP callback to send the last GOB */
1799
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4636 emms_c();
2025
591233f22963 rtp callback context patch by ("Chris Flerackers" <cflerackers at androme dot be>)
michael
parents: 2024
diff changeset
4637 s->avctx->rtp_callback(s->avctx, s->ptr_lastgob, pdif, 0);
231
840cd25bf259 - Fixes on RTP and GOB headers for H.263.
pulento
parents: 230
diff changeset
4638 }
1799
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4639
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4640 return 0;
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4641 }
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4642
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4643 #define MERGE(field) dst->field += src->field; src->field=0
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4644 static void merge_context_after_me(MpegEncContext *dst, MpegEncContext *src){
2015
3ab8f3e2ae6a moving motion estimation specific variables from MpegEncContext -> MotionEstContext
michael
parents: 1994
diff changeset
4645 MERGE(me.scene_change_score);
3ab8f3e2ae6a moving motion estimation specific variables from MpegEncContext -> MotionEstContext
michael
parents: 1994
diff changeset
4646 MERGE(me.mc_mb_var_sum_temp);
3ab8f3e2ae6a moving motion estimation specific variables from MpegEncContext -> MotionEstContext
michael
parents: 1994
diff changeset
4647 MERGE(me.mb_var_sum_temp);
1799
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4648 }
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4649
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4650 static void merge_context_after_encode(MpegEncContext *dst, MpegEncContext *src){
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4651 int i;
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4652
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4653 MERGE(dct_count[0]); //note, the other dct vars are not part of the context
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4654 MERGE(dct_count[1]);
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4655 MERGE(mv_bits);
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4656 MERGE(i_tex_bits);
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4657 MERGE(p_tex_bits);
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4658 MERGE(i_count);
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4659 MERGE(f_count);
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4660 MERGE(b_count);
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4661 MERGE(skip_count);
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4662 MERGE(misc_bits);
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4663 MERGE(error_count);
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4664 MERGE(padding_bug_score);
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4665
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4666 if(dst->avctx->noise_reduction){
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4667 for(i=0; i<64; i++){
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4668 MERGE(dct_error_sum[0][i]);
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4669 MERGE(dct_error_sum[1][i]);
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4670 }
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4671 }
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4672
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4673 assert(put_bits_count(&src->pb) % 8 ==0);
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4674 assert(put_bits_count(&dst->pb) % 8 ==0);
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4675 ff_copy_bits(&dst->pb, src->pb.buf, put_bits_count(&src->pb));
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4676 flush_put_bits(&dst->pb);
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4677 }
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4678
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4679 static void encode_picture(MpegEncContext *s, int picture_number)
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4680 {
2024
f65d87bfdd5a some of the warning fixes by (Michael Roitzsch <mroi at users dot sourceforge dot net>)
michael
parents: 2015
diff changeset
4681 int i;
1799
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4682 int bits;
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4683
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4684 s->picture_number = picture_number;
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4685
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4686 /* Reset the average MB variance */
2015
3ab8f3e2ae6a moving motion estimation specific variables from MpegEncContext -> MotionEstContext
michael
parents: 1994
diff changeset
4687 s->me.mb_var_sum_temp =
3ab8f3e2ae6a moving motion estimation specific variables from MpegEncContext -> MotionEstContext
michael
parents: 1994
diff changeset
4688 s->me.mc_mb_var_sum_temp = 0;
1799
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4689
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4690 #ifdef CONFIG_RISKY
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4691 /* we need to initialize some time vars before we can encode b-frames */
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4692 // RAL: Condition added for MPEG1VIDEO
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4693 if (s->codec_id == CODEC_ID_MPEG1VIDEO || s->codec_id == CODEC_ID_MPEG2VIDEO || (s->h263_pred && !s->h263_msmpeg4))
1834
41c324b09fcc 100l (field picture decoding fix)
michael
parents: 1833
diff changeset
4694 ff_set_mpeg4_time(s, s->picture_number); //FIXME rename and use has_b_frames or similar
1799
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4695 #endif
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4696
2015
3ab8f3e2ae6a moving motion estimation specific variables from MpegEncContext -> MotionEstContext
michael
parents: 1994
diff changeset
4697 s->me.scene_change_score=0;
1799
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4698
2053
c46e203dd698 change qscale -> lambda for the motion estimation
michael
parents: 2048
diff changeset
4699 // s->lambda= s->current_picture_ptr->quality; //FIXME qscale / ... stuff for ME ratedistoration
1799
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4700
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4701 if(s->pict_type==I_TYPE){
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4702 if(s->msmpeg4_version >= 3) s->no_rounding=1;
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4703 else s->no_rounding=0;
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4704 }else if(s->pict_type!=B_TYPE){
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4705 if(s->flipflop_rounding || s->codec_id == CODEC_ID_H263P || s->codec_id == CODEC_ID_MPEG4)
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4706 s->no_rounding ^= 1;
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4707 }
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4708
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4709 s->mb_intra=0; //for the rate distoration & bit compare functions
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4710 for(i=1; i<s->avctx->thread_count; i++){
1827
fcbf31baa1af multithreaded mpeg2 decoding
michael
parents: 1820
diff changeset
4711 ff_update_duplicate_context(s->thread_context[i], s);
1799
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4712 }
1962
1d5abf80fa41 minor motion estimation cleanup
michael
parents: 1958
diff changeset
4713
1d5abf80fa41 minor motion estimation cleanup
michael
parents: 1958
diff changeset
4714 ff_init_me(s);
1d5abf80fa41 minor motion estimation cleanup
michael
parents: 1958
diff changeset
4715
1799
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4716 /* Estimate motion for every MB */
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4717 if(s->pict_type != I_TYPE){
1955
5dafb10e0252 reuse motion vectors/mb types/field select values of the source video, if the SSE for a macroblock which is predicted with these values is below me_threshold
michael
parents: 1948
diff changeset
4718 if(s->pict_type != B_TYPE && s->avctx->me_threshold==0){
1799
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4719 if((s->avctx->pre_me && s->last_non_b_pict_type==I_TYPE) || s->avctx->pre_me==2){
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4720 s->avctx->execute(s->avctx, pre_estimate_motion_thread, (void**)&(s->thread_context[0]), NULL, s->avctx->thread_count);
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4721 }
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4722 }
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4723
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4724 s->avctx->execute(s->avctx, estimate_motion_thread, (void**)&(s->thread_context[0]), NULL, s->avctx->thread_count);
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4725 }else /* if(s->pict_type == I_TYPE) */{
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4726 /* I-Frame */
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4727 for(i=0; i<s->mb_stride*s->mb_height; i++)
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4728 s->mb_type[i]= CANDIDATE_MB_TYPE_INTRA;
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4729
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4730 if(!s->fixed_qscale){
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4731 /* finding spatial complexity for I-frame rate control */
1804
cc0a15943a87 multithreaded spatial complexity calculation for i frames
michael
parents: 1803
diff changeset
4732 s->avctx->execute(s->avctx, mb_var_thread, (void**)&(s->thread_context[0]), NULL, s->avctx->thread_count);
1799
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4733 }
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4734 }
1804
cc0a15943a87 multithreaded spatial complexity calculation for i frames
michael
parents: 1803
diff changeset
4735 for(i=1; i<s->avctx->thread_count; i++){
cc0a15943a87 multithreaded spatial complexity calculation for i frames
michael
parents: 1803
diff changeset
4736 merge_context_after_me(s, s->thread_context[i]);
cc0a15943a87 multithreaded spatial complexity calculation for i frames
michael
parents: 1803
diff changeset
4737 }
2015
3ab8f3e2ae6a moving motion estimation specific variables from MpegEncContext -> MotionEstContext
michael
parents: 1994
diff changeset
4738 s->current_picture.mc_mb_var_sum= s->current_picture_ptr->mc_mb_var_sum= s->me.mc_mb_var_sum_temp;
3ab8f3e2ae6a moving motion estimation specific variables from MpegEncContext -> MotionEstContext
michael
parents: 1994
diff changeset
4739 s->current_picture. mb_var_sum= s->current_picture_ptr-> mb_var_sum= s->me. mb_var_sum_temp;
1799
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4740 emms_c();
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4741
2015
3ab8f3e2ae6a moving motion estimation specific variables from MpegEncContext -> MotionEstContext
michael
parents: 1994
diff changeset
4742 if(s->me.scene_change_score > s->avctx->scenechange_threshold && s->pict_type == P_TYPE){
1799
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4743 s->pict_type= I_TYPE;
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4744 for(i=0; i<s->mb_stride*s->mb_height; i++)
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4745 s->mb_type[i]= CANDIDATE_MB_TYPE_INTRA;
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4746 //printf("Scene change detected, encoding as I Frame %d %d\n", s->current_picture.mb_var_sum, s->current_picture.mc_mb_var_sum);
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4747 }
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4748
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4749 if(!s->umvplus){
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4750 if(s->pict_type==P_TYPE || s->pict_type==S_TYPE) {
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4751 s->f_code= ff_get_best_fcode(s, s->p_mv_table, CANDIDATE_MB_TYPE_INTER);
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4752
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4753 if(s->flags & CODEC_FLAG_INTERLACED_ME){
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4754 int a,b;
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4755 a= ff_get_best_fcode(s, s->p_field_mv_table[0][0], CANDIDATE_MB_TYPE_INTER_I); //FIXME field_select
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4756 b= ff_get_best_fcode(s, s->p_field_mv_table[1][1], CANDIDATE_MB_TYPE_INTER_I);
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4757 s->f_code= FFMAX(s->f_code, FFMAX(a,b));
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4758 }
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4759
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4760 ff_fix_long_p_mvs(s);
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4761 ff_fix_long_mvs(s, NULL, 0, s->p_mv_table, s->f_code, CANDIDATE_MB_TYPE_INTER, 0);
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4762 if(s->flags & CODEC_FLAG_INTERLACED_ME){
2024
f65d87bfdd5a some of the warning fixes by (Michael Roitzsch <mroi at users dot sourceforge dot net>)
michael
parents: 2015
diff changeset
4763 int j;
1799
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4764 for(i=0; i<2; i++){
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4765 for(j=0; j<2; j++)
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4766 ff_fix_long_mvs(s, s->p_field_select_table[i], j,
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4767 s->p_field_mv_table[i][j], s->f_code, CANDIDATE_MB_TYPE_INTER_I, 0);
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4768 }
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4769 }
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4770 }
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4771
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4772 if(s->pict_type==B_TYPE){
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4773 int a, b;
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4774
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4775 a = ff_get_best_fcode(s, s->b_forw_mv_table, CANDIDATE_MB_TYPE_FORWARD);
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4776 b = ff_get_best_fcode(s, s->b_bidir_forw_mv_table, CANDIDATE_MB_TYPE_BIDIR);
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4777 s->f_code = FFMAX(a, b);
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4778
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4779 a = ff_get_best_fcode(s, s->b_back_mv_table, CANDIDATE_MB_TYPE_BACKWARD);
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4780 b = ff_get_best_fcode(s, s->b_bidir_back_mv_table, CANDIDATE_MB_TYPE_BIDIR);
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4781 s->b_code = FFMAX(a, b);
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4782
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4783 ff_fix_long_mvs(s, NULL, 0, s->b_forw_mv_table, s->f_code, CANDIDATE_MB_TYPE_FORWARD, 1);
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4784 ff_fix_long_mvs(s, NULL, 0, s->b_back_mv_table, s->b_code, CANDIDATE_MB_TYPE_BACKWARD, 1);
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4785 ff_fix_long_mvs(s, NULL, 0, s->b_bidir_forw_mv_table, s->f_code, CANDIDATE_MB_TYPE_BIDIR, 1);
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4786 ff_fix_long_mvs(s, NULL, 0, s->b_bidir_back_mv_table, s->b_code, CANDIDATE_MB_TYPE_BIDIR, 1);
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4787 if(s->flags & CODEC_FLAG_INTERLACED_ME){
2024
f65d87bfdd5a some of the warning fixes by (Michael Roitzsch <mroi at users dot sourceforge dot net>)
michael
parents: 2015
diff changeset
4788 int dir, j;
1799
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4789 for(dir=0; dir<2; dir++){
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4790 for(i=0; i<2; i++){
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4791 for(j=0; j<2; j++){
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4792 int type= dir ? (CANDIDATE_MB_TYPE_BACKWARD_I|CANDIDATE_MB_TYPE_BIDIR_I)
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4793 : (CANDIDATE_MB_TYPE_FORWARD_I |CANDIDATE_MB_TYPE_BIDIR_I);
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4794 ff_fix_long_mvs(s, s->b_field_select_table[dir][i], j,
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4795 s->b_field_mv_table[dir][i][j], dir ? s->b_code : s->f_code, type, 1);
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4796 }
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4797 }
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4798 }
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4799 }
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4800 }
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4801 }
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4802
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4803 if (!s->fixed_qscale)
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4804 s->current_picture.quality = ff_rate_estimate_qscale(s); //FIXME pic_ptr
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4805
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4806 if(s->adaptive_quant){
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4807 #ifdef CONFIG_RISKY
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4808 switch(s->codec_id){
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4809 case CODEC_ID_MPEG4:
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4810 ff_clean_mpeg4_qscales(s);
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4811 break;
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4812 case CODEC_ID_H263:
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4813 case CODEC_ID_H263P:
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4814 case CODEC_ID_FLV1:
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4815 ff_clean_h263_qscales(s);
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4816 break;
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4817 }
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4818 #endif
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4819
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4820 s->lambda= s->lambda_table[0];
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4821 //FIXME broken
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4822 }else
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4823 s->lambda= s->current_picture.quality;
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4824 //printf("%d %d\n", s->avctx->global_quality, s->current_picture.quality);
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4825 update_qscale(s);
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4826
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4827 if(s->qscale < 3 && s->max_qcoeff<=128 && s->pict_type==I_TYPE && !(s->flags & CODEC_FLAG_QSCALE))
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4828 s->qscale= 3; //reduce cliping problems
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4829
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4830 if (s->out_format == FMT_MJPEG) {
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4831 /* for mjpeg, we do include qscale in the matrix */
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4832 s->intra_matrix[0] = ff_mpeg1_default_intra_matrix[0];
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4833 for(i=1;i<64;i++){
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4834 int j= s->dsp.idct_permutation[i];
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4835
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4836 s->intra_matrix[j] = CLAMP_TO_8BIT((ff_mpeg1_default_intra_matrix[i] * s->qscale) >> 3);
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4837 }
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4838 convert_matrix(&s->dsp, s->q_intra_matrix, s->q_intra_matrix16,
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4839 s->intra_matrix, s->intra_quant_bias, 8, 8);
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4840 s->qscale= 8;
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4841 }
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4842
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4843 //FIXME var duplication
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4844 s->current_picture.key_frame= s->pict_type == I_TYPE; //FIXME pic_ptr
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4845 s->current_picture.pict_type= s->pict_type;
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4846
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4847 if(s->current_picture.key_frame)
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4848 s->picture_in_gop_number=0;
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4849
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4850 s->last_bits= put_bits_count(&s->pb);
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4851 switch(s->out_format) {
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4852 case FMT_MJPEG:
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4853 mjpeg_picture_header(s);
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4854 break;
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4855 #ifdef CONFIG_RISKY
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4856 case FMT_H263:
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4857 if (s->codec_id == CODEC_ID_WMV2)
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4858 ff_wmv2_encode_picture_header(s, picture_number);
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4859 else if (s->h263_msmpeg4)
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4860 msmpeg4_encode_picture_header(s, picture_number);
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4861 else if (s->h263_pred)
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4862 mpeg4_encode_picture_header(s, picture_number);
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4863 else if (s->codec_id == CODEC_ID_RV10)
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4864 rv10_encode_picture_header(s, picture_number);
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4865 else if (s->codec_id == CODEC_ID_FLV1)
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4866 ff_flv_encode_picture_header(s, picture_number);
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4867 else
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4868 h263_encode_picture_header(s, picture_number);
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4869 break;
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4870 #endif
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4871 case FMT_MPEG1:
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4872 mpeg1_encode_picture_header(s, picture_number);
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4873 break;
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4874 case FMT_H264:
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4875 break;
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4876 default:
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4877 assert(0);
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4878 }
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4879 bits= put_bits_count(&s->pb);
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4880 s->header_bits= bits - s->last_bits;
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4881
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4882 for(i=1; i<s->avctx->thread_count; i++){
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4883 update_duplicate_context_after_me(s->thread_context[i], s);
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4884 }
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4885 s->avctx->execute(s->avctx, encode_thread, (void**)&(s->thread_context[0]), NULL, s->avctx->thread_count);
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4886 for(i=1; i<s->avctx->thread_count; i++){
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4887 merge_context_after_encode(s, s->thread_context[i]);
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4888 }
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1790
diff changeset
4889 emms_c();
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4890 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
4891
1686
68abbec33289 Here are juste two added #ifdef CONFIG_ENCODERS to allow
michael
parents: 1685
diff changeset
4892 #endif //CONFIG_ENCODERS
68abbec33289 Here are juste two added #ifdef CONFIG_ENCODERS to allow
michael
parents: 1685
diff changeset
4893
1719
4e72fb256b25 denoise_dct_mmx()
michael
parents: 1718
diff changeset
4894 static void denoise_dct_c(MpegEncContext *s, DCTELEM *block){
1597
4c9165372ab3 noise reduction of dct coefficients
michael
parents: 1586
diff changeset
4895 const int intra= s->mb_intra;
4c9165372ab3 noise reduction of dct coefficients
michael
parents: 1586
diff changeset
4896 int i;
4c9165372ab3 noise reduction of dct coefficients
michael
parents: 1586
diff changeset
4897
1599
079239998a38 10l (fixes dct coeff noise reduction)
michael
parents: 1598
diff changeset
4898 s->dct_count[intra]++;
079239998a38 10l (fixes dct coeff noise reduction)
michael
parents: 1598
diff changeset
4899
1597
4c9165372ab3 noise reduction of dct coefficients
michael
parents: 1586
diff changeset
4900 for(i=0; i<64; i++){
4c9165372ab3 noise reduction of dct coefficients
michael
parents: 1586
diff changeset
4901 int level= block[i];
4c9165372ab3 noise reduction of dct coefficients
michael
parents: 1586
diff changeset
4902
4c9165372ab3 noise reduction of dct coefficients
michael
parents: 1586
diff changeset
4903 if(level){
4c9165372ab3 noise reduction of dct coefficients
michael
parents: 1586
diff changeset
4904 if(level>0){
4c9165372ab3 noise reduction of dct coefficients
michael
parents: 1586
diff changeset
4905 s->dct_error_sum[intra][i] += level;
4c9165372ab3 noise reduction of dct coefficients
michael
parents: 1586
diff changeset
4906 level -= s->dct_offset[intra][i];
4c9165372ab3 noise reduction of dct coefficients
michael
parents: 1586
diff changeset
4907 if(level<0) level=0;
4c9165372ab3 noise reduction of dct coefficients
michael
parents: 1586
diff changeset
4908 }else{
4c9165372ab3 noise reduction of dct coefficients
michael
parents: 1586
diff changeset
4909 s->dct_error_sum[intra][i] -= level;
4c9165372ab3 noise reduction of dct coefficients
michael
parents: 1586
diff changeset
4910 level += s->dct_offset[intra][i];
4c9165372ab3 noise reduction of dct coefficients
michael
parents: 1586
diff changeset
4911 if(level>0) level=0;
4c9165372ab3 noise reduction of dct coefficients
michael
parents: 1586
diff changeset
4912 }
4c9165372ab3 noise reduction of dct coefficients
michael
parents: 1586
diff changeset
4913 block[i]= level;
4c9165372ab3 noise reduction of dct coefficients
michael
parents: 1586
diff changeset
4914 }
4c9165372ab3 noise reduction of dct coefficients
michael
parents: 1586
diff changeset
4915 }
4c9165372ab3 noise reduction of dct coefficients
michael
parents: 1586
diff changeset
4916 }
4c9165372ab3 noise reduction of dct coefficients
michael
parents: 1586
diff changeset
4917
1686
68abbec33289 Here are juste two added #ifdef CONFIG_ENCODERS to allow
michael
parents: 1685
diff changeset
4918 #ifdef CONFIG_ENCODERS
68abbec33289 Here are juste two added #ifdef CONFIG_ENCODERS to allow
michael
parents: 1685
diff changeset
4919
945
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
4920 static int dct_quantize_trellis_c(MpegEncContext *s,
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
4921 DCTELEM *block, int n,
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
4922 int qscale, int *overflow){
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
4923 const int *qmat;
1064
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1059
diff changeset
4924 const uint8_t *scantable= s->intra_scantable.scantable;
1718
fdd1bc71da55 more trellis quant optimizations
michael
parents: 1716
diff changeset
4925 const uint8_t *perm_scantable= s->intra_scantable.permutated;
945
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
4926 int max=0;
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
4927 unsigned int threshold1, threshold2;
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
4928 int bias=0;
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
4929 int run_tab[65];
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
4930 int level_tab[65];
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
4931 int score_tab[65];
1718
fdd1bc71da55 more trellis quant optimizations
michael
parents: 1716
diff changeset
4932 int survivor[65];
fdd1bc71da55 more trellis quant optimizations
michael
parents: 1716
diff changeset
4933 int survivor_count;
946
4f522c9e6099 more optimized trellis quantizer
michaelni
parents: 945
diff changeset
4934 int last_run=0;
4f522c9e6099 more optimized trellis quantizer
michaelni
parents: 945
diff changeset
4935 int last_level=0;
4f522c9e6099 more optimized trellis quantizer
michaelni
parents: 945
diff changeset
4936 int last_score= 0;
1718
fdd1bc71da55 more trellis quant optimizations
michael
parents: 1716
diff changeset
4937 int last_i;
1715
88a2c6cc45f4 optimizing (trellis) quantizer
michael
parents: 1712
diff changeset
4938 int coeff[2][64];
945
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
4939 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
4940 int qmul, qadd, start_i, last_non_zero, i, dc;
945
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
4941 const int esc_length= s->ac_esc_length;
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
4942 uint8_t * length;
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
4943 uint8_t * last_length;
1505
010f76d07a27 use lagrange multipler instead of qp for ratecontrol, this may break some things, tell me ASAP if u notice anything broken
michaelni
parents: 1497
diff changeset
4944 const int lambda= s->lambda2 >> (FF_LAMBDA_SHIFT - 6);
945
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
4945
1092
f59c3f66363b MpegEncContext.(i)dct_* -> DspContext.(i)dct_*
michaelni
parents: 1089
diff changeset
4946 s->dsp.fdct (block);
1597
4c9165372ab3 noise reduction of dct coefficients
michael
parents: 1586
diff changeset
4947
4c9165372ab3 noise reduction of dct coefficients
michael
parents: 1586
diff changeset
4948 if(s->dct_error_sum)
1719
4e72fb256b25 denoise_dct_mmx()
michael
parents: 1718
diff changeset
4949 s->denoise_dct(s, block);
945
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
4950 qmul= qscale*16;
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
4951 qadd= ((qscale-1)|1)*8;
946
4f522c9e6099 more optimized trellis quantizer
michaelni
parents: 945
diff changeset
4952
945
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
4953 if (s->mb_intra) {
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
4954 int q;
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
4955 if (!s->h263_aic) {
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
4956 if (n < 4)
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
4957 q = s->y_dc_scale;
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
4958 else
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
4959 q = s->c_dc_scale;
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
4960 q = q << 3;
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
4961 } else{
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
4962 /* For AIC we skip quant/dequant of INTRADC */
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
4963 q = 1 << 3;
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
4964 qadd=0;
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
4965 }
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
4966
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
4967 /* note: block[0] is assumed to be positive */
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
4968 block[0] = (block[0] + (q >> 1)) / q;
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
4969 start_i = 1;
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
4970 last_non_zero = 0;
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
4971 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
4972 if(s->mpeg_quant || s->out_format == FMT_MPEG1)
945
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
4973 bias= 1<<(QMAT_SHIFT-1);
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
4974 length = s->intra_ac_vlc_length;
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
4975 last_length= s->intra_ac_vlc_last_length;
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
4976 } else {
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
4977 start_i = 0;
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
4978 last_non_zero = -1;
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
4979 qmat = s->q_inter_matrix[qscale];
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
4980 length = s->inter_ac_vlc_length;
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
4981 last_length= s->inter_ac_vlc_last_length;
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
4982 }
1718
fdd1bc71da55 more trellis quant optimizations
michael
parents: 1716
diff changeset
4983 last_i= start_i;
945
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
4984
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
4985 threshold1= (1<<QMAT_SHIFT) - bias - 1;
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
4986 threshold2= (threshold1<<1);
946
4f522c9e6099 more optimized trellis quantizer
michaelni
parents: 945
diff changeset
4987
1715
88a2c6cc45f4 optimizing (trellis) quantizer
michael
parents: 1712
diff changeset
4988 for(i=63; i>=start_i; i--) {
88a2c6cc45f4 optimizing (trellis) quantizer
michael
parents: 1712
diff changeset
4989 const int j = scantable[i];
88a2c6cc45f4 optimizing (trellis) quantizer
michael
parents: 1712
diff changeset
4990 int level = block[j] * qmat[j];
88a2c6cc45f4 optimizing (trellis) quantizer
michael
parents: 1712
diff changeset
4991
88a2c6cc45f4 optimizing (trellis) quantizer
michael
parents: 1712
diff changeset
4992 if(((unsigned)(level+threshold1))>threshold2){
88a2c6cc45f4 optimizing (trellis) quantizer
michael
parents: 1712
diff changeset
4993 last_non_zero = i;
88a2c6cc45f4 optimizing (trellis) quantizer
michael
parents: 1712
diff changeset
4994 break;
88a2c6cc45f4 optimizing (trellis) quantizer
michael
parents: 1712
diff changeset
4995 }
88a2c6cc45f4 optimizing (trellis) quantizer
michael
parents: 1712
diff changeset
4996 }
88a2c6cc45f4 optimizing (trellis) quantizer
michael
parents: 1712
diff changeset
4997
88a2c6cc45f4 optimizing (trellis) quantizer
michael
parents: 1712
diff changeset
4998 for(i=start_i; i<=last_non_zero; i++) {
945
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
4999 const int j = scantable[i];
1715
88a2c6cc45f4 optimizing (trellis) quantizer
michael
parents: 1712
diff changeset
5000 int level = block[j] * qmat[j];
945
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
5001
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
5002 // if( bias+level >= (1<<(QMAT_SHIFT - 3))
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
5003 // || bias-level >= (1<<(QMAT_SHIFT - 3))){
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
5004 if(((unsigned)(level+threshold1))>threshold2){
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
5005 if(level>0){
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
5006 level= (bias + level)>>QMAT_SHIFT;
1718
fdd1bc71da55 more trellis quant optimizations
michael
parents: 1716
diff changeset
5007 coeff[0][i]= level;
fdd1bc71da55 more trellis quant optimizations
michael
parents: 1716
diff changeset
5008 coeff[1][i]= level-1;
946
4f522c9e6099 more optimized trellis quantizer
michaelni
parents: 945
diff changeset
5009 // coeff[2][k]= level-2;
945
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
5010 }else{
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
5011 level= (bias - level)>>QMAT_SHIFT;
1718
fdd1bc71da55 more trellis quant optimizations
michael
parents: 1716
diff changeset
5012 coeff[0][i]= -level;
fdd1bc71da55 more trellis quant optimizations
michael
parents: 1716
diff changeset
5013 coeff[1][i]= -level+1;
946
4f522c9e6099 more optimized trellis quantizer
michaelni
parents: 945
diff changeset
5014 // coeff[2][k]= -level+2;
945
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
5015 }
1718
fdd1bc71da55 more trellis quant optimizations
michael
parents: 1716
diff changeset
5016 coeff_count[i]= FFMIN(level, 2);
fdd1bc71da55 more trellis quant optimizations
michael
parents: 1716
diff changeset
5017 assert(coeff_count[i]);
945
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
5018 max |=level;
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
5019 }else{
1718
fdd1bc71da55 more trellis quant optimizations
michael
parents: 1716
diff changeset
5020 coeff[0][i]= (level>>31)|1;
fdd1bc71da55 more trellis quant optimizations
michael
parents: 1716
diff changeset
5021 coeff_count[i]= 1;
945
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
5022 }
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
5023 }
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
5024
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
5025 *overflow= s->max_qcoeff < max; //overflow might have happend
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
5026
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
5027 if(last_non_zero < start_i){
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
5028 memset(block + start_i, 0, (64-start_i)*sizeof(DCTELEM));
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
5029 return last_non_zero;
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
5030 }
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
5031
1718
fdd1bc71da55 more trellis quant optimizations
michael
parents: 1716
diff changeset
5032 score_tab[start_i]= 0;
fdd1bc71da55 more trellis quant optimizations
michael
parents: 1716
diff changeset
5033 survivor[0]= start_i;
fdd1bc71da55 more trellis quant optimizations
michael
parents: 1716
diff changeset
5034 survivor_count= 1;
1505
010f76d07a27 use lagrange multipler instead of qp for ratecontrol, this may break some things, tell me ASAP if u notice anything broken
michaelni
parents: 1497
diff changeset
5035
1718
fdd1bc71da55 more trellis quant optimizations
michael
parents: 1716
diff changeset
5036 for(i=start_i; i<=last_non_zero; i++){
fdd1bc71da55 more trellis quant optimizations
michael
parents: 1716
diff changeset
5037 int level_index, j;
fdd1bc71da55 more trellis quant optimizations
michael
parents: 1716
diff changeset
5038 const int dct_coeff= ABS(block[ scantable[i] ]);
945
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
5039 const int zero_distoration= dct_coeff*dct_coeff;
946
4f522c9e6099 more optimized trellis quantizer
michaelni
parents: 945
diff changeset
5040 int best_score=256*256*256*120;
945
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
5041 for(level_index=0; level_index < coeff_count[i]; level_index++){
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
5042 int distoration;
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
5043 int level= coeff[level_index][i];
1716
da5d64a0fa02 cleanup
michael
parents: 1715
diff changeset
5044 const int alevel= ABS(level);
945
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
5045 int unquant_coeff;
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
5046
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
5047 assert(level);
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
5048
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
5049 if(s->out_format == FMT_H263){
1716
da5d64a0fa02 cleanup
michael
parents: 1715
diff changeset
5050 unquant_coeff= alevel*qmul + qadd;
947
9be53be2d1a9 trellis quantization for mpeg1
michaelni
parents: 946
diff changeset
5051 }else{ //MPEG1
1718
fdd1bc71da55 more trellis quant optimizations
michael
parents: 1716
diff changeset
5052 j= s->dsp.idct_permutation[ scantable[i] ]; //FIXME optimize
947
9be53be2d1a9 trellis quantization for mpeg1
michaelni
parents: 946
diff changeset
5053 if(s->mb_intra){
1716
da5d64a0fa02 cleanup
michael
parents: 1715
diff changeset
5054 unquant_coeff = (int)( alevel * qscale * s->intra_matrix[j]) >> 3;
947
9be53be2d1a9 trellis quantization for mpeg1
michaelni
parents: 946
diff changeset
5055 unquant_coeff = (unquant_coeff - 1) | 1;
9be53be2d1a9 trellis quantization for mpeg1
michaelni
parents: 946
diff changeset
5056 }else{
1716
da5d64a0fa02 cleanup
michael
parents: 1715
diff changeset
5057 unquant_coeff = ((( alevel << 1) + 1) * qscale * ((int) s->inter_matrix[j])) >> 4;
947
9be53be2d1a9 trellis quantization for mpeg1
michaelni
parents: 946
diff changeset
5058 unquant_coeff = (unquant_coeff - 1) | 1;
9be53be2d1a9 trellis quantization for mpeg1
michaelni
parents: 946
diff changeset
5059 }
9be53be2d1a9 trellis quantization for mpeg1
michaelni
parents: 946
diff changeset
5060 unquant_coeff<<= 3;
9be53be2d1a9 trellis quantization for mpeg1
michaelni
parents: 946
diff changeset
5061 }
946
4f522c9e6099 more optimized trellis quantizer
michaelni
parents: 945
diff changeset
5062
1715
88a2c6cc45f4 optimizing (trellis) quantizer
michael
parents: 1712
diff changeset
5063 distoration= (unquant_coeff - dct_coeff) * (unquant_coeff - dct_coeff) - zero_distoration;
945
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
5064 level+=64;
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
5065 if((level&(~127)) == 0){
1718
fdd1bc71da55 more trellis quant optimizations
michael
parents: 1716
diff changeset
5066 for(j=survivor_count-1; j>=0; j--){
fdd1bc71da55 more trellis quant optimizations
michael
parents: 1716
diff changeset
5067 int run= i - survivor[j];
947
9be53be2d1a9 trellis quantization for mpeg1
michaelni
parents: 946
diff changeset
5068 int score= distoration + length[UNI_AC_ENC_INDEX(run, level)]*lambda;
945
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
5069 score += score_tab[i-run];
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
5070
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
5071 if(score < best_score){
1718
fdd1bc71da55 more trellis quant optimizations
michael
parents: 1716
diff changeset
5072 best_score= score;
945
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
5073 run_tab[i+1]= run;
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
5074 level_tab[i+1]= level-64;
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
5075 }
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
5076 }
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
5077
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
5078 if(s->out_format == FMT_H263){
1718
fdd1bc71da55 more trellis quant optimizations
michael
parents: 1716
diff changeset
5079 for(j=survivor_count-1; j>=0; j--){
fdd1bc71da55 more trellis quant optimizations
michael
parents: 1716
diff changeset
5080 int run= i - survivor[j];
947
9be53be2d1a9 trellis quantization for mpeg1
michaelni
parents: 946
diff changeset
5081 int score= distoration + last_length[UNI_AC_ENC_INDEX(run, level)]*lambda;
945
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
5082 score += score_tab[i-run];
946
4f522c9e6099 more optimized trellis quantizer
michaelni
parents: 945
diff changeset
5083 if(score < last_score){
4f522c9e6099 more optimized trellis quantizer
michaelni
parents: 945
diff changeset
5084 last_score= score;
4f522c9e6099 more optimized trellis quantizer
michaelni
parents: 945
diff changeset
5085 last_run= run;
4f522c9e6099 more optimized trellis quantizer
michaelni
parents: 945
diff changeset
5086 last_level= level-64;
4f522c9e6099 more optimized trellis quantizer
michaelni
parents: 945
diff changeset
5087 last_i= i+1;
945
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
5088 }
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
5089 }
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
5090 }
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
5091 }else{
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
5092 distoration += esc_length*lambda;
1718
fdd1bc71da55 more trellis quant optimizations
michael
parents: 1716
diff changeset
5093 for(j=survivor_count-1; j>=0; j--){
fdd1bc71da55 more trellis quant optimizations
michael
parents: 1716
diff changeset
5094 int run= i - survivor[j];
945
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
5095 int score= distoration + score_tab[i-run];
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
5096
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
5097 if(score < best_score){
1718
fdd1bc71da55 more trellis quant optimizations
michael
parents: 1716
diff changeset
5098 best_score= score;
945
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
5099 run_tab[i+1]= run;
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
5100 level_tab[i+1]= level-64;
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
5101 }
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
5102 }
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
5103
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
5104 if(s->out_format == FMT_H263){
1718
fdd1bc71da55 more trellis quant optimizations
michael
parents: 1716
diff changeset
5105 for(j=survivor_count-1; j>=0; j--){
fdd1bc71da55 more trellis quant optimizations
michael
parents: 1716
diff changeset
5106 int run= i - survivor[j];
945
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
5107 int score= distoration + score_tab[i-run];
946
4f522c9e6099 more optimized trellis quantizer
michaelni
parents: 945
diff changeset
5108 if(score < last_score){
4f522c9e6099 more optimized trellis quantizer
michaelni
parents: 945
diff changeset
5109 last_score= score;
4f522c9e6099 more optimized trellis quantizer
michaelni
parents: 945
diff changeset
5110 last_run= run;
4f522c9e6099 more optimized trellis quantizer
michaelni
parents: 945
diff changeset
5111 last_level= level-64;
4f522c9e6099 more optimized trellis quantizer
michaelni
parents: 945
diff changeset
5112 last_i= i+1;
945
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
5113 }
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
5114 }
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
5115 }
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
5116 }
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
5117 }
946
4f522c9e6099 more optimized trellis quantizer
michaelni
parents: 945
diff changeset
5118
1718
fdd1bc71da55 more trellis quant optimizations
michael
parents: 1716
diff changeset
5119 score_tab[i+1]= best_score;
fdd1bc71da55 more trellis quant optimizations
michael
parents: 1716
diff changeset
5120
946
4f522c9e6099 more optimized trellis quantizer
michaelni
parents: 945
diff changeset
5121 //Note: there is a vlc code in mpeg4 which is 1 bit shorter then another one with a shorter run and the same level
1718
fdd1bc71da55 more trellis quant optimizations
michael
parents: 1716
diff changeset
5122 if(last_non_zero <= 27){
fdd1bc71da55 more trellis quant optimizations
michael
parents: 1716
diff changeset
5123 for(; survivor_count; survivor_count--){
fdd1bc71da55 more trellis quant optimizations
michael
parents: 1716
diff changeset
5124 if(score_tab[ survivor[survivor_count-1] ] <= best_score)
fdd1bc71da55 more trellis quant optimizations
michael
parents: 1716
diff changeset
5125 break;
fdd1bc71da55 more trellis quant optimizations
michael
parents: 1716
diff changeset
5126 }
fdd1bc71da55 more trellis quant optimizations
michael
parents: 1716
diff changeset
5127 }else{
fdd1bc71da55 more trellis quant optimizations
michael
parents: 1716
diff changeset
5128 for(; survivor_count; survivor_count--){
fdd1bc71da55 more trellis quant optimizations
michael
parents: 1716
diff changeset
5129 if(score_tab[ survivor[survivor_count-1] ] <= best_score + lambda)
fdd1bc71da55 more trellis quant optimizations
michael
parents: 1716
diff changeset
5130 break;
fdd1bc71da55 more trellis quant optimizations
michael
parents: 1716
diff changeset
5131 }
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
5132 }
1718
fdd1bc71da55 more trellis quant optimizations
michael
parents: 1716
diff changeset
5133
fdd1bc71da55 more trellis quant optimizations
michael
parents: 1716
diff changeset
5134 survivor[ survivor_count++ ]= i+1;
945
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
5135 }
946
4f522c9e6099 more optimized trellis quantizer
michaelni
parents: 945
diff changeset
5136
945
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
5137 if(s->out_format != FMT_H263){
946
4f522c9e6099 more optimized trellis quantizer
michaelni
parents: 945
diff changeset
5138 last_score= 256*256*256*120;
1718
fdd1bc71da55 more trellis quant optimizations
michael
parents: 1716
diff changeset
5139 for(i= survivor[0]; i<=last_non_zero + 1; i++){
946
4f522c9e6099 more optimized trellis quantizer
michaelni
parents: 945
diff changeset
5140 int score= score_tab[i];
947
9be53be2d1a9 trellis quantization for mpeg1
michaelni
parents: 946
diff changeset
5141 if(i) score += lambda*2; //FIXME exacter?
9be53be2d1a9 trellis quantization for mpeg1
michaelni
parents: 946
diff changeset
5142
946
4f522c9e6099 more optimized trellis quantizer
michaelni
parents: 945
diff changeset
5143 if(score < last_score){
4f522c9e6099 more optimized trellis quantizer
michaelni
parents: 945
diff changeset
5144 last_score= score;
4f522c9e6099 more optimized trellis quantizer
michaelni
parents: 945
diff changeset
5145 last_i= i;
4f522c9e6099 more optimized trellis quantizer
michaelni
parents: 945
diff changeset
5146 last_level= level_tab[i];
4f522c9e6099 more optimized trellis quantizer
michaelni
parents: 945
diff changeset
5147 last_run= run_tab[i];
4f522c9e6099 more optimized trellis quantizer
michaelni
parents: 945
diff changeset
5148 }
945
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
5149 }
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
5150 }
1490
0355f2b3519a rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents: 1480
diff changeset
5151
1715
88a2c6cc45f4 optimizing (trellis) quantizer
michael
parents: 1712
diff changeset
5152 s->coded_score[n] = last_score;
945
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
5153
1716
da5d64a0fa02 cleanup
michael
parents: 1715
diff changeset
5154 dc= ABS(block[0]);
1718
fdd1bc71da55 more trellis quant optimizations
michael
parents: 1716
diff changeset
5155 last_non_zero= last_i - 1;
945
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
5156 memset(block + start_i, 0, (64-start_i)*sizeof(DCTELEM));
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
5157
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
5158 if(last_non_zero < start_i)
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
5159 return last_non_zero;
1490
0355f2b3519a rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents: 1480
diff changeset
5160
1480
8657d6800d15 slight quality improvement ( < +0.04 PSNR) for high bitrate videos with trellis quantization
michaelni
parents: 1471
diff changeset
5161 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
5162 int best_level= 0;
8657d6800d15 slight quality improvement ( < +0.04 PSNR) for high bitrate videos with trellis quantization
michaelni
parents: 1471
diff changeset
5163 int best_score= dc * dc;
1490
0355f2b3519a rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents: 1480
diff changeset
5164
1480
8657d6800d15 slight quality improvement ( < +0.04 PSNR) for high bitrate videos with trellis quantization
michaelni
parents: 1471
diff changeset
5165 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
5166 int level= coeff[i][0];
1716
da5d64a0fa02 cleanup
michael
parents: 1715
diff changeset
5167 int alevel= ABS(level);
da5d64a0fa02 cleanup
michael
parents: 1715
diff changeset
5168 int unquant_coeff, score, distortion;
1480
8657d6800d15 slight quality improvement ( < +0.04 PSNR) for high bitrate videos with trellis quantization
michaelni
parents: 1471
diff changeset
5169
8657d6800d15 slight quality improvement ( < +0.04 PSNR) for high bitrate videos with trellis quantization
michaelni
parents: 1471
diff changeset
5170 if(s->out_format == FMT_H263){
1716
da5d64a0fa02 cleanup
michael
parents: 1715
diff changeset
5171 unquant_coeff= (alevel*qmul + qadd)>>3;
1480
8657d6800d15 slight quality improvement ( < +0.04 PSNR) for high bitrate videos with trellis quantization
michaelni
parents: 1471
diff changeset
5172 }else{ //MPEG1
1716
da5d64a0fa02 cleanup
michael
parents: 1715
diff changeset
5173 unquant_coeff = ((( alevel << 1) + 1) * qscale * ((int) s->inter_matrix[0])) >> 4;
da5d64a0fa02 cleanup
michael
parents: 1715
diff changeset
5174 unquant_coeff = (unquant_coeff - 1) | 1;
1480
8657d6800d15 slight quality improvement ( < +0.04 PSNR) for high bitrate videos with trellis quantization
michaelni
parents: 1471
diff changeset
5175 }
8657d6800d15 slight quality improvement ( < +0.04 PSNR) for high bitrate videos with trellis quantization
michaelni
parents: 1471
diff changeset
5176 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
5177 unquant_coeff<<= 3 + 3;
8657d6800d15 slight quality improvement ( < +0.04 PSNR) for high bitrate videos with trellis quantization
michaelni
parents: 1471
diff changeset
5178
1716
da5d64a0fa02 cleanup
michael
parents: 1715
diff changeset
5179 distortion= (unquant_coeff - dc) * (unquant_coeff - dc);
1490
0355f2b3519a rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents: 1480
diff changeset
5180 level+=64;
1716
da5d64a0fa02 cleanup
michael
parents: 1715
diff changeset
5181 if((level&(~127)) == 0) score= distortion + last_length[UNI_AC_ENC_INDEX(0, level)]*lambda;
da5d64a0fa02 cleanup
michael
parents: 1715
diff changeset
5182 else score= distortion + esc_length*lambda;
1490
0355f2b3519a rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents: 1480
diff changeset
5183
1480
8657d6800d15 slight quality improvement ( < +0.04 PSNR) for high bitrate videos with trellis quantization
michaelni
parents: 1471
diff changeset
5184 if(score < best_score){
8657d6800d15 slight quality improvement ( < +0.04 PSNR) for high bitrate videos with trellis quantization
michaelni
parents: 1471
diff changeset
5185 best_score= score;
1490
0355f2b3519a rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents: 1480
diff changeset
5186 best_level= level - 64;
1480
8657d6800d15 slight quality improvement ( < +0.04 PSNR) for high bitrate videos with trellis quantization
michaelni
parents: 1471
diff changeset
5187 }
8657d6800d15 slight quality improvement ( < +0.04 PSNR) for high bitrate videos with trellis quantization
michaelni
parents: 1471
diff changeset
5188 }
8657d6800d15 slight quality improvement ( < +0.04 PSNR) for high bitrate videos with trellis quantization
michaelni
parents: 1471
diff changeset
5189 block[0]= best_level;
1490
0355f2b3519a rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents: 1480
diff changeset
5190 s->coded_score[n] = best_score - dc*dc;
0355f2b3519a rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents: 1480
diff changeset
5191 if(best_level == 0) return -1;
0355f2b3519a rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents: 1480
diff changeset
5192 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
5193 }
1490
0355f2b3519a rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents: 1480
diff changeset
5194
946
4f522c9e6099 more optimized trellis quantizer
michaelni
parents: 945
diff changeset
5195 i= last_i;
4f522c9e6099 more optimized trellis quantizer
michaelni
parents: 945
diff changeset
5196 assert(last_level);
1718
fdd1bc71da55 more trellis quant optimizations
michael
parents: 1716
diff changeset
5197
fdd1bc71da55 more trellis quant optimizations
michael
parents: 1716
diff changeset
5198 block[ perm_scantable[last_non_zero] ]= last_level;
946
4f522c9e6099 more optimized trellis quantizer
michaelni
parents: 945
diff changeset
5199 i -= last_run + 1;
945
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
5200
1718
fdd1bc71da55 more trellis quant optimizations
michael
parents: 1716
diff changeset
5201 for(; i>start_i; i -= run_tab[i] + 1){
fdd1bc71da55 more trellis quant optimizations
michael
parents: 1716
diff changeset
5202 block[ perm_scantable[i-1] ]= level_tab[i];
945
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
5203 }
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
5204
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
5205 return last_non_zero;
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
5206 }
463f7260b155 trellis quantization
michaelni
parents: 936
diff changeset
5207
1777
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5208 //#define REFINE_STATS 1
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5209 static int16_t basis[64][64];
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5210
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5211 static void build_basis(uint8_t *perm){
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5212 int i, j, x, y;
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5213 emms_c();
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5214 for(i=0; i<8; i++){
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5215 for(j=0; j<8; j++){
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5216 for(y=0; y<8; y++){
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5217 for(x=0; x<8; x++){
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5218 double s= 0.25*(1<<BASIS_SHIFT);
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5219 int index= 8*i + j;
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5220 int perm_index= perm[index];
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5221 if(i==0) s*= sqrt(0.5);
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5222 if(j==0) s*= sqrt(0.5);
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5223 basis[perm_index][8*x + y]= lrintf(s * cos((M_PI/8.0)*i*(x+0.5)) * cos((M_PI/8.0)*j*(y+0.5)));
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5224 }
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5225 }
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5226 }
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5227 }
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5228 }
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5229
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5230 static int dct_quantize_refine(MpegEncContext *s, //FIXME breaks denoise?
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5231 DCTELEM *block, int16_t *weight, DCTELEM *orig,
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5232 int n, int qscale){
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5233 int16_t rem[64];
1785
14d918d0ef42 analyze the gradient of the error surface to avoid a few checks in the quantizing noise shaper
michael
parents: 1784
diff changeset
5234 DCTELEM d1[64];
1777
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5235 const int *qmat;
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5236 const uint8_t *scantable= s->intra_scantable.scantable;
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5237 const uint8_t *perm_scantable= s->intra_scantable.permutated;
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5238 // unsigned int threshold1, threshold2;
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5239 // int bias=0;
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5240 int run_tab[65];
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5241 int prev_run=0;
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5242 int prev_level=0;
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5243 int qmul, qadd, start_i, last_non_zero, i, dc;
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5244 uint8_t * length;
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5245 uint8_t * last_length;
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5246 int lambda;
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5247 int rle_index, run, q, sum;
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5248 #ifdef REFINE_STATS
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5249 static int count=0;
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5250 static int after_last=0;
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5251 static int to_zero=0;
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5252 static int from_zero=0;
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5253 static int raise=0;
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5254 static int lower=0;
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5255 static int messed_sign=0;
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5256 #endif
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5257
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5258 if(basis[0][0] == 0)
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5259 build_basis(s->dsp.idct_permutation);
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5260
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5261 qmul= qscale*2;
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5262 qadd= (qscale-1)|1;
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5263 if (s->mb_intra) {
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5264 if (!s->h263_aic) {
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5265 if (n < 4)
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5266 q = s->y_dc_scale;
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5267 else
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5268 q = s->c_dc_scale;
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5269 } else{
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5270 /* For AIC we skip quant/dequant of INTRADC */
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5271 q = 1;
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5272 qadd=0;
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5273 }
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5274 q <<= RECON_SHIFT-3;
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5275 /* note: block[0] is assumed to be positive */
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5276 dc= block[0]*q;
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5277 // block[0] = (block[0] + (q >> 1)) / q;
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5278 start_i = 1;
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5279 qmat = s->q_intra_matrix[qscale];
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5280 // if(s->mpeg_quant || s->out_format == FMT_MPEG1)
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5281 // bias= 1<<(QMAT_SHIFT-1);
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5282 length = s->intra_ac_vlc_length;
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5283 last_length= s->intra_ac_vlc_last_length;
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5284 } else {
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5285 dc= 0;
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5286 start_i = 0;
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5287 qmat = s->q_inter_matrix[qscale];
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5288 length = s->inter_ac_vlc_length;
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5289 last_length= s->inter_ac_vlc_last_length;
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5290 }
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5291 last_non_zero = s->block_last_index[n];
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5292
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5293 #ifdef REFINE_STATS
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5294 {START_TIMER
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5295 #endif
1784
65f7bd09f37b quantizer noise shaping optimization
michael
parents: 1778
diff changeset
5296 dc += (1<<(RECON_SHIFT-1));
65f7bd09f37b quantizer noise shaping optimization
michael
parents: 1778
diff changeset
5297 for(i=0; i<64; i++){
65f7bd09f37b quantizer noise shaping optimization
michael
parents: 1778
diff changeset
5298 rem[i]= dc - (orig[i]<<RECON_SHIFT); //FIXME use orig dirrectly insteadof copying to rem[]
1777
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5299 }
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5300 #ifdef REFINE_STATS
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5301 STOP_TIMER("memset rem[]")}
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5302 #endif
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5303 sum=0;
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5304 for(i=0; i<64; i++){
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5305 int one= 36;
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5306 int qns=4;
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5307 int w;
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5308
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5309 w= ABS(weight[i]) + qns*one;
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5310 w= 15 + (48*qns*one + w/2)/w; // 16 .. 63
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5311
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5312 weight[i] = w;
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5313 // w=weight[i] = (63*qns + (w/2)) / w;
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5314
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5315 assert(w>0);
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5316 assert(w<(1<<6));
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5317 sum += w*w;
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5318 }
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5319 lambda= sum*(uint64_t)s->lambda2 >> (FF_LAMBDA_SHIFT - 6 + 6 + 6 + 6);
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5320 #ifdef REFINE_STATS
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5321 {START_TIMER
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5322 #endif
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5323 run=0;
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5324 rle_index=0;
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5325 for(i=start_i; i<=last_non_zero; i++){
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5326 int j= perm_scantable[i];
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5327 const int level= block[j];
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5328 int coeff;
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5329
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5330 if(level){
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5331 if(level<0) coeff= qmul*level - qadd;
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5332 else coeff= qmul*level + qadd;
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5333 run_tab[rle_index++]=run;
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5334 run=0;
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5335
1784
65f7bd09f37b quantizer noise shaping optimization
michael
parents: 1778
diff changeset
5336 s->dsp.add_8x8basis(rem, basis[j], coeff);
1777
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5337 }else{
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5338 run++;
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5339 }
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5340 }
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5341 #ifdef REFINE_STATS
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5342 if(last_non_zero>0){
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5343 STOP_TIMER("init rem[]")
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5344 }
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5345 }
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5346
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5347 {START_TIMER
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5348 #endif
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5349 for(;;){
1784
65f7bd09f37b quantizer noise shaping optimization
michael
parents: 1778
diff changeset
5350 int best_score=s->dsp.try_8x8basis(rem, weight, basis[0], 0);
1777
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5351 int best_coeff=0;
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5352 int best_change=0;
2024
f65d87bfdd5a some of the warning fixes by (Michael Roitzsch <mroi at users dot sourceforge dot net>)
michael
parents: 2015
diff changeset
5353 int run2, best_unquant_change=0, analyze_gradient;
1785
14d918d0ef42 analyze the gradient of the error surface to avoid a few checks in the quantizing noise shaper
michael
parents: 1784
diff changeset
5354 #ifdef REFINE_STATS
14d918d0ef42 analyze the gradient of the error surface to avoid a few checks in the quantizing noise shaper
michael
parents: 1784
diff changeset
5355 {START_TIMER
14d918d0ef42 analyze the gradient of the error surface to avoid a few checks in the quantizing noise shaper
michael
parents: 1784
diff changeset
5356 #endif
14d918d0ef42 analyze the gradient of the error surface to avoid a few checks in the quantizing noise shaper
michael
parents: 1784
diff changeset
5357 analyze_gradient = last_non_zero > 2 || s->avctx->quantizer_noise_shaping >= 3;
14d918d0ef42 analyze the gradient of the error surface to avoid a few checks in the quantizing noise shaper
michael
parents: 1784
diff changeset
5358
14d918d0ef42 analyze the gradient of the error surface to avoid a few checks in the quantizing noise shaper
michael
parents: 1784
diff changeset
5359 if(analyze_gradient){
1777
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5360 #ifdef REFINE_STATS
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5361 {START_TIMER
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5362 #endif
1785
14d918d0ef42 analyze the gradient of the error surface to avoid a few checks in the quantizing noise shaper
michael
parents: 1784
diff changeset
5363 for(i=0; i<64; i++){
14d918d0ef42 analyze the gradient of the error surface to avoid a few checks in the quantizing noise shaper
michael
parents: 1784
diff changeset
5364 int w= weight[i];
14d918d0ef42 analyze the gradient of the error surface to avoid a few checks in the quantizing noise shaper
michael
parents: 1784
diff changeset
5365
14d918d0ef42 analyze the gradient of the error surface to avoid a few checks in the quantizing noise shaper
michael
parents: 1784
diff changeset
5366 d1[i] = (rem[i]*w*w + (1<<(RECON_SHIFT+12-1)))>>(RECON_SHIFT+12);
14d918d0ef42 analyze the gradient of the error surface to avoid a few checks in the quantizing noise shaper
michael
parents: 1784
diff changeset
5367 }
14d918d0ef42 analyze the gradient of the error surface to avoid a few checks in the quantizing noise shaper
michael
parents: 1784
diff changeset
5368 #ifdef REFINE_STATS
14d918d0ef42 analyze the gradient of the error surface to avoid a few checks in the quantizing noise shaper
michael
parents: 1784
diff changeset
5369 STOP_TIMER("rem*w*w")}
14d918d0ef42 analyze the gradient of the error surface to avoid a few checks in the quantizing noise shaper
michael
parents: 1784
diff changeset
5370 {START_TIMER
14d918d0ef42 analyze the gradient of the error surface to avoid a few checks in the quantizing noise shaper
michael
parents: 1784
diff changeset
5371 #endif
14d918d0ef42 analyze the gradient of the error surface to avoid a few checks in the quantizing noise shaper
michael
parents: 1784
diff changeset
5372 s->dsp.fdct(d1);
14d918d0ef42 analyze the gradient of the error surface to avoid a few checks in the quantizing noise shaper
michael
parents: 1784
diff changeset
5373 #ifdef REFINE_STATS
14d918d0ef42 analyze the gradient of the error surface to avoid a few checks in the quantizing noise shaper
michael
parents: 1784
diff changeset
5374 STOP_TIMER("dct")}
14d918d0ef42 analyze the gradient of the error surface to avoid a few checks in the quantizing noise shaper
michael
parents: 1784
diff changeset
5375 #endif
14d918d0ef42 analyze the gradient of the error surface to avoid a few checks in the quantizing noise shaper
michael
parents: 1784
diff changeset
5376 }
14d918d0ef42 analyze the gradient of the error surface to avoid a few checks in the quantizing noise shaper
michael
parents: 1784
diff changeset
5377
1777
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5378 if(start_i){
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5379 const int level= block[0];
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5380 int change, old_coeff;
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5381
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5382 assert(s->mb_intra);
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5383
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5384 old_coeff= q*level;
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5385
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5386 for(change=-1; change<=1; change+=2){
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5387 int new_level= level + change;
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5388 int score, new_coeff;
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5389
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5390 new_coeff= q*new_level;
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5391 if(new_coeff >= 2048 || new_coeff < 0)
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5392 continue;
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5393
1784
65f7bd09f37b quantizer noise shaping optimization
michael
parents: 1778
diff changeset
5394 score= s->dsp.try_8x8basis(rem, weight, basis[0], new_coeff - old_coeff);
1777
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5395 if(score<best_score){
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5396 best_score= score;
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5397 best_coeff= 0;
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5398 best_change= change;
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5399 best_unquant_change= new_coeff - old_coeff;
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5400 }
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5401 }
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5402 }
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5403
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5404 run=0;
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5405 rle_index=0;
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5406 run2= run_tab[rle_index++];
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5407 prev_level=0;
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5408 prev_run=0;
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5409
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5410 for(i=start_i; i<64; i++){
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5411 int j= perm_scantable[i];
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5412 const int level= block[j];
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5413 int change, old_coeff;
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5414
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5415 if(s->avctx->quantizer_noise_shaping < 3 && i > last_non_zero + 1)
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5416 break;
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5417
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5418 if(level){
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5419 if(level<0) old_coeff= qmul*level - qadd;
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5420 else old_coeff= qmul*level + qadd;
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5421 run2= run_tab[rle_index++]; //FIXME ! maybe after last
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5422 }else{
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5423 old_coeff=0;
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5424 run2--;
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5425 assert(run2>=0 || i >= last_non_zero );
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5426 }
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5427
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5428 for(change=-1; change<=1; change+=2){
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5429 int new_level= level + change;
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5430 int score, new_coeff, unquant_change;
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5431
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5432 score=0;
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5433 if(s->avctx->quantizer_noise_shaping < 2 && ABS(new_level) > ABS(level))
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5434 continue;
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5435
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5436 if(new_level){
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5437 if(new_level<0) new_coeff= qmul*new_level - qadd;
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5438 else new_coeff= qmul*new_level + qadd;
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5439 if(new_coeff >= 2048 || new_coeff <= -2048)
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5440 continue;
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5441 //FIXME check for overflow
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5442
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5443 if(level){
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5444 if(level < 63 && level > -63){
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5445 if(i < last_non_zero)
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5446 score += length[UNI_AC_ENC_INDEX(run, new_level+64)]
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5447 - length[UNI_AC_ENC_INDEX(run, level+64)];
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5448 else
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5449 score += last_length[UNI_AC_ENC_INDEX(run, new_level+64)]
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5450 - last_length[UNI_AC_ENC_INDEX(run, level+64)];
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5451 }
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5452 }else{
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5453 assert(ABS(new_level)==1);
1785
14d918d0ef42 analyze the gradient of the error surface to avoid a few checks in the quantizing noise shaper
michael
parents: 1784
diff changeset
5454
14d918d0ef42 analyze the gradient of the error surface to avoid a few checks in the quantizing noise shaper
michael
parents: 1784
diff changeset
5455 if(analyze_gradient){
14d918d0ef42 analyze the gradient of the error surface to avoid a few checks in the quantizing noise shaper
michael
parents: 1784
diff changeset
5456 int g= d1[ scantable[i] ];
14d918d0ef42 analyze the gradient of the error surface to avoid a few checks in the quantizing noise shaper
michael
parents: 1784
diff changeset
5457 if(g && (g^new_level) >= 0)
14d918d0ef42 analyze the gradient of the error surface to avoid a few checks in the quantizing noise shaper
michael
parents: 1784
diff changeset
5458 continue;
14d918d0ef42 analyze the gradient of the error surface to avoid a few checks in the quantizing noise shaper
michael
parents: 1784
diff changeset
5459 }
14d918d0ef42 analyze the gradient of the error surface to avoid a few checks in the quantizing noise shaper
michael
parents: 1784
diff changeset
5460
1777
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5461 if(i < last_non_zero){
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5462 int next_i= i + run2 + 1;
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5463 int next_level= block[ perm_scantable[next_i] ] + 64;
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5464
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5465 if(next_level&(~127))
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5466 next_level= 0;
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5467
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5468 if(next_i < last_non_zero)
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5469 score += length[UNI_AC_ENC_INDEX(run, 65)]
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5470 + length[UNI_AC_ENC_INDEX(run2, next_level)]
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5471 - length[UNI_AC_ENC_INDEX(run + run2 + 1, next_level)];
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5472 else
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5473 score += length[UNI_AC_ENC_INDEX(run, 65)]
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5474 + last_length[UNI_AC_ENC_INDEX(run2, next_level)]
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5475 - last_length[UNI_AC_ENC_INDEX(run + run2 + 1, next_level)];
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5476 }else{
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5477 score += last_length[UNI_AC_ENC_INDEX(run, 65)];
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5478 if(prev_level){
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5479 score += length[UNI_AC_ENC_INDEX(prev_run, prev_level)]
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5480 - last_length[UNI_AC_ENC_INDEX(prev_run, prev_level)];
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5481 }
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5482 }
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5483 }
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5484 }else{
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5485 new_coeff=0;
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5486 assert(ABS(level)==1);
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5487
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5488 if(i < last_non_zero){
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5489 int next_i= i + run2 + 1;
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5490 int next_level= block[ perm_scantable[next_i] ] + 64;
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5491
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5492 if(next_level&(~127))
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5493 next_level= 0;
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5494
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5495 if(next_i < last_non_zero)
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5496 score += length[UNI_AC_ENC_INDEX(run + run2 + 1, next_level)]
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5497 - length[UNI_AC_ENC_INDEX(run2, next_level)]
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5498 - length[UNI_AC_ENC_INDEX(run, 65)];
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5499 else
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5500 score += last_length[UNI_AC_ENC_INDEX(run + run2 + 1, next_level)]
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5501 - last_length[UNI_AC_ENC_INDEX(run2, next_level)]
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5502 - length[UNI_AC_ENC_INDEX(run, 65)];
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5503 }else{
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5504 score += -last_length[UNI_AC_ENC_INDEX(run, 65)];
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5505 if(prev_level){
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5506 score += last_length[UNI_AC_ENC_INDEX(prev_run, prev_level)]
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5507 - length[UNI_AC_ENC_INDEX(prev_run, prev_level)];
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5508 }
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5509 }
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5510 }
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5511
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5512 score *= lambda;
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5513
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5514 unquant_change= new_coeff - old_coeff;
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5515 assert((score < 100*lambda && score > -100*lambda) || lambda==0);
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5516
1784
65f7bd09f37b quantizer noise shaping optimization
michael
parents: 1778
diff changeset
5517 score+= s->dsp.try_8x8basis(rem, weight, basis[j], unquant_change);
1777
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5518 if(score<best_score){
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5519 best_score= score;
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5520 best_coeff= i;
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5521 best_change= change;
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5522 best_unquant_change= unquant_change;
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5523 }
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5524 }
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5525 if(level){
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5526 prev_level= level + 64;
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5527 if(prev_level&(~127))
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5528 prev_level= 0;
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5529 prev_run= run;
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5530 run=0;
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5531 }else{
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5532 run++;
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5533 }
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5534 }
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5535 #ifdef REFINE_STATS
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5536 STOP_TIMER("iterative step")}
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5537 #endif
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5538
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5539 if(best_change){
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5540 int j= perm_scantable[ best_coeff ];
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5541
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5542 block[j] += best_change;
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5543
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5544 if(best_coeff > last_non_zero){
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5545 last_non_zero= best_coeff;
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5546 assert(block[j]);
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5547 #ifdef REFINE_STATS
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5548 after_last++;
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5549 #endif
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5550 }else{
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5551 #ifdef REFINE_STATS
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5552 if(block[j]){
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5553 if(block[j] - best_change){
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5554 if(ABS(block[j]) > ABS(block[j] - best_change)){
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5555 raise++;
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5556 }else{
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5557 lower++;
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5558 }
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5559 }else{
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5560 from_zero++;
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5561 }
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5562 }else{
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5563 to_zero++;
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5564 }
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5565 #endif
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5566 for(; last_non_zero>=start_i; last_non_zero--){
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5567 if(block[perm_scantable[last_non_zero]])
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5568 break;
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5569 }
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5570 }
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5571 #ifdef REFINE_STATS
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5572 count++;
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5573 if(256*256*256*64 % count == 0){
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5574 printf("after_last:%d to_zero:%d from_zero:%d raise:%d lower:%d sign:%d xyp:%d/%d/%d\n", after_last, to_zero, from_zero, raise, lower, messed_sign, s->mb_x, s->mb_y, s->picture_number);
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5575 }
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5576 #endif
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5577 run=0;
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5578 rle_index=0;
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5579 for(i=start_i; i<=last_non_zero; i++){
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5580 int j= perm_scantable[i];
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5581 const int level= block[j];
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5582
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5583 if(level){
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5584 run_tab[rle_index++]=run;
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5585 run=0;
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5586 }else{
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5587 run++;
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5588 }
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5589 }
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5590
1784
65f7bd09f37b quantizer noise shaping optimization
michael
parents: 1778
diff changeset
5591 s->dsp.add_8x8basis(rem, basis[j], best_unquant_change);
1777
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5592 }else{
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5593 break;
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5594 }
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5595 }
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5596 #ifdef REFINE_STATS
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5597 if(last_non_zero>0){
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5598 STOP_TIMER("iterative search")
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5599 }
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5600 }
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5601 #endif
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5602
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5603 return last_non_zero;
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5604 }
d183026acdfa quantizer noise shaping
michael
parents: 1766
diff changeset
5605
220
0b234715e205 (commit by michael)
arpi_esp
parents: 217
diff changeset
5606 static int dct_quantize_c(MpegEncContext *s,
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
5607 DCTELEM *block, int n,
344
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
5608 int qscale, int *overflow)
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
5609 {
1715
88a2c6cc45f4 optimizing (trellis) quantizer
michael
parents: 1712
diff changeset
5610 int i, j, level, last_non_zero, q, start_i;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
5611 const int *qmat;
1064
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1059
diff changeset
5612 const uint8_t *scantable= s->intra_scantable.scantable;
344
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
5613 int bias;
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
5614 int max=0;
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
5615 unsigned int threshold1, threshold2;
828
ace3ccd18dd2 Altivec Patch (Mark III) by (Dieter Shirley <dieters at schemasoft dot com>)
michaelni
parents: 815
diff changeset
5616
1092
f59c3f66363b MpegEncContext.(i)dct_* -> DspContext.(i)dct_*
michaelni
parents: 1089
diff changeset
5617 s->dsp.fdct (block);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
5618
1597
4c9165372ab3 noise reduction of dct coefficients
michael
parents: 1586
diff changeset
5619 if(s->dct_error_sum)
1719
4e72fb256b25 denoise_dct_mmx()
michael
parents: 1718
diff changeset
5620 s->denoise_dct(s, block);
1597
4c9165372ab3 noise reduction of dct coefficients
michael
parents: 1586
diff changeset
5621
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
5622 if (s->mb_intra) {
350
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 347
diff changeset
5623 if (!s->h263_aic) {
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 347
diff changeset
5624 if (n < 4)
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 347
diff changeset
5625 q = s->y_dc_scale;
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 347
diff changeset
5626 else
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 347
diff changeset
5627 q = s->c_dc_scale;
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 347
diff changeset
5628 q = q << 3;
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 347
diff changeset
5629 } else
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 347
diff changeset
5630 /* 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
5631 q = 1 << 3;
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 347
diff changeset
5632
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
5633 /* note: block[0] is assumed to be positive */
986e461dc072 Initial revision
glantau
parents:
diff changeset
5634 block[0] = (block[0] + (q >> 1)) / q;
1715
88a2c6cc45f4 optimizing (trellis) quantizer
michael
parents: 1712
diff changeset
5635 start_i = 1;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
5636 last_non_zero = 0;
344
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
5637 qmat = s->q_intra_matrix[qscale];
635
3e0f62e5eed6 dct cleanup
michaelni
parents: 628
diff changeset
5638 bias= s->intra_quant_bias<<(QMAT_SHIFT - QUANT_BIAS_SHIFT);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
5639 } else {
1715
88a2c6cc45f4 optimizing (trellis) quantizer
michael
parents: 1712
diff changeset
5640 start_i = 0;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
5641 last_non_zero = -1;
344
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
5642 qmat = s->q_inter_matrix[qscale];
635
3e0f62e5eed6 dct cleanup
michaelni
parents: 628
diff changeset
5643 bias= s->inter_quant_bias<<(QMAT_SHIFT - QUANT_BIAS_SHIFT);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
5644 }
635
3e0f62e5eed6 dct cleanup
michaelni
parents: 628
diff changeset
5645 threshold1= (1<<QMAT_SHIFT) - bias - 1;
3e0f62e5eed6 dct cleanup
michaelni
parents: 628
diff changeset
5646 threshold2= (threshold1<<1);
1715
88a2c6cc45f4 optimizing (trellis) quantizer
michael
parents: 1712
diff changeset
5647 for(i=63;i>=start_i;i--) {
764
d4726182dfd2 optimize block_permute()
michaelni
parents: 763
diff changeset
5648 j = scantable[i];
1715
88a2c6cc45f4 optimizing (trellis) quantizer
michael
parents: 1712
diff changeset
5649 level = block[j] * qmat[j];
88a2c6cc45f4 optimizing (trellis) quantizer
michael
parents: 1712
diff changeset
5650
88a2c6cc45f4 optimizing (trellis) quantizer
michael
parents: 1712
diff changeset
5651 if(((unsigned)(level+threshold1))>threshold2){
88a2c6cc45f4 optimizing (trellis) quantizer
michael
parents: 1712
diff changeset
5652 last_non_zero = i;
88a2c6cc45f4 optimizing (trellis) quantizer
michael
parents: 1712
diff changeset
5653 break;
88a2c6cc45f4 optimizing (trellis) quantizer
michael
parents: 1712
diff changeset
5654 }else{
88a2c6cc45f4 optimizing (trellis) quantizer
michael
parents: 1712
diff changeset
5655 block[j]=0;
88a2c6cc45f4 optimizing (trellis) quantizer
michael
parents: 1712
diff changeset
5656 }
88a2c6cc45f4 optimizing (trellis) quantizer
michael
parents: 1712
diff changeset
5657 }
88a2c6cc45f4 optimizing (trellis) quantizer
michael
parents: 1712
diff changeset
5658 for(i=start_i; i<=last_non_zero; i++) {
88a2c6cc45f4 optimizing (trellis) quantizer
michael
parents: 1712
diff changeset
5659 j = scantable[i];
88a2c6cc45f4 optimizing (trellis) quantizer
michael
parents: 1712
diff changeset
5660 level = block[j] * qmat[j];
344
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
5661
1215
9182f5e70e9b typo in a comment ...
michaelni
parents: 1214
diff changeset
5662 // if( bias+level >= (1<<QMAT_SHIFT)
9182f5e70e9b typo in a comment ...
michaelni
parents: 1214
diff changeset
5663 // || bias-level >= (1<<QMAT_SHIFT)){
344
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
5664 if(((unsigned)(level+threshold1))>threshold2){
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
5665 if(level>0){
635
3e0f62e5eed6 dct cleanup
michaelni
parents: 628
diff changeset
5666 level= (bias + level)>>QMAT_SHIFT;
344
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
5667 block[j]= level;
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
5668 }else{
635
3e0f62e5eed6 dct cleanup
michaelni
parents: 628
diff changeset
5669 level= (bias - level)>>QMAT_SHIFT;
344
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
5670 block[j]= -level;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
5671 }
344
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
5672 max |=level;
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
5673 }else{
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
5674 block[j]=0;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
5675 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
5676 }
344
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
5677 *overflow= s->max_qcoeff < max; //overflow might have happend
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
5678
764
d4726182dfd2 optimize block_permute()
michaelni
parents: 763
diff changeset
5679 /* we need this permutation so that we correct the IDCT, we only permute the !=0 elements */
1092
f59c3f66363b MpegEncContext.(i)dct_* -> DspContext.(i)dct_*
michaelni
parents: 1089
diff changeset
5680 if (s->dsp.idct_permutation_type != FF_NO_IDCT_PERM)
f59c3f66363b MpegEncContext.(i)dct_* -> DspContext.(i)dct_*
michaelni
parents: 1089
diff changeset
5681 ff_block_permute(block, s->dsp.idct_permutation, scantable, last_non_zero);
764
d4726182dfd2 optimize block_permute()
michaelni
parents: 763
diff changeset
5682
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
5683 return last_non_zero;
986e461dc072 Initial revision
glantau
parents:
diff changeset
5684 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
5685
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
5686 #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
5687
1689
1a2db2073848 split intra / inter dequantization
michael
parents: 1688
diff changeset
5688 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
5689 DCTELEM *block, int n, int qscale)
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
5690 {
200
6ab301aaa652 (commit by michael)
arpi_esp
parents: 198
diff changeset
5691 int i, level, nCoeffs;
1064
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1059
diff changeset
5692 const uint16_t *quant_matrix;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
5693
706
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 704
diff changeset
5694 nCoeffs= s->block_last_index[n];
200
6ab301aaa652 (commit by michael)
arpi_esp
parents: 198
diff changeset
5695
1689
1a2db2073848 split intra / inter dequantization
michael
parents: 1688
diff changeset
5696 if (n < 4)
1a2db2073848 split intra / inter dequantization
michael
parents: 1688
diff changeset
5697 block[0] = block[0] * s->y_dc_scale;
1a2db2073848 split intra / inter dequantization
michael
parents: 1688
diff changeset
5698 else
1a2db2073848 split intra / inter dequantization
michael
parents: 1688
diff changeset
5699 block[0] = block[0] * s->c_dc_scale;
1a2db2073848 split intra / inter dequantization
michael
parents: 1688
diff changeset
5700 /* XXX: only mpeg1 */
1a2db2073848 split intra / inter dequantization
michael
parents: 1688
diff changeset
5701 quant_matrix = s->intra_matrix;
1a2db2073848 split intra / inter dequantization
michael
parents: 1688
diff changeset
5702 for(i=1;i<=nCoeffs;i++) {
1a2db2073848 split intra / inter dequantization
michael
parents: 1688
diff changeset
5703 int j= s->intra_scantable.permutated[i];
1a2db2073848 split intra / inter dequantization
michael
parents: 1688
diff changeset
5704 level = block[j];
1a2db2073848 split intra / inter dequantization
michael
parents: 1688
diff changeset
5705 if (level) {
1a2db2073848 split intra / inter dequantization
michael
parents: 1688
diff changeset
5706 if (level < 0) {
1a2db2073848 split intra / inter dequantization
michael
parents: 1688
diff changeset
5707 level = -level;
1a2db2073848 split intra / inter dequantization
michael
parents: 1688
diff changeset
5708 level = (int)(level * qscale * quant_matrix[j]) >> 3;
1a2db2073848 split intra / inter dequantization
michael
parents: 1688
diff changeset
5709 level = (level - 1) | 1;
1a2db2073848 split intra / inter dequantization
michael
parents: 1688
diff changeset
5710 level = -level;
1a2db2073848 split intra / inter dequantization
michael
parents: 1688
diff changeset
5711 } else {
1a2db2073848 split intra / inter dequantization
michael
parents: 1688
diff changeset
5712 level = (int)(level * qscale * quant_matrix[j]) >> 3;
1a2db2073848 split intra / inter dequantization
michael
parents: 1688
diff changeset
5713 level = (level - 1) | 1;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
5714 }
1689
1a2db2073848 split intra / inter dequantization
michael
parents: 1688
diff changeset
5715 block[j] = level;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
5716 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
5717 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
5718 }
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
5719
1689
1a2db2073848 split intra / inter dequantization
michael
parents: 1688
diff changeset
5720 static void dct_unquantize_mpeg1_inter_c(MpegEncContext *s,
1a2db2073848 split intra / inter dequantization
michael
parents: 1688
diff changeset
5721 DCTELEM *block, int n, int qscale)
1a2db2073848 split intra / inter dequantization
michael
parents: 1688
diff changeset
5722 {
1a2db2073848 split intra / inter dequantization
michael
parents: 1688
diff changeset
5723 int i, level, nCoeffs;
1a2db2073848 split intra / inter dequantization
michael
parents: 1688
diff changeset
5724 const uint16_t *quant_matrix;
1a2db2073848 split intra / inter dequantization
michael
parents: 1688
diff changeset
5725
1a2db2073848 split intra / inter dequantization
michael
parents: 1688
diff changeset
5726 nCoeffs= s->block_last_index[n];
1a2db2073848 split intra / inter dequantization
michael
parents: 1688
diff changeset
5727
1a2db2073848 split intra / inter dequantization
michael
parents: 1688
diff changeset
5728 quant_matrix = s->inter_matrix;
1a2db2073848 split intra / inter dequantization
michael
parents: 1688
diff changeset
5729 for(i=0; i<=nCoeffs; i++) {
1a2db2073848 split intra / inter dequantization
michael
parents: 1688
diff changeset
5730 int j= s->intra_scantable.permutated[i];
1a2db2073848 split intra / inter dequantization
michael
parents: 1688
diff changeset
5731 level = block[j];
1a2db2073848 split intra / inter dequantization
michael
parents: 1688
diff changeset
5732 if (level) {
1a2db2073848 split intra / inter dequantization
michael
parents: 1688
diff changeset
5733 if (level < 0) {
1a2db2073848 split intra / inter dequantization
michael
parents: 1688
diff changeset
5734 level = -level;
1a2db2073848 split intra / inter dequantization
michael
parents: 1688
diff changeset
5735 level = (((level << 1) + 1) * qscale *
1a2db2073848 split intra / inter dequantization
michael
parents: 1688
diff changeset
5736 ((int) (quant_matrix[j]))) >> 4;
1a2db2073848 split intra / inter dequantization
michael
parents: 1688
diff changeset
5737 level = (level - 1) | 1;
1a2db2073848 split intra / inter dequantization
michael
parents: 1688
diff changeset
5738 level = -level;
1a2db2073848 split intra / inter dequantization
michael
parents: 1688
diff changeset
5739 } else {
1a2db2073848 split intra / inter dequantization
michael
parents: 1688
diff changeset
5740 level = (((level << 1) + 1) * qscale *
1a2db2073848 split intra / inter dequantization
michael
parents: 1688
diff changeset
5741 ((int) (quant_matrix[j]))) >> 4;
1a2db2073848 split intra / inter dequantization
michael
parents: 1688
diff changeset
5742 level = (level - 1) | 1;
1a2db2073848 split intra / inter dequantization
michael
parents: 1688
diff changeset
5743 }
1a2db2073848 split intra / inter dequantization
michael
parents: 1688
diff changeset
5744 block[j] = level;
1a2db2073848 split intra / inter dequantization
michael
parents: 1688
diff changeset
5745 }
1a2db2073848 split intra / inter dequantization
michael
parents: 1688
diff changeset
5746 }
1a2db2073848 split intra / inter dequantization
michael
parents: 1688
diff changeset
5747 }
1a2db2073848 split intra / inter dequantization
michael
parents: 1688
diff changeset
5748
1a2db2073848 split intra / inter dequantization
michael
parents: 1688
diff changeset
5749 static void dct_unquantize_mpeg2_intra_c(MpegEncContext *s,
325
15efd80cf51e mpeg2/mpeg4 dequantizer support (c & mmx)
michaelni
parents: 324
diff changeset
5750 DCTELEM *block, int n, int qscale)
15efd80cf51e mpeg2/mpeg4 dequantizer support (c & mmx)
michaelni
parents: 324
diff changeset
5751 {
15efd80cf51e mpeg2/mpeg4 dequantizer support (c & mmx)
michaelni
parents: 324
diff changeset
5752 int i, level, nCoeffs;
1064
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1059
diff changeset
5753 const uint16_t *quant_matrix;
325
15efd80cf51e mpeg2/mpeg4 dequantizer support (c & mmx)
michaelni
parents: 324
diff changeset
5754
706
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 704
diff changeset
5755 if(s->alternate_scan) nCoeffs= 63;
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 704
diff changeset
5756 else nCoeffs= s->block_last_index[n];
325
15efd80cf51e mpeg2/mpeg4 dequantizer support (c & mmx)
michaelni
parents: 324
diff changeset
5757
1689
1a2db2073848 split intra / inter dequantization
michael
parents: 1688
diff changeset
5758 if (n < 4)
1a2db2073848 split intra / inter dequantization
michael
parents: 1688
diff changeset
5759 block[0] = block[0] * s->y_dc_scale;
1a2db2073848 split intra / inter dequantization
michael
parents: 1688
diff changeset
5760 else
1a2db2073848 split intra / inter dequantization
michael
parents: 1688
diff changeset
5761 block[0] = block[0] * s->c_dc_scale;
1a2db2073848 split intra / inter dequantization
michael
parents: 1688
diff changeset
5762 quant_matrix = s->intra_matrix;
1a2db2073848 split intra / inter dequantization
michael
parents: 1688
diff changeset
5763 for(i=1;i<=nCoeffs;i++) {
1a2db2073848 split intra / inter dequantization
michael
parents: 1688
diff changeset
5764 int j= s->intra_scantable.permutated[i];
1a2db2073848 split intra / inter dequantization
michael
parents: 1688
diff changeset
5765 level = block[j];
1a2db2073848 split intra / inter dequantization
michael
parents: 1688
diff changeset
5766 if (level) {
1a2db2073848 split intra / inter dequantization
michael
parents: 1688
diff changeset
5767 if (level < 0) {
1a2db2073848 split intra / inter dequantization
michael
parents: 1688
diff changeset
5768 level = -level;
1a2db2073848 split intra / inter dequantization
michael
parents: 1688
diff changeset
5769 level = (int)(level * qscale * quant_matrix[j]) >> 3;
1a2db2073848 split intra / inter dequantization
michael
parents: 1688
diff changeset
5770 level = -level;
1a2db2073848 split intra / inter dequantization
michael
parents: 1688
diff changeset
5771 } else {
1a2db2073848 split intra / inter dequantization
michael
parents: 1688
diff changeset
5772 level = (int)(level * qscale * quant_matrix[j]) >> 3;
1a2db2073848 split intra / inter dequantization
michael
parents: 1688
diff changeset
5773 }
1a2db2073848 split intra / inter dequantization
michael
parents: 1688
diff changeset
5774 block[j] = level;
1a2db2073848 split intra / inter dequantization
michael
parents: 1688
diff changeset
5775 }
1a2db2073848 split intra / inter dequantization
michael
parents: 1688
diff changeset
5776 }
1a2db2073848 split intra / inter dequantization
michael
parents: 1688
diff changeset
5777 }
1a2db2073848 split intra / inter dequantization
michael
parents: 1688
diff changeset
5778
1a2db2073848 split intra / inter dequantization
michael
parents: 1688
diff changeset
5779 static void dct_unquantize_mpeg2_inter_c(MpegEncContext *s,
1a2db2073848 split intra / inter dequantization
michael
parents: 1688
diff changeset
5780 DCTELEM *block, int n, int qscale)
1a2db2073848 split intra / inter dequantization
michael
parents: 1688
diff changeset
5781 {
1a2db2073848 split intra / inter dequantization
michael
parents: 1688
diff changeset
5782 int i, level, nCoeffs;
1a2db2073848 split intra / inter dequantization
michael
parents: 1688
diff changeset
5783 const uint16_t *quant_matrix;
1a2db2073848 split intra / inter dequantization
michael
parents: 1688
diff changeset
5784 int sum=-1;
1a2db2073848 split intra / inter dequantization
michael
parents: 1688
diff changeset
5785
1a2db2073848 split intra / inter dequantization
michael
parents: 1688
diff changeset
5786 if(s->alternate_scan) nCoeffs= 63;
1a2db2073848 split intra / inter dequantization
michael
parents: 1688
diff changeset
5787 else nCoeffs= s->block_last_index[n];
1a2db2073848 split intra / inter dequantization
michael
parents: 1688
diff changeset
5788
1a2db2073848 split intra / inter dequantization
michael
parents: 1688
diff changeset
5789 quant_matrix = s->inter_matrix;
1a2db2073848 split intra / inter dequantization
michael
parents: 1688
diff changeset
5790 for(i=0; i<=nCoeffs; i++) {
1a2db2073848 split intra / inter dequantization
michael
parents: 1688
diff changeset
5791 int j= s->intra_scantable.permutated[i];
1a2db2073848 split intra / inter dequantization
michael
parents: 1688
diff changeset
5792 level = block[j];
1a2db2073848 split intra / inter dequantization
michael
parents: 1688
diff changeset
5793 if (level) {
1a2db2073848 split intra / inter dequantization
michael
parents: 1688
diff changeset
5794 if (level < 0) {
1a2db2073848 split intra / inter dequantization
michael
parents: 1688
diff changeset
5795 level = -level;
1a2db2073848 split intra / inter dequantization
michael
parents: 1688
diff changeset
5796 level = (((level << 1) + 1) * qscale *
1a2db2073848 split intra / inter dequantization
michael
parents: 1688
diff changeset
5797 ((int) (quant_matrix[j]))) >> 4;
1a2db2073848 split intra / inter dequantization
michael
parents: 1688
diff changeset
5798 level = -level;
1a2db2073848 split intra / inter dequantization
michael
parents: 1688
diff changeset
5799 } else {
1a2db2073848 split intra / inter dequantization
michael
parents: 1688
diff changeset
5800 level = (((level << 1) + 1) * qscale *
1a2db2073848 split intra / inter dequantization
michael
parents: 1688
diff changeset
5801 ((int) (quant_matrix[j]))) >> 4;
1a2db2073848 split intra / inter dequantization
michael
parents: 1688
diff changeset
5802 }
1a2db2073848 split intra / inter dequantization
michael
parents: 1688
diff changeset
5803 block[j] = level;
1a2db2073848 split intra / inter dequantization
michael
parents: 1688
diff changeset
5804 sum+=level;
1a2db2073848 split intra / inter dequantization
michael
parents: 1688
diff changeset
5805 }
1a2db2073848 split intra / inter dequantization
michael
parents: 1688
diff changeset
5806 }
1a2db2073848 split intra / inter dequantization
michael
parents: 1688
diff changeset
5807 block[63]^=sum&1;
1a2db2073848 split intra / inter dequantization
michael
parents: 1688
diff changeset
5808 }
1a2db2073848 split intra / inter dequantization
michael
parents: 1688
diff changeset
5809
1a2db2073848 split intra / inter dequantization
michael
parents: 1688
diff changeset
5810 static void dct_unquantize_h263_intra_c(MpegEncContext *s,
1a2db2073848 split intra / inter dequantization
michael
parents: 1688
diff changeset
5811 DCTELEM *block, int n, int qscale)
1a2db2073848 split intra / inter dequantization
michael
parents: 1688
diff changeset
5812 {
1a2db2073848 split intra / inter dequantization
michael
parents: 1688
diff changeset
5813 int i, level, qmul, qadd;
1a2db2073848 split intra / inter dequantization
michael
parents: 1688
diff changeset
5814 int nCoeffs;
1a2db2073848 split intra / inter dequantization
michael
parents: 1688
diff changeset
5815
1a2db2073848 split intra / inter dequantization
michael
parents: 1688
diff changeset
5816 assert(s->block_last_index[n]>=0);
1a2db2073848 split intra / inter dequantization
michael
parents: 1688
diff changeset
5817
1a2db2073848 split intra / inter dequantization
michael
parents: 1688
diff changeset
5818 qmul = qscale << 1;
1a2db2073848 split intra / inter dequantization
michael
parents: 1688
diff changeset
5819
1a2db2073848 split intra / inter dequantization
michael
parents: 1688
diff changeset
5820 if (!s->h263_aic) {
325
15efd80cf51e mpeg2/mpeg4 dequantizer support (c & mmx)
michaelni
parents: 324
diff changeset
5821 if (n < 4)
15efd80cf51e mpeg2/mpeg4 dequantizer support (c & mmx)
michaelni
parents: 324
diff changeset
5822 block[0] = block[0] * s->y_dc_scale;
15efd80cf51e mpeg2/mpeg4 dequantizer support (c & mmx)
michaelni
parents: 324
diff changeset
5823 else
15efd80cf51e mpeg2/mpeg4 dequantizer support (c & mmx)
michaelni
parents: 324
diff changeset
5824 block[0] = block[0] * s->c_dc_scale;
1689
1a2db2073848 split intra / inter dequantization
michael
parents: 1688
diff changeset
5825 qadd = (qscale - 1) | 1;
1a2db2073848 split intra / inter dequantization
michael
parents: 1688
diff changeset
5826 }else{
1a2db2073848 split intra / inter dequantization
michael
parents: 1688
diff changeset
5827 qadd = 0;
1a2db2073848 split intra / inter dequantization
michael
parents: 1688
diff changeset
5828 }
1a2db2073848 split intra / inter dequantization
michael
parents: 1688
diff changeset
5829 if(s->ac_pred)
1a2db2073848 split intra / inter dequantization
michael
parents: 1688
diff changeset
5830 nCoeffs=63;
1a2db2073848 split intra / inter dequantization
michael
parents: 1688
diff changeset
5831 else
1a2db2073848 split intra / inter dequantization
michael
parents: 1688
diff changeset
5832 nCoeffs= s->inter_scantable.raster_end[ s->block_last_index[n] ];
1a2db2073848 split intra / inter dequantization
michael
parents: 1688
diff changeset
5833
1a2db2073848 split intra / inter dequantization
michael
parents: 1688
diff changeset
5834 for(i=1; i<=nCoeffs; i++) {
1a2db2073848 split intra / inter dequantization
michael
parents: 1688
diff changeset
5835 level = block[i];
1a2db2073848 split intra / inter dequantization
michael
parents: 1688
diff changeset
5836 if (level) {
1a2db2073848 split intra / inter dequantization
michael
parents: 1688
diff changeset
5837 if (level < 0) {
1a2db2073848 split intra / inter dequantization
michael
parents: 1688
diff changeset
5838 level = level * qmul - qadd;
1a2db2073848 split intra / inter dequantization
michael
parents: 1688
diff changeset
5839 } else {
1a2db2073848 split intra / inter dequantization
michael
parents: 1688
diff changeset
5840 level = level * qmul + qadd;
325
15efd80cf51e mpeg2/mpeg4 dequantizer support (c & mmx)
michaelni
parents: 324
diff changeset
5841 }
1689
1a2db2073848 split intra / inter dequantization
michael
parents: 1688
diff changeset
5842 block[i] = level;
325
15efd80cf51e mpeg2/mpeg4 dequantizer support (c & mmx)
michaelni
parents: 324
diff changeset
5843 }
15efd80cf51e mpeg2/mpeg4 dequantizer support (c & mmx)
michaelni
parents: 324
diff changeset
5844 }
15efd80cf51e mpeg2/mpeg4 dequantizer support (c & mmx)
michaelni
parents: 324
diff changeset
5845 }
15efd80cf51e mpeg2/mpeg4 dequantizer support (c & mmx)
michaelni
parents: 324
diff changeset
5846
1689
1a2db2073848 split intra / inter dequantization
michael
parents: 1688
diff changeset
5847 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
5848 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
5849 {
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
5850 int i, level, qmul, qadd;
200
6ab301aaa652 (commit by michael)
arpi_esp
parents: 198
diff changeset
5851 int nCoeffs;
249
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
5852
706
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 704
diff changeset
5853 assert(s->block_last_index[n]>=0);
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 704
diff changeset
5854
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 704
diff changeset
5855 qadd = (qscale - 1) | 1;
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 704
diff changeset
5856 qmul = qscale << 1;
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 704
diff changeset
5857
1689
1a2db2073848 split intra / inter dequantization
michael
parents: 1688
diff changeset
5858 nCoeffs= s->inter_scantable.raster_end[ s->block_last_index[n] ];
1a2db2073848 split intra / inter dequantization
michael
parents: 1688
diff changeset
5859
1a2db2073848 split intra / inter dequantization
michael
parents: 1688
diff changeset
5860 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
5861 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
5862 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
5863 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
5864 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
5865 } 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
5866 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
5867 }
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
5868 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
5869 }
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
5870 }
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
5871 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
5872
2044
b6f2add2511e h261 decoder by (Maarten Daniels <maarten.daniels at student dot luc dot ac dot be>)
michael
parents: 2042
diff changeset
5873 static void dct_unquantize_h261_intra_c(MpegEncContext *s,
b6f2add2511e h261 decoder by (Maarten Daniels <maarten.daniels at student dot luc dot ac dot be>)
michael
parents: 2042
diff changeset
5874 DCTELEM *block, int n, int qscale)
b6f2add2511e h261 decoder by (Maarten Daniels <maarten.daniels at student dot luc dot ac dot be>)
michael
parents: 2042
diff changeset
5875 {
2048
533717e2910f h261 dequant fix
michael
parents: 2044
diff changeset
5876 int i, level, even;
2044
b6f2add2511e h261 decoder by (Maarten Daniels <maarten.daniels at student dot luc dot ac dot be>)
michael
parents: 2042
diff changeset
5877 int nCoeffs;
b6f2add2511e h261 decoder by (Maarten Daniels <maarten.daniels at student dot luc dot ac dot be>)
michael
parents: 2042
diff changeset
5878
b6f2add2511e h261 decoder by (Maarten Daniels <maarten.daniels at student dot luc dot ac dot be>)
michael
parents: 2042
diff changeset
5879 assert(s->block_last_index[n]>=0);
b6f2add2511e h261 decoder by (Maarten Daniels <maarten.daniels at student dot luc dot ac dot be>)
michael
parents: 2042
diff changeset
5880
b6f2add2511e h261 decoder by (Maarten Daniels <maarten.daniels at student dot luc dot ac dot be>)
michael
parents: 2042
diff changeset
5881 if (n < 4)
b6f2add2511e h261 decoder by (Maarten Daniels <maarten.daniels at student dot luc dot ac dot be>)
michael
parents: 2042
diff changeset
5882 block[0] = block[0] * s->y_dc_scale;
b6f2add2511e h261 decoder by (Maarten Daniels <maarten.daniels at student dot luc dot ac dot be>)
michael
parents: 2042
diff changeset
5883 else
b6f2add2511e h261 decoder by (Maarten Daniels <maarten.daniels at student dot luc dot ac dot be>)
michael
parents: 2042
diff changeset
5884 block[0] = block[0] * s->c_dc_scale;
2048
533717e2910f h261 dequant fix
michael
parents: 2044
diff changeset
5885 even = (qscale & 1)^1;
2044
b6f2add2511e h261 decoder by (Maarten Daniels <maarten.daniels at student dot luc dot ac dot be>)
michael
parents: 2042
diff changeset
5886 nCoeffs= s->inter_scantable.raster_end[ s->block_last_index[n] ];
b6f2add2511e h261 decoder by (Maarten Daniels <maarten.daniels at student dot luc dot ac dot be>)
michael
parents: 2042
diff changeset
5887
b6f2add2511e h261 decoder by (Maarten Daniels <maarten.daniels at student dot luc dot ac dot be>)
michael
parents: 2042
diff changeset
5888 for(i=1; i<=nCoeffs; i++){
b6f2add2511e h261 decoder by (Maarten Daniels <maarten.daniels at student dot luc dot ac dot be>)
michael
parents: 2042
diff changeset
5889 level = block[i];
b6f2add2511e h261 decoder by (Maarten Daniels <maarten.daniels at student dot luc dot ac dot be>)
michael
parents: 2042
diff changeset
5890 if (level){
b6f2add2511e h261 decoder by (Maarten Daniels <maarten.daniels at student dot luc dot ac dot be>)
michael
parents: 2042
diff changeset
5891 if (level < 0){
2048
533717e2910f h261 dequant fix
michael
parents: 2044
diff changeset
5892 level = qscale * ((level << 1) - 1) + even;
2044
b6f2add2511e h261 decoder by (Maarten Daniels <maarten.daniels at student dot luc dot ac dot be>)
michael
parents: 2042
diff changeset
5893 }else{
2048
533717e2910f h261 dequant fix
michael
parents: 2044
diff changeset
5894 level = qscale * ((level << 1) + 1) - even;
2044
b6f2add2511e h261 decoder by (Maarten Daniels <maarten.daniels at student dot luc dot ac dot be>)
michael
parents: 2042
diff changeset
5895 }
b6f2add2511e h261 decoder by (Maarten Daniels <maarten.daniels at student dot luc dot ac dot be>)
michael
parents: 2042
diff changeset
5896 }
b6f2add2511e h261 decoder by (Maarten Daniels <maarten.daniels at student dot luc dot ac dot be>)
michael
parents: 2042
diff changeset
5897 block[i] = level;
b6f2add2511e h261 decoder by (Maarten Daniels <maarten.daniels at student dot luc dot ac dot be>)
michael
parents: 2042
diff changeset
5898 }
b6f2add2511e h261 decoder by (Maarten Daniels <maarten.daniels at student dot luc dot ac dot be>)
michael
parents: 2042
diff changeset
5899 }
b6f2add2511e h261 decoder by (Maarten Daniels <maarten.daniels at student dot luc dot ac dot be>)
michael
parents: 2042
diff changeset
5900
b6f2add2511e h261 decoder by (Maarten Daniels <maarten.daniels at student dot luc dot ac dot be>)
michael
parents: 2042
diff changeset
5901 static void dct_unquantize_h261_inter_c(MpegEncContext *s,
b6f2add2511e h261 decoder by (Maarten Daniels <maarten.daniels at student dot luc dot ac dot be>)
michael
parents: 2042
diff changeset
5902 DCTELEM *block, int n, int qscale)
b6f2add2511e h261 decoder by (Maarten Daniels <maarten.daniels at student dot luc dot ac dot be>)
michael
parents: 2042
diff changeset
5903 {
2048
533717e2910f h261 dequant fix
michael
parents: 2044
diff changeset
5904 int i, level, even;
2044
b6f2add2511e h261 decoder by (Maarten Daniels <maarten.daniels at student dot luc dot ac dot be>)
michael
parents: 2042
diff changeset
5905 int nCoeffs;
b6f2add2511e h261 decoder by (Maarten Daniels <maarten.daniels at student dot luc dot ac dot be>)
michael
parents: 2042
diff changeset
5906
b6f2add2511e h261 decoder by (Maarten Daniels <maarten.daniels at student dot luc dot ac dot be>)
michael
parents: 2042
diff changeset
5907 assert(s->block_last_index[n]>=0);
2048
533717e2910f h261 dequant fix
michael
parents: 2044
diff changeset
5908
533717e2910f h261 dequant fix
michael
parents: 2044
diff changeset
5909 even = (qscale & 1)^1;
2044
b6f2add2511e h261 decoder by (Maarten Daniels <maarten.daniels at student dot luc dot ac dot be>)
michael
parents: 2042
diff changeset
5910
b6f2add2511e h261 decoder by (Maarten Daniels <maarten.daniels at student dot luc dot ac dot be>)
michael
parents: 2042
diff changeset
5911 nCoeffs= s->inter_scantable.raster_end[ s->block_last_index[n] ];
b6f2add2511e h261 decoder by (Maarten Daniels <maarten.daniels at student dot luc dot ac dot be>)
michael
parents: 2042
diff changeset
5912
b6f2add2511e h261 decoder by (Maarten Daniels <maarten.daniels at student dot luc dot ac dot be>)
michael
parents: 2042
diff changeset
5913 for(i=0; i<=nCoeffs; i++){
b6f2add2511e h261 decoder by (Maarten Daniels <maarten.daniels at student dot luc dot ac dot be>)
michael
parents: 2042
diff changeset
5914 level = block[i];
b6f2add2511e h261 decoder by (Maarten Daniels <maarten.daniels at student dot luc dot ac dot be>)
michael
parents: 2042
diff changeset
5915 if (level){
b6f2add2511e h261 decoder by (Maarten Daniels <maarten.daniels at student dot luc dot ac dot be>)
michael
parents: 2042
diff changeset
5916 if (level < 0){
2048
533717e2910f h261 dequant fix
michael
parents: 2044
diff changeset
5917 level = qscale * ((level << 1) - 1) + even;
2044
b6f2add2511e h261 decoder by (Maarten Daniels <maarten.daniels at student dot luc dot ac dot be>)
michael
parents: 2042
diff changeset
5918 }else{
2048
533717e2910f h261 dequant fix
michael
parents: 2044
diff changeset
5919 level = qscale * ((level << 1) + 1) - even;
2044
b6f2add2511e h261 decoder by (Maarten Daniels <maarten.daniels at student dot luc dot ac dot be>)
michael
parents: 2042
diff changeset
5920 }
b6f2add2511e h261 decoder by (Maarten Daniels <maarten.daniels at student dot luc dot ac dot be>)
michael
parents: 2042
diff changeset
5921 }
b6f2add2511e h261 decoder by (Maarten Daniels <maarten.daniels at student dot luc dot ac dot be>)
michael
parents: 2042
diff changeset
5922 block[i] = level;
b6f2add2511e h261 decoder by (Maarten Daniels <maarten.daniels at student dot luc dot ac dot be>)
michael
parents: 2042
diff changeset
5923 }
b6f2add2511e h261 decoder by (Maarten Daniels <maarten.daniels at student dot luc dot ac dot be>)
michael
parents: 2042
diff changeset
5924 }
b6f2add2511e h261 decoder by (Maarten Daniels <maarten.daniels at student dot luc dot ac dot be>)
michael
parents: 2042
diff changeset
5925
1059
890b9fb44e84 * still unfinished code for Options
kabi
parents: 1051
diff changeset
5926 static const AVOption mpeg4_options[] =
890b9fb44e84 * still unfinished code for Options
kabi
parents: 1051
diff changeset
5927 {
890b9fb44e84 * still unfinished code for Options
kabi
parents: 1051
diff changeset
5928 AVOPTION_CODEC_INT("bitrate", "desired video bitrate", bit_rate, 4, 240000000, 800000),
890b9fb44e84 * still unfinished code for Options
kabi
parents: 1051
diff changeset
5929 AVOPTION_CODEC_INT("ratetol", "number of bits the bitstream is allowed to diverge from the reference"
890b9fb44e84 * still unfinished code for Options
kabi
parents: 1051
diff changeset
5930 "the reference can be CBR (for CBR pass1) or VBR (for pass2)",
890b9fb44e84 * still unfinished code for Options
kabi
parents: 1051
diff changeset
5931 bit_rate_tolerance, 4, 240000000, 8000),
890b9fb44e84 * still unfinished code for Options
kabi
parents: 1051
diff changeset
5932 AVOPTION_CODEC_INT("qmin", "minimum quantizer", qmin, 1, 31, 2),
890b9fb44e84 * still unfinished code for Options
kabi
parents: 1051
diff changeset
5933 AVOPTION_CODEC_INT("qmax", "maximum quantizer", qmax, 1, 31, 31),
890b9fb44e84 * still unfinished code for Options
kabi
parents: 1051
diff changeset
5934 AVOPTION_CODEC_STRING("rc_eq", "rate control equation",
890b9fb44e84 * still unfinished code for Options
kabi
parents: 1051
diff changeset
5935 rc_eq, "tex^qComp,option1,options2", 0),
890b9fb44e84 * still unfinished code for Options
kabi
parents: 1051
diff changeset
5936 AVOPTION_CODEC_INT("rc_minrate", "rate control minimum bitrate",
890b9fb44e84 * still unfinished code for Options
kabi
parents: 1051
diff changeset
5937 rc_min_rate, 4, 24000000, 0),
890b9fb44e84 * still unfinished code for Options
kabi
parents: 1051
diff changeset
5938 AVOPTION_CODEC_INT("rc_maxrate", "rate control maximum bitrate",
890b9fb44e84 * still unfinished code for Options
kabi
parents: 1051
diff changeset
5939 rc_max_rate, 4, 24000000, 0),
1130
c8dfb8579606 * added more options
kabi
parents: 1126
diff changeset
5940 AVOPTION_CODEC_DOUBLE("rc_buf_aggresivity", "rate control buffer aggresivity",
c8dfb8579606 * added more options
kabi
parents: 1126
diff changeset
5941 rc_buffer_aggressivity, 4, 24000000, 0),
c8dfb8579606 * added more options
kabi
parents: 1126
diff changeset
5942 AVOPTION_CODEC_DOUBLE("rc_initial_cplx", "initial complexity for pass1 ratecontrol",
c8dfb8579606 * added more options
kabi
parents: 1126
diff changeset
5943 rc_initial_cplx, 0., 9999999., 0),
c8dfb8579606 * added more options
kabi
parents: 1126
diff changeset
5944 AVOPTION_CODEC_DOUBLE("i_quant_factor", "qscale factor between p and i frames",
c8dfb8579606 * added more options
kabi
parents: 1126
diff changeset
5945 i_quant_factor, 0., 0., 0),
c8dfb8579606 * added more options
kabi
parents: 1126
diff changeset
5946 AVOPTION_CODEC_DOUBLE("i_quant_offset", "qscale offset between p and i frames",
c8dfb8579606 * added more options
kabi
parents: 1126
diff changeset
5947 i_quant_factor, -999999., 999999., 0),
c8dfb8579606 * added more options
kabi
parents: 1126
diff changeset
5948 AVOPTION_CODEC_INT("dct_algo", "dct alghorithm",
c8dfb8579606 * added more options
kabi
parents: 1126
diff changeset
5949 dct_algo, 0, 5, 0), // fixme - "Auto,FastInt,Int,MMX,MLib,Altivec"
c8dfb8579606 * added more options
kabi
parents: 1126
diff changeset
5950 AVOPTION_CODEC_DOUBLE("lumi_masking", "luminance masking",
c8dfb8579606 * added more options
kabi
parents: 1126
diff changeset
5951 lumi_masking, 0., 999999., 0),
c8dfb8579606 * added more options
kabi
parents: 1126
diff changeset
5952 AVOPTION_CODEC_DOUBLE("temporal_cplx_masking", "temporary complexity masking",
c8dfb8579606 * added more options
kabi
parents: 1126
diff changeset
5953 temporal_cplx_masking, 0., 999999., 0),
c8dfb8579606 * added more options
kabi
parents: 1126
diff changeset
5954 AVOPTION_CODEC_DOUBLE("spatial_cplx_masking", "spatial complexity masking",
c8dfb8579606 * added more options
kabi
parents: 1126
diff changeset
5955 spatial_cplx_masking, 0., 999999., 0),
c8dfb8579606 * added more options
kabi
parents: 1126
diff changeset
5956 AVOPTION_CODEC_DOUBLE("p_masking", "p block masking",
c8dfb8579606 * added more options
kabi
parents: 1126
diff changeset
5957 p_masking, 0., 999999., 0),
c8dfb8579606 * added more options
kabi
parents: 1126
diff changeset
5958 AVOPTION_CODEC_DOUBLE("dark_masking", "darkness masking",
c8dfb8579606 * added more options
kabi
parents: 1126
diff changeset
5959 dark_masking, 0., 999999., 0),
c8dfb8579606 * added more options
kabi
parents: 1126
diff changeset
5960 AVOPTION_CODEC_INT("idct_algo", "idct alghorithm",
c8dfb8579606 * added more options
kabi
parents: 1126
diff changeset
5961 idct_algo, 0, 8, 0), // fixme - "Auto,Int,Simple,SimpleMMX,LibMPEG2MMX,PS2,MLib,ARM,Altivec"
c8dfb8579606 * added more options
kabi
parents: 1126
diff changeset
5962
c8dfb8579606 * added more options
kabi
parents: 1126
diff changeset
5963 AVOPTION_CODEC_INT("mb_qmin", "minimum MB quantizer",
c8dfb8579606 * added more options
kabi
parents: 1126
diff changeset
5964 mb_qmin, 0, 8, 0),
c8dfb8579606 * added more options
kabi
parents: 1126
diff changeset
5965 AVOPTION_CODEC_INT("mb_qmax", "maximum MB quantizer",
c8dfb8579606 * added more options
kabi
parents: 1126
diff changeset
5966 mb_qmin, 0, 8, 0),
c8dfb8579606 * added more options
kabi
parents: 1126
diff changeset
5967
c8dfb8579606 * added more options
kabi
parents: 1126
diff changeset
5968 AVOPTION_CODEC_INT("me_cmp", "ME compare function",
c8dfb8579606 * added more options
kabi
parents: 1126
diff changeset
5969 me_cmp, 0, 24000000, 0),
c8dfb8579606 * added more options
kabi
parents: 1126
diff changeset
5970 AVOPTION_CODEC_INT("me_sub_cmp", "subpixel ME compare function",
c8dfb8579606 * added more options
kabi
parents: 1126
diff changeset
5971 me_sub_cmp, 0, 24000000, 0),
c8dfb8579606 * added more options
kabi
parents: 1126
diff changeset
5972
c8dfb8579606 * added more options
kabi
parents: 1126
diff changeset
5973
c8dfb8579606 * added more options
kabi
parents: 1126
diff changeset
5974 AVOPTION_CODEC_INT("dia_size", "ME diamond size & shape",
c8dfb8579606 * added more options
kabi
parents: 1126
diff changeset
5975 dia_size, 0, 24000000, 0),
c8dfb8579606 * added more options
kabi
parents: 1126
diff changeset
5976 AVOPTION_CODEC_INT("last_predictor_count", "amount of previous MV predictors",
c8dfb8579606 * added more options
kabi
parents: 1126
diff changeset
5977 last_predictor_count, 0, 24000000, 0),
c8dfb8579606 * added more options
kabi
parents: 1126
diff changeset
5978
c8dfb8579606 * added more options
kabi
parents: 1126
diff changeset
5979 AVOPTION_CODEC_INT("pre_me", "pre pass for ME",
c8dfb8579606 * added more options
kabi
parents: 1126
diff changeset
5980 pre_me, 0, 24000000, 0),
c8dfb8579606 * added more options
kabi
parents: 1126
diff changeset
5981 AVOPTION_CODEC_INT("me_pre_cmp", "ME pre pass compare function",
c8dfb8579606 * added more options
kabi
parents: 1126
diff changeset
5982 me_pre_cmp, 0, 24000000, 0),
c8dfb8579606 * added more options
kabi
parents: 1126
diff changeset
5983
c8dfb8579606 * added more options
kabi
parents: 1126
diff changeset
5984 AVOPTION_CODEC_INT("me_range", "maximum ME search range",
c8dfb8579606 * added more options
kabi
parents: 1126
diff changeset
5985 me_range, 0, 24000000, 0),
c8dfb8579606 * added more options
kabi
parents: 1126
diff changeset
5986 AVOPTION_CODEC_INT("pre_dia_size", "ME pre pass diamod size & shape",
c8dfb8579606 * added more options
kabi
parents: 1126
diff changeset
5987 pre_dia_size, 0, 24000000, 0),
c8dfb8579606 * added more options
kabi
parents: 1126
diff changeset
5988 AVOPTION_CODEC_INT("me_subpel_quality", "subpel ME quality",
c8dfb8579606 * added more options
kabi
parents: 1126
diff changeset
5989 me_subpel_quality, 0, 24000000, 0),
c8dfb8579606 * added more options
kabi
parents: 1126
diff changeset
5990 AVOPTION_CODEC_INT("me_range", "maximum ME search range",
c8dfb8579606 * added more options
kabi
parents: 1126
diff changeset
5991 me_range, 0, 24000000, 0),
1059
890b9fb44e84 * still unfinished code for Options
kabi
parents: 1051
diff changeset
5992 AVOPTION_CODEC_FLAG("psnr", "calculate PSNR of compressed frames",
890b9fb44e84 * still unfinished code for Options
kabi
parents: 1051
diff changeset
5993 flags, CODEC_FLAG_PSNR, 0),
890b9fb44e84 * still unfinished code for Options
kabi
parents: 1051
diff changeset
5994 AVOPTION_CODEC_RCOVERRIDE("rc_override", "ratecontrol override (=startframe,endframe,qscale,quality_factor)",
890b9fb44e84 * still unfinished code for Options
kabi
parents: 1051
diff changeset
5995 rc_override),
1124
64c7c76ed17c * 'externaly' visible option list begins avoptions_ prefix
kabi
parents: 1116
diff changeset
5996 AVOPTION_SUB(avoptions_common),
1059
890b9fb44e84 * still unfinished code for Options
kabi
parents: 1051
diff changeset
5997 AVOPTION_END()
890b9fb44e84 * still unfinished code for Options
kabi
parents: 1051
diff changeset
5998 };
890b9fb44e84 * still unfinished code for Options
kabi
parents: 1051
diff changeset
5999
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
6000 #ifdef CONFIG_ENCODERS
1042
a78f6f72d54e --disable-risky support
michaelni
parents: 1026
diff changeset
6001 #ifdef CONFIG_RISKY
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
6002 AVCodec h263_encoder = {
986e461dc072 Initial revision
glantau
parents:
diff changeset
6003 "h263",
986e461dc072 Initial revision
glantau
parents:
diff changeset
6004 CODEC_TYPE_VIDEO,
986e461dc072 Initial revision
glantau
parents:
diff changeset
6005 CODEC_ID_H263,
986e461dc072 Initial revision
glantau
parents:
diff changeset
6006 sizeof(MpegEncContext),
986e461dc072 Initial revision
glantau
parents:
diff changeset
6007 MPV_encode_init,
986e461dc072 Initial revision
glantau
parents:
diff changeset
6008 MPV_encode_picture,
986e461dc072 Initial revision
glantau
parents:
diff changeset
6009 MPV_encode_end,
986e461dc072 Initial revision
glantau
parents:
diff changeset
6010 };
986e461dc072 Initial revision
glantau
parents:
diff changeset
6011
986e461dc072 Initial revision
glantau
parents:
diff changeset
6012 AVCodec h263p_encoder = {
986e461dc072 Initial revision
glantau
parents:
diff changeset
6013 "h263p",
986e461dc072 Initial revision
glantau
parents:
diff changeset
6014 CODEC_TYPE_VIDEO,
986e461dc072 Initial revision
glantau
parents:
diff changeset
6015 CODEC_ID_H263P,
986e461dc072 Initial revision
glantau
parents:
diff changeset
6016 sizeof(MpegEncContext),
986e461dc072 Initial revision
glantau
parents:
diff changeset
6017 MPV_encode_init,
986e461dc072 Initial revision
glantau
parents:
diff changeset
6018 MPV_encode_picture,
986e461dc072 Initial revision
glantau
parents:
diff changeset
6019 MPV_encode_end,
986e461dc072 Initial revision
glantau
parents:
diff changeset
6020 };
986e461dc072 Initial revision
glantau
parents:
diff changeset
6021
1353
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1344
diff changeset
6022 AVCodec flv_encoder = {
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1344
diff changeset
6023 "flv",
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1344
diff changeset
6024 CODEC_TYPE_VIDEO,
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1344
diff changeset
6025 CODEC_ID_FLV1,
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1344
diff changeset
6026 sizeof(MpegEncContext),
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1344
diff changeset
6027 MPV_encode_init,
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1344
diff changeset
6028 MPV_encode_picture,
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1344
diff changeset
6029 MPV_encode_end,
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1344
diff changeset
6030 };
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1344
diff changeset
6031
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
6032 AVCodec rv10_encoder = {
986e461dc072 Initial revision
glantau
parents:
diff changeset
6033 "rv10",
986e461dc072 Initial revision
glantau
parents:
diff changeset
6034 CODEC_TYPE_VIDEO,
986e461dc072 Initial revision
glantau
parents:
diff changeset
6035 CODEC_ID_RV10,
986e461dc072 Initial revision
glantau
parents:
diff changeset
6036 sizeof(MpegEncContext),
986e461dc072 Initial revision
glantau
parents:
diff changeset
6037 MPV_encode_init,
986e461dc072 Initial revision
glantau
parents:
diff changeset
6038 MPV_encode_picture,
986e461dc072 Initial revision
glantau
parents:
diff changeset
6039 MPV_encode_end,
986e461dc072 Initial revision
glantau
parents:
diff changeset
6040 };
986e461dc072 Initial revision
glantau
parents:
diff changeset
6041
71
79be2c581c01 changed opendivx to mpeg4
glantau
parents: 64
diff changeset
6042 AVCodec mpeg4_encoder = {
79be2c581c01 changed opendivx to mpeg4
glantau
parents: 64
diff changeset
6043 "mpeg4",
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
6044 CODEC_TYPE_VIDEO,
71
79be2c581c01 changed opendivx to mpeg4
glantau
parents: 64
diff changeset
6045 CODEC_ID_MPEG4,
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
6046 sizeof(MpegEncContext),
986e461dc072 Initial revision
glantau
parents:
diff changeset
6047 MPV_encode_init,
986e461dc072 Initial revision
glantau
parents:
diff changeset
6048 MPV_encode_picture,
986e461dc072 Initial revision
glantau
parents:
diff changeset
6049 MPV_encode_end,
1059
890b9fb44e84 * still unfinished code for Options
kabi
parents: 1051
diff changeset
6050 .options = mpeg4_options,
2111
3c1dba53954e 10l (fixes delayed frames during encoding)
michael
parents: 2074
diff changeset
6051 .capabilities= CODEC_CAP_DELAY,
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
6052 };
986e461dc072 Initial revision
glantau
parents:
diff changeset
6053
307
764aeec1320e msmpeg4v2 decoding (no encoding yet)
michaelni
parents: 302
diff changeset
6054 AVCodec msmpeg4v1_encoder = {
764aeec1320e msmpeg4v2 decoding (no encoding yet)
michaelni
parents: 302
diff changeset
6055 "msmpeg4v1",
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
6056 CODEC_TYPE_VIDEO,
307
764aeec1320e msmpeg4v2 decoding (no encoding yet)
michaelni
parents: 302
diff changeset
6057 CODEC_ID_MSMPEG4V1,
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
6058 sizeof(MpegEncContext),
986e461dc072 Initial revision
glantau
parents:
diff changeset
6059 MPV_encode_init,
986e461dc072 Initial revision
glantau
parents:
diff changeset
6060 MPV_encode_picture,
986e461dc072 Initial revision
glantau
parents:
diff changeset
6061 MPV_encode_end,
1130
c8dfb8579606 * added more options
kabi
parents: 1126
diff changeset
6062 .options = mpeg4_options,
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
6063 };
307
764aeec1320e msmpeg4v2 decoding (no encoding yet)
michaelni
parents: 302
diff changeset
6064
764aeec1320e msmpeg4v2 decoding (no encoding yet)
michaelni
parents: 302
diff changeset
6065 AVCodec msmpeg4v2_encoder = {
764aeec1320e msmpeg4v2 decoding (no encoding yet)
michaelni
parents: 302
diff changeset
6066 "msmpeg4v2",
764aeec1320e msmpeg4v2 decoding (no encoding yet)
michaelni
parents: 302
diff changeset
6067 CODEC_TYPE_VIDEO,
764aeec1320e msmpeg4v2 decoding (no encoding yet)
michaelni
parents: 302
diff changeset
6068 CODEC_ID_MSMPEG4V2,
764aeec1320e msmpeg4v2 decoding (no encoding yet)
michaelni
parents: 302
diff changeset
6069 sizeof(MpegEncContext),
764aeec1320e msmpeg4v2 decoding (no encoding yet)
michaelni
parents: 302
diff changeset
6070 MPV_encode_init,
764aeec1320e msmpeg4v2 decoding (no encoding yet)
michaelni
parents: 302
diff changeset
6071 MPV_encode_picture,
764aeec1320e msmpeg4v2 decoding (no encoding yet)
michaelni
parents: 302
diff changeset
6072 MPV_encode_end,
1130
c8dfb8579606 * added more options
kabi
parents: 1126
diff changeset
6073 .options = mpeg4_options,
307
764aeec1320e msmpeg4v2 decoding (no encoding yet)
michaelni
parents: 302
diff changeset
6074 };
764aeec1320e msmpeg4v2 decoding (no encoding yet)
michaelni
parents: 302
diff changeset
6075
764aeec1320e msmpeg4v2 decoding (no encoding yet)
michaelni
parents: 302
diff changeset
6076 AVCodec msmpeg4v3_encoder = {
764aeec1320e msmpeg4v2 decoding (no encoding yet)
michaelni
parents: 302
diff changeset
6077 "msmpeg4",
764aeec1320e msmpeg4v2 decoding (no encoding yet)
michaelni
parents: 302
diff changeset
6078 CODEC_TYPE_VIDEO,
764aeec1320e msmpeg4v2 decoding (no encoding yet)
michaelni
parents: 302
diff changeset
6079 CODEC_ID_MSMPEG4V3,
764aeec1320e msmpeg4v2 decoding (no encoding yet)
michaelni
parents: 302
diff changeset
6080 sizeof(MpegEncContext),
764aeec1320e msmpeg4v2 decoding (no encoding yet)
michaelni
parents: 302
diff changeset
6081 MPV_encode_init,
764aeec1320e msmpeg4v2 decoding (no encoding yet)
michaelni
parents: 302
diff changeset
6082 MPV_encode_picture,
764aeec1320e msmpeg4v2 decoding (no encoding yet)
michaelni
parents: 302
diff changeset
6083 MPV_encode_end,
1130
c8dfb8579606 * added more options
kabi
parents: 1126
diff changeset
6084 .options = mpeg4_options,
307
764aeec1320e msmpeg4v2 decoding (no encoding yet)
michaelni
parents: 302
diff changeset
6085 };
499
8b7a54d58549 wmv1 support
michaelni
parents: 487
diff changeset
6086
8b7a54d58549 wmv1 support
michaelni
parents: 487
diff changeset
6087 AVCodec wmv1_encoder = {
8b7a54d58549 wmv1 support
michaelni
parents: 487
diff changeset
6088 "wmv1",
8b7a54d58549 wmv1 support
michaelni
parents: 487
diff changeset
6089 CODEC_TYPE_VIDEO,
8b7a54d58549 wmv1 support
michaelni
parents: 487
diff changeset
6090 CODEC_ID_WMV1,
8b7a54d58549 wmv1 support
michaelni
parents: 487
diff changeset
6091 sizeof(MpegEncContext),
8b7a54d58549 wmv1 support
michaelni
parents: 487
diff changeset
6092 MPV_encode_init,
8b7a54d58549 wmv1 support
michaelni
parents: 487
diff changeset
6093 MPV_encode_picture,
8b7a54d58549 wmv1 support
michaelni
parents: 487
diff changeset
6094 MPV_encode_end,
1130
c8dfb8579606 * added more options
kabi
parents: 1126
diff changeset
6095 .options = mpeg4_options,
499
8b7a54d58549 wmv1 support
michaelni
parents: 487
diff changeset
6096 };
8b7a54d58549 wmv1 support
michaelni
parents: 487
diff changeset
6097
1042
a78f6f72d54e --disable-risky support
michaelni
parents: 1026
diff changeset
6098 #endif
a78f6f72d54e --disable-risky support
michaelni
parents: 1026
diff changeset
6099
a78f6f72d54e --disable-risky support
michaelni
parents: 1026
diff changeset
6100 AVCodec mjpeg_encoder = {
a78f6f72d54e --disable-risky support
michaelni
parents: 1026
diff changeset
6101 "mjpeg",
a78f6f72d54e --disable-risky support
michaelni
parents: 1026
diff changeset
6102 CODEC_TYPE_VIDEO,
a78f6f72d54e --disable-risky support
michaelni
parents: 1026
diff changeset
6103 CODEC_ID_MJPEG,
a78f6f72d54e --disable-risky support
michaelni
parents: 1026
diff changeset
6104 sizeof(MpegEncContext),
a78f6f72d54e --disable-risky support
michaelni
parents: 1026
diff changeset
6105 MPV_encode_init,
a78f6f72d54e --disable-risky support
michaelni
parents: 1026
diff changeset
6106 MPV_encode_picture,
a78f6f72d54e --disable-risky support
michaelni
parents: 1026
diff changeset
6107 MPV_encode_end,
a78f6f72d54e --disable-risky support
michaelni
parents: 1026
diff changeset
6108 };
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
6109
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
6110 #endif //CONFIG_ENCODERS