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