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