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