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