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