annotate mpegvideo.c @ 9018:98995efdf3aa libavcodec

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