Mercurial > libavcodec.hg
annotate mpegvideo.c @ 5310:9aa9197034d7 libavcodec
AC-3 decoder, soc revision 40, Aug 9 00:10:14 2006 UTC by cloud9
More code cleanup.
Window is now runtime generated.
Fixed the bugs in rematrixing routine and
in Decoding AC3 Bitstreams when coupling is in use.
Still struggling to find out what affects the quality of
the produced sound. Can anybody have a look at the
imdct routines do_imdct_256 and do_imdct_512 and tell me
whether it is the correctly implemented as described in
standard.
author | jbr |
---|---|
date | Sat, 14 Jul 2007 15:57:51 +0000 |
parents | 4393e09e32ec |
children | 07844149dfa9 |
rev | line source |
---|---|
0 | 1 /* |
2 * The simplest mpeg encoder (well, it was the simplest!) | |
429 | 3 * Copyright (c) 2000,2001 Fabrice Bellard. |
1739
07a484280a82
copyright year update of the files i touched and remembered, things look annoyingly unmaintained otherwise
michael
parents:
1729
diff
changeset
|
4 * Copyright (c) 2002-2004 Michael Niedermayer <michaelni@gmx.at> |
0 | 5 * |
5214 | 6 * 4MV & hq & B-frame encoding stuff by Michael Niedermayer <michaelni@gmx.at> |
7 * | |
3947
c8c591fe26f8
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
3939
diff
changeset
|
8 * This file is part of FFmpeg. |
c8c591fe26f8
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
3939
diff
changeset
|
9 * |
c8c591fe26f8
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
3939
diff
changeset
|
10 * FFmpeg is free software; you can redistribute it and/or |
429 | 11 * modify it under the terms of the GNU Lesser General Public |
12 * License as published by the Free Software Foundation; either | |
3947
c8c591fe26f8
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
3939
diff
changeset
|
13 * version 2.1 of the License, or (at your option) any later version. |
0 | 14 * |
3947
c8c591fe26f8
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
3939
diff
changeset
|
15 * FFmpeg is distributed in the hope that it will be useful, |
0 | 16 * but WITHOUT ANY WARRANTY; without even the implied warranty of |
429 | 17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
18 * Lesser General Public License for more details. | |
0 | 19 * |
429 | 20 * You should have received a copy of the GNU Lesser General Public |
3947
c8c591fe26f8
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
3939
diff
changeset
|
21 * License along with FFmpeg; if not, write to the Free Software |
3036
0b546eab515d
Update licensing information: The FSF changed postal address.
diego
parents:
3011
diff
changeset
|
22 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA |
0 | 23 */ |
2967 | 24 |
1106 | 25 /** |
26 * @file mpegvideo.c | |
27 * The simplest mpeg encoder (well, it was the simplest!). | |
2967 | 28 */ |
29 | |
0 | 30 #include "avcodec.h" |
31 #include "dsputil.h" | |
32 #include "mpegvideo.h" | |
5204 | 33 #include "mpegvideo_common.h" |
5028 | 34 #include "mjpegenc.h" |
4967
6d45158e0249
disable reference to msmpeg4 and wmv2 code when those codecs are not compiled in
aurel
parents:
4668
diff
changeset
|
35 #include "msmpeg4.h" |
1557 | 36 #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
|
37 #include <limits.h> |
0 | 38 |
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
|
39 //#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
|
40 //#include <assert.h> |
706
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
41 |
2967 | 42 static void dct_unquantize_mpeg1_intra_c(MpegEncContext *s, |
1689 | 43 DCTELEM *block, int n, int qscale); |
2967 | 44 static void dct_unquantize_mpeg1_inter_c(MpegEncContext *s, |
1689 | 45 DCTELEM *block, int n, int qscale); |
46 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
|
47 DCTELEM *block, int n, int qscale); |
3281
7fac25904a8b
missmatch control for mpeg2 intra dequantization if bitexact=1
michael
parents:
3268
diff
changeset
|
48 static void dct_unquantize_mpeg2_intra_bitexact(MpegEncContext *s, |
7fac25904a8b
missmatch control for mpeg2 intra dequantization if bitexact=1
michael
parents:
3268
diff
changeset
|
49 DCTELEM *block, int n, int qscale); |
1689 | 50 static void dct_unquantize_mpeg2_inter_c(MpegEncContext *s, |
325 | 51 DCTELEM *block, int n, int qscale); |
2967 | 52 static void dct_unquantize_h263_intra_c(MpegEncContext *s, |
1689 | 53 DCTELEM *block, int n, int qscale); |
2967 | 54 static void dct_unquantize_h263_inter_c(MpegEncContext *s, |
13
174ef88f619a
use block[] in structure to have it aligned on 8 bytes for mmx optimizations - dct_unquantize is always a function pointer - added specialized dct_unquantize_h263
glantau
parents:
8
diff
changeset
|
55 DCTELEM *block, int n, int qscale); |
1064 | 56 static void draw_edges_c(uint8_t *buf, int wrap, int width, int height, int w); |
206 | 57 |
1381 | 58 #ifdef HAVE_XVMC |
59 extern int XVMC_field_start(MpegEncContext*s, AVCodecContext *avctx); | |
60 extern void XVMC_field_end(MpegEncContext *s); | |
1580
628bf341e099
XvMC speedup by removing one memcpy and doing MB packing
iive
parents:
1579
diff
changeset
|
61 extern void XVMC_decode_mb(MpegEncContext *s); |
1381 | 62 #endif |
63 | |
1064 | 64 void (*draw_edges)(uint8_t *buf, int wrap, int width, int height, int w)= draw_edges_c; |
206 | 65 |
0 | 66 |
67 /* enable all paranoid tests for rounding, overflows, etc... */ | |
68 //#define PARANOID | |
69 | |
70 //#define DEBUG | |
71 | |
321 | 72 |
1644 | 73 static const uint8_t ff_default_chroma_qscale_table[32]={ |
74 // 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 | |
75 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 | |
76 }; | |
77 | |
1273 | 78 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
|
79 int i; |
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
80 int end; |
2967 | 81 |
764 | 82 st->scantable= src_scantable; |
706
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
83 |
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
84 for(i=0; i<64; i++){ |
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
85 int j; |
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
86 j = src_scantable[i]; |
1273 | 87 st->permutated[i] = permutation[j]; |
828
ace3ccd18dd2
Altivec Patch (Mark III) by (Dieter Shirley <dieters at schemasoft dot com>)
michaelni
parents:
815
diff
changeset
|
88 #ifdef ARCH_POWERPC |
ace3ccd18dd2
Altivec Patch (Mark III) by (Dieter Shirley <dieters at schemasoft dot com>)
michaelni
parents:
815
diff
changeset
|
89 st->inverse[j] = i; |
ace3ccd18dd2
Altivec Patch (Mark III) by (Dieter Shirley <dieters at schemasoft dot com>)
michaelni
parents:
815
diff
changeset
|
90 #endif |
706
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
91 } |
2967 | 92 |
706
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
93 end=-1; |
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
94 for(i=0; i<64; i++){ |
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
95 int j; |
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
96 j = st->permutated[i]; |
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
97 if(j>end) end=j; |
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
98 st->raster_end[i]= end; |
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
99 } |
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
100 } |
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
101 |
3086 | 102 const uint8_t *ff_find_start_code(const uint8_t * restrict p, const uint8_t *end, uint32_t * restrict state){ |
103 int i; | |
104 | |
3092 | 105 assert(p<=end); |
106 if(p>=end) | |
107 return end; | |
108 | |
3086 | 109 for(i=0; i<3; i++){ |
110 uint32_t tmp= *state << 8; | |
111 *state= tmp + *(p++); | |
112 if(tmp == 0x100 || p==end) | |
113 return p; | |
114 } | |
115 | |
116 while(p<end){ | |
3087 | 117 if (p[-1] > 1 ) p+= 3; |
118 else if(p[-2] ) p+= 2; | |
119 else if(p[-3]|(p[-1]-1)) p++; | |
3086 | 120 else{ |
121 p++; | |
122 break; | |
123 } | |
124 } | |
125 | |
3087 | 126 p= FFMIN(p, end)-4; |
3086 | 127 *state= be2me_32(unaligned32(p)); |
128 | |
129 return p+4; | |
130 } | |
131 | |
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
|
132 /* init common dct for both encoder and decoder */ |
5213 | 133 static int DCT_common_init(MpegEncContext *s) |
0 | 134 { |
1689 | 135 s->dct_unquantize_h263_intra = dct_unquantize_h263_intra_c; |
136 s->dct_unquantize_h263_inter = dct_unquantize_h263_inter_c; | |
137 s->dct_unquantize_mpeg1_intra = dct_unquantize_mpeg1_intra_c; | |
138 s->dct_unquantize_mpeg1_inter = dct_unquantize_mpeg1_inter_c; | |
139 s->dct_unquantize_mpeg2_intra = dct_unquantize_mpeg2_intra_c; | |
3281
7fac25904a8b
missmatch control for mpeg2 intra dequantization if bitexact=1
michael
parents:
3268
diff
changeset
|
140 if(s->flags & CODEC_FLAG_BITEXACT) |
7fac25904a8b
missmatch control for mpeg2 intra dequantization if bitexact=1
michael
parents:
3268
diff
changeset
|
141 s->dct_unquantize_mpeg2_intra = dct_unquantize_mpeg2_intra_bitexact; |
1689 | 142 s->dct_unquantize_mpeg2_inter = dct_unquantize_mpeg2_inter_c; |
1092 | 143 |
5140 | 144 #if defined(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
|
145 MPV_common_init_mmx(s); |
5140 | 146 #elif defined(ARCH_ALPHA) |
514
c9f724e3a797
Update and activate dct_unquantize_h263_mvi. Thanks to M«©ns Rullg«©rd
mellum
parents:
506
diff
changeset
|
147 MPV_common_init_axp(s); |
5140 | 148 #elif defined(HAVE_MLIB) |
628
f596db4aa871
sun solaris compilation bugfix, patch by (Martin Olschewski <olschewski at zpr dot uni-koeln dot de>)
michaelni
parents:
625
diff
changeset
|
149 MPV_common_init_mlib(s); |
5140 | 150 #elif defined(HAVE_MMI) |
721
71f669e9f633
ps2 optimizations update patch by (Leon van Stuivenberg <leonvs at iae dot nl>)
michaelni
parents:
717
diff
changeset
|
151 MPV_common_init_mmi(s); |
5140 | 152 #elif defined(ARCH_ARMV4L) |
874 | 153 MPV_common_init_armv4l(s); |
5140 | 154 #elif defined(ARCH_POWERPC) |
828
ace3ccd18dd2
Altivec Patch (Mark III) by (Dieter Shirley <dieters at schemasoft dot com>)
michaelni
parents:
815
diff
changeset
|
155 MPV_common_init_ppc(s); |
5140 | 156 #elif defined(ARCH_BFIN) |
5132
a3b82ca01e68
integrating MPV_common_init_bfin into the build system and mpegvideo.c
mhoffman
parents:
5129
diff
changeset
|
157 MPV_common_init_bfin(s); |
a3b82ca01e68
integrating MPV_common_init_bfin into the build system and mpegvideo.c
mhoffman
parents:
5129
diff
changeset
|
158 #endif |
730 | 159 |
706
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
160 /* load & permutate scantables |
2967 | 161 note: only wmv uses different ones |
706
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
162 */ |
1708 | 163 if(s->alternate_scan){ |
164 ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable , ff_alternate_vertical_scan); | |
165 ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable , ff_alternate_vertical_scan); | |
166 }else{ | |
167 ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable , ff_zigzag_direct); | |
168 ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable , ff_zigzag_direct); | |
169 } | |
1273 | 170 ff_init_scantable(s->dsp.idct_permutation, &s->intra_h_scantable, ff_alternate_horizontal_scan); |
171 ff_init_scantable(s->dsp.idct_permutation, &s->intra_v_scantable, ff_alternate_vertical_scan); | |
591 | 172 |
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
|
173 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
|
174 } |
a91203b34e71
moved dct init out from mpv_common_init to dct_common_init (for less-uglier way for dv)
al3x
parents:
721
diff
changeset
|
175 |
5204 | 176 void copy_picture(Picture *dst, Picture *src){ |
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
|
177 *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
|
178 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
|
179 } |
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
|
180 |
903 | 181 /** |
924 | 182 * allocates a Picture |
183 * The pixels are allocated/set by calling get_buffer() if shared=0 | |
903 | 184 */ |
5204 | 185 int alloc_picture(MpegEncContext *s, Picture *pic, int shared){ |
5127 | 186 const int big_mb_num= s->mb_stride*(s->mb_height+1) + 1; //the +1 is needed so memset(,,stride*height) does not sig11 |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1173
diff
changeset
|
187 const int mb_array_size= s->mb_stride*s->mb_height; |
1655 | 188 const int b8_array_size= s->b8_stride*s->mb_height*2; |
189 const int b4_array_size= s->b4_stride*s->mb_height*4; | |
1168 | 190 int i; |
2967 | 191 |
924 | 192 if(shared){ |
193 assert(pic->data[0]); | |
194 assert(pic->type == 0 || pic->type == FF_BUFFER_TYPE_SHARED); | |
195 pic->type= FF_BUFFER_TYPE_SHARED; | |
196 }else{ | |
197 int r; | |
2967 | 198 |
924 | 199 assert(!pic->data[0]); |
2967 | 200 |
925 | 201 r= s->avctx->get_buffer(s->avctx, (AVFrame*)pic); |
2967 | 202 |
924 | 203 if(r<0 || !pic->age || !pic->type || !pic->data[0]){ |
2979 | 204 av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed (%d %d %d %p)\n", r, pic->age, pic->type, pic->data[0]); |
924 | 205 return -1; |
206 } | |
207 | |
208 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
|
209 av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed (stride changed)\n"); |
924 | 210 return -1; |
211 } | |
212 | |
213 if(pic->linesize[1] != pic->linesize[2]){ | |
2764 | 214 av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed (uv stride mismatch)\n"); |
924 | 215 return -1; |
216 } | |
217 | |
218 s->linesize = pic->linesize[0]; | |
219 s->uvlinesize= pic->linesize[1]; | |
903 | 220 } |
2967 | 221 |
924 | 222 if(pic->qscale_table==NULL){ |
2967 | 223 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
|
224 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
|
225 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
|
226 CHECKED_ALLOCZ(pic->mb_mean , mb_array_size * sizeof(int8_t)) |
924 | 227 } |
228 | |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1173
diff
changeset
|
229 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
|
230 CHECKED_ALLOCZ(pic->qscale_table , mb_array_size * sizeof(uint8_t)) |
1742 | 231 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
|
232 pic->mb_type= pic->mb_type_base + s->mb_stride+1; |
1168 | 233 if(s->out_format == FMT_H264){ |
234 for(i=0; i<2; i++){ | |
2570 | 235 CHECKED_ALLOCZ(pic->motion_val_base[i], 2 * (b4_array_size+4) * sizeof(int16_t)) |
236 pic->motion_val[i]= pic->motion_val_base[i]+4; | |
1948 | 237 CHECKED_ALLOCZ(pic->ref_index[i], b8_array_size * sizeof(uint8_t)) |
1655 | 238 } |
1669 | 239 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
|
240 }else if(s->out_format == FMT_H263 || s->encoding || (s->avctx->debug&FF_DEBUG_MV) || (s->avctx->debug_mv)){ |
1655 | 241 for(i=0; i<2; i++){ |
2570 | 242 CHECKED_ALLOCZ(pic->motion_val_base[i], 2 * (b8_array_size+4) * sizeof(int16_t)) |
243 pic->motion_val[i]= pic->motion_val_base[i]+4; | |
1948 | 244 CHECKED_ALLOCZ(pic->ref_index[i], b8_array_size * sizeof(uint8_t)) |
1168 | 245 } |
1669 | 246 pic->motion_subsample_log2= 3; |
1168 | 247 } |
1833
ba27ce284d07
export DCT coefficients patch by (Wolfgang Hesseler <wolfgang.hesseler at imk dot fraunhofer dot de>)
michael
parents:
1831
diff
changeset
|
248 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
|
249 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
|
250 } |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1173
diff
changeset
|
251 pic->qstride= s->mb_stride; |
1546 | 252 CHECKED_ALLOCZ(pic->pan_scan , 1 * sizeof(AVPanScan)) |
924 | 253 } |
1168 | 254 |
5129 | 255 /* It might be nicer if the application would keep track of these |
256 * but it would require an API change. */ | |
1021
2d7c9f5738de
trying to fix mb skip bug in mpeg1/2 if slices are not used
michaelni
parents:
1014
diff
changeset
|
257 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
|
258 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
|
259 if(pic->age < PREV_PICT_TYPES_BUFFER_SIZE && s->prev_pict_types[pic->age] == B_TYPE) |
5129 | 260 pic->age= INT_MAX; // Skipped MBs in B-frames are quite rare in MPEG-1/2 and it is a bit tricky to skip them anyway. |
2967 | 261 |
903 | 262 return 0; |
263 fail: //for the CHECKED_ALLOCZ macro | |
264 return -1; | |
265 } | |
266 | |
924 | 267 /** |
268 * deallocates a picture | |
269 */ | |
903 | 270 static void free_picture(MpegEncContext *s, Picture *pic){ |
271 int i; | |
924 | 272 |
273 if(pic->data[0] && pic->type!=FF_BUFFER_TYPE_SHARED){ | |
925 | 274 s->avctx->release_buffer(s->avctx, (AVFrame*)pic); |
924 | 275 } |
276 | |
903 | 277 av_freep(&pic->mb_var); |
278 av_freep(&pic->mc_mb_var); | |
279 av_freep(&pic->mb_mean); | |
280 av_freep(&pic->mbskip_table); | |
281 av_freep(&pic->qscale_table); | |
1168 | 282 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
|
283 av_freep(&pic->dct_coeff); |
1546 | 284 av_freep(&pic->pan_scan); |
1168 | 285 pic->mb_type= NULL; |
286 for(i=0; i<2; i++){ | |
1655 | 287 av_freep(&pic->motion_val_base[i]); |
1168 | 288 av_freep(&pic->ref_index[i]); |
289 } | |
2967 | 290 |
1214 | 291 if(pic->type == FF_BUFFER_TYPE_SHARED){ |
924 | 292 for(i=0; i<4; i++){ |
293 pic->base[i]= | |
294 pic->data[i]= NULL; | |
295 } | |
2967 | 296 pic->type= 0; |
903 | 297 } |
298 } | |
299 | |
1799 | 300 static int init_duplicate_context(MpegEncContext *s, MpegEncContext *base){ |
301 int i; | |
302 | |
2967 | 303 // edge emu needs blocksize + filter length - 1 (=17x17 for halfpel / 21x21 for h264) |
3316 | 304 CHECKED_ALLOCZ(s->allocated_edge_emu_buffer, (s->width+64)*2*21*2); //(width + edge + align)*interlaced*MBsize*tolerance |
305 s->edge_emu_buffer= s->allocated_edge_emu_buffer + (s->width+64)*2*21; | |
1799 | 306 |
5127 | 307 //FIXME should be linesize instead of s->width*2 but that is not known before get_buffer() |
2967 | 308 CHECKED_ALLOCZ(s->me.scratchpad, (s->width+64)*4*16*2*sizeof(uint8_t)) |
1799 | 309 s->rd_scratchpad= s->me.scratchpad; |
310 s->b_scratchpad= s->me.scratchpad; | |
311 s->obmc_scratchpad= s->me.scratchpad + 16; | |
312 if (s->encoding) { | |
313 CHECKED_ALLOCZ(s->me.map , ME_MAP_SIZE*sizeof(uint32_t)) | |
314 CHECKED_ALLOCZ(s->me.score_map, ME_MAP_SIZE*sizeof(uint32_t)) | |
315 if(s->avctx->noise_reduction){ | |
316 CHECKED_ALLOCZ(s->dct_error_sum, 2 * 64 * sizeof(int)) | |
317 } | |
2967 | 318 } |
1848
c72589baee53
initial chroma_format changes,xvmc tweaks and codec_cap
iive
parents:
1846
diff
changeset
|
319 CHECKED_ALLOCZ(s->blocks, 64*12*2 * sizeof(DCTELEM)) |
1799 | 320 s->block= s->blocks[0]; |
321 | |
322 for(i=0;i<12;i++){ | |
323 s->pblocks[i] = (short *)(&s->block[i]); | |
324 } | |
325 return 0; | |
326 fail: | |
327 return -1; //free() through MPV_common_end() | |
328 } | |
329 | |
330 static void free_duplicate_context(MpegEncContext *s){ | |
331 if(s==NULL) return; | |
332 | |
333 av_freep(&s->allocated_edge_emu_buffer); s->edge_emu_buffer= NULL; | |
334 av_freep(&s->me.scratchpad); | |
2967 | 335 s->rd_scratchpad= |
336 s->b_scratchpad= | |
1799 | 337 s->obmc_scratchpad= NULL; |
2967 | 338 |
1799 | 339 av_freep(&s->dct_error_sum); |
340 av_freep(&s->me.map); | |
341 av_freep(&s->me.score_map); | |
342 av_freep(&s->blocks); | |
343 s->block= NULL; | |
344 } | |
345 | |
346 static void backup_duplicate_context(MpegEncContext *bak, MpegEncContext *src){ | |
347 #define COPY(a) bak->a= src->a | |
348 COPY(allocated_edge_emu_buffer); | |
349 COPY(edge_emu_buffer); | |
350 COPY(me.scratchpad); | |
351 COPY(rd_scratchpad); | |
352 COPY(b_scratchpad); | |
353 COPY(obmc_scratchpad); | |
354 COPY(me.map); | |
355 COPY(me.score_map); | |
356 COPY(blocks); | |
357 COPY(block); | |
358 COPY(start_mb_y); | |
359 COPY(end_mb_y); | |
360 COPY(me.map_generation); | |
361 COPY(pb); | |
362 COPY(dct_error_sum); | |
1810 | 363 COPY(dct_count[0]); |
364 COPY(dct_count[1]); | |
1799 | 365 #undef COPY |
366 } | |
367 | |
1827 | 368 void ff_update_duplicate_context(MpegEncContext *dst, MpegEncContext *src){ |
1799 | 369 MpegEncContext bak; |
1827 | 370 int i; |
1799 | 371 //FIXME copy only needed parts |
372 //START_TIMER | |
373 backup_duplicate_context(&bak, dst); | |
374 memcpy(dst, src, sizeof(MpegEncContext)); | |
375 backup_duplicate_context(dst, &bak); | |
1827 | 376 for(i=0;i<12;i++){ |
377 dst->pblocks[i] = (short *)(&dst->block[i]); | |
378 } | |
1799 | 379 //STOP_TIMER("update_duplicate_context") //about 10k cycles / 0.01 sec for 1000frames on 1ghz with 2 threads |
380 } | |
381 | |
1892 | 382 /** |
383 * sets the given MpegEncContext to common defaults (same for encoding and decoding). | |
384 * the changed fields will not depend upon the prior state of the MpegEncContext. | |
385 */ | |
5204 | 386 void MPV_common_defaults(MpegEncContext *s){ |
1892 | 387 s->y_dc_scale_table= |
388 s->c_dc_scale_table= ff_mpeg1_dc_scale_table; | |
389 s->chroma_qscale_table= ff_default_chroma_qscale_table; | |
390 s->progressive_frame= 1; | |
391 s->progressive_sequence= 1; | |
392 s->picture_structure= PICT_FRAME; | |
393 | |
394 s->coded_picture_number = 0; | |
395 s->picture_number = 0; | |
396 s->input_picture_number = 0; | |
397 | |
398 s->picture_in_gop_number = 0; | |
1894 | 399 |
400 s->f_code = 1; | |
401 s->b_code = 1; | |
1892 | 402 } |
403 | |
404 /** | |
405 * sets the given MpegEncContext to defaults for decoding. | |
406 * the changed fields will not depend upon the prior state of the MpegEncContext. | |
407 */ | |
408 void MPV_decode_defaults(MpegEncContext *s){ | |
409 MPV_common_defaults(s); | |
410 } | |
411 | |
412 /** | |
413 * init common structure for both encoder and decoder. | |
414 * this assumes that some variables like width/height are already set | |
415 */ | |
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
|
416 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
|
417 { |
1708 | 418 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
|
419 |
3070 | 420 s->mb_height = (s->height + 15) / 16; |
421 | |
422 if(s->avctx->thread_count > MAX_THREADS || (s->avctx->thread_count > s->mb_height && s->mb_height)){ | |
1989 | 423 av_log(s->avctx, AV_LOG_ERROR, "too many threads\n"); |
424 return -1; | |
425 } | |
426 | |
2422 | 427 if((s->width || s->height) && avcodec_check_dimensions(s->avctx, s->width, s->height)) |
428 return -1; | |
429 | |
1092 | 430 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
|
431 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
|
432 |
754 | 433 s->flags= s->avctx->flags; |
1754
bdf3927bf8c5
closed gop support & flags2 as all bits in flags are used
michael
parents:
1751
diff
changeset
|
434 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
|
435 |
903 | 436 s->mb_width = (s->width + 15) / 16; |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1173
diff
changeset
|
437 s->mb_stride = s->mb_width + 1; |
1655 | 438 s->b8_stride = s->mb_width*2 + 1; |
439 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
|
440 mb_array_size= s->mb_height * s->mb_stride; |
1708 | 441 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
|
442 |
2074
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
443 /* set chroma shifts */ |
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
444 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
|
445 &(s->chroma_y_shift) ); |
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
446 |
853
eacc2dd8fd9d
* using DSPContext - so each codec could use its local (sub)set of CPU extension
kabi
parents:
847
diff
changeset
|
447 /* 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
|
448 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
|
449 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
|
450 |
eacc2dd8fd9d
* using DSPContext - so each codec could use its local (sub)set of CPU extension
kabi
parents:
847
diff
changeset
|
451 s->mb_num = s->mb_width * s->mb_height; |
2967 | 452 |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1173
diff
changeset
|
453 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
|
454 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
|
455 s->block_wrap[2]= |
1938
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1918
diff
changeset
|
456 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
|
457 s->block_wrap[4]= |
1938
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1918
diff
changeset
|
458 s->block_wrap[5]= s->mb_stride; |
2967 | 459 |
1938
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1918
diff
changeset
|
460 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
|
461 c_size = s->mb_stride * (s->mb_height + 1); |
756 | 462 yc_size = y_size + 2 * c_size; |
2967 | 463 |
701 | 464 /* convert fourcc to upper case */ |
4155
0f28fc219799
add codec_tag and codec_stream_tag to MpegEncContext to not alter avctx values
bcoudurier
parents:
4122
diff
changeset
|
465 s->codec_tag= toupper( s->avctx->codec_tag &0xFF) |
1116 | 466 + (toupper((s->avctx->codec_tag>>8 )&0xFF)<<8 ) |
2967 | 467 + (toupper((s->avctx->codec_tag>>16)&0xFF)<<16) |
1116 | 468 + (toupper((s->avctx->codec_tag>>24)&0xFF)<<24); |
582
5132a4ee50cd
different edge positions fixed with edge emu / dr1
michaelni
parents:
575
diff
changeset
|
469 |
4155
0f28fc219799
add codec_tag and codec_stream_tag to MpegEncContext to not alter avctx values
bcoudurier
parents:
4122
diff
changeset
|
470 s->stream_codec_tag= toupper( s->avctx->stream_codec_tag &0xFF) |
1458
40b69d238beb
AVI stream header FCC / more reliable detection of old xvid files
michaelni
parents:
1451
diff
changeset
|
471 + (toupper((s->avctx->stream_codec_tag>>8 )&0xFF)<<8 ) |
2967 | 472 + (toupper((s->avctx->stream_codec_tag>>16)&0xFF)<<16) |
1458
40b69d238beb
AVI stream header FCC / more reliable detection of old xvid files
michaelni
parents:
1451
diff
changeset
|
473 + (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
|
474 |
925 | 475 s->avctx->coded_frame= (AVFrame*)&s->current_picture; |
903 | 476 |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1173
diff
changeset
|
477 CHECKED_ALLOCZ(s->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
|
478 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
|
479 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
|
480 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
|
481 } |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1173
diff
changeset
|
482 } |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1173
diff
changeset
|
483 s->mb_index2xy[ s->mb_height*s->mb_width ] = (s->mb_height-1)*s->mb_stride + s->mb_width; //FIXME really needed? |
2967 | 484 |
232
b640ec5948b0
- Now the ME is done for the entire picture when enconding, the
pulento
parents:
231
diff
changeset
|
485 if (s->encoding) { |
324 | 486 /* 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
|
487 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
|
488 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
|
489 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
|
490 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
|
491 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
|
492 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
|
493 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
|
494 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
|
495 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
|
496 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
|
497 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
|
498 s->b_direct_mv_table = s->b_direct_mv_table_base + s->mb_stride + 1; |
324 | 499 |
650
ef4a33aad86e
reducing sizeof MpegEncContext to avoid stack overflow on crap M$ windo$
michaelni
parents:
635
diff
changeset
|
500 if(s->msmpeg4_version){ |
ef4a33aad86e
reducing sizeof MpegEncContext to avoid stack overflow on crap M$ windo$
michaelni
parents:
635
diff
changeset
|
501 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
|
502 } |
612 | 503 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
|
504 |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1173
diff
changeset
|
505 /* Allocate MB type table */ |
1708 | 506 CHECKED_ALLOCZ(s->mb_type , mb_array_size * sizeof(uint16_t)) //needed for encoding |
2967 | 507 |
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
|
508 CHECKED_ALLOCZ(s->lambda_table, mb_array_size * sizeof(int)) |
2967 | 509 |
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
|
510 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
|
511 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
|
512 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
|
513 CHECKED_ALLOCZ(s->q_inter_matrix16, 64*32*2 * sizeof(uint16_t)) |
1556 | 514 CHECKED_ALLOCZ(s->input_picture, MAX_PICTURE_COUNT * sizeof(Picture*)) |
515 CHECKED_ALLOCZ(s->reordered_input_picture, MAX_PICTURE_COUNT * sizeof(Picture*)) | |
2967 | 516 |
1597 | 517 if(s->avctx->noise_reduction){ |
518 CHECKED_ALLOCZ(s->dct_offset, 2 * 64 * sizeof(uint16_t)) | |
519 } | |
232
b640ec5948b0
- Now the ME is done for the entire picture when enconding, the
pulento
parents:
231
diff
changeset
|
520 } |
1552
26c6ecba99a1
dynamic alloc of picture structs instead of putting them in MpegEncContext
michael
parents:
1546
diff
changeset
|
521 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
|
522 |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1173
diff
changeset
|
523 CHECKED_ALLOCZ(s->error_status_table, mb_array_size*sizeof(uint8_t)) |
2967 | 524 |
1708 | 525 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
|
526 /* interlaced direct mode decoding tables */ |
1708 | 527 for(i=0; i<2; i++){ |
528 int j, k; | |
529 for(j=0; j<2; j++){ | |
530 for(k=0; k<2; k++){ | |
531 CHECKED_ALLOCZ(s->b_field_mv_table_base[i][j][k] , mv_table_size * 2 * sizeof(int16_t)) | |
532 s->b_field_mv_table[i][j][k] = s->b_field_mv_table_base[i][j][k] + s->mb_stride + 1; | |
533 } | |
534 CHECKED_ALLOCZ(s->b_field_select_table[i][j] , mb_array_size * 2 * sizeof(uint8_t)) | |
535 CHECKED_ALLOCZ(s->p_field_mv_table_base[i][j] , mv_table_size * 2 * sizeof(int16_t)) | |
536 s->p_field_mv_table[i][j] = s->p_field_mv_table_base[i][j] + s->mb_stride + 1; | |
537 } | |
538 CHECKED_ALLOCZ(s->p_field_select_table[i] , mb_array_size * 2 * sizeof(uint8_t)) | |
539 } | |
0 | 540 } |
767 | 541 if (s->out_format == FMT_H263) { |
0 | 542 /* ac values */ |
1938
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1918
diff
changeset
|
543 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
|
544 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
|
545 s->ac_val[1] = s->ac_val_base + y_size + s->mb_stride + 1; |
0 | 546 s->ac_val[2] = s->ac_val[1] + c_size; |
2967 | 547 |
0 | 548 /* cbp values */ |
1938
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1918
diff
changeset
|
549 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
|
550 s->coded_block= s->coded_block_base + s->b8_stride + 1; |
2967 | 551 |
456 | 552 /* cbp, ac_pred, pred_dir */ |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1173
diff
changeset
|
553 CHECKED_ALLOCZ(s->cbp_table , mb_array_size * sizeof(uint8_t)) |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1173
diff
changeset
|
554 CHECKED_ALLOCZ(s->pred_dir_table, mb_array_size * sizeof(uint8_t)) |
197
21abf1b20016
different fix, s->mbintra_table used only if h263_pred set. - patch by Michael Niedermayer <michaelni@gmx.at>
arpi_esp
parents:
196
diff
changeset
|
555 } |
2967 | 556 |
756 | 557 if (s->h263_pred || s->h263_plus || !s->encoding) { |
558 /* dc values */ | |
559 //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
|
560 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
|
561 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
|
562 s->dc_val[1] = s->dc_val_base + y_size + s->mb_stride + 1; |
756 | 563 s->dc_val[2] = s->dc_val[1] + c_size; |
564 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
|
565 s->dc_val_base[i] = 1024; |
756 | 566 } |
567 | |
611
3214d3f4519e
error concealment needs the mbintra_table so it should allways be allocated
michaelni
parents:
608
diff
changeset
|
568 /* 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
|
569 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
|
570 memset(s->mbintra_table, 1, mb_array_size); |
2967 | 571 |
7
1d3ac9654178
added skip macroblock optimization (big perf win on black regions for example)
glantau
parents:
0
diff
changeset
|
572 /* 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
|
573 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
|
574 //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
|
575 CHECKED_ALLOCZ(s->prev_pict_types, PREV_PICT_TYPES_BUFFER_SIZE); |
2967 | 576 |
842
e460775adb38
cleanup (breaks compatibility, requested by fabrice)
michaelni
parents:
828
diff
changeset
|
577 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
|
578 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
|
579 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
|
580 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
|
581 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
|
582 } |
842
e460775adb38
cleanup (breaks compatibility, requested by fabrice)
michaelni
parents:
828
diff
changeset
|
583 |
0 | 584 s->context_initialized = 1; |
1799 | 585 |
586 s->thread_context[0]= s; | |
587 for(i=1; i<s->avctx->thread_count; i++){ | |
588 s->thread_context[i]= av_malloc(sizeof(MpegEncContext)); | |
589 memcpy(s->thread_context[i], s, sizeof(MpegEncContext)); | |
590 } | |
591 | |
592 for(i=0; i<s->avctx->thread_count; i++){ | |
593 if(init_duplicate_context(s->thread_context[i], s) < 0) | |
594 goto fail; | |
595 s->thread_context[i]->start_mb_y= (s->mb_height*(i ) + s->avctx->thread_count/2) / s->avctx->thread_count; | |
596 s->thread_context[i]->end_mb_y = (s->mb_height*(i+1) + s->avctx->thread_count/2) / s->avctx->thread_count; | |
597 } | |
598 | |
0 | 599 return 0; |
600 fail: | |
244 | 601 MPV_common_end(s); |
602 return -1; | |
603 } | |
604 | |
605 /* init common structure for both encoder and decoder */ | |
606 void MPV_common_end(MpegEncContext *s) | |
607 { | |
1708 | 608 int i, j, k; |
244 | 609 |
1799 | 610 for(i=0; i<s->avctx->thread_count; i++){ |
611 free_duplicate_context(s->thread_context[i]); | |
612 } | |
613 for(i=1; i<s->avctx->thread_count; i++){ | |
614 av_freep(&s->thread_context[i]); | |
615 } | |
616 | |
1344
447b88b784ee
memleak fix by (Jake Page <jake at CS dot Stanford dot EDU>)
michaelni
parents:
1339
diff
changeset
|
617 av_freep(&s->parse_context.buffer); |
447b88b784ee
memleak fix by (Jake Page <jake at CS dot Stanford dot EDU>)
michaelni
parents:
1339
diff
changeset
|
618 s->parse_context.buffer_size=0; |
447b88b784ee
memleak fix by (Jake Page <jake at CS dot Stanford dot EDU>)
michaelni
parents:
1339
diff
changeset
|
619 |
396
fce0a2520551
removed useless header includes - use av memory functions
glantau
parents:
376
diff
changeset
|
620 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
|
621 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
|
622 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
|
623 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
|
624 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
|
625 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
|
626 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
|
627 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
|
628 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
|
629 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
|
630 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
|
631 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
|
632 s->b_direct_mv_table= NULL; |
1708 | 633 for(i=0; i<2; i++){ |
634 for(j=0; j<2; j++){ | |
635 for(k=0; k<2; k++){ | |
636 av_freep(&s->b_field_mv_table_base[i][j][k]); | |
637 s->b_field_mv_table[i][j][k]=NULL; | |
638 } | |
639 av_freep(&s->b_field_select_table[i][j]); | |
640 av_freep(&s->p_field_mv_table_base[i][j]); | |
641 s->p_field_mv_table[i][j]=NULL; | |
642 } | |
643 av_freep(&s->p_field_select_table[i]); | |
644 } | |
2967 | 645 |
1938
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1918
diff
changeset
|
646 av_freep(&s->dc_val_base); |
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1918
diff
changeset
|
647 av_freep(&s->ac_val_base); |
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1918
diff
changeset
|
648 av_freep(&s->coded_block_base); |
396
fce0a2520551
removed useless header includes - use av memory functions
glantau
parents:
376
diff
changeset
|
649 av_freep(&s->mbintra_table); |
456 | 650 av_freep(&s->cbp_table); |
651 av_freep(&s->pred_dir_table); | |
2967 | 652 |
396
fce0a2520551
removed useless header includes - use av memory functions
glantau
parents:
376
diff
changeset
|
653 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
|
654 av_freep(&s->prev_pict_types); |
396
fce0a2520551
removed useless header includes - use av memory functions
glantau
parents:
376
diff
changeset
|
655 av_freep(&s->bitstream_buffer); |
2422 | 656 s->allocated_bitstream_buffer_size=0; |
657 | |
612 | 658 av_freep(&s->avctx->stats_out); |
650
ef4a33aad86e
reducing sizeof MpegEncContext to avoid stack overflow on crap M$ windo$
michaelni
parents:
635
diff
changeset
|
659 av_freep(&s->ac_stats); |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
731
diff
changeset
|
660 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
|
661 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
|
662 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
|
663 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
|
664 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
|
665 av_freep(&s->q_intra_matrix16); |
d736e24bf303
move mmx quantizer matrixes out of MpegEncContext (23k -> 7k) (no meassureable slowdown)
michael
parents:
1553
diff
changeset
|
666 av_freep(&s->q_inter_matrix16); |
1556 | 667 av_freep(&s->input_picture); |
668 av_freep(&s->reordered_input_picture); | |
1597 | 669 av_freep(&s->dct_offset); |
903 | 670 |
1573 | 671 if(s->picture){ |
672 for(i=0; i<MAX_PICTURE_COUNT; i++){ | |
673 free_picture(s, &s->picture[i]); | |
674 } | |
0 | 675 } |
1552
26c6ecba99a1
dynamic alloc of picture structs instead of putting them in MpegEncContext
michael
parents:
1546
diff
changeset
|
676 av_freep(&s->picture); |
0 | 677 s->context_initialized = 0; |
1523 | 678 s->last_picture_ptr= |
679 s->next_picture_ptr= | |
680 s->current_picture_ptr= NULL; | |
2231 | 681 s->linesize= s->uvlinesize= 0; |
1918
ea20f38b8d57
nicer looking arrows for the motion vector vissualization
michael
parents:
1916
diff
changeset
|
682 |
1706
3ba5c493db6f
motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1705
diff
changeset
|
683 for(i=0; i<3; i++) |
1918
ea20f38b8d57
nicer looking arrows for the motion vector vissualization
michael
parents:
1916
diff
changeset
|
684 av_freep(&s->visualization_buffer[i]); |
2231 | 685 |
686 avcodec_default_free_buffers(s->avctx); | |
0 | 687 } |
688 | |
4668 | 689 void init_rl(RLTable *rl, uint8_t static_store[2][2*MAX_RUN + MAX_LEVEL + 3]) |
1042 | 690 { |
1064 | 691 int8_t max_level[MAX_RUN+1], max_run[MAX_LEVEL+1]; |
692 uint8_t index_run[MAX_RUN+1]; | |
1042 | 693 int last, run, level, start, end, i; |
694 | |
2370
26560d4fdb1f
Memory leak fix patch by (Burkhard Plaum <plaum >at< ipf.uni-stuttgart )dot( de>)
michael
parents:
2364
diff
changeset
|
695 /* If table is static, we can quit if rl->max_level[0] is not NULL */ |
4668 | 696 if(static_store && rl->max_level[0]) |
2370
26560d4fdb1f
Memory leak fix patch by (Burkhard Plaum <plaum >at< ipf.uni-stuttgart )dot( de>)
michael
parents:
2364
diff
changeset
|
697 return; |
26560d4fdb1f
Memory leak fix patch by (Burkhard Plaum <plaum >at< ipf.uni-stuttgart )dot( de>)
michael
parents:
2364
diff
changeset
|
698 |
1042 | 699 /* compute max_level[], max_run[] and index_run[] */ |
700 for(last=0;last<2;last++) { | |
701 if (last == 0) { | |
702 start = 0; | |
703 end = rl->last; | |
704 } else { | |
705 start = rl->last; | |
706 end = rl->n; | |
707 } | |
708 | |
709 memset(max_level, 0, MAX_RUN + 1); | |
710 memset(max_run, 0, MAX_LEVEL + 1); | |
711 memset(index_run, rl->n, MAX_RUN + 1); | |
712 for(i=start;i<end;i++) { | |
713 run = rl->table_run[i]; | |
714 level = rl->table_level[i]; | |
715 if (index_run[run] == rl->n) | |
716 index_run[run] = i; | |
717 if (level > max_level[run]) | |
718 max_level[run] = level; | |
719 if (run > max_run[level]) | |
720 max_run[level] = run; | |
721 } | |
4668 | 722 if(static_store) |
723 rl->max_level[last] = static_store[last]; | |
2370
26560d4fdb1f
Memory leak fix patch by (Burkhard Plaum <plaum >at< ipf.uni-stuttgart )dot( de>)
michael
parents:
2364
diff
changeset
|
724 else |
26560d4fdb1f
Memory leak fix patch by (Burkhard Plaum <plaum >at< ipf.uni-stuttgart )dot( de>)
michael
parents:
2364
diff
changeset
|
725 rl->max_level[last] = av_malloc(MAX_RUN + 1); |
1042 | 726 memcpy(rl->max_level[last], max_level, MAX_RUN + 1); |
4668 | 727 if(static_store) |
728 rl->max_run[last] = static_store[last] + MAX_RUN + 1; | |
2370
26560d4fdb1f
Memory leak fix patch by (Burkhard Plaum <plaum >at< ipf.uni-stuttgart )dot( de>)
michael
parents:
2364
diff
changeset
|
729 else |
26560d4fdb1f
Memory leak fix patch by (Burkhard Plaum <plaum >at< ipf.uni-stuttgart )dot( de>)
michael
parents:
2364
diff
changeset
|
730 rl->max_run[last] = av_malloc(MAX_LEVEL + 1); |
1042 | 731 memcpy(rl->max_run[last], max_run, MAX_LEVEL + 1); |
4668 | 732 if(static_store) |
733 rl->index_run[last] = static_store[last] + MAX_RUN + MAX_LEVEL + 2; | |
2370
26560d4fdb1f
Memory leak fix patch by (Burkhard Plaum <plaum >at< ipf.uni-stuttgart )dot( de>)
michael
parents:
2364
diff
changeset
|
734 else |
26560d4fdb1f
Memory leak fix patch by (Burkhard Plaum <plaum >at< ipf.uni-stuttgart )dot( de>)
michael
parents:
2364
diff
changeset
|
735 rl->index_run[last] = av_malloc(MAX_RUN + 1); |
1042 | 736 memcpy(rl->index_run[last], index_run, MAX_RUN + 1); |
737 } | |
738 } | |
739 | |
5274 | 740 void init_vlc_rl(RLTable *rl, int use_static) |
741 { | |
742 int i, q; | |
743 | |
744 /* Return if static table is already initialized */ | |
745 if(use_static && rl->rl_vlc[0]) | |
746 return; | |
747 | |
748 init_vlc(&rl->vlc, 9, rl->n + 1, | |
749 &rl->table_vlc[0][1], 4, 2, | |
750 &rl->table_vlc[0][0], 4, 2, use_static); | |
751 | |
752 | |
753 for(q=0; q<32; q++){ | |
754 int qmul= q*2; | |
755 int qadd= (q-1)|1; | |
756 | |
757 if(q==0){ | |
758 qmul=1; | |
759 qadd=0; | |
760 } | |
761 if(use_static) | |
762 rl->rl_vlc[q]= av_mallocz_static(rl->vlc.table_size*sizeof(RL_VLC_ELEM)); | |
763 else | |
764 rl->rl_vlc[q]= av_malloc(rl->vlc.table_size*sizeof(RL_VLC_ELEM)); | |
765 for(i=0; i<rl->vlc.table_size; i++){ | |
766 int code= rl->vlc.table[i][0]; | |
767 int len = rl->vlc.table[i][1]; | |
768 int level, run; | |
769 | |
770 if(len==0){ // illegal code | |
771 run= 66; | |
772 level= MAX_LEVEL; | |
773 }else if(len<0){ //more bits needed | |
774 run= 0; | |
775 level= code; | |
776 }else{ | |
777 if(code==rl->n){ //esc | |
778 run= 66; | |
779 level= 0; | |
780 }else{ | |
781 run= rl->table_run [code] + 1; | |
782 level= rl->table_level[code] * qmul + qadd; | |
783 if(code >= rl->last) run+=192; | |
784 } | |
785 } | |
786 rl->rl_vlc[q][i].len= len; | |
787 rl->rl_vlc[q][i].level= level; | |
788 rl->rl_vlc[q][i].run= run; | |
789 } | |
790 } | |
791 } | |
792 | |
0 | 793 /* 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
|
794 //FIXME check that this is ok for mpeg4 interlaced |
1064 | 795 static void draw_edges_c(uint8_t *buf, int wrap, int width, int height, int w) |
0 | 796 { |
1064 | 797 uint8_t *ptr, *last_line; |
0 | 798 int i; |
799 | |
800 last_line = buf + (height - 1) * wrap; | |
801 for(i=0;i<w;i++) { | |
802 /* top and bottom */ | |
803 memcpy(buf - (i + 1) * wrap, buf, width); | |
804 memcpy(last_line + (i + 1) * wrap, last_line, width); | |
805 } | |
806 /* left and right */ | |
807 ptr = buf; | |
808 for(i=0;i<height;i++) { | |
809 memset(ptr - w, ptr[0], w); | |
810 memset(ptr + width, ptr[width-1], w); | |
811 ptr += wrap; | |
812 } | |
813 /* corners */ | |
814 for(i=0;i<w;i++) { | |
815 memset(buf - (i + 1) * wrap - w, buf[0], w); /* top left */ | |
816 memset(buf - (i + 1) * wrap + width, buf[width-1], w); /* top right */ | |
817 memset(last_line + (i + 1) * wrap - w, last_line[0], w); /* top left */ | |
818 memset(last_line + (i + 1) * wrap + width, last_line[width-1], w); /* top right */ | |
819 } | |
820 } | |
821 | |
1586 | 822 int ff_find_unused_picture(MpegEncContext *s, int shared){ |
924 | 823 int i; |
2967 | 824 |
924 | 825 if(shared){ |
826 for(i=0; i<MAX_PICTURE_COUNT; i++){ | |
1586 | 827 if(s->picture[i].data[0]==NULL && s->picture[i].type==0) return i; |
924 | 828 } |
829 }else{ | |
830 for(i=0; i<MAX_PICTURE_COUNT; i++){ | |
1586 | 831 if(s->picture[i].data[0]==NULL && s->picture[i].type!=0) return i; //FIXME |
924 | 832 } |
833 for(i=0; i<MAX_PICTURE_COUNT; i++){ | |
1586 | 834 if(s->picture[i].data[0]==NULL) return i; |
924 | 835 } |
836 } | |
837 | |
1586 | 838 assert(0); |
839 return -1; | |
924 | 840 } |
841 | |
1597 | 842 static void update_noise_reduction(MpegEncContext *s){ |
843 int intra, i; | |
844 | |
845 for(intra=0; intra<2; intra++){ | |
846 if(s->dct_count[intra] > (1<<16)){ | |
847 for(i=0; i<64; i++){ | |
848 s->dct_error_sum[intra][i] >>=1; | |
849 } | |
850 s->dct_count[intra] >>= 1; | |
851 } | |
2967 | 852 |
1597 | 853 for(i=0; i<64; i++){ |
854 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); | |
855 } | |
856 } | |
857 } | |
858 | |
1586 | 859 /** |
860 * generic function for encode/decode called after coding/decoding the header and before a frame is coded/decoded | |
861 */ | |
771
d4cc92144266
handle direct rendering buffer allocation failure
michaelni
parents:
768
diff
changeset
|
862 int MPV_frame_start(MpegEncContext *s, AVCodecContext *avctx) |
0 | 863 { |
924 | 864 int i; |
925 | 865 AVFrame *pic; |
2628
511e3afc43e1
Ministry of English Composition, reporting for duty (and the word is "skipped", not "skiped"; "skiped" would rhyme with "hyped")
melanson
parents:
2627
diff
changeset
|
866 s->mb_skipped = 0; |
1168 | 867 |
1234 | 868 assert(s->last_picture_ptr==NULL || s->out_format != FMT_H264 || s->codec_id == CODEC_ID_SVQ3); |
1228 | 869 |
903 | 870 /* mark&release old frames */ |
1944 | 871 if (s->pict_type != B_TYPE && s->last_picture_ptr && s->last_picture_ptr != s->next_picture_ptr && s->last_picture_ptr->data[0]) { |
4396
8e78248586b0
set last_picture for h.264 too, this significantly improves error concealment quality, i hope it doesnt break anything as last_picture_ptr was always NULL for h.264
michael
parents:
4346
diff
changeset
|
872 if(s->out_format != FMT_H264 || s->codec_id == CODEC_ID_SVQ3){ |
1138 | 873 avctx->release_buffer(avctx, (AVFrame*)s->last_picture_ptr); |
903 | 874 |
875 /* release forgotten pictures */ | |
876 /* if(mpeg124/h263) */ | |
877 if(!s->encoding){ | |
878 for(i=0; i<MAX_PICTURE_COUNT; i++){ | |
1138 | 879 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
|
880 av_log(avctx, AV_LOG_ERROR, "releasing zombie picture\n"); |
2967 | 881 avctx->release_buffer(avctx, (AVFrame*)&s->picture[i]); |
903 | 882 } |
883 } | |
884 } | |
4396
8e78248586b0
set last_picture for h.264 too, this significantly improves error concealment quality, i hope it doesnt break anything as last_picture_ptr was always NULL for h.264
michael
parents:
4346
diff
changeset
|
885 } |
903 | 886 } |
910
eb448df811be
fixing files where the first frame isn a keyframe
michaelni
parents:
909
diff
changeset
|
887 alloc: |
eb448df811be
fixing files where the first frame isn a keyframe
michaelni
parents:
909
diff
changeset
|
888 if(!s->encoding){ |
2764 | 889 /* release non reference frames */ |
1228 | 890 for(i=0; i<MAX_PICTURE_COUNT; i++){ |
891 if(s->picture[i].data[0] && !s->picture[i].reference /*&& s->picture[i].type!=FF_BUFFER_TYPE_SHARED*/){ | |
892 s->avctx->release_buffer(s->avctx, (AVFrame*)&s->picture[i]); | |
893 } | |
894 } | |
895 | |
1586 | 896 if(s->current_picture_ptr && s->current_picture_ptr->data[0]==NULL) |
897 pic= (AVFrame*)s->current_picture_ptr; //we allready have a unused image (maybe it was set before reading the header) | |
898 else{ | |
899 i= ff_find_unused_picture(s, 0); | |
900 pic= (AVFrame*)&s->picture[i]; | |
901 } | |
902 | |
2537
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2534
diff
changeset
|
903 pic->reference= (s->pict_type != B_TYPE || s->codec_id == CODEC_ID_H264) |
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2534
diff
changeset
|
904 && !s->dropable ? 3 : 0; |
1138 | 905 |
1705 | 906 pic->coded_picture_number= s->coded_picture_number++; |
2967 | 907 |
1384 | 908 if( alloc_picture(s, (Picture*)pic, 0) < 0) |
909 return -1; | |
903 | 910 |
1586 | 911 s->current_picture_ptr= (Picture*)pic; |
1658 | 912 s->current_picture_ptr->top_field_first= s->top_field_first; //FIXME use only the vars from current_pic |
1659 | 913 s->current_picture_ptr->interlaced_frame= !s->progressive_frame && !s->progressive_sequence; |
903 | 914 } |
456 | 915 |
1173 | 916 s->current_picture_ptr->pict_type= s->pict_type; |
2967 | 917 // if(s->flags && CODEC_FLAG_QSCALE) |
1505
010f76d07a27
use lagrange multipler instead of qp for ratecontrol, this may break some things, tell me ASAP if u notice anything broken
michaelni
parents:
1497
diff
changeset
|
918 // 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
|
919 s->current_picture_ptr->key_frame= s->pict_type == I_TYPE; |
1173 | 920 |
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
|
921 copy_picture(&s->current_picture, s->current_picture_ptr); |
2967 | 922 |
903 | 923 if (s->pict_type != B_TYPE) { |
1138 | 924 s->last_picture_ptr= s->next_picture_ptr; |
1944 | 925 if(!s->dropable) |
926 s->next_picture_ptr= s->current_picture_ptr; | |
927 } | |
928 /* av_log(s->avctx, AV_LOG_DEBUG, "L%p N%p C%p L%p N%p C%p type:%d drop:%d\n", s->last_picture_ptr, s->next_picture_ptr,s->current_picture_ptr, | |
2967 | 929 s->last_picture_ptr ? s->last_picture_ptr->data[0] : NULL, |
930 s->next_picture_ptr ? s->next_picture_ptr->data[0] : NULL, | |
1944 | 931 s->current_picture_ptr ? s->current_picture_ptr->data[0] : NULL, |
932 s->pict_type, s->dropable);*/ | |
2967 | 933 |
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
|
934 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
|
935 if(s->next_picture_ptr) copy_picture(&s->next_picture, s->next_picture_ptr); |
2967 | 936 |
4413
371bb9f644da
fix inifnite loop with http://sam.zoy.org/zzuf/lol-mplayer.mpg
michael
parents:
4399
diff
changeset
|
937 if(s->pict_type != I_TYPE && (s->last_picture_ptr==NULL || s->last_picture_ptr->data[0]==NULL) && !s->dropable){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1597
diff
changeset
|
938 av_log(avctx, AV_LOG_ERROR, "warning: first frame is no keyframe\n"); |
2764 | 939 assert(s->pict_type != B_TYPE); //these should have been dropped if we don't have a reference |
1393 | 940 goto alloc; |
941 } | |
942 | |
943 assert(s->pict_type == I_TYPE || (s->last_picture_ptr && s->last_picture_ptr->data[0])); | |
944 | |
1138 | 945 if(s->picture_structure!=PICT_FRAME){ |
946 int i; | |
947 for(i=0; i<4; i++){ | |
948 if(s->picture_structure == PICT_BOTTOM_FIELD){ | |
949 s->current_picture.data[i] += s->current_picture.linesize[i]; | |
2967 | 950 } |
1138 | 951 s->current_picture.linesize[i] *= 2; |
952 s->last_picture.linesize[i] *=2; | |
953 s->next_picture.linesize[i] *=2; | |
954 } | |
553 | 955 } |
2967 | 956 |
910
eb448df811be
fixing files where the first frame isn a keyframe
michaelni
parents:
909
diff
changeset
|
957 s->hurry_up= s->avctx->hurry_up; |
eb448df811be
fixing files where the first frame isn a keyframe
michaelni
parents:
909
diff
changeset
|
958 s->error_resilience= avctx->error_resilience; |
eb448df811be
fixing files where the first frame isn a keyframe
michaelni
parents:
909
diff
changeset
|
959 |
2764 | 960 /* set dequantizer, we can't do it during init as it might change for mpeg4 |
5127 | 961 and we can't do it in the header decode as init is not called for mpeg4 there yet */ |
1689 | 962 if(s->mpeg_quant || s->codec_id == CODEC_ID_MPEG2VIDEO){ |
963 s->dct_unquantize_intra = s->dct_unquantize_mpeg2_intra; | |
964 s->dct_unquantize_inter = s->dct_unquantize_mpeg2_inter; | |
2345 | 965 }else if(s->out_format == FMT_H263 || s->out_format == FMT_H261){ |
1689 | 966 s->dct_unquantize_intra = s->dct_unquantize_h263_intra; |
967 s->dct_unquantize_inter = s->dct_unquantize_h263_inter; | |
968 }else{ | |
969 s->dct_unquantize_intra = s->dct_unquantize_mpeg1_intra; | |
970 s->dct_unquantize_inter = s->dct_unquantize_mpeg1_inter; | |
971 } | |
771
d4cc92144266
handle direct rendering buffer allocation failure
michaelni
parents:
768
diff
changeset
|
972 |
1597 | 973 if(s->dct_error_sum){ |
974 assert(s->avctx->noise_reduction && s->encoding); | |
975 | |
976 update_noise_reduction(s); | |
977 } | |
2967 | 978 |
1381 | 979 #ifdef HAVE_XVMC |
980 if(s->avctx->xvmc_acceleration) | |
981 return XVMC_field_start(s, avctx); | |
982 #endif | |
771
d4cc92144266
handle direct rendering buffer allocation failure
michaelni
parents:
768
diff
changeset
|
983 return 0; |
0 | 984 } |
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
|
985 |
0 | 986 /* generic function for encode/decode called after a frame has been coded/decoded */ |
987 void MPV_frame_end(MpegEncContext *s) | |
988 { | |
903 | 989 int i; |
0 | 990 /* draw edge for correct motion prediction if outside */ |
1381 | 991 #ifdef HAVE_XVMC |
992 //just to make sure that all data is rendered. | |
993 if(s->avctx->xvmc_acceleration){ | |
994 XVMC_field_end(s); | |
995 }else | |
996 #endif | |
2537
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2534
diff
changeset
|
997 if(s->unrestricted_mv && s->current_picture.reference && !s->intra_only && !(s->flags&CODEC_FLAG_EMU_EDGE)) { |
903 | 998 draw_edges(s->current_picture.data[0], s->linesize , s->h_edge_pos , s->v_edge_pos , EDGE_WIDTH ); |
999 draw_edges(s->current_picture.data[1], s->uvlinesize, s->h_edge_pos>>1, s->v_edge_pos>>1, EDGE_WIDTH/2); | |
1000 draw_edges(s->current_picture.data[2], s->uvlinesize, s->h_edge_pos>>1, s->v_edge_pos>>1, EDGE_WIDTH/2); | |
0 | 1001 } |
207 | 1002 emms_c(); |
2967 | 1003 |
612 | 1004 s->last_pict_type = s->pict_type; |
2997
188f4ef688f2
second try of improved lambda/qp guessing for motion estimation RD in first pass
michael
parents:
2990
diff
changeset
|
1005 s->last_lambda_for[s->pict_type]= s->current_picture_ptr->quality; |
329 | 1006 if(s->pict_type!=B_TYPE){ |
1007 s->last_non_b_pict_type= s->pict_type; | |
1008 } | |
1138 | 1009 #if 0 |
1010 /* copy back current_picture variables */ | |
903 | 1011 for(i=0; i<MAX_PICTURE_COUNT; i++){ |
1012 if(s->picture[i].data[0] == s->current_picture.data[0]){ | |
1013 s->picture[i]= s->current_picture; | |
1014 break; | |
2967 | 1015 } |
903 | 1016 } |
1017 assert(i<MAX_PICTURE_COUNT); | |
2967 | 1018 #endif |
903 | 1019 |
1228 | 1020 if(s->encoding){ |
2764 | 1021 /* release non-reference frames */ |
1228 | 1022 for(i=0; i<MAX_PICTURE_COUNT; i++){ |
1023 if(s->picture[i].data[0] && !s->picture[i].reference /*&& s->picture[i].type!=FF_BUFFER_TYPE_SHARED*/){ | |
1024 s->avctx->release_buffer(s->avctx, (AVFrame*)&s->picture[i]); | |
1025 } | |
1026 } | |
324 | 1027 } |
1138 | 1028 // clear copies, to avoid confusion |
1029 #if 0 | |
1030 memset(&s->last_picture, 0, sizeof(Picture)); | |
1031 memset(&s->next_picture, 0, sizeof(Picture)); | |
1032 memset(&s->current_picture, 0, sizeof(Picture)); | |
1033 #endif | |
2213 | 1034 s->avctx->coded_frame= (AVFrame*)s->current_picture_ptr; |
903 | 1035 } |
1036 | |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1173
diff
changeset
|
1037 /** |
1285 | 1038 * draws an line from (ex, ey) -> (sx, sy). |
1039 * @param w width of the image | |
1040 * @param h height of the image | |
1041 * @param stride stride/linesize of the image | |
1042 * @param color color of the arrow | |
1043 */ | |
1044 static void draw_line(uint8_t *buf, int sx, int sy, int ex, int ey, int w, int h, int stride, int color){ | |
3595 | 1045 int x, y, fr, f; |
2967 | 1046 |
4594 | 1047 sx= av_clip(sx, 0, w-1); |
1048 sy= av_clip(sy, 0, h-1); | |
1049 ex= av_clip(ex, 0, w-1); | |
1050 ey= av_clip(ey, 0, h-1); | |
2967 | 1051 |
1285 | 1052 buf[sy*stride + sx]+= color; |
2967 | 1053 |
4001 | 1054 if(FFABS(ex - sx) > FFABS(ey - sy)){ |
1285 | 1055 if(sx > ex){ |
4120 | 1056 FFSWAP(int, sx, ex); |
1057 FFSWAP(int, sy, ey); | |
1285 | 1058 } |
1059 buf+= sx + sy*stride; | |
1060 ex-= sx; | |
1061 f= ((ey-sy)<<16)/ex; | |
1062 for(x= 0; x <= ex; x++){ | |
1918
ea20f38b8d57
nicer looking arrows for the motion vector vissualization
michael
parents:
1916
diff
changeset
|
1063 y = (x*f)>>16; |
ea20f38b8d57
nicer looking arrows for the motion vector vissualization
michael
parents:
1916
diff
changeset
|
1064 fr= (x*f)&0xFFFF; |
ea20f38b8d57
nicer looking arrows for the motion vector vissualization
michael
parents:
1916
diff
changeset
|
1065 buf[ y *stride + x]+= (color*(0x10000-fr))>>16; |
ea20f38b8d57
nicer looking arrows for the motion vector vissualization
michael
parents:
1916
diff
changeset
|
1066 buf[(y+1)*stride + x]+= (color* fr )>>16; |
1285 | 1067 } |
1068 }else{ | |
1069 if(sy > ey){ | |
4120 | 1070 FFSWAP(int, sx, ex); |
1071 FFSWAP(int, sy, ey); | |
1285 | 1072 } |
1073 buf+= sx + sy*stride; | |
1074 ey-= sy; | |
1075 if(ey) f= ((ex-sx)<<16)/ey; | |
1076 else f= 0; | |
1077 for(y= 0; y <= ey; y++){ | |
1918
ea20f38b8d57
nicer looking arrows for the motion vector vissualization
michael
parents:
1916
diff
changeset
|
1078 x = (y*f)>>16; |
ea20f38b8d57
nicer looking arrows for the motion vector vissualization
michael
parents:
1916
diff
changeset
|
1079 fr= (y*f)&0xFFFF; |
ea20f38b8d57
nicer looking arrows for the motion vector vissualization
michael
parents:
1916
diff
changeset
|
1080 buf[y*stride + x ]+= (color*(0x10000-fr))>>16;; |
ea20f38b8d57
nicer looking arrows for the motion vector vissualization
michael
parents:
1916
diff
changeset
|
1081 buf[y*stride + x+1]+= (color* fr )>>16;; |
1285 | 1082 } |
1083 } | |
1084 } | |
1085 | |
1086 /** | |
1087 * draws an arrow from (ex, ey) -> (sx, sy). | |
1088 * @param w width of the image | |
1089 * @param h height of the image | |
1090 * @param stride stride/linesize of the image | |
1091 * @param color color of the arrow | |
1092 */ | |
2967 | 1093 static void draw_arrow(uint8_t *buf, int sx, int sy, int ex, int ey, int w, int h, int stride, int color){ |
1285 | 1094 int dx,dy; |
1095 | |
4594 | 1096 sx= av_clip(sx, -100, w+100); |
1097 sy= av_clip(sy, -100, h+100); | |
1098 ex= av_clip(ex, -100, w+100); | |
1099 ey= av_clip(ey, -100, h+100); | |
2967 | 1100 |
1285 | 1101 dx= ex - sx; |
1102 dy= ey - sy; | |
2967 | 1103 |
1285 | 1104 if(dx*dx + dy*dy > 3*3){ |
1105 int rx= dx + dy; | |
1106 int ry= -dx + dy; | |
1107 int length= ff_sqrt((rx*rx + ry*ry)<<8); | |
2967 | 1108 |
1285 | 1109 //FIXME subpixel accuracy |
1110 rx= ROUNDED_DIV(rx*3<<4, length); | |
1111 ry= ROUNDED_DIV(ry*3<<4, length); | |
2967 | 1112 |
1285 | 1113 draw_line(buf, sx, sy, sx + rx, sy + ry, w, h, stride, color); |
1114 draw_line(buf, sx, sy, sx - ry, sy + rx, w, h, stride, color); | |
1115 } | |
1116 draw_line(buf, sx, sy, ex, ey, w, h, stride, color); | |
1117 } | |
1118 | |
1119 /** | |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1173
diff
changeset
|
1120 * 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
|
1121 */ |
1706
3ba5c493db6f
motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1705
diff
changeset
|
1122 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
|
1123 |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1173
diff
changeset
|
1124 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
|
1125 |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1173
diff
changeset
|
1126 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
|
1127 int x,y; |
2967 | 1128 |
1706
3ba5c493db6f
motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1705
diff
changeset
|
1129 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
|
1130 switch (pict->pict_type) { |
3ba5c493db6f
motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1705
diff
changeset
|
1131 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
|
1132 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
|
1133 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
|
1134 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
|
1135 case FF_SI_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"SI\n"); break; |
2967 | 1136 case FF_SP_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"SP\n"); break; |
1706
3ba5c493db6f
motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1705
diff
changeset
|
1137 } |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1173
diff
changeset
|
1138 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
|
1139 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
|
1140 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
|
1141 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
|
1142 if(count>9) count=9; |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1597
diff
changeset
|
1143 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
|
1144 } |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1173
diff
changeset
|
1145 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
|
1146 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
|
1147 } |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1173
diff
changeset
|
1148 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
|
1149 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
|
1150 //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
|
1151 if(IS_PCM(mb_type)) |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1597
diff
changeset
|
1152 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
|
1153 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
|
1154 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
|
1155 else if(IS_INTRA4x4(mb_type)) |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1597
diff
changeset
|
1156 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
|
1157 else if(IS_INTRA16x16(mb_type)) |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1597
diff
changeset
|
1158 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
|
1159 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
|
1160 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
|
1161 else if(IS_DIRECT(mb_type)) |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1597
diff
changeset
|
1162 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
|
1163 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
|
1164 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
|
1165 else if(IS_GMC(mb_type)) |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1597
diff
changeset
|
1166 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
|
1167 else if(IS_SKIP(mb_type)) |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1597
diff
changeset
|
1168 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
|
1169 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
|
1170 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
|
1171 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
|
1172 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
|
1173 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
|
1174 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
|
1175 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
|
1176 } |
2967 | 1177 |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1173
diff
changeset
|
1178 //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
|
1179 if(IS_8X8(mb_type)) |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1597
diff
changeset
|
1180 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
|
1181 else if(IS_16X8(mb_type)) |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1597
diff
changeset
|
1182 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
|
1183 else if(IS_8X16(mb_type)) |
2677 | 1184 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
|
1185 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
|
1186 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
|
1187 else |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1597
diff
changeset
|
1188 av_log(s->avctx, AV_LOG_DEBUG, "?"); |
2967 | 1189 |
1190 | |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1173
diff
changeset
|
1191 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
|
1192 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
|
1193 else |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1597
diff
changeset
|
1194 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
|
1195 } |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1597
diff
changeset
|
1196 // 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
|
1197 } |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1597
diff
changeset
|
1198 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
|
1199 } |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1173
diff
changeset
|
1200 } |
1668
30746f429df6
move motion_val & mb_type to AVFrame patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1662
diff
changeset
|
1201 |
1706
3ba5c493db6f
motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1705
diff
changeset
|
1202 if((s->avctx->debug&(FF_DEBUG_VIS_QP|FF_DEBUG_VIS_MB_TYPE)) || (s->avctx->debug_mv)){ |
1285 | 1203 const int shift= 1 + s->quarter_sample; |
1204 int mb_y; | |
1706
3ba5c493db6f
motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1705
diff
changeset
|
1205 uint8_t *ptr; |
1707 | 1206 int i; |
1723
033d889d7c2c
non YV12 vissualization fix by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1722
diff
changeset
|
1207 int h_chroma_shift, v_chroma_shift; |
2266
514949de5d15
set AVCodecContext.width/height to the picture width/height instead of the one stored in the bitstream (that only matters if lowres!=0)
michael
parents:
2265
diff
changeset
|
1208 const int width = s->avctx->width; |
514949de5d15
set AVCodecContext.width/height to the picture width/height instead of the one stored in the bitstream (that only matters if lowres!=0)
michael
parents:
2265
diff
changeset
|
1209 const int height= s->avctx->height; |
2395 | 1210 const int mv_sample_log2= 4 - pict->motion_subsample_log2; |
3268 | 1211 const int mv_stride= (s->mb_width << mv_sample_log2) + (s->codec_id == CODEC_ID_H264 ? 0 : 1); |
1285 | 1212 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
|
1213 |
1723
033d889d7c2c
non YV12 vissualization fix by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1722
diff
changeset
|
1214 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
|
1215 for(i=0; i<3; i++){ |
2266
514949de5d15
set AVCodecContext.width/height to the picture width/height instead of the one stored in the bitstream (that only matters if lowres!=0)
michael
parents:
2265
diff
changeset
|
1216 memcpy(s->visualization_buffer[i], pict->data[i], (i==0) ? pict->linesize[i]*height:pict->linesize[i]*height >> v_chroma_shift); |
1706
3ba5c493db6f
motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1705
diff
changeset
|
1217 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
|
1218 } |
3ba5c493db6f
motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1705
diff
changeset
|
1219 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
|
1220 ptr= pict->data[0]; |
1285 | 1221 |
1222 for(mb_y=0; mb_y<s->mb_height; mb_y++){ | |
1223 int mb_x; | |
1224 for(mb_x=0; mb_x<s->mb_width; mb_x++){ | |
1225 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
|
1226 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
|
1227 int type; |
3ba5c493db6f
motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1705
diff
changeset
|
1228 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
|
1229 int direction = 0; |
1706
3ba5c493db6f
motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1705
diff
changeset
|
1230 switch (type) { |
3ba5c493db6f
motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1705
diff
changeset
|
1231 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
|
1232 continue; |
3ba5c493db6f
motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1705
diff
changeset
|
1233 direction = 0; |
3ba5c493db6f
motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1705
diff
changeset
|
1234 break; |
3ba5c493db6f
motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1705
diff
changeset
|
1235 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
|
1236 continue; |
3ba5c493db6f
motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1705
diff
changeset
|
1237 direction = 0; |
3ba5c493db6f
motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1705
diff
changeset
|
1238 break; |
3ba5c493db6f
motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1705
diff
changeset
|
1239 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
|
1240 continue; |
3ba5c493db6f
motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1705
diff
changeset
|
1241 direction = 1; |
3ba5c493db6f
motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1705
diff
changeset
|
1242 break; |
3ba5c493db6f
motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1705
diff
changeset
|
1243 } |
1712 | 1244 if(!USES_LIST(pict->mb_type[mb_index], direction)) |
1245 continue; | |
1246 | |
1706
3ba5c493db6f
motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1705
diff
changeset
|
1247 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
|
1248 int i; |
3ba5c493db6f
motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1705
diff
changeset
|
1249 for(i=0; i<4; i++){ |
1285 | 1250 int sx= mb_x*16 + 4 + 8*(i&1); |
1251 int sy= mb_y*16 + 4 + 8*(i>>1); | |
2522
e25782262d7d
kill warnings patch by (M«©ns Rullg«©rd <mru inprovide com>)
michael
parents:
2514
diff
changeset
|
1252 int xy= (mb_x*2 + (i&1) + (mb_y*2 + (i>>1))*mv_stride) << (mv_sample_log2-1); |
1706
3ba5c493db6f
motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1705
diff
changeset
|
1253 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
|
1254 int my= (pict->motion_val[direction][xy][1]>>shift) + sy; |
2266
514949de5d15
set AVCodecContext.width/height to the picture width/height instead of the one stored in the bitstream (that only matters if lowres!=0)
michael
parents:
2265
diff
changeset
|
1255 draw_arrow(ptr, sx, sy, mx, my, width, height, s->linesize, 100); |
1706
3ba5c493db6f
motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1705
diff
changeset
|
1256 } |
3ba5c493db6f
motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1705
diff
changeset
|
1257 }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
|
1258 int i; |
3ba5c493db6f
motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1705
diff
changeset
|
1259 for(i=0; i<2; i++){ |
1629
74685a0ec851
16x8 MV vissualization by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1628
diff
changeset
|
1260 int sx=mb_x*16 + 8; |
74685a0ec851
16x8 MV vissualization by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1628
diff
changeset
|
1261 int sy=mb_y*16 + 4 + 8*i; |
2522
e25782262d7d
kill warnings patch by (M«©ns Rullg«©rd <mru inprovide com>)
michael
parents:
2514
diff
changeset
|
1262 int xy= (mb_x*2 + (mb_y*2 + i)*mv_stride) << (mv_sample_log2-1); |
2395 | 1263 int mx=(pict->motion_val[direction][xy][0]>>shift); |
1264 int my=(pict->motion_val[direction][xy][1]>>shift); | |
2967 | 1265 |
2395 | 1266 if(IS_INTERLACED(pict->mb_type[mb_index])) |
1267 my*=2; | |
2967 | 1268 |
2395 | 1269 draw_arrow(ptr, sx, sy, mx+sx, my+sy, width, height, s->linesize, 100); |
1270 } | |
1271 }else if(IS_8X16(pict->mb_type[mb_index])){ | |
1272 int i; | |
1273 for(i=0; i<2; i++){ | |
1274 int sx=mb_x*16 + 4 + 8*i; | |
1275 int sy=mb_y*16 + 8; | |
2522
e25782262d7d
kill warnings patch by (M«©ns Rullg«©rd <mru inprovide com>)
michael
parents:
2514
diff
changeset
|
1276 int xy= (mb_x*2 + i + mb_y*2*mv_stride) << (mv_sample_log2-1); |
1947
b306574523ad
fix y scale of mv vissualization of interlaced MVs
michael
parents:
1945
diff
changeset
|
1277 int mx=(pict->motion_val[direction][xy][0]>>shift); |
b306574523ad
fix y scale of mv vissualization of interlaced MVs
michael
parents:
1945
diff
changeset
|
1278 int my=(pict->motion_val[direction][xy][1]>>shift); |
2967 | 1279 |
1947
b306574523ad
fix y scale of mv vissualization of interlaced MVs
michael
parents:
1945
diff
changeset
|
1280 if(IS_INTERLACED(pict->mb_type[mb_index])) |
b306574523ad
fix y scale of mv vissualization of interlaced MVs
michael
parents:
1945
diff
changeset
|
1281 my*=2; |
2967 | 1282 |
2266
514949de5d15
set AVCodecContext.width/height to the picture width/height instead of the one stored in the bitstream (that only matters if lowres!=0)
michael
parents:
2265
diff
changeset
|
1283 draw_arrow(ptr, sx, sy, mx+sx, my+sy, width, height, s->linesize, 100); |
1706
3ba5c493db6f
motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1705
diff
changeset
|
1284 } |
3ba5c493db6f
motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1705
diff
changeset
|
1285 }else{ |
3ba5c493db6f
motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1705
diff
changeset
|
1286 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
|
1287 int sy= mb_y*16 + 8; |
2395 | 1288 int xy= (mb_x + mb_y*mv_stride) << mv_sample_log2; |
1706
3ba5c493db6f
motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1705
diff
changeset
|
1289 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
|
1290 int my= (pict->motion_val[direction][xy][1]>>shift) + sy; |
2266
514949de5d15
set AVCodecContext.width/height to the picture width/height instead of the one stored in the bitstream (that only matters if lowres!=0)
michael
parents:
2265
diff
changeset
|
1291 draw_arrow(ptr, sx, sy, mx, my, width, height, s->linesize, 100); |
1629
74685a0ec851
16x8 MV vissualization by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1628
diff
changeset
|
1292 } |
2967 | 1293 } |
1685 | 1294 } |
1295 if((s->avctx->debug&FF_DEBUG_VIS_QP) && pict->motion_val){ | |
1296 uint64_t c= (pict->qscale_table[mb_index]*128/31) * 0x0101010101010101ULL; | |
1297 int y; | |
1298 for(y=0; y<8; y++){ | |
1299 *(uint64_t*)(pict->data[1] + 8*mb_x + (8*mb_y + y)*pict->linesize[1])= c; | |
1300 *(uint64_t*)(pict->data[2] + 8*mb_x + (8*mb_y + y)*pict->linesize[2])= c; | |
1301 } | |
1302 } | |
1303 if((s->avctx->debug&FF_DEBUG_VIS_MB_TYPE) && pict->motion_val){ | |
1304 int mb_type= pict->mb_type[mb_index]; | |
1305 uint64_t u,v; | |
1306 int y; | |
1307 #define COLOR(theta, r)\ | |
1308 u= (int)(128 + r*cos(theta*3.141592/180));\ | |
1309 v= (int)(128 + r*sin(theta*3.141592/180)); | |
1310 | |
2967 | 1311 |
1685 | 1312 u=v=128; |
1313 if(IS_PCM(mb_type)){ | |
1314 COLOR(120,48) | |
1315 }else if((IS_INTRA(mb_type) && IS_ACPRED(mb_type)) || IS_INTRA16x16(mb_type)){ | |
1316 COLOR(30,48) | |
1317 }else if(IS_INTRA4x4(mb_type)){ | |
1318 COLOR(90,48) | |
1319 }else if(IS_DIRECT(mb_type) && IS_SKIP(mb_type)){ | |
1320 // COLOR(120,48) | |
1321 }else if(IS_DIRECT(mb_type)){ | |
1322 COLOR(150,48) | |
1323 }else if(IS_GMC(mb_type) && IS_SKIP(mb_type)){ | |
1324 COLOR(170,48) | |
1325 }else if(IS_GMC(mb_type)){ | |
1326 COLOR(190,48) | |
1327 }else if(IS_SKIP(mb_type)){ | |
1328 // COLOR(180,48) | |
1329 }else if(!USES_LIST(mb_type, 1)){ | |
1330 COLOR(240,48) | |
1331 }else if(!USES_LIST(mb_type, 0)){ | |
1332 COLOR(0,48) | |
1333 }else{ | |
1334 assert(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1)); | |
1335 COLOR(300,48) | |
1336 } | |
1337 | |
1338 u*= 0x0101010101010101ULL; | |
1339 v*= 0x0101010101010101ULL; | |
1340 for(y=0; y<8; y++){ | |
1341 *(uint64_t*)(pict->data[1] + 8*mb_x + (8*mb_y + y)*pict->linesize[1])= u; | |
1342 *(uint64_t*)(pict->data[2] + 8*mb_x + (8*mb_y + y)*pict->linesize[2])= v; | |
1343 } | |
1344 | |
1345 //segmentation | |
1346 if(IS_8X8(mb_type) || IS_16X8(mb_type)){ | |
1347 *(uint64_t*)(pict->data[0] + 16*mb_x + 0 + (16*mb_y + 8)*pict->linesize[0])^= 0x8080808080808080ULL; | |
1348 *(uint64_t*)(pict->data[0] + 16*mb_x + 8 + (16*mb_y + 8)*pict->linesize[0])^= 0x8080808080808080ULL; | |
1349 } | |
1350 if(IS_8X8(mb_type) || IS_8X16(mb_type)){ | |
1351 for(y=0; y<16; y++) | |
1352 pict->data[0][16*mb_x + 8 + (16*mb_y + y)*pict->linesize[0]]^= 0x80; | |
1353 } | |
2534 | 1354 if(IS_8X8(mb_type) && mv_sample_log2 >= 2){ |
1355 int dm= 1 << (mv_sample_log2-2); | |
1356 for(i=0; i<4; i++){ | |
1357 int sx= mb_x*16 + 8*(i&1); | |
1358 int sy= mb_y*16 + 8*(i>>1); | |
1359 int xy= (mb_x*2 + (i&1) + (mb_y*2 + (i>>1))*mv_stride) << (mv_sample_log2-1); | |
1360 //FIXME bidir | |
1361 int32_t *mv = (int32_t*)&pict->motion_val[0][xy]; | |
1362 if(mv[0] != mv[dm] || mv[dm*mv_stride] != mv[dm*(mv_stride+1)]) | |
1363 for(y=0; y<8; y++) | |
1364 pict->data[0][sx + 4 + (sy + y)*pict->linesize[0]]^= 0x80; | |
1365 if(mv[0] != mv[dm*mv_stride] || mv[dm] != mv[dm*(mv_stride+1)]) | |
1366 *(uint64_t*)(pict->data[0] + sx + (sy + 4)*pict->linesize[0])^= 0x8080808080808080ULL; | |
1367 } | |
1368 } | |
2967 | 1369 |
1685 | 1370 if(IS_INTERLACED(mb_type) && s->codec_id == CODEC_ID_H264){ |
1371 // hmm | |
1372 } | |
1285 | 1373 } |
1374 s->mbskip_table[mb_index]=0; | |
1375 } | |
1376 } | |
1377 } | |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1173
diff
changeset
|
1378 } |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1173
diff
changeset
|
1379 |
1317
26c44d2433c1
make ff_emulated_edge_mc() independant of MpegEncContext
michaelni
parents:
1315
diff
changeset
|
1380 /** |
26c44d2433c1
make ff_emulated_edge_mc() independant of MpegEncContext
michaelni
parents:
1315
diff
changeset
|
1381 * 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
|
1382 * @param buf destination buffer |
26c44d2433c1
make ff_emulated_edge_mc() independant of MpegEncContext
michaelni
parents:
1315
diff
changeset
|
1383 * @param src source buffer |
26c44d2433c1
make ff_emulated_edge_mc() independant of MpegEncContext
michaelni
parents:
1315
diff
changeset
|
1384 * @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
|
1385 * @param block_w width of block |
26c44d2433c1
make ff_emulated_edge_mc() independant of MpegEncContext
michaelni
parents:
1315
diff
changeset
|
1386 * @param block_h height of block |
26c44d2433c1
make ff_emulated_edge_mc() independant of MpegEncContext
michaelni
parents:
1315
diff
changeset
|
1387 * @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
|
1388 * @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
|
1389 * @param w width of the source buffer |
26c44d2433c1
make ff_emulated_edge_mc() independant of MpegEncContext
michaelni
parents:
1315
diff
changeset
|
1390 * @param h height of the source buffer |
26c44d2433c1
make ff_emulated_edge_mc() independant of MpegEncContext
michaelni
parents:
1315
diff
changeset
|
1391 */ |
2967 | 1392 void ff_emulated_edge_mc(uint8_t *buf, uint8_t *src, int linesize, int block_w, int block_h, |
553 | 1393 int src_x, int src_y, int w, int h){ |
1394 int x, y; | |
1395 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
|
1396 |
553 | 1397 if(src_y>= h){ |
1398 src+= (h-1-src_y)*linesize; | |
1399 src_y=h-1; | |
554 | 1400 }else if(src_y<=-block_h){ |
1401 src+= (1-block_h-src_y)*linesize; | |
1402 src_y=1-block_h; | |
553 | 1403 } |
1404 if(src_x>= w){ | |
1405 src+= (w-1-src_x); | |
1406 src_x=w-1; | |
554 | 1407 }else if(src_x<=-block_w){ |
1408 src+= (1-block_w-src_x); | |
1409 src_x=1-block_w; | |
553 | 1410 } |
1411 | |
847 | 1412 start_y= FFMAX(0, -src_y); |
1413 start_x= FFMAX(0, -src_x); | |
1414 end_y= FFMIN(block_h, h-src_y); | |
1415 end_x= FFMIN(block_w, w-src_x); | |
566 | 1416 |
553 | 1417 // copy existing part |
1418 for(y=start_y; y<end_y; y++){ | |
1419 for(x=start_x; x<end_x; x++){ | |
1420 buf[x + y*linesize]= src[x + y*linesize]; | |
1421 } | |
1422 } | |
1423 | |
1424 //top | |
1425 for(y=0; y<start_y; y++){ | |
1426 for(x=start_x; x<end_x; x++){ | |
1427 buf[x + y*linesize]= buf[x + start_y*linesize]; | |
1428 } | |
1429 } | |
1430 | |
1431 //bottom | |
1432 for(y=end_y; y<block_h; y++){ | |
1433 for(x=start_x; x<end_x; x++){ | |
1434 buf[x + y*linesize]= buf[x + (end_y-1)*linesize]; | |
1435 } | |
1436 } | |
2967 | 1437 |
553 | 1438 for(y=0; y<block_h; y++){ |
1439 //left | |
1440 for(x=0; x<start_x; x++){ | |
1441 buf[x + y*linesize]= buf[start_x + y*linesize]; | |
1442 } | |
2967 | 1443 |
553 | 1444 //right |
1445 for(x=end_x; x<block_w; x++){ | |
1446 buf[x + y*linesize]= buf[end_x - 1 + y*linesize]; | |
1447 } | |
1448 } | |
1449 } | |
1450 | |
2967 | 1451 static inline int hpel_motion_lowres(MpegEncContext *s, |
2292 | 1452 uint8_t *dest, uint8_t *src, |
1453 int field_based, int field_select, | |
1454 int src_x, int src_y, | |
1455 int width, int height, int stride, | |
1456 int h_edge_pos, int v_edge_pos, | |
1457 int w, int h, h264_chroma_mc_func *pix_op, | |
1458 int motion_x, int motion_y) | |
1459 { | |
1460 const int lowres= s->avctx->lowres; | |
1461 const int s_mask= (2<<lowres)-1; | |
1462 int emu=0; | |
1463 int sx, sy; | |
1464 | |
1465 if(s->quarter_sample){ | |
1466 motion_x/=2; | |
1467 motion_y/=2; | |
1468 } | |
1469 | |
1470 sx= motion_x & s_mask; | |
1471 sy= motion_y & s_mask; | |
1472 src_x += motion_x >> (lowres+1); | |
1473 src_y += motion_y >> (lowres+1); | |
2967 | 1474 |
2292 | 1475 src += src_y * stride + src_x; |
1476 | |
1477 if( (unsigned)src_x > h_edge_pos - (!!sx) - w | |
1478 || (unsigned)src_y >(v_edge_pos >> field_based) - (!!sy) - h){ | |
1479 ff_emulated_edge_mc(s->edge_emu_buffer, src, s->linesize, w+1, (h+1)<<field_based, | |
1480 src_x, src_y<<field_based, h_edge_pos, v_edge_pos); | |
1481 src= s->edge_emu_buffer; | |
1482 emu=1; | |
1483 } | |
1484 | |
1485 sx <<= 2 - lowres; | |
1486 sy <<= 2 - lowres; | |
1487 if(field_select) | |
1488 src += s->linesize; | |
1489 pix_op[lowres](dest, src, stride, h, sx, sy); | |
1490 return emu; | |
1491 } | |
1492 | |
0 | 1493 /* apply one mpeg motion vector to the three components */ |
4283
d6f83e2f8804
rename always_inline to av_always_inline and move to common.h
mru
parents:
4281
diff
changeset
|
1494 static av_always_inline void mpeg_motion_lowres(MpegEncContext *s, |
2256 | 1495 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr, |
1496 int field_based, int bottom_field, int field_select, | |
1497 uint8_t **ref_picture, h264_chroma_mc_func *pix_op, | |
1498 int motion_x, int motion_y, int h) | |
1499 { | |
1500 uint8_t *ptr_y, *ptr_cb, *ptr_cr; | |
1501 int mx, my, src_x, src_y, uvsrc_x, uvsrc_y, uvlinesize, linesize, sx, sy, uvsx, uvsy; | |
1502 const int lowres= s->avctx->lowres; | |
1503 const int block_s= 8>>lowres; | |
1504 const int s_mask= (2<<lowres)-1; | |
1505 const int h_edge_pos = s->h_edge_pos >> lowres; | |
1506 const int v_edge_pos = s->v_edge_pos >> lowres; | |
1507 linesize = s->current_picture.linesize[0] << field_based; | |
1508 uvlinesize = s->current_picture.linesize[1] << field_based; | |
1509 | |
2260 | 1510 if(s->quarter_sample){ //FIXME obviously not perfect but qpel wont work in lowres anyway |
1511 motion_x/=2; | |
1512 motion_y/=2; | |
1513 } | |
2967 | 1514 |
2260 | 1515 if(field_based){ |
1516 motion_y += (bottom_field - field_select)*((1<<lowres)-1); | |
1517 } | |
1518 | |
2256 | 1519 sx= motion_x & s_mask; |
1520 sy= motion_y & s_mask; | |
1521 src_x = s->mb_x*2*block_s + (motion_x >> (lowres+1)); | |
2260 | 1522 src_y =(s->mb_y*2*block_s>>field_based) + (motion_y >> (lowres+1)); |
2967 | 1523 |
2256 | 1524 if (s->out_format == FMT_H263) { |
2265 | 1525 uvsx = ((motion_x>>1) & s_mask) | (sx&1); |
1526 uvsy = ((motion_y>>1) & s_mask) | (sy&1); | |
2256 | 1527 uvsrc_x = src_x>>1; |
1528 uvsrc_y = src_y>>1; | |
1529 }else if(s->out_format == FMT_H261){//even chroma mv's are full pel in H261 | |
1530 mx = motion_x / 4; | |
1531 my = motion_y / 4; | |
1532 uvsx = (2*mx) & s_mask; | |
1533 uvsy = (2*my) & s_mask; | |
1534 uvsrc_x = s->mb_x*block_s + (mx >> lowres); | |
1535 uvsrc_y = s->mb_y*block_s + (my >> lowres); | |
1536 } else { | |
1537 mx = motion_x / 2; | |
1538 my = motion_y / 2; | |
1539 uvsx = mx & s_mask; | |
1540 uvsy = my & s_mask; | |
1541 uvsrc_x = s->mb_x*block_s + (mx >> (lowres+1)); | |
2260 | 1542 uvsrc_y =(s->mb_y*block_s>>field_based) + (my >> (lowres+1)); |
2256 | 1543 } |
1544 | |
1545 ptr_y = ref_picture[0] + src_y * linesize + src_x; | |
1546 ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x; | |
1547 ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x; | |
1548 | |
1549 if( (unsigned)src_x > h_edge_pos - (!!sx) - 2*block_s | |
1550 || (unsigned)src_y >(v_edge_pos >> field_based) - (!!sy) - h){ | |
1551 ff_emulated_edge_mc(s->edge_emu_buffer, ptr_y, s->linesize, 17, 17+field_based, | |
1552 src_x, src_y<<field_based, h_edge_pos, v_edge_pos); | |
1553 ptr_y = s->edge_emu_buffer; | |
1554 if(!(s->flags&CODEC_FLAG_GRAY)){ | |
1555 uint8_t *uvbuf= s->edge_emu_buffer+18*s->linesize; | |
2967 | 1556 ff_emulated_edge_mc(uvbuf , ptr_cb, s->uvlinesize, 9, 9+field_based, |
2256 | 1557 uvsrc_x, uvsrc_y<<field_based, h_edge_pos>>1, v_edge_pos>>1); |
2967 | 1558 ff_emulated_edge_mc(uvbuf+16, ptr_cr, s->uvlinesize, 9, 9+field_based, |
2256 | 1559 uvsrc_x, uvsrc_y<<field_based, h_edge_pos>>1, v_edge_pos>>1); |
1560 ptr_cb= uvbuf; | |
1561 ptr_cr= uvbuf+16; | |
1562 } | |
1563 } | |
1564 | |
2260 | 1565 if(bottom_field){ //FIXME use this for field pix too instead of the obnoxious hack which changes picture.data |
1566 dest_y += s->linesize; | |
1567 dest_cb+= s->uvlinesize; | |
1568 dest_cr+= s->uvlinesize; | |
1569 } | |
1570 | |
1571 if(field_select){ | |
1572 ptr_y += s->linesize; | |
1573 ptr_cb+= s->uvlinesize; | |
1574 ptr_cr+= s->uvlinesize; | |
1575 } | |
1576 | |
2256 | 1577 sx <<= 2 - lowres; |
1578 sy <<= 2 - lowres; | |
1579 pix_op[lowres-1](dest_y, ptr_y, linesize, h, sx, sy); | |
2967 | 1580 |
2256 | 1581 if(!(s->flags&CODEC_FLAG_GRAY)){ |
1582 uvsx <<= 2 - lowres; | |
1583 uvsy <<= 2 - lowres; | |
1584 pix_op[lowres](dest_cb, ptr_cb, uvlinesize, h >> s->chroma_y_shift, uvsx, uvsy); | |
1585 pix_op[lowres](dest_cr, ptr_cr, uvlinesize, h >> s->chroma_y_shift, uvsx, uvsy); | |
1586 } | |
2291 | 1587 //FIXME h261 lowres loop filter |
2256 | 1588 } |
1589 | |
2292 | 1590 static inline void chroma_4mv_motion_lowres(MpegEncContext *s, |
1591 uint8_t *dest_cb, uint8_t *dest_cr, | |
1592 uint8_t **ref_picture, | |
1593 h264_chroma_mc_func *pix_op, | |
1594 int mx, int my){ | |
1595 const int lowres= s->avctx->lowres; | |
1596 const int block_s= 8>>lowres; | |
1597 const int s_mask= (2<<lowres)-1; | |
1598 const int h_edge_pos = s->h_edge_pos >> (lowres+1); | |
1599 const int v_edge_pos = s->v_edge_pos >> (lowres+1); | |
1600 int emu=0, src_x, src_y, offset, sx, sy; | |
1601 uint8_t *ptr; | |
2967 | 1602 |
2292 | 1603 if(s->quarter_sample){ |
1604 mx/=2; | |
1605 my/=2; | |
1606 } | |
1607 | |
1608 /* In case of 8X8, we construct a single chroma motion vector | |
1609 with a special rounding */ | |
1610 mx= ff_h263_round_chroma(mx); | |
1611 my= ff_h263_round_chroma(my); | |
2967 | 1612 |
2292 | 1613 sx= mx & s_mask; |
1614 sy= my & s_mask; | |
1615 src_x = s->mb_x*block_s + (mx >> (lowres+1)); | |
1616 src_y = s->mb_y*block_s + (my >> (lowres+1)); | |
2967 | 1617 |
2292 | 1618 offset = src_y * s->uvlinesize + src_x; |
1619 ptr = ref_picture[1] + offset; | |
1620 if(s->flags&CODEC_FLAG_EMU_EDGE){ | |
1621 if( (unsigned)src_x > h_edge_pos - (!!sx) - block_s | |
1622 || (unsigned)src_y > v_edge_pos - (!!sy) - block_s){ | |
1623 ff_emulated_edge_mc(s->edge_emu_buffer, ptr, s->uvlinesize, 9, 9, src_x, src_y, h_edge_pos, v_edge_pos); | |
1624 ptr= s->edge_emu_buffer; | |
1625 emu=1; | |
1626 } | |
2967 | 1627 } |
2292 | 1628 sx <<= 2 - lowres; |
1629 sy <<= 2 - lowres; | |
1630 pix_op[lowres](dest_cb, ptr, s->uvlinesize, block_s, sx, sy); | |
2967 | 1631 |
2292 | 1632 ptr = ref_picture[2] + offset; |
1633 if(emu){ | |
1634 ff_emulated_edge_mc(s->edge_emu_buffer, ptr, s->uvlinesize, 9, 9, src_x, src_y, h_edge_pos, v_edge_pos); | |
1635 ptr= s->edge_emu_buffer; | |
1636 } | |
1637 pix_op[lowres](dest_cr, ptr, s->uvlinesize, block_s, sx, sy); | |
1638 } | |
1639 | |
2256 | 1640 /** |
2764 | 1641 * motion compensation of a single macroblock |
2256 | 1642 * @param s context |
1643 * @param dest_y luma destination pointer | |
1644 * @param dest_cb chroma cb/u destination pointer | |
1645 * @param dest_cr chroma cr/v destination pointer | |
1646 * @param dir direction (0->forward, 1->backward) | |
1647 * @param ref_picture array[3] of pointers to the 3 planes of the reference picture | |
1648 * @param pic_op halfpel motion compensation function (average or put normally) | |
1649 * the motion vectors are taken from s->mv and the MV type from s->mv_type | |
1650 */ | |
2967 | 1651 static inline void MPV_motion_lowres(MpegEncContext *s, |
2256 | 1652 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr, |
2967 | 1653 int dir, uint8_t **ref_picture, |
2256 | 1654 h264_chroma_mc_func *pix_op) |
1655 { | |
2292 | 1656 int mx, my; |
2260 | 1657 int mb_x, mb_y, i; |
1658 const int lowres= s->avctx->lowres; | |
2967 | 1659 const int block_s= 8>>lowres; |
2260 | 1660 |
1661 mb_x = s->mb_x; | |
1662 mb_y = s->mb_y; | |
1663 | |
1664 switch(s->mv_type) { | |
1665 case MV_TYPE_16X16: | |
2967 | 1666 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr, |
2260 | 1667 0, 0, 0, |
1668 ref_picture, pix_op, | |
1669 s->mv[dir][0][0], s->mv[dir][0][1], 2*block_s); | |
1670 break; | |
2292 | 1671 case MV_TYPE_8X8: |
2260 | 1672 mx = 0; |
1673 my = 0; | |
1674 for(i=0;i<4;i++) { | |
2292 | 1675 hpel_motion_lowres(s, dest_y + ((i & 1) + (i >> 1) * s->linesize)*block_s, |
2260 | 1676 ref_picture[0], 0, 0, |
2292 | 1677 (2*mb_x + (i & 1))*block_s, (2*mb_y + (i >>1))*block_s, |
2260 | 1678 s->width, s->height, s->linesize, |
2292 | 1679 s->h_edge_pos >> lowres, s->v_edge_pos >> lowres, |
1680 block_s, block_s, pix_op, | |
2260 | 1681 s->mv[dir][i][0], s->mv[dir][i][1]); |
1682 | |
1683 mx += s->mv[dir][i][0]; | |
1684 my += s->mv[dir][i][1]; | |
1685 } | |
1686 | |
1687 if(!(s->flags&CODEC_FLAG_GRAY)) | |
2292 | 1688 chroma_4mv_motion_lowres(s, dest_cb, dest_cr, ref_picture, pix_op, mx, my); |
1689 break; | |
2260 | 1690 case MV_TYPE_FIELD: |
1691 if (s->picture_structure == PICT_FRAME) { | |
2967 | 1692 /* top field */ |
2260 | 1693 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr, |
1694 1, 0, s->field_select[dir][0], | |
1695 ref_picture, pix_op, | |
1696 s->mv[dir][0][0], s->mv[dir][0][1], block_s); | |
1697 /* bottom field */ | |
1698 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr, | |
1699 1, 1, s->field_select[dir][1], | |
1700 ref_picture, pix_op, | |
1701 s->mv[dir][1][0], s->mv[dir][1][1], block_s); | |
1702 } else { | |
1703 if(s->picture_structure != s->field_select[dir][0] + 1 && s->pict_type != B_TYPE && !s->first_field){ | |
1704 ref_picture= s->current_picture_ptr->data; | |
2967 | 1705 } |
2260 | 1706 |
1707 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr, | |
1708 0, 0, s->field_select[dir][0], | |
1709 ref_picture, pix_op, | |
1710 s->mv[dir][0][0], s->mv[dir][0][1], 2*block_s); | |
1711 } | |
1712 break; | |
1713 case MV_TYPE_16X8: | |
1714 for(i=0; i<2; i++){ | |
1715 uint8_t ** ref2picture; | |
1716 | |
1717 if(s->picture_structure == s->field_select[dir][i] + 1 || s->pict_type == B_TYPE || s->first_field){ | |
1718 ref2picture= ref_picture; | |
1719 }else{ | |
1720 ref2picture= s->current_picture_ptr->data; | |
2967 | 1721 } |
1722 | |
1723 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr, | |
2260 | 1724 0, 0, s->field_select[dir][i], |
1725 ref2picture, pix_op, | |
1726 s->mv[dir][i][0], s->mv[dir][i][1] + 2*block_s*i, block_s); | |
2967 | 1727 |
2260 | 1728 dest_y += 2*block_s*s->linesize; |
1729 dest_cb+= (2*block_s>>s->chroma_y_shift)*s->uvlinesize; | |
1730 dest_cr+= (2*block_s>>s->chroma_y_shift)*s->uvlinesize; | |
2967 | 1731 } |
2260 | 1732 break; |
1733 case MV_TYPE_DMV: | |
1734 if(s->picture_structure == PICT_FRAME){ | |
1735 for(i=0; i<2; i++){ | |
1736 int j; | |
1737 for(j=0; j<2; j++){ | |
1738 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr, | |
1739 1, j, j^i, | |
1740 ref_picture, pix_op, | |
1741 s->mv[dir][2*i + j][0], s->mv[dir][2*i + j][1], block_s); | |
1742 } | |
1743 pix_op = s->dsp.avg_h264_chroma_pixels_tab; | |
1744 } | |
1745 }else{ | |
1746 for(i=0; i<2; i++){ | |
2967 | 1747 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr, |
2260 | 1748 0, 0, s->picture_structure != i+1, |
1749 ref_picture, pix_op, | |
1750 s->mv[dir][2*i][0],s->mv[dir][2*i][1],2*block_s); | |
1751 | |
1752 // after put we make avg of the same block | |
1753 pix_op = s->dsp.avg_h264_chroma_pixels_tab; | |
1754 | |
1755 //opposite parity is always in the same frame if this is second field | |
1756 if(!s->first_field){ | |
2967 | 1757 ref_picture = s->current_picture_ptr->data; |
2260 | 1758 } |
1759 } | |
1760 } | |
1761 break; | |
1762 default: assert(0); | |
1763 } | |
2256 | 1764 } |
0 | 1765 |
1766 /* put block[] to dest[] */ | |
2967 | 1767 static inline void put_dct(MpegEncContext *s, |
1651 | 1768 DCTELEM *block, int i, uint8_t *dest, int line_size, int qscale) |
0 | 1769 { |
1689 | 1770 s->dct_unquantize_intra(s, block, i, qscale); |
1092 | 1771 s->dsp.idct_put (dest, line_size, block); |
0 | 1772 } |
1773 | |
1774 /* add block[] to dest[] */ | |
2967 | 1775 static inline void add_dct(MpegEncContext *s, |
1064 | 1776 DCTELEM *block, int i, uint8_t *dest, int line_size) |
0 | 1777 { |
1778 if (s->block_last_index[i] >= 0) { | |
1092 | 1779 s->dsp.idct_add (dest, line_size, block); |
481 | 1780 } |
1781 } | |
1782 | |
2967 | 1783 static inline void add_dequant_dct(MpegEncContext *s, |
1644 | 1784 DCTELEM *block, int i, uint8_t *dest, int line_size, int qscale) |
481 | 1785 { |
1786 if (s->block_last_index[i] >= 0) { | |
1689 | 1787 s->dct_unquantize_inter(s, block, i, qscale); |
324 | 1788 |
1092 | 1789 s->dsp.idct_add (dest, line_size, block); |
0 | 1790 } |
1791 } | |
1792 | |
456 | 1793 /** |
1794 * cleans dc, ac, coded_block for the current non intra MB | |
1795 */ | |
1796 void ff_clean_intra_table_entries(MpegEncContext *s) | |
1797 { | |
1938
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1918
diff
changeset
|
1798 int wrap = s->b8_stride; |
456 | 1799 int xy = s->block_index[0]; |
2967 | 1800 |
1801 s->dc_val[0][xy ] = | |
1802 s->dc_val[0][xy + 1 ] = | |
456 | 1803 s->dc_val[0][xy + wrap] = |
1804 s->dc_val[0][xy + 1 + wrap] = 1024; | |
1805 /* ac pred */ | |
1064 | 1806 memset(s->ac_val[0][xy ], 0, 32 * sizeof(int16_t)); |
1807 memset(s->ac_val[0][xy + wrap], 0, 32 * sizeof(int16_t)); | |
456 | 1808 if (s->msmpeg4_version>=3) { |
1809 s->coded_block[xy ] = | |
1810 s->coded_block[xy + 1 ] = | |
1811 s->coded_block[xy + wrap] = | |
1812 s->coded_block[xy + 1 + wrap] = 0; | |
1813 } | |
1814 /* chroma */ | |
1938
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1918
diff
changeset
|
1815 wrap = s->mb_stride; |
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1918
diff
changeset
|
1816 xy = s->mb_x + s->mb_y * wrap; |
456 | 1817 s->dc_val[1][xy] = |
1818 s->dc_val[2][xy] = 1024; | |
1819 /* ac pred */ | |
1064 | 1820 memset(s->ac_val[1][xy], 0, 16 * sizeof(int16_t)); |
1821 memset(s->ac_val[2][xy], 0, 16 * sizeof(int16_t)); | |
2967 | 1822 |
1938
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1918
diff
changeset
|
1823 s->mbintra_table[xy]= 0; |
456 | 1824 } |
1825 | |
0 | 1826 /* generic function called after a macroblock has been parsed by the |
1827 decoder or after it has been encoded by the encoder. | |
1828 | |
1829 Important variables used: | |
1830 s->mb_intra : true if intra macroblock | |
1831 s->mv_dir : motion vector direction | |
1832 s->mv_type : motion vector type | |
1833 s->mv : motion vector | |
1834 s->interlaced_dct : true if interlaced dct used (mpeg2) | |
1835 */ | |
4283
d6f83e2f8804
rename always_inline to av_always_inline and move to common.h
mru
parents:
4281
diff
changeset
|
1836 static av_always_inline void MPV_decode_mb_internal(MpegEncContext *s, DCTELEM block[12][64], int lowres_flag) |
0 | 1837 { |
244 | 1838 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
|
1839 const int mb_xy = s->mb_y * s->mb_stride + s->mb_x; |
1381 | 1840 #ifdef HAVE_XVMC |
1841 if(s->avctx->xvmc_acceleration){ | |
1580
628bf341e099
XvMC speedup by removing one memcpy and doing MB packing
iive
parents:
1579
diff
changeset
|
1842 XVMC_decode_mb(s);//xvmc uses pblocks |
1381 | 1843 return; |
1844 } | |
1845 #endif | |
0 | 1846 |
1847 mb_x = s->mb_x; | |
1848 mb_y = s->mb_y; | |
1849 | |
1833
ba27ce284d07
export DCT coefficients patch by (Wolfgang Hesseler <wolfgang.hesseler at imk dot fraunhofer dot de>)
michael
parents:
1831
diff
changeset
|
1850 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
|
1851 /* save DCT coefficients */ |
ba27ce284d07
export DCT coefficients patch by (Wolfgang Hesseler <wolfgang.hesseler at imk dot fraunhofer dot de>)
michael
parents:
1831
diff
changeset
|
1852 int i,j; |
ba27ce284d07
export DCT coefficients patch by (Wolfgang Hesseler <wolfgang.hesseler at imk dot fraunhofer dot de>)
michael
parents:
1831
diff
changeset
|
1853 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
|
1854 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
|
1855 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
|
1856 *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
|
1857 } |
ba27ce284d07
export DCT coefficients patch by (Wolfgang Hesseler <wolfgang.hesseler at imk dot fraunhofer dot de>)
michael
parents:
1831
diff
changeset
|
1858 |
903 | 1859 s->current_picture.qscale_table[mb_xy]= s->qscale; |
108
1e4a4af694d1
exporting qscale data for postprocessing (for MPlayer)
arpi_esp
parents:
79
diff
changeset
|
1860 |
0 | 1861 /* update DC predictors for P macroblocks */ |
1862 if (!s->mb_intra) { | |
249
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1863 if (s->h263_pred || s->h263_aic) { |
481 | 1864 if(s->mbintra_table[mb_xy]) |
456 | 1865 ff_clean_intra_table_entries(s); |
0 | 1866 } else { |
456 | 1867 s->last_dc[0] = |
1868 s->last_dc[1] = | |
0 | 1869 s->last_dc[2] = 128 << s->intra_dc_precision; |
1870 } | |
1871 } | |
249
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1872 else if (s->h263_pred || s->h263_aic) |
481 | 1873 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
|
1874 |
4224
8e0dcefcb464
fix b frames + -mbd rd without -psnr (yes that was seriously buggy and probably hasnt been noticed as everyone who tested stuff used -psnr)
michael
parents:
4223
diff
changeset
|
1875 if ((s->flags&CODEC_FLAG_PSNR) || !(s->encoding && (s->intra_only || s->pict_type==B_TYPE) && s->avctx->mb_decision != FF_MB_DECISION_RD)) { //FIXME precalc |
1064 | 1876 uint8_t *dest_y, *dest_cb, *dest_cr; |
481 | 1877 int dct_linesize, dct_offset; |
651 | 1878 op_pixels_func (*op_pix)[4]; |
1879 qpel_mc_func (*op_qpix)[16]; | |
2627
bf158d23bbcc
Spelling errors patch by (Kevin Baragona | kevinmb500 gawab com)
michael
parents:
2620
diff
changeset
|
1880 const int linesize= s->current_picture.linesize[0]; //not s->linesize as this would be wrong for field pics |
1138 | 1881 const int uvlinesize= s->current_picture.linesize[1]; |
2256 | 1882 const int readable= s->pict_type != B_TYPE || s->encoding || s->avctx->draw_horiz_band || lowres_flag; |
1883 const int block_size= lowres_flag ? 8>>s->avctx->lowres : 8; | |
7
1d3ac9654178
added skip macroblock optimization (big perf win on black regions for example)
glantau
parents:
0
diff
changeset
|
1884 |
903 | 1885 /* avoid copy if macroblock skipped in last frame too */ |
1886 /* skip only during decoding as we might trash the buffers during encoding a bit */ | |
1887 if(!s->encoding){ | |
1064 | 1888 uint8_t *mbskip_ptr = &s->mbskip_table[mb_xy]; |
903 | 1889 const int age= s->current_picture.age; |
1890 | |
1891 assert(age); | |
1892 | |
2628
511e3afc43e1
Ministry of English Composition, reporting for duty (and the word is "skipped", not "skiped"; "skiped" would rhyme with "hyped")
melanson
parents:
2627
diff
changeset
|
1893 if (s->mb_skipped) { |
511e3afc43e1
Ministry of English Composition, reporting for duty (and the word is "skipped", not "skiped"; "skiped" would rhyme with "hyped")
melanson
parents:
2627
diff
changeset
|
1894 s->mb_skipped= 0; |
903 | 1895 assert(s->pict_type!=I_TYPE); |
2967 | 1896 |
2628
511e3afc43e1
Ministry of English Composition, reporting for duty (and the word is "skipped", not "skiped"; "skiped" would rhyme with "hyped")
melanson
parents:
2627
diff
changeset
|
1897 (*mbskip_ptr) ++; /* indicate that this time we skipped it */ |
556 | 1898 if(*mbskip_ptr >99) *mbskip_ptr= 99; |
1899 | |
903 | 1900 /* 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
|
1901 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
|
1902 return; |
903 | 1903 } |
1021
2d7c9f5738de
trying to fix mb skip bug in mpeg1/2 if slices are not used
michaelni
parents:
1014
diff
changeset
|
1904 } 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
|
1905 (*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
|
1906 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
|
1907 } else{ |
7
1d3ac9654178
added skip macroblock optimization (big perf win on black regions for example)
glantau
parents:
0
diff
changeset
|
1908 *mbskip_ptr = 0; /* not skipped */ |
1d3ac9654178
added skip macroblock optimization (big perf win on black regions for example)
glantau
parents:
0
diff
changeset
|
1909 } |
717 | 1910 } |
2967 | 1911 |
2074
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
1912 dct_linesize = linesize << s->interlaced_dct; |
2256 | 1913 dct_offset =(s->interlaced_dct)? linesize : linesize*block_size; |
2967 | 1914 |
1632 | 1915 if(readable){ |
1916 dest_y= s->dest[0]; | |
1917 dest_cb= s->dest[1]; | |
1918 dest_cr= s->dest[2]; | |
1919 }else{ | |
1799 | 1920 dest_y = s->b_scratchpad; |
1834 | 1921 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
|
1922 dest_cr= s->b_scratchpad+32*linesize; |
1632 | 1923 } |
2256 | 1924 |
0 | 1925 if (!s->mb_intra) { |
1926 /* motion handling */ | |
2627
bf158d23bbcc
Spelling errors patch by (Kevin Baragona | kevinmb500 gawab com)
michael
parents:
2620
diff
changeset
|
1927 /* decoding or more than one mb_type (MC was already done otherwise) */ |
1389 | 1928 if(!s->encoding){ |
2256 | 1929 if(lowres_flag){ |
1930 h264_chroma_mc_func *op_pix = s->dsp.put_h264_chroma_pixels_tab; | |
1931 | |
1932 if (s->mv_dir & MV_DIR_FORWARD) { | |
1933 MPV_motion_lowres(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.data, op_pix); | |
1934 op_pix = s->dsp.avg_h264_chroma_pixels_tab; | |
1935 } | |
1936 if (s->mv_dir & MV_DIR_BACKWARD) { | |
1937 MPV_motion_lowres(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.data, op_pix); | |
1938 } | |
324 | 1939 }else{ |
3807
6a40092eb9e6
approximate qpel functions: sacrifice some quality for some decoding speed. enabled on B-frames with -lavdopts fast.
lorenm
parents:
3780
diff
changeset
|
1940 op_qpix= s->me.qpel_put; |
2967 | 1941 if ((!s->no_rounding) || s->pict_type==B_TYPE){ |
2256 | 1942 op_pix = s->dsp.put_pixels_tab; |
1943 }else{ | |
1944 op_pix = s->dsp.put_no_rnd_pixels_tab; | |
1945 } | |
1946 if (s->mv_dir & MV_DIR_FORWARD) { | |
1947 MPV_motion(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.data, op_pix, op_qpix); | |
1948 op_pix = s->dsp.avg_pixels_tab; | |
3807
6a40092eb9e6
approximate qpel functions: sacrifice some quality for some decoding speed. enabled on B-frames with -lavdopts fast.
lorenm
parents:
3780
diff
changeset
|
1949 op_qpix= s->me.qpel_avg; |
2256 | 1950 } |
1951 if (s->mv_dir & MV_DIR_BACKWARD) { | |
1952 MPV_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.data, op_pix, op_qpix); | |
1953 } | |
324 | 1954 } |
0 | 1955 } |
1956 | |
481 | 1957 /* skip dequant / idct if we are really late ;) */ |
2792 | 1958 if(s->hurry_up>1) goto skip_idct; |
1959 if(s->avctx->skip_idct){ | |
1960 if( (s->avctx->skip_idct >= AVDISCARD_NONREF && s->pict_type == B_TYPE) | |
1961 ||(s->avctx->skip_idct >= AVDISCARD_NONKEY && s->pict_type != I_TYPE) | |
1962 || s->avctx->skip_idct >= AVDISCARD_ALL) | |
1963 goto skip_idct; | |
1964 } | |
481 | 1965 |
0 | 1966 /* add dct residue */ |
1421 | 1967 if(s->encoding || !( s->h263_msmpeg4 || s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO |
711 | 1968 || (s->codec_id==CODEC_ID_MPEG4 && !s->mpeg_quant))){ |
2256 | 1969 add_dequant_dct(s, block[0], 0, dest_y , dct_linesize, s->qscale); |
1970 add_dequant_dct(s, block[1], 1, dest_y + block_size, dct_linesize, s->qscale); | |
1971 add_dequant_dct(s, block[2], 2, dest_y + dct_offset , dct_linesize, s->qscale); | |
1972 add_dequant_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize, s->qscale); | |
0 | 1973 |
485 | 1974 if(!(s->flags&CODEC_FLAG_GRAY)){ |
3309 | 1975 if (s->chroma_y_shift){ |
1976 add_dequant_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale); | |
1977 add_dequant_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale); | |
1978 }else{ | |
1979 dct_linesize >>= 1; | |
1980 dct_offset >>=1; | |
1981 add_dequant_dct(s, block[4], 4, dest_cb, dct_linesize, s->chroma_qscale); | |
1982 add_dequant_dct(s, block[5], 5, dest_cr, dct_linesize, s->chroma_qscale); | |
1983 add_dequant_dct(s, block[6], 6, dest_cb + dct_offset, dct_linesize, s->chroma_qscale); | |
1984 add_dequant_dct(s, block[7], 7, dest_cr + dct_offset, dct_linesize, s->chroma_qscale); | |
1985 } | |
485 | 1986 } |
936 | 1987 } else if(s->codec_id != CODEC_ID_WMV2){ |
2256 | 1988 add_dct(s, block[0], 0, dest_y , dct_linesize); |
1989 add_dct(s, block[1], 1, dest_y + block_size, dct_linesize); | |
1990 add_dct(s, block[2], 2, dest_y + dct_offset , dct_linesize); | |
1991 add_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize); | |
481 | 1992 |
485 | 1993 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
|
1994 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
|
1995 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
|
1996 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
|
1997 }else{ |
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
1998 //chroma422 |
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
1999 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
|
2000 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
|
2001 |
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
2002 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
|
2003 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
|
2004 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
|
2005 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
|
2006 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
|
2007 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
|
2008 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
|
2009 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
|
2010 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
|
2011 } |
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
2012 } |
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
2013 }//fi gray |
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
2014 } |
4967
6d45158e0249
disable reference to msmpeg4 and wmv2 code when those codecs are not compiled in
aurel
parents:
4668
diff
changeset
|
2015 else if (ENABLE_WMV2) { |
936 | 2016 ff_wmv2_add_mb(s, block, dest_y, dest_cb, dest_cr); |
481 | 2017 } |
0 | 2018 } else { |
2019 /* dct only in intra block */ | |
1421 | 2020 if(s->encoding || !(s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO)){ |
2256 | 2021 put_dct(s, block[0], 0, dest_y , dct_linesize, s->qscale); |
2022 put_dct(s, block[1], 1, dest_y + block_size, dct_linesize, s->qscale); | |
2023 put_dct(s, block[2], 2, dest_y + dct_offset , dct_linesize, s->qscale); | |
2024 put_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize, s->qscale); | |
0 | 2025 |
711 | 2026 if(!(s->flags&CODEC_FLAG_GRAY)){ |
3309 | 2027 if(s->chroma_y_shift){ |
2028 put_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale); | |
2029 put_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale); | |
2030 }else{ | |
2031 dct_offset >>=1; | |
2032 dct_linesize >>=1; | |
2033 put_dct(s, block[4], 4, dest_cb, dct_linesize, s->chroma_qscale); | |
2034 put_dct(s, block[5], 5, dest_cr, dct_linesize, s->chroma_qscale); | |
2035 put_dct(s, block[6], 6, dest_cb + dct_offset, dct_linesize, s->chroma_qscale); | |
2036 put_dct(s, block[7], 7, dest_cr + dct_offset, dct_linesize, s->chroma_qscale); | |
2037 } | |
711 | 2038 } |
2039 }else{ | |
2256 | 2040 s->dsp.idct_put(dest_y , dct_linesize, block[0]); |
2041 s->dsp.idct_put(dest_y + block_size, dct_linesize, block[1]); | |
2042 s->dsp.idct_put(dest_y + dct_offset , dct_linesize, block[2]); | |
2043 s->dsp.idct_put(dest_y + dct_offset + block_size, dct_linesize, block[3]); | |
711 | 2044 |
2045 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
|
2046 if(s->chroma_y_shift){ |
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
2047 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
|
2048 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
|
2049 }else{ |
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
2050 |
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
2051 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
|
2052 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
|
2053 |
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
2054 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
|
2055 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
|
2056 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
|
2057 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
|
2058 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
|
2059 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
|
2060 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
|
2061 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
|
2062 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
|
2063 } |
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
2064 } |
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
2065 }//gray |
485 | 2066 } |
0 | 2067 } |
2792 | 2068 skip_idct: |
1632 | 2069 if(!readable){ |
2070 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
|
2071 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
|
2072 s->dsp.put_pixels_tab[s->chroma_x_shift][0](s->dest[2], dest_cr, uvlinesize,16 >> s->chroma_y_shift); |
1632 | 2073 } |
0 | 2074 } |
294 | 2075 } |
2076 | |
2256 | 2077 void MPV_decode_mb(MpegEncContext *s, DCTELEM block[12][64]){ |
2078 if(s->avctx->lowres) MPV_decode_mb_internal(s, block, 1); | |
2079 else MPV_decode_mb_internal(s, block, 0); | |
2080 } | |
2081 | |
1098
b7f267d168b7
mpeg2 field pictures + sliced mode (doesnt work with mplayer though, dunno why)
michaelni
parents:
1096
diff
changeset
|
2082 /** |
b7f267d168b7
mpeg2 field pictures + sliced mode (doesnt work with mplayer though, dunno why)
michaelni
parents:
1096
diff
changeset
|
2083 * |
b7f267d168b7
mpeg2 field pictures + sliced mode (doesnt work with mplayer though, dunno why)
michaelni
parents:
1096
diff
changeset
|
2084 * @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
|
2085 */ |
b7f267d168b7
mpeg2 field pictures + sliced mode (doesnt work with mplayer though, dunno why)
michaelni
parents:
1096
diff
changeset
|
2086 void ff_draw_horiz_band(MpegEncContext *s, int y, int h){ |
1368 | 2087 if (s->avctx->draw_horiz_band) { |
1370 | 2088 AVFrame *src; |
1368 | 2089 int offset[4]; |
2967 | 2090 |
1370 | 2091 if(s->picture_structure != PICT_FRAME){ |
2092 h <<= 1; | |
2093 y <<= 1; | |
2094 if(s->first_field && !(s->avctx->slice_flags&SLICE_FLAG_ALLOW_FIELD)) return; | |
2095 } | |
2096 | |
2266
514949de5d15
set AVCodecContext.width/height to the picture width/height instead of the one stored in the bitstream (that only matters if lowres!=0)
michael
parents:
2265
diff
changeset
|
2097 h= FFMIN(h, s->avctx->height - y); |
1098
b7f267d168b7
mpeg2 field pictures + sliced mode (doesnt work with mplayer though, dunno why)
michaelni
parents:
1096
diff
changeset
|
2098 |
2967 | 2099 if(s->pict_type==B_TYPE || s->low_delay || (s->avctx->slice_flags&SLICE_FLAG_CODED_ORDER)) |
1370 | 2100 src= (AVFrame*)s->current_picture_ptr; |
2101 else if(s->last_picture_ptr) | |
2102 src= (AVFrame*)s->last_picture_ptr; | |
2103 else | |
2104 return; | |
2967 | 2105 |
1369 | 2106 if(s->pict_type==B_TYPE && s->picture_structure == PICT_FRAME && s->out_format != FMT_H264){ |
1368 | 2107 offset[0]= |
2108 offset[1]= | |
2109 offset[2]= | |
2110 offset[3]= 0; | |
2111 }else{ | |
2112 offset[0]= y * s->linesize;; | |
2967 | 2113 offset[1]= |
2074
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
2114 offset[2]= (y >> s->chroma_y_shift) * s->uvlinesize; |
1368 | 2115 offset[3]= 0; |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
731
diff
changeset
|
2116 } |
1368 | 2117 |
813 | 2118 emms_c(); |
2119 | |
1370 | 2120 s->avctx->draw_horiz_band(s->avctx, src, offset, |
2121 y, s->picture_structure, h); | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
731
diff
changeset
|
2122 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
731
diff
changeset
|
2123 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
731
diff
changeset
|
2124 |
1389 | 2125 void ff_init_block_index(MpegEncContext *s){ //FIXME maybe rename |
2764 | 2126 const int linesize= s->current_picture.linesize[0]; //not s->linesize as this would be wrong for field pics |
1389 | 2127 const int uvlinesize= s->current_picture.linesize[1]; |
2256 | 2128 const int mb_size= 4 - s->avctx->lowres; |
2967 | 2129 |
1938
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1918
diff
changeset
|
2130 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
|
2131 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
|
2132 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
|
2133 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
|
2134 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
|
2135 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
|
2136 //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
|
2137 |
2256 | 2138 s->dest[0] = s->current_picture.data[0] + ((s->mb_x - 1) << mb_size); |
2139 s->dest[1] = s->current_picture.data[1] + ((s->mb_x - 1) << (mb_size - s->chroma_x_shift)); | |
2140 s->dest[2] = s->current_picture.data[2] + ((s->mb_x - 1) << (mb_size - s->chroma_x_shift)); | |
2168 | 2141 |
2074
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
2142 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
|
2143 { |
2256 | 2144 s->dest[0] += s->mb_y * linesize << mb_size; |
2145 s->dest[1] += s->mb_y * uvlinesize << (mb_size - s->chroma_y_shift); | |
2146 s->dest[2] += s->mb_y * uvlinesize << (mb_size - s->chroma_y_shift); | |
2074
2faafe7a3db6
mpeg2 chroma422/444 support, may be slower, may be faster for other codecs
iive
parents:
2066
diff
changeset
|
2147 } |
1389 | 2148 } |
2149 | |
1368 | 2150 void ff_mpeg_flush(AVCodecContext *avctx){ |
2151 int i; | |
2152 MpegEncContext *s = avctx->priv_data; | |
2967 | 2153 |
2154 if(s==NULL || s->picture==NULL) | |
1751 | 2155 return; |
2967 | 2156 |
1368 | 2157 for(i=0; i<MAX_PICTURE_COUNT; i++){ |
2158 if(s->picture[i].data[0] && ( s->picture[i].type == FF_BUFFER_TYPE_INTERNAL | |
2159 || s->picture[i].type == FF_BUFFER_TYPE_USER)) | |
2160 avctx->release_buffer(avctx, (AVFrame*)&s->picture[i]); | |
2161 } | |
1601 | 2162 s->current_picture_ptr = s->last_picture_ptr = s->next_picture_ptr = NULL; |
2967 | 2163 |
2380 | 2164 s->mb_x= s->mb_y= 0; |
2967 | 2165 |
1395 | 2166 s->parse_context.state= -1; |
2167 s->parse_context.frame_start_found= 0; | |
2168 s->parse_context.overread= 0; | |
2169 s->parse_context.overread_index= 0; | |
2170 s->parse_context.index= 0; | |
2171 s->parse_context.last_index= 0; | |
1851 | 2172 s->bitstream_buffer_size=0; |
4346 | 2173 s->pp_time=0; |
1368 | 2174 } |
2175 | |
2967 | 2176 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
|
2177 DCTELEM *block, int n, int qscale) |
0 | 2178 { |
200 | 2179 int i, level, nCoeffs; |
1064 | 2180 const uint16_t *quant_matrix; |
0 | 2181 |
706
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
2182 nCoeffs= s->block_last_index[n]; |
2967 | 2183 |
2184 if (n < 4) | |
1689 | 2185 block[0] = block[0] * s->y_dc_scale; |
2186 else | |
2187 block[0] = block[0] * s->c_dc_scale; | |
2188 /* XXX: only mpeg1 */ | |
2189 quant_matrix = s->intra_matrix; | |
2190 for(i=1;i<=nCoeffs;i++) { | |
2191 int j= s->intra_scantable.permutated[i]; | |
2192 level = block[j]; | |
2193 if (level) { | |
2194 if (level < 0) { | |
2195 level = -level; | |
2196 level = (int)(level * qscale * quant_matrix[j]) >> 3; | |
2197 level = (level - 1) | 1; | |
2198 level = -level; | |
2199 } else { | |
2200 level = (int)(level * qscale * quant_matrix[j]) >> 3; | |
2201 level = (level - 1) | 1; | |
0 | 2202 } |
1689 | 2203 block[j] = level; |
0 | 2204 } |
2205 } | |
2206 } | |
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
|
2207 |
2967 | 2208 static void dct_unquantize_mpeg1_inter_c(MpegEncContext *s, |
1689 | 2209 DCTELEM *block, int n, int qscale) |
2210 { | |
2211 int i, level, nCoeffs; | |
2212 const uint16_t *quant_matrix; | |
2213 | |
2214 nCoeffs= s->block_last_index[n]; | |
2967 | 2215 |
1689 | 2216 quant_matrix = s->inter_matrix; |
2217 for(i=0; i<=nCoeffs; i++) { | |
2218 int j= s->intra_scantable.permutated[i]; | |
2219 level = block[j]; | |
2220 if (level) { | |
2221 if (level < 0) { | |
2222 level = -level; | |
2223 level = (((level << 1) + 1) * qscale * | |
2224 ((int) (quant_matrix[j]))) >> 4; | |
2225 level = (level - 1) | 1; | |
2226 level = -level; | |
2227 } else { | |
2228 level = (((level << 1) + 1) * qscale * | |
2229 ((int) (quant_matrix[j]))) >> 4; | |
2230 level = (level - 1) | 1; | |
2231 } | |
2232 block[j] = level; | |
2233 } | |
2234 } | |
2235 } | |
2236 | |
2967 | 2237 static void dct_unquantize_mpeg2_intra_c(MpegEncContext *s, |
325 | 2238 DCTELEM *block, int n, int qscale) |
2239 { | |
2240 int i, level, nCoeffs; | |
1064 | 2241 const uint16_t *quant_matrix; |
325 | 2242 |
706
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
2243 if(s->alternate_scan) nCoeffs= 63; |
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
2244 else nCoeffs= s->block_last_index[n]; |
2967 | 2245 |
2246 if (n < 4) | |
1689 | 2247 block[0] = block[0] * s->y_dc_scale; |
2248 else | |
2249 block[0] = block[0] * s->c_dc_scale; | |
2250 quant_matrix = s->intra_matrix; | |
2251 for(i=1;i<=nCoeffs;i++) { | |
2252 int j= s->intra_scantable.permutated[i]; | |
2253 level = block[j]; | |
2254 if (level) { | |
2255 if (level < 0) { | |
2256 level = -level; | |
2257 level = (int)(level * qscale * quant_matrix[j]) >> 3; | |
2258 level = -level; | |
2259 } else { | |
2260 level = (int)(level * qscale * quant_matrix[j]) >> 3; | |
2261 } | |
2262 block[j] = level; | |
2263 } | |
2264 } | |
2265 } | |
2266 | |
3281
7fac25904a8b
missmatch control for mpeg2 intra dequantization if bitexact=1
michael
parents:
3268
diff
changeset
|
2267 static void dct_unquantize_mpeg2_intra_bitexact(MpegEncContext *s, |
7fac25904a8b
missmatch control for mpeg2 intra dequantization if bitexact=1
michael
parents:
3268
diff
changeset
|
2268 DCTELEM *block, int n, int qscale) |
7fac25904a8b
missmatch control for mpeg2 intra dequantization if bitexact=1
michael
parents:
3268
diff
changeset
|
2269 { |
7fac25904a8b
missmatch control for mpeg2 intra dequantization if bitexact=1
michael
parents:
3268
diff
changeset
|
2270 int i, level, nCoeffs; |
7fac25904a8b
missmatch control for mpeg2 intra dequantization if bitexact=1
michael
parents:
3268
diff
changeset
|
2271 const uint16_t *quant_matrix; |
7fac25904a8b
missmatch control for mpeg2 intra dequantization if bitexact=1
michael
parents:
3268
diff
changeset
|
2272 int sum=-1; |
7fac25904a8b
missmatch control for mpeg2 intra dequantization if bitexact=1
michael
parents:
3268
diff
changeset
|
2273 |
7fac25904a8b
missmatch control for mpeg2 intra dequantization if bitexact=1
michael
parents:
3268
diff
changeset
|
2274 if(s->alternate_scan) nCoeffs= 63; |
7fac25904a8b
missmatch control for mpeg2 intra dequantization if bitexact=1
michael
parents:
3268
diff
changeset
|
2275 else nCoeffs= s->block_last_index[n]; |
7fac25904a8b
missmatch control for mpeg2 intra dequantization if bitexact=1
michael
parents:
3268
diff
changeset
|
2276 |
7fac25904a8b
missmatch control for mpeg2 intra dequantization if bitexact=1
michael
parents:
3268
diff
changeset
|
2277 if (n < 4) |
7fac25904a8b
missmatch control for mpeg2 intra dequantization if bitexact=1
michael
parents:
3268
diff
changeset
|
2278 block[0] = block[0] * s->y_dc_scale; |
7fac25904a8b
missmatch control for mpeg2 intra dequantization if bitexact=1
michael
parents:
3268
diff
changeset
|
2279 else |
7fac25904a8b
missmatch control for mpeg2 intra dequantization if bitexact=1
michael
parents:
3268
diff
changeset
|
2280 block[0] = block[0] * s->c_dc_scale; |
7fac25904a8b
missmatch control for mpeg2 intra dequantization if bitexact=1
michael
parents:
3268
diff
changeset
|
2281 quant_matrix = s->intra_matrix; |
7fac25904a8b
missmatch control for mpeg2 intra dequantization if bitexact=1
michael
parents:
3268
diff
changeset
|
2282 for(i=1;i<=nCoeffs;i++) { |
7fac25904a8b
missmatch control for mpeg2 intra dequantization if bitexact=1
michael
parents:
3268
diff
changeset
|
2283 int j= s->intra_scantable.permutated[i]; |
7fac25904a8b
missmatch control for mpeg2 intra dequantization if bitexact=1
michael
parents:
3268
diff
changeset
|
2284 level = block[j]; |
7fac25904a8b
missmatch control for mpeg2 intra dequantization if bitexact=1
michael
parents:
3268
diff
changeset
|
2285 if (level) { |
7fac25904a8b
missmatch control for mpeg2 intra dequantization if bitexact=1
michael
parents:
3268
diff
changeset
|
2286 if (level < 0) { |
7fac25904a8b
missmatch control for mpeg2 intra dequantization if bitexact=1
michael
parents:
3268
diff
changeset
|
2287 level = -level; |
7fac25904a8b
missmatch control for mpeg2 intra dequantization if bitexact=1
michael
parents:
3268
diff
changeset
|
2288 level = (int)(level * qscale * quant_matrix[j]) >> 3; |
7fac25904a8b
missmatch control for mpeg2 intra dequantization if bitexact=1
michael
parents:
3268
diff
changeset
|
2289 level = -level; |
7fac25904a8b
missmatch control for mpeg2 intra dequantization if bitexact=1
michael
parents:
3268
diff
changeset
|
2290 } else { |
7fac25904a8b
missmatch control for mpeg2 intra dequantization if bitexact=1
michael
parents:
3268
diff
changeset
|
2291 level = (int)(level * qscale * quant_matrix[j]) >> 3; |
7fac25904a8b
missmatch control for mpeg2 intra dequantization if bitexact=1
michael
parents:
3268
diff
changeset
|
2292 } |
7fac25904a8b
missmatch control for mpeg2 intra dequantization if bitexact=1
michael
parents:
3268
diff
changeset
|
2293 block[j] = level; |
7fac25904a8b
missmatch control for mpeg2 intra dequantization if bitexact=1
michael
parents:
3268
diff
changeset
|
2294 sum+=level; |
7fac25904a8b
missmatch control for mpeg2 intra dequantization if bitexact=1
michael
parents:
3268
diff
changeset
|
2295 } |
7fac25904a8b
missmatch control for mpeg2 intra dequantization if bitexact=1
michael
parents:
3268
diff
changeset
|
2296 } |
7fac25904a8b
missmatch control for mpeg2 intra dequantization if bitexact=1
michael
parents:
3268
diff
changeset
|
2297 block[63]^=sum&1; |
7fac25904a8b
missmatch control for mpeg2 intra dequantization if bitexact=1
michael
parents:
3268
diff
changeset
|
2298 } |
7fac25904a8b
missmatch control for mpeg2 intra dequantization if bitexact=1
michael
parents:
3268
diff
changeset
|
2299 |
2967 | 2300 static void dct_unquantize_mpeg2_inter_c(MpegEncContext *s, |
1689 | 2301 DCTELEM *block, int n, int qscale) |
2302 { | |
2303 int i, level, nCoeffs; | |
2304 const uint16_t *quant_matrix; | |
2305 int sum=-1; | |
2306 | |
2307 if(s->alternate_scan) nCoeffs= 63; | |
2308 else nCoeffs= s->block_last_index[n]; | |
2967 | 2309 |
1689 | 2310 quant_matrix = s->inter_matrix; |
2311 for(i=0; i<=nCoeffs; i++) { | |
2312 int j= s->intra_scantable.permutated[i]; | |
2313 level = block[j]; | |
2314 if (level) { | |
2315 if (level < 0) { | |
2316 level = -level; | |
2317 level = (((level << 1) + 1) * qscale * | |
2318 ((int) (quant_matrix[j]))) >> 4; | |
2319 level = -level; | |
2320 } else { | |
2321 level = (((level << 1) + 1) * qscale * | |
2322 ((int) (quant_matrix[j]))) >> 4; | |
2323 } | |
2324 block[j] = level; | |
2325 sum+=level; | |
2326 } | |
2327 } | |
2328 block[63]^=sum&1; | |
2329 } | |
2330 | |
2967 | 2331 static void dct_unquantize_h263_intra_c(MpegEncContext *s, |
1689 | 2332 DCTELEM *block, int n, int qscale) |
2333 { | |
2334 int i, level, qmul, qadd; | |
2335 int nCoeffs; | |
2967 | 2336 |
1689 | 2337 assert(s->block_last_index[n]>=0); |
2967 | 2338 |
1689 | 2339 qmul = qscale << 1; |
2967 | 2340 |
1689 | 2341 if (!s->h263_aic) { |
2967 | 2342 if (n < 4) |
325 | 2343 block[0] = block[0] * s->y_dc_scale; |
2344 else | |
2345 block[0] = block[0] * s->c_dc_scale; | |
1689 | 2346 qadd = (qscale - 1) | 1; |
2347 }else{ | |
2348 qadd = 0; | |
2349 } | |
2350 if(s->ac_pred) | |
2351 nCoeffs=63; | |
2352 else | |
2353 nCoeffs= s->inter_scantable.raster_end[ s->block_last_index[n] ]; | |
2354 | |
2355 for(i=1; i<=nCoeffs; i++) { | |
2356 level = block[i]; | |
2357 if (level) { | |
2358 if (level < 0) { | |
2359 level = level * qmul - qadd; | |
2360 } else { | |
2361 level = level * qmul + qadd; | |
325 | 2362 } |
1689 | 2363 block[i] = level; |
325 | 2364 } |
2365 } | |
2366 } | |
2367 | |
2967 | 2368 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
|
2369 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
|
2370 { |
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
|
2371 int i, level, qmul, qadd; |
200 | 2372 int nCoeffs; |
2967 | 2373 |
706
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
2374 assert(s->block_last_index[n]>=0); |
2967 | 2375 |
706
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
2376 qadd = (qscale - 1) | 1; |
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
704
diff
changeset
|
2377 qmul = qscale << 1; |
2967 | 2378 |
1689 | 2379 nCoeffs= s->inter_scantable.raster_end[ s->block_last_index[n] ]; |
2380 | |
2381 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
|
2382 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
|
2383 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
|
2384 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
|
2385 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
|
2386 } 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
|
2387 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
|
2388 } |
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
|
2389 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
|
2390 } |
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
|
2391 } |
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
|
2392 } |
0 | 2393 |
5265 | 2394 /** |
2395 * set qscale and update qscale dependent variables. | |
2396 */ | |
2397 void ff_set_qscale(MpegEncContext * s, int qscale) | |
2398 { | |
2399 if (qscale < 1) | |
2400 qscale = 1; | |
2401 else if (qscale > 31) | |
2402 qscale = 31; | |
2403 | |
2404 s->qscale = qscale; | |
2405 s->chroma_qscale= s->chroma_qscale_table[qscale]; | |
2406 | |
2407 s->y_dc_scale= s->y_dc_scale_table[ qscale ]; | |
2408 s->c_dc_scale= s->c_dc_scale_table[ s->chroma_qscale ]; | |
2409 } |