Mercurial > libavcodec.hg
annotate dv.c @ 10320:44f31c1c9acc libavcodec
Make sure that dv encoder initializes all encoded packet data.
The specification does not say which value to use for unused
parts, so fill all unused bytes with 0xff, which is consistent
with what DV usually uses for reserved or unused parts.
author | reimar |
---|---|
date | Tue, 29 Sep 2009 19:17:18 +0000 |
parents | 38cfe222e1a4 |
children | 7f609ddb85bf |
rev | line source |
---|---|
723 | 1 /* |
2 * DV decoder | |
8629
04423b2f6e0b
cosmetics: Remove pointless period after copyright statement non-sentences.
diego
parents:
8596
diff
changeset
|
3 * Copyright (c) 2002 Fabrice Bellard |
04423b2f6e0b
cosmetics: Remove pointless period after copyright statement non-sentences.
diego
parents:
8596
diff
changeset
|
4 * Copyright (c) 2004 Roman Shaposhnik |
723 | 5 * |
2967 | 6 * DV encoder |
8629
04423b2f6e0b
cosmetics: Remove pointless period after copyright statement non-sentences.
diego
parents:
8596
diff
changeset
|
7 * Copyright (c) 2003 Roman Shaposhnik |
1493
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
8 * |
3167 | 9 * 50 Mbps (DVCPRO50) support |
10 * Copyright (c) 2006 Daniel Maas <dmaas@maasdigital.com> | |
11 * | |
7715
e8f71784062e
Intial implementation of the DV100 (AKA DVCPRO HD) decoder and demuxer as
romansh
parents:
7708
diff
changeset
|
12 * 100 Mbps (DVCPRO HD) support |
e8f71784062e
Intial implementation of the DV100 (AKA DVCPRO HD) decoder and demuxer as
romansh
parents:
7708
diff
changeset
|
13 * Initial code by Daniel Maas <dmaas@maasdigital.com> (funded by BBC R&D) |
e8f71784062e
Intial implementation of the DV100 (AKA DVCPRO HD) decoder and demuxer as
romansh
parents:
7708
diff
changeset
|
14 * Final code by Roman Shaposhnik |
e8f71784062e
Intial implementation of the DV100 (AKA DVCPRO HD) decoder and demuxer as
romansh
parents:
7708
diff
changeset
|
15 * |
1493
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
16 * Many thanks to Dan Dennedy <dan@dennedy.org> for providing wealth |
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
17 * of DV technical info. |
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
18 * |
3947
c8c591fe26f8
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
3806
diff
changeset
|
19 * This file is part of FFmpeg. |
c8c591fe26f8
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
3806
diff
changeset
|
20 * |
c8c591fe26f8
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
3806
diff
changeset
|
21 * FFmpeg is free software; you can redistribute it and/or |
723 | 22 * modify it under the terms of the GNU Lesser General Public |
23 * 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:
3806
diff
changeset
|
24 * version 2.1 of the License, or (at your option) any later version. |
723 | 25 * |
3947
c8c591fe26f8
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
3806
diff
changeset
|
26 * FFmpeg is distributed in the hope that it will be useful, |
723 | 27 * but WITHOUT ANY WARRANTY; without even the implied warranty of |
28 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |
29 * Lesser General Public License for more details. | |
30 * | |
31 * 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:
3806
diff
changeset
|
32 * License along with FFmpeg; if not, write to the Free Software |
3036
0b546eab515d
Update licensing information: The FSF changed postal address.
diego
parents:
3016
diff
changeset
|
33 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA |
723 | 34 */ |
1106 | 35 |
36 /** | |
8718
e9d9d946f213
Use full internal pathname in doxygen @file directives.
diego
parents:
8716
diff
changeset
|
37 * @file libavcodec/dv.c |
1493
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
38 * DV codec. |
1106 | 39 */ |
3649 | 40 #define ALT_BITSTREAM_READER |
723 | 41 #include "avcodec.h" |
42 #include "dsputil.h" | |
9428 | 43 #include "get_bits.h" |
9411
4cb7c65fc775
Split bitstream.h, put the bitstream writer stuff in the new file
stefano
parents:
9355
diff
changeset
|
44 #include "put_bits.h" |
723 | 45 #include "simple_idct.h" |
1489
337d13aee605
* DV handling was streamlined for both muxing/demuxing and
romansh
parents:
1416
diff
changeset
|
46 #include "dvdata.h" |
723 | 47 |
2847 | 48 //#undef NDEBUG |
49 //#include <assert.h> | |
50 | |
1887
85fe2f4633ec
* DV decoding/encoding now supports MultiThreading for up to 324 CPUs ;-)
romansh
parents:
1886
diff
changeset
|
51 typedef struct DVVideoContext { |
8051 | 52 const DVprofile *sys; |
53 AVFrame picture; | |
54 AVCodecContext *avctx; | |
55 uint8_t *buf; | |
2967 | 56 |
8051 | 57 uint8_t dv_zigzag[2][64]; |
2967 | 58 |
1489
337d13aee605
* DV handling was streamlined for both muxing/demuxing and
romansh
parents:
1416
diff
changeset
|
59 void (*get_pixels)(DCTELEM *block, const uint8_t *pixels, int line_size); |
1567 | 60 void (*fdct[2])(DCTELEM *block); |
61 void (*idct_put[2])(uint8_t *dest, int line_size, DCTELEM *block); | |
8979
5337b260a70d
transitioning dv_guess_dct_mode to dsputil cmp function
romansh
parents:
8954
diff
changeset
|
62 me_cmp_func ildct_cmp; |
3016
97e6c0f82182
Moving dv_anchor back to the global scope. This creates a tiny memory
romansh
parents:
2991
diff
changeset
|
63 } DVVideoContext; |
2991
d377b0788381
Fix DV memory leak and allow multiple instances patch by (Burkhard Plaum?)
michael
parents:
2979
diff
changeset
|
64 |
1489
337d13aee605
* DV handling was streamlined for both muxing/demuxing and
romansh
parents:
1416
diff
changeset
|
65 #define TEX_VLC_BITS 9 |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
66 |
8596
68e959302527
replace all occurrence of ENABLE_ by the corresponding CONFIG_, HAVE_ or ARCH_
aurel
parents:
8590
diff
changeset
|
67 #if CONFIG_SMALL |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
68 #define DV_VLC_MAP_RUN_SIZE 15 |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
69 #define DV_VLC_MAP_LEV_SIZE 23 |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
70 #else |
2967 | 71 #define DV_VLC_MAP_RUN_SIZE 64 |
2847 | 72 #define DV_VLC_MAP_LEV_SIZE 512 //FIXME sign was removed so this should be /2 but needs check |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
73 #endif |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
74 |
723 | 75 /* XXX: also include quantization */ |
4661 | 76 static RL_VLC_ELEM dv_rl_vlc[1184]; |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
77 /* VLC encoding lookup table */ |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
78 static struct dv_vlc_pair { |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
79 uint32_t vlc; |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
80 uint8_t size; |
4666 | 81 } dv_vlc_map[DV_VLC_MAP_RUN_SIZE][DV_VLC_MAP_LEV_SIZE]; |
723 | 82 |
8118
890df98a7848
implementing more efficient (and direct) allocation of work for DV codec workers
romansh
parents:
8088
diff
changeset
|
83 static inline int dv_work_pool_size(const DVprofile *d) |
890df98a7848
implementing more efficient (and direct) allocation of work for DV codec workers
romansh
parents:
8088
diff
changeset
|
84 { |
890df98a7848
implementing more efficient (and direct) allocation of work for DV codec workers
romansh
parents:
8088
diff
changeset
|
85 int size = d->n_difchan*d->difseg_size*27; |
890df98a7848
implementing more efficient (and direct) allocation of work for DV codec workers
romansh
parents:
8088
diff
changeset
|
86 if (DV_PROFILE_IS_1080i50(d)) |
890df98a7848
implementing more efficient (and direct) allocation of work for DV codec workers
romansh
parents:
8088
diff
changeset
|
87 size -= 3*27; |
890df98a7848
implementing more efficient (and direct) allocation of work for DV codec workers
romansh
parents:
8088
diff
changeset
|
88 if (DV_PROFILE_IS_720p50(d)) |
890df98a7848
implementing more efficient (and direct) allocation of work for DV codec workers
romansh
parents:
8088
diff
changeset
|
89 size -= 4*27; |
890df98a7848
implementing more efficient (and direct) allocation of work for DV codec workers
romansh
parents:
8088
diff
changeset
|
90 return size; |
890df98a7848
implementing more efficient (and direct) allocation of work for DV codec workers
romansh
parents:
8088
diff
changeset
|
91 } |
890df98a7848
implementing more efficient (and direct) allocation of work for DV codec workers
romansh
parents:
8088
diff
changeset
|
92 |
8164 | 93 static inline void dv_calc_mb_coordinates(const DVprofile *d, int chan, int seq, int slot, |
94 uint16_t *tbl) | |
95 { | |
8954
409d20e15da8
cosmetics: 'const static' --> 'static const' to avoid warnings of the type
diego
parents:
8738
diff
changeset
|
96 static const uint8_t off[] = { 2, 6, 8, 0, 4 }; |
409d20e15da8
cosmetics: 'const static' --> 'static const' to avoid warnings of the type
diego
parents:
8738
diff
changeset
|
97 static const uint8_t shuf1[] = { 36, 18, 54, 0, 72 }; |
409d20e15da8
cosmetics: 'const static' --> 'static const' to avoid warnings of the type
diego
parents:
8738
diff
changeset
|
98 static const uint8_t shuf2[] = { 24, 12, 36, 0, 48 }; |
409d20e15da8
cosmetics: 'const static' --> 'static const' to avoid warnings of the type
diego
parents:
8738
diff
changeset
|
99 static const uint8_t shuf3[] = { 18, 9, 27, 0, 36 }; |
8164 | 100 |
8954
409d20e15da8
cosmetics: 'const static' --> 'static const' to avoid warnings of the type
diego
parents:
8738
diff
changeset
|
101 static const uint8_t l_start[] = {0, 4, 9, 13, 18, 22, 27, 31, 36, 40}; |
409d20e15da8
cosmetics: 'const static' --> 'static const' to avoid warnings of the type
diego
parents:
8738
diff
changeset
|
102 static const uint8_t l_start_shuffled[] = { 9, 4, 13, 0, 18 }; |
8164 | 103 |
8954
409d20e15da8
cosmetics: 'const static' --> 'static const' to avoid warnings of the type
diego
parents:
8738
diff
changeset
|
104 static const uint8_t serpent1[] = {0, 1, 2, 2, 1, 0, |
8164 | 105 0, 1, 2, 2, 1, 0, |
106 0, 1, 2, 2, 1, 0, | |
107 0, 1, 2, 2, 1, 0, | |
108 0, 1, 2}; | |
8954
409d20e15da8
cosmetics: 'const static' --> 'static const' to avoid warnings of the type
diego
parents:
8738
diff
changeset
|
109 static const uint8_t serpent2[] = {0, 1, 2, 3, 4, 5, 5, 4, 3, 2, 1, 0, |
8164 | 110 0, 1, 2, 3, 4, 5, 5, 4, 3, 2, 1, 0, |
111 0, 1, 2, 3, 4, 5}; | |
112 | |
8954
409d20e15da8
cosmetics: 'const static' --> 'static const' to avoid warnings of the type
diego
parents:
8738
diff
changeset
|
113 static const uint8_t remap[][2] = {{ 0, 0}, { 0, 0}, { 0, 0}, { 0, 0}, /* dummy */ |
8164 | 114 { 0, 0}, { 0, 1}, { 0, 2}, { 0, 3}, {10, 0}, |
115 {10, 1}, {10, 2}, {10, 3}, {20, 0}, {20, 1}, | |
116 {20, 2}, {20, 3}, {30, 0}, {30, 1}, {30, 2}, | |
117 {30, 3}, {40, 0}, {40, 1}, {40, 2}, {40, 3}, | |
118 {50, 0}, {50, 1}, {50, 2}, {50, 3}, {60, 0}, | |
119 {60, 1}, {60, 2}, {60, 3}, {70, 0}, {70, 1}, | |
120 {70, 2}, {70, 3}, { 0,64}, { 0,65}, { 0,66}, | |
121 {10,64}, {10,65}, {10,66}, {20,64}, {20,65}, | |
122 {20,66}, {30,64}, {30,65}, {30,66}, {40,64}, | |
123 {40,65}, {40,66}, {50,64}, {50,65}, {50,66}, | |
124 {60,64}, {60,65}, {60,66}, {70,64}, {70,65}, | |
125 {70,66}, { 0,67}, {20,67}, {40,67}, {60,67}}; | |
126 | |
127 int i, k, m; | |
128 int x, y, blk; | |
129 | |
130 for (m=0; m<5; m++) { | |
131 switch (d->width) { | |
132 case 1440: | |
133 blk = (chan*11+seq)*27+slot; | |
134 | |
135 if (chan == 0 && seq == 11) { | |
136 x = m*27+slot; | |
137 if (x<90) { | |
138 y = 0; | |
139 } else { | |
140 x = (x - 90)*2; | |
141 y = 67; | |
142 } | |
143 } else { | |
144 i = (4*chan + blk + off[m])%11; | |
145 k = (blk/11)%27; | |
146 | |
147 x = shuf1[m] + (chan&1)*9 + k%9; | |
148 y = (i*3+k/9)*2 + (chan>>1) + 1; | |
149 } | |
150 tbl[m] = (x<<1)|(y<<9); | |
151 break; | |
152 case 1280: | |
153 blk = (chan*10+seq)*27+slot; | |
154 | |
155 i = (4*chan + (seq/5) + 2*blk + off[m])%10; | |
156 k = (blk/5)%27; | |
157 | |
158 x = shuf1[m]+(chan&1)*9 + k%9; | |
159 y = (i*3+k/9)*2 + (chan>>1) + 4; | |
160 | |
161 if (x >= 80) { | |
162 x = remap[y][0]+((x-80)<<(y>59)); | |
163 y = remap[y][1]; | |
164 } | |
165 tbl[m] = (x<<1)|(y<<9); | |
166 break; | |
167 case 960: | |
168 blk = (chan*10+seq)*27+slot; | |
169 | |
170 i = (4*chan + (seq/5) + 2*blk + off[m])%10; | |
171 k = (blk/5)%27 + (i&1)*3; | |
172 | |
173 x = shuf2[m] + k%6 + 6*(chan&1); | |
174 y = l_start[i] + k/6 + 45*(chan>>1); | |
175 tbl[m] = (x<<1)|(y<<9); | |
176 break; | |
177 case 720: | |
178 switch (d->pix_fmt) { | |
179 case PIX_FMT_YUV422P: | |
180 x = shuf3[m] + slot/3; | |
181 y = serpent1[slot] + | |
182 ((((seq + off[m]) % d->difseg_size)<<1) + chan)*3; | |
183 tbl[m] = (x<<1)|(y<<8); | |
184 break; | |
185 case PIX_FMT_YUV420P: | |
186 x = shuf3[m] + slot/3; | |
187 y = serpent1[slot] + | |
188 ((seq + off[m]) % d->difseg_size)*3; | |
189 tbl[m] = (x<<1)|(y<<9); | |
190 break; | |
191 case PIX_FMT_YUV411P: | |
192 i = (seq + off[m]) % d->difseg_size; | |
193 k = slot + ((m==1||m==2)?3:0); | |
194 | |
195 x = l_start_shuffled[m] + k/6; | |
196 y = serpent2[k] + i*6; | |
197 if (x>21) | |
198 y = y*2 - i*6; | |
199 tbl[m] = (x<<2)|(y<<8); | |
200 break; | |
201 } | |
202 default: | |
203 break; | |
204 } | |
205 } | |
206 } | |
207 | |
8118
890df98a7848
implementing more efficient (and direct) allocation of work for DV codec workers
romansh
parents:
8088
diff
changeset
|
208 static int dv_init_dynamic_tables(const DVprofile *d) |
890df98a7848
implementing more efficient (and direct) allocation of work for DV codec workers
romansh
parents:
8088
diff
changeset
|
209 { |
8164 | 210 int j,i,c,s,p; |
8175 | 211 uint32_t *factor1, *factor2; |
212 const int *iweight1, *iweight2; | |
8118
890df98a7848
implementing more efficient (and direct) allocation of work for DV codec workers
romansh
parents:
8088
diff
changeset
|
213 |
8173 | 214 if (!d->work_chunks[dv_work_pool_size(d)-1].buf_offset) { |
215 p = i = 0; | |
216 for (c=0; c<d->n_difchan; c++) { | |
217 for (s=0; s<d->difseg_size; s++) { | |
218 p += 6; | |
219 for (j=0; j<27; j++) { | |
220 p += !(j%3); | |
221 if (!(DV_PROFILE_IS_1080i50(d) && c != 0 && s == 11) && | |
222 !(DV_PROFILE_IS_720p50(d) && s > 9)) { | |
223 dv_calc_mb_coordinates(d, c, s, j, &d->work_chunks[i].mb_coordinates[0]); | |
224 d->work_chunks[i++].buf_offset = p; | |
225 } | |
226 p += 5; | |
227 } | |
8118
890df98a7848
implementing more efficient (and direct) allocation of work for DV codec workers
romansh
parents:
8088
diff
changeset
|
228 } |
890df98a7848
implementing more efficient (and direct) allocation of work for DV codec workers
romansh
parents:
8088
diff
changeset
|
229 } |
890df98a7848
implementing more efficient (and direct) allocation of work for DV codec workers
romansh
parents:
8088
diff
changeset
|
230 } |
890df98a7848
implementing more efficient (and direct) allocation of work for DV codec workers
romansh
parents:
8088
diff
changeset
|
231 |
8175 | 232 if (!d->idct_factor[DV_PROFILE_IS_HD(d)?8191:5631]) { |
233 factor1 = &d->idct_factor[0]; | |
234 factor2 = &d->idct_factor[DV_PROFILE_IS_HD(d)?4096:2816]; | |
235 if (d->height == 720) { | |
236 iweight1 = &dv_iweight_720_y[0]; | |
237 iweight2 = &dv_iweight_720_c[0]; | |
238 } else { | |
239 iweight1 = &dv_iweight_1080_y[0]; | |
240 iweight2 = &dv_iweight_1080_c[0]; | |
241 } | |
242 if (DV_PROFILE_IS_HD(d)) { | |
243 for (c = 0; c < 4; c++) { | |
244 for (s = 0; s < 16; s++) { | |
245 for (i = 0; i < 64; i++) { | |
246 *factor1++ = (dv100_qstep[s] << (c + 9)) * iweight1[i]; | |
247 *factor2++ = (dv100_qstep[s] << (c + 9)) * iweight2[i]; | |
248 } | |
249 } | |
250 } | |
251 } else { | |
252 iweight1 = &dv_iweight_88[0]; | |
253 for (j = 0; j < 2; j++, iweight1 = &dv_iweight_248[0]) { | |
254 for (s = 0; s < 22; s++) { | |
255 for (i = c = 0; c < 4; c++) { | |
256 for (; i < dv_quant_areas[c]; i++) { | |
257 *factor1 = iweight1[i] << (dv_quant_shifts[s][c] + 1); | |
258 *factor2++ = (*factor1++) << 1; | |
259 } | |
260 } | |
7536
910087e97750
Coalescing the un-weighting and de-quantization steps for faster
romansh
parents:
7240
diff
changeset
|
261 } |
723 | 262 } |
263 } | |
8175 | 264 } |
7715
e8f71784062e
Intial implementation of the DV100 (AKA DVCPRO HD) decoder and demuxer as
romansh
parents:
7708
diff
changeset
|
265 |
8175 | 266 return 0; |
723 | 267 } |
268 | |
6517
48759bfbd073
Apply 'cold' attribute to init/uninit functions in libavcodec
zuxy
parents:
6450
diff
changeset
|
269 static av_cold int dvvideo_init(AVCodecContext *avctx) |
723 | 270 { |
1887
85fe2f4633ec
* DV decoding/encoding now supports MultiThreading for up to 324 CPUs ;-)
romansh
parents:
1886
diff
changeset
|
271 DVVideoContext *s = avctx->priv_data; |
1567 | 272 DSPContext dsp; |
8051 | 273 static int done = 0; |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
274 int i, j; |
723 | 275 |
276 if (!done) { | |
1489
337d13aee605
* DV handling was streamlined for both muxing/demuxing and
romansh
parents:
1416
diff
changeset
|
277 VLC dv_vlc; |
1905
2761950695cc
* some significant clean-up of the dv_decode_ac (it looks real
romansh
parents:
1904
diff
changeset
|
278 uint16_t new_dv_vlc_bits[NB_DV_VLC*2]; |
8051 | 279 uint8_t new_dv_vlc_len[NB_DV_VLC*2]; |
280 uint8_t new_dv_vlc_run[NB_DV_VLC*2]; | |
281 int16_t new_dv_vlc_level[NB_DV_VLC*2]; | |
723 | 282 |
283 done = 1; | |
284 | |
2979 | 285 /* it's faster to include sign bit in a generic VLC parsing scheme */ |
8051 | 286 for (i = 0, j = 0; i < NB_DV_VLC; i++, j++) { |
287 new_dv_vlc_bits[j] = dv_vlc_bits[i]; | |
288 new_dv_vlc_len[j] = dv_vlc_len[i]; | |
289 new_dv_vlc_run[j] = dv_vlc_run[i]; | |
2979 | 290 new_dv_vlc_level[j] = dv_vlc_level[i]; |
2967 | 291 |
2979 | 292 if (dv_vlc_level[i]) { |
293 new_dv_vlc_bits[j] <<= 1; | |
294 new_dv_vlc_len[j]++; | |
1905
2761950695cc
* some significant clean-up of the dv_decode_ac (it looks real
romansh
parents:
1904
diff
changeset
|
295 |
2979 | 296 j++; |
8051 | 297 new_dv_vlc_bits[j] = (dv_vlc_bits[i] << 1) | 1; |
298 new_dv_vlc_len[j] = dv_vlc_len[i] + 1; | |
299 new_dv_vlc_run[j] = dv_vlc_run[i]; | |
2979 | 300 new_dv_vlc_level[j] = -dv_vlc_level[i]; |
301 } | |
302 } | |
2967 | 303 |
723 | 304 /* NOTE: as a trick, we use the fact the no codes are unused |
305 to accelerate the parsing of partial codes */ | |
2967 | 306 init_vlc(&dv_vlc, TEX_VLC_BITS, j, |
2370
26560d4fdb1f
Memory leak fix patch by (Burkhard Plaum <plaum >at< ipf.uni-stuttgart )dot( de>)
michael
parents:
2247
diff
changeset
|
307 new_dv_vlc_len, 1, 1, new_dv_vlc_bits, 2, 2, 0); |
4661 | 308 assert(dv_vlc.table_size == 1184); |
3016
97e6c0f82182
Moving dv_anchor back to the global scope. This creates a tiny memory
romansh
parents:
2991
diff
changeset
|
309 |
8051 | 310 for (i = 0; i < dv_vlc.table_size; i++){ |
311 int code = dv_vlc.table[i][0]; | |
312 int len = dv_vlc.table[i][1]; | |
723 | 313 int level, run; |
2967 | 314 |
8051 | 315 if (len < 0){ //more bits needed |
316 run = 0; | |
317 level = code; | |
723 | 318 } else { |
8051 | 319 run = new_dv_vlc_run [code] + 1; |
320 level = new_dv_vlc_level[code]; | |
723 | 321 } |
8051 | 322 dv_rl_vlc[i].len = len; |
1886
fbcf02596520
* DV decoder simplifications. Now it looks to be 6% faster. At least
romansh
parents:
1875
diff
changeset
|
323 dv_rl_vlc[i].level = level; |
8051 | 324 dv_rl_vlc[i].run = run; |
723 | 325 } |
2979 | 326 free_vlc(&dv_vlc); |
1489
337d13aee605
* DV handling was streamlined for both muxing/demuxing and
romansh
parents:
1416
diff
changeset
|
327 |
2979 | 328 for (i = 0; i < NB_DV_VLC - 1; i++) { |
2027
3a78447c3b53
oops, forgot to commit that change from the warning fixes by (Michael Roitzsch <mroi at users dot sourceforge dot net>)
michael
parents:
1994
diff
changeset
|
329 if (dv_vlc_run[i] >= DV_VLC_MAP_RUN_SIZE) |
2979 | 330 continue; |
8596
68e959302527
replace all occurrence of ENABLE_ by the corresponding CONFIG_, HAVE_ or ARCH_
aurel
parents:
8590
diff
changeset
|
331 #if CONFIG_SMALL |
2027
3a78447c3b53
oops, forgot to commit that change from the warning fixes by (Michael Roitzsch <mroi at users dot sourceforge dot net>)
michael
parents:
1994
diff
changeset
|
332 if (dv_vlc_level[i] >= DV_VLC_MAP_LEV_SIZE) |
2979 | 333 continue; |
2027
3a78447c3b53
oops, forgot to commit that change from the warning fixes by (Michael Roitzsch <mroi at users dot sourceforge dot net>)
michael
parents:
1994
diff
changeset
|
334 #endif |
2967 | 335 |
2979 | 336 if (dv_vlc_map[dv_vlc_run[i]][dv_vlc_level[i]].size != 0) |
337 continue; | |
2967 | 338 |
8051 | 339 dv_vlc_map[dv_vlc_run[i]][dv_vlc_level[i]].vlc = |
340 dv_vlc_bits[i] << (!!dv_vlc_level[i]); | |
341 dv_vlc_map[dv_vlc_run[i]][dv_vlc_level[i]].size = | |
342 dv_vlc_len[i] + (!!dv_vlc_level[i]); | |
2979 | 343 } |
344 for (i = 0; i < DV_VLC_MAP_RUN_SIZE; i++) { | |
8596
68e959302527
replace all occurrence of ENABLE_ by the corresponding CONFIG_, HAVE_ or ARCH_
aurel
parents:
8590
diff
changeset
|
345 #if CONFIG_SMALL |
2979 | 346 for (j = 1; j < DV_VLC_MAP_LEV_SIZE; j++) { |
347 if (dv_vlc_map[i][j].size == 0) { | |
348 dv_vlc_map[i][j].vlc = dv_vlc_map[0][j].vlc | | |
349 (dv_vlc_map[i-1][0].vlc << (dv_vlc_map[0][j].size)); | |
350 dv_vlc_map[i][j].size = dv_vlc_map[i-1][0].size + | |
351 dv_vlc_map[0][j].size; | |
352 } | |
353 } | |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
354 #else |
2979 | 355 for (j = 1; j < DV_VLC_MAP_LEV_SIZE/2; j++) { |
356 if (dv_vlc_map[i][j].size == 0) { | |
357 dv_vlc_map[i][j].vlc = dv_vlc_map[0][j].vlc | | |
358 (dv_vlc_map[i-1][0].vlc << (dv_vlc_map[0][j].size)); | |
359 dv_vlc_map[i][j].size = dv_vlc_map[i-1][0].size + | |
360 dv_vlc_map[0][j].size; | |
361 } | |
362 dv_vlc_map[i][((uint16_t)(-j))&0x1ff].vlc = | |
363 dv_vlc_map[i][j].vlc | 1; | |
364 dv_vlc_map[i][((uint16_t)(-j))&0x1ff].size = | |
365 dv_vlc_map[i][j].size; | |
366 } | |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
367 #endif |
2979 | 368 } |
723 | 369 } |
725 | 370 |
1567 | 371 /* Generic DSP setup */ |
372 dsputil_init(&dsp, avctx); | |
8979
5337b260a70d
transitioning dv_guess_dct_mode to dsputil cmp function
romansh
parents:
8954
diff
changeset
|
373 ff_set_cmp(&dsp, dsp.ildct_cmp, avctx->ildct_cmp); |
1567 | 374 s->get_pixels = dsp.get_pixels; |
8979
5337b260a70d
transitioning dv_guess_dct_mode to dsputil cmp function
romansh
parents:
8954
diff
changeset
|
375 s->ildct_cmp = dsp.ildct_cmp[5]; |
725 | 376 |
1567 | 377 /* 88DCT setup */ |
8051 | 378 s->fdct[0] = dsp.fdct; |
1567 | 379 s->idct_put[0] = dsp.idct_put; |
8051 | 380 for (i = 0; i < 64; i++) |
1567 | 381 s->dv_zigzag[0][i] = dsp.idct_permutation[ff_zigzag_direct[i]]; |
725 | 382 |
1567 | 383 /* 248DCT setup */ |
8051 | 384 s->fdct[1] = dsp.fdct248; |
6001 | 385 s->idct_put[1] = ff_simple_idct248_put; // FIXME: need to add it to DSP |
8051 | 386 if (avctx->lowres){ |
387 for (i = 0; i < 64; i++){ | |
388 int j = ff_zigzag248_direct[i]; | |
389 s->dv_zigzag[1][i] = dsp.idct_permutation[(j & 7) + (j & 8) * 4 + (j & 48) / 2]; | |
2849 | 390 } |
391 }else | |
392 memcpy(s->dv_zigzag[1], ff_zigzag248_direct, 64); | |
725 | 393 |
1543
7542cb99b950
* providing MPEG codecs with a generic fields in AVFrame to use.
romansh
parents:
1540
diff
changeset
|
394 avctx->coded_frame = &s->picture; |
8051 | 395 s->avctx = avctx; |
9626
bd3e11b60ccd
Add a chroma_sample_location field to define positioning of chroma samples
conrad
parents:
9428
diff
changeset
|
396 avctx->chroma_sample_location = AVCHROMA_LOC_TOPLEFT; |
2967 | 397 |
723 | 398 return 0; |
399 } | |
400 | |
1489
337d13aee605
* DV handling was streamlined for both muxing/demuxing and
romansh
parents:
1416
diff
changeset
|
401 // #define VLC_DEBUG |
1905
2761950695cc
* some significant clean-up of the dv_decode_ac (it looks real
romansh
parents:
1904
diff
changeset
|
402 // #define printf(...) av_log(NULL, AV_LOG_ERROR, __VA_ARGS__) |
723 | 403 |
725 | 404 typedef struct BlockInfo { |
7536
910087e97750
Coalescing the un-weighting and de-quantization steps for faster
romansh
parents:
7240
diff
changeset
|
405 const uint32_t *factor_table; |
1064 | 406 const uint8_t *scan_table; |
407 uint8_t pos; /* position in block */ | |
7706 | 408 void (*idct_put)(uint8_t *dest, int line_size, DCTELEM *block); |
1064 | 409 uint8_t partial_bit_count; |
410 uint16_t partial_bit_buffer; | |
725 | 411 int shift_offset; |
412 } BlockInfo; | |
723 | 413 |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
414 /* bit budget for AC only in 5 MBs */ |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
415 static const int vs_total_ac_bits = (100 * 4 + 68*2) * 5; |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
416 /* see dv_88_areas and dv_248_areas for details */ |
2967 | 417 static const int mb_area_start[5] = { 1, 6, 21, 43, 64 }; |
723 | 418 |
1895
e5687117cc7f
* removing casualties of battle of the wits and English language
romansh
parents:
1887
diff
changeset
|
419 static inline int get_bits_left(GetBitContext *s) |
e5687117cc7f
* removing casualties of battle of the wits and English language
romansh
parents:
1887
diff
changeset
|
420 { |
e5687117cc7f
* removing casualties of battle of the wits and English language
romansh
parents:
1887
diff
changeset
|
421 return s->size_in_bits - get_bits_count(s); |
e5687117cc7f
* removing casualties of battle of the wits and English language
romansh
parents:
1887
diff
changeset
|
422 } |
e5687117cc7f
* removing casualties of battle of the wits and English language
romansh
parents:
1887
diff
changeset
|
423 |
e5687117cc7f
* removing casualties of battle of the wits and English language
romansh
parents:
1887
diff
changeset
|
424 static inline int put_bits_left(PutBitContext* s) |
e5687117cc7f
* removing casualties of battle of the wits and English language
romansh
parents:
1887
diff
changeset
|
425 { |
e5687117cc7f
* removing casualties of battle of the wits and English language
romansh
parents:
1887
diff
changeset
|
426 return (s->buf_end - s->buf) * 8 - put_bits_count(s); |
e5687117cc7f
* removing casualties of battle of the wits and English language
romansh
parents:
1887
diff
changeset
|
427 } |
e5687117cc7f
* removing casualties of battle of the wits and English language
romansh
parents:
1887
diff
changeset
|
428 |
7980 | 429 /* decode ac coefficients */ |
1887
85fe2f4633ec
* DV decoding/encoding now supports MultiThreading for up to 324 CPUs ;-)
romansh
parents:
1886
diff
changeset
|
430 static void dv_decode_ac(GetBitContext *gb, BlockInfo *mb, DCTELEM *block) |
723 | 431 { |
7039 | 432 int last_index = gb->size_in_bits; |
8051 | 433 const uint8_t *scan_table = mb->scan_table; |
7536
910087e97750
Coalescing the un-weighting and de-quantization steps for faster
romansh
parents:
7240
diff
changeset
|
434 const uint32_t *factor_table = mb->factor_table; |
8051 | 435 int pos = mb->pos; |
1905
2761950695cc
* some significant clean-up of the dv_decode_ac (it looks real
romansh
parents:
1904
diff
changeset
|
436 int partial_bit_count = mb->partial_bit_count; |
7536
910087e97750
Coalescing the un-weighting and de-quantization steps for faster
romansh
parents:
7240
diff
changeset
|
437 int level, run, vlc_len, index; |
2967 | 438 |
1887
85fe2f4633ec
* DV decoding/encoding now supports MultiThreading for up to 324 CPUs ;-)
romansh
parents:
1886
diff
changeset
|
439 OPEN_READER(re, gb); |
1905
2761950695cc
* some significant clean-up of the dv_decode_ac (it looks real
romansh
parents:
1904
diff
changeset
|
440 UPDATE_CACHE(re, gb); |
2967 | 441 |
723 | 442 /* if we must parse a partial vlc, we do it here */ |
443 if (partial_bit_count > 0) { | |
1905
2761950695cc
* some significant clean-up of the dv_decode_ac (it looks real
romansh
parents:
1904
diff
changeset
|
444 re_cache = ((unsigned)re_cache >> partial_bit_count) | |
8051 | 445 (mb->partial_bit_buffer << (sizeof(re_cache) * 8 - partial_bit_count)); |
2979 | 446 re_index -= partial_bit_count; |
447 mb->partial_bit_count = 0; | |
723 | 448 } |
449 | |
450 /* get the AC coefficients until last_index is reached */ | |
8051 | 451 for (;;) { |
723 | 452 #ifdef VLC_DEBUG |
1905
2761950695cc
* some significant clean-up of the dv_decode_ac (it looks real
romansh
parents:
1904
diff
changeset
|
453 printf("%2d: bits=%04x index=%d\n", pos, SHOW_UBITS(re, gb, 16), re_index); |
723 | 454 #endif |
1905
2761950695cc
* some significant clean-up of the dv_decode_ac (it looks real
romansh
parents:
1904
diff
changeset
|
455 /* our own optimized GET_RL_VLC */ |
8051 | 456 index = NEG_USR32(re_cache, TEX_VLC_BITS); |
2979 | 457 vlc_len = dv_rl_vlc[index].len; |
1905
2761950695cc
* some significant clean-up of the dv_decode_ac (it looks real
romansh
parents:
1904
diff
changeset
|
458 if (vlc_len < 0) { |
2761950695cc
* some significant clean-up of the dv_decode_ac (it looks real
romansh
parents:
1904
diff
changeset
|
459 index = NEG_USR32((unsigned)re_cache << TEX_VLC_BITS, -vlc_len) + dv_rl_vlc[index].level; |
2761950695cc
* some significant clean-up of the dv_decode_ac (it looks real
romansh
parents:
1904
diff
changeset
|
460 vlc_len = TEX_VLC_BITS - vlc_len; |
2761950695cc
* some significant clean-up of the dv_decode_ac (it looks real
romansh
parents:
1904
diff
changeset
|
461 } |
2761950695cc
* some significant clean-up of the dv_decode_ac (it looks real
romansh
parents:
1904
diff
changeset
|
462 level = dv_rl_vlc[index].level; |
8051 | 463 run = dv_rl_vlc[index].run; |
2967 | 464 |
2979 | 465 /* gotta check if we're still within gb boundaries */ |
466 if (re_index + vlc_len > last_index) { | |
467 /* should be < 16 bits otherwise a codeword could have been parsed */ | |
468 mb->partial_bit_count = last_index - re_index; | |
469 mb->partial_bit_buffer = NEG_USR32(re_cache, mb->partial_bit_count); | |
470 re_index = last_index; | |
471 break; | |
472 } | |
473 re_index += vlc_len; | |
1905
2761950695cc
* some significant clean-up of the dv_decode_ac (it looks real
romansh
parents:
1904
diff
changeset
|
474 |
2761950695cc
* some significant clean-up of the dv_decode_ac (it looks real
romansh
parents:
1904
diff
changeset
|
475 #ifdef VLC_DEBUG |
2979 | 476 printf("run=%d level=%d\n", run, level); |
1905
2761950695cc
* some significant clean-up of the dv_decode_ac (it looks real
romansh
parents:
1904
diff
changeset
|
477 #endif |
2979 | 478 pos += run; |
479 if (pos >= 64) | |
480 break; | |
2967 | 481 |
8051 | 482 level = (level * factor_table[pos] + (1 << (dv_iweight_bits - 1))) >> dv_iweight_bits; |
7536
910087e97750
Coalescing the un-weighting and de-quantization steps for faster
romansh
parents:
7240
diff
changeset
|
483 block[scan_table[pos]] = level; |
1905
2761950695cc
* some significant clean-up of the dv_decode_ac (it looks real
romansh
parents:
1904
diff
changeset
|
484 |
2761950695cc
* some significant clean-up of the dv_decode_ac (it looks real
romansh
parents:
1904
diff
changeset
|
485 UPDATE_CACHE(re, gb); |
723 | 486 } |
1887
85fe2f4633ec
* DV decoding/encoding now supports MultiThreading for up to 324 CPUs ;-)
romansh
parents:
1886
diff
changeset
|
487 CLOSE_READER(re, gb); |
725 | 488 mb->pos = pos; |
723 | 489 } |
490 | |
1886
fbcf02596520
* DV decoder simplifications. Now it looks to be 6% faster. At least
romansh
parents:
1875
diff
changeset
|
491 static inline void bit_copy(PutBitContext *pb, GetBitContext *gb) |
723 | 492 { |
1886
fbcf02596520
* DV decoder simplifications. Now it looks to be 6% faster. At least
romansh
parents:
1875
diff
changeset
|
493 int bits_left = get_bits_left(gb); |
2847 | 494 while (bits_left >= MIN_CACHE_BITS) { |
495 put_bits(pb, MIN_CACHE_BITS, get_bits(gb, MIN_CACHE_BITS)); | |
496 bits_left -= MIN_CACHE_BITS; | |
723 | 497 } |
498 if (bits_left > 0) { | |
499 put_bits(pb, bits_left, get_bits(gb, bits_left)); | |
500 } | |
501 } | |
502 | |
8131 | 503 static inline void dv_calculate_mb_xy(DVVideoContext *s, DVwork_chunk *work_chunk, int m, int *mb_x, int *mb_y) |
8118
890df98a7848
implementing more efficient (and direct) allocation of work for DV codec workers
romansh
parents:
8088
diff
changeset
|
504 { |
8131 | 505 *mb_x = work_chunk->mb_coordinates[m] & 0xff; |
506 *mb_y = work_chunk->mb_coordinates[m] >> 8; | |
8118
890df98a7848
implementing more efficient (and direct) allocation of work for DV codec workers
romansh
parents:
8088
diff
changeset
|
507 |
890df98a7848
implementing more efficient (and direct) allocation of work for DV codec workers
romansh
parents:
8088
diff
changeset
|
508 /* We work with 720p frames split in half. The odd half-frame (chan==2,3) is displaced :-( */ |
890df98a7848
implementing more efficient (and direct) allocation of work for DV codec workers
romansh
parents:
8088
diff
changeset
|
509 if (s->sys->height == 720 && !(s->buf[1]&0x0C)) { |
890df98a7848
implementing more efficient (and direct) allocation of work for DV codec workers
romansh
parents:
8088
diff
changeset
|
510 *mb_y -= (*mb_y>17)?18:-72; /* shifting the Y coordinate down by 72/2 macro blocks */ |
890df98a7848
implementing more efficient (and direct) allocation of work for DV codec workers
romansh
parents:
8088
diff
changeset
|
511 } |
890df98a7848
implementing more efficient (and direct) allocation of work for DV codec workers
romansh
parents:
8088
diff
changeset
|
512 } |
890df98a7848
implementing more efficient (and direct) allocation of work for DV codec workers
romansh
parents:
8088
diff
changeset
|
513 |
723 | 514 /* mb_x and mb_y are in units of 8 pixels */ |
8716 | 515 static int dv_decode_video_segment(AVCodecContext *avctx, void *arg) |
723 | 516 { |
8163 | 517 DVVideoContext *s = avctx->priv_data; |
8716 | 518 DVwork_chunk *work_chunk = arg; |
723 | 519 int quant, dc, dct_mode, class1, j; |
8118
890df98a7848
implementing more efficient (and direct) allocation of work for DV codec workers
romansh
parents:
8088
diff
changeset
|
520 int mb_index, mb_x, mb_y, last_index; |
8011 | 521 int y_stride, linesize; |
723 | 522 DCTELEM *block, *block1; |
1886
fbcf02596520
* DV decoder simplifications. Now it looks to be 6% faster. At least
romansh
parents:
1875
diff
changeset
|
523 int c_offset; |
1064 | 524 uint8_t *y_ptr; |
6266 | 525 const uint8_t *buf_ptr; |
723 | 526 PutBitContext pb, vs_pb; |
1887
85fe2f4633ec
* DV decoding/encoding now supports MultiThreading for up to 324 CPUs ;-)
romansh
parents:
1886
diff
changeset
|
527 GetBitContext gb; |
7614
1afa1171b7b2
Introducing DV_MAX_BPM macro instead of a hardcoded value for the
romansh
parents:
7538
diff
changeset
|
528 BlockInfo mb_data[5 * DV_MAX_BPM], *mb, *mb1; |
1afa1171b7b2
Introducing DV_MAX_BPM macro instead of a hardcoded value for the
romansh
parents:
7538
diff
changeset
|
529 DECLARE_ALIGNED_16(DCTELEM, sblock[5*DV_MAX_BPM][64]); |
10093 | 530 uint8_t mb_bit_buffer[80 + 4]; /* allow some slack */ |
531 uint8_t vs_bit_buffer[5 * 80 + 4]; /* allow some slack */ | |
8051 | 532 const int log2_blocksize = 3-s->avctx->lowres; |
7715
e8f71784062e
Intial implementation of the DV100 (AKA DVCPRO HD) decoder and demuxer as
romansh
parents:
7708
diff
changeset
|
533 int is_field_mode[5]; |
2967 | 534 |
8051 | 535 assert((((int)mb_bit_buffer) & 7) == 0); |
536 assert((((int)vs_bit_buffer) & 7) == 0); | |
2967 | 537 |
1887
85fe2f4633ec
* DV decoding/encoding now supports MultiThreading for up to 324 CPUs ;-)
romansh
parents:
1886
diff
changeset
|
538 memset(sblock, 0, sizeof(sblock)); |
723 | 539 |
540 /* pass 1 : read DC and AC coefficients in blocks */ | |
8131 | 541 buf_ptr = &s->buf[work_chunk->buf_offset*80]; |
8051 | 542 block1 = &sblock[0][0]; |
543 mb1 = mb_data; | |
1522
79dddc5cd990
removed the obsolete and unused parameters of init_put_bits
alex
parents:
1507
diff
changeset
|
544 init_put_bits(&vs_pb, vs_bit_buffer, 5 * 80); |
8051 | 545 for (mb_index = 0; mb_index < 5; mb_index++, mb1 += s->sys->bpm, block1 += s->sys->bpm * 64) { |
723 | 546 /* skip header */ |
547 quant = buf_ptr[3] & 0x0f; | |
548 buf_ptr += 4; | |
1522
79dddc5cd990
removed the obsolete and unused parameters of init_put_bits
alex
parents:
1507
diff
changeset
|
549 init_put_bits(&pb, mb_bit_buffer, 80); |
8051 | 550 mb = mb1; |
723 | 551 block = block1; |
7715
e8f71784062e
Intial implementation of the DV100 (AKA DVCPRO HD) decoder and demuxer as
romansh
parents:
7708
diff
changeset
|
552 is_field_mode[mb_index] = 0; |
8051 | 553 for (j = 0; j < s->sys->bpm; j++) { |
7616
685ef77c9fe5
Making block size in bits variable and dependent on the DV spec
romansh
parents:
7615
diff
changeset
|
554 last_index = s->sys->block_sizes[j]; |
2979 | 555 init_get_bits(&gb, buf_ptr, last_index); |
2967 | 556 |
723 | 557 /* get the dc */ |
8051 | 558 dc = get_sbits(&gb, 9); |
1887
85fe2f4633ec
* DV decoding/encoding now supports MultiThreading for up to 324 CPUs ;-)
romansh
parents:
1886
diff
changeset
|
559 dct_mode = get_bits1(&gb); |
8051 | 560 class1 = get_bits(&gb, 2); |
7715
e8f71784062e
Intial implementation of the DV100 (AKA DVCPRO HD) decoder and demuxer as
romansh
parents:
7708
diff
changeset
|
561 if (DV_PROFILE_IS_HD(s->sys)) { |
8051 | 562 mb->idct_put = s->idct_put[0]; |
563 mb->scan_table = s->dv_zigzag[0]; | |
8175 | 564 mb->factor_table = &s->sys->idct_factor[(j >= 4)*4*16*64 + class1*16*64 + quant*64]; |
7715
e8f71784062e
Intial implementation of the DV100 (AKA DVCPRO HD) decoder and demuxer as
romansh
parents:
7708
diff
changeset
|
565 is_field_mode[mb_index] |= !j && dct_mode; |
e8f71784062e
Intial implementation of the DV100 (AKA DVCPRO HD) decoder and demuxer as
romansh
parents:
7708
diff
changeset
|
566 } else { |
8051 | 567 mb->idct_put = s->idct_put[dct_mode && log2_blocksize == 3]; |
568 mb->scan_table = s->dv_zigzag[dct_mode]; | |
8175 | 569 mb->factor_table = &s->sys->idct_factor[(class1 == 3)*2*22*64 + dct_mode*22*64 + |
570 (quant + dv_quant_offset[class1])*64]; | |
7715
e8f71784062e
Intial implementation of the DV100 (AKA DVCPRO HD) decoder and demuxer as
romansh
parents:
7708
diff
changeset
|
571 } |
723 | 572 dc = dc << 2; |
573 /* convert to unsigned because 128 is not added in the | |
574 standard IDCT */ | |
575 dc += 1024; | |
576 block[0] = dc; | |
577 buf_ptr += last_index >> 3; | |
8051 | 578 mb->pos = 0; |
725 | 579 mb->partial_bit_count = 0; |
723 | 580 |
1493
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
581 #ifdef VLC_DEBUG |
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
582 printf("MB block: %d, %d ", mb_index, j); |
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
583 #endif |
1887
85fe2f4633ec
* DV decoding/encoding now supports MultiThreading for up to 324 CPUs ;-)
romansh
parents:
1886
diff
changeset
|
584 dv_decode_ac(&gb, mb, block); |
723 | 585 |
586 /* write the remaining bits in a new buffer only if the | |
587 block is finished */ | |
1886
fbcf02596520
* DV decoder simplifications. Now it looks to be 6% faster. At least
romansh
parents:
1875
diff
changeset
|
588 if (mb->pos >= 64) |
1887
85fe2f4633ec
* DV decoding/encoding now supports MultiThreading for up to 324 CPUs ;-)
romansh
parents:
1886
diff
changeset
|
589 bit_copy(&pb, &gb); |
2967 | 590 |
723 | 591 block += 64; |
725 | 592 mb++; |
723 | 593 } |
2967 | 594 |
723 | 595 /* pass 2 : we can do it just after */ |
596 #ifdef VLC_DEBUG | |
1886
fbcf02596520
* DV decoder simplifications. Now it looks to be 6% faster. At least
romansh
parents:
1875
diff
changeset
|
597 printf("***pass 2 size=%d MB#=%d\n", put_bits_count(&pb), mb_index); |
723 | 598 #endif |
599 block = block1; | |
8051 | 600 mb = mb1; |
1887
85fe2f4633ec
* DV decoding/encoding now supports MultiThreading for up to 324 CPUs ;-)
romansh
parents:
1886
diff
changeset
|
601 init_get_bits(&gb, mb_bit_buffer, put_bits_count(&pb)); |
2979 | 602 flush_put_bits(&pb); |
8051 | 603 for (j = 0; j < s->sys->bpm; j++, block += 64, mb++) { |
1887
85fe2f4633ec
* DV decoding/encoding now supports MultiThreading for up to 324 CPUs ;-)
romansh
parents:
1886
diff
changeset
|
604 if (mb->pos < 64 && get_bits_left(&gb) > 0) { |
85fe2f4633ec
* DV decoding/encoding now supports MultiThreading for up to 324 CPUs ;-)
romansh
parents:
1886
diff
changeset
|
605 dv_decode_ac(&gb, mb, block); |
723 | 606 /* if still not finished, no need to parse other blocks */ |
1886
fbcf02596520
* DV decoder simplifications. Now it looks to be 6% faster. At least
romansh
parents:
1875
diff
changeset
|
607 if (mb->pos < 64) |
fbcf02596520
* DV decoder simplifications. Now it looks to be 6% faster. At least
romansh
parents:
1875
diff
changeset
|
608 break; |
723 | 609 } |
610 } | |
611 /* all blocks are finished, so the extra bytes can be used at | |
612 the video segment level */ | |
7615
290fd3ae1219
Making the number of blocks per macroblock dependent on the DV stream
romansh
parents:
7614
diff
changeset
|
613 if (j >= s->sys->bpm) |
2979 | 614 bit_copy(&vs_pb, &gb); |
723 | 615 } |
616 | |
617 /* we need a pass other the whole video segment */ | |
618 #ifdef VLC_DEBUG | |
1886
fbcf02596520
* DV decoder simplifications. Now it looks to be 6% faster. At least
romansh
parents:
1875
diff
changeset
|
619 printf("***pass 3 size=%d\n", put_bits_count(&vs_pb)); |
723 | 620 #endif |
1887
85fe2f4633ec
* DV decoding/encoding now supports MultiThreading for up to 324 CPUs ;-)
romansh
parents:
1886
diff
changeset
|
621 block = &sblock[0][0]; |
8051 | 622 mb = mb_data; |
1887
85fe2f4633ec
* DV decoding/encoding now supports MultiThreading for up to 324 CPUs ;-)
romansh
parents:
1886
diff
changeset
|
623 init_get_bits(&gb, vs_bit_buffer, put_bits_count(&vs_pb)); |
1886
fbcf02596520
* DV decoder simplifications. Now it looks to be 6% faster. At least
romansh
parents:
1875
diff
changeset
|
624 flush_put_bits(&vs_pb); |
8051 | 625 for (mb_index = 0; mb_index < 5; mb_index++) { |
626 for (j = 0; j < s->sys->bpm; j++) { | |
1886
fbcf02596520
* DV decoder simplifications. Now it looks to be 6% faster. At least
romansh
parents:
1875
diff
changeset
|
627 if (mb->pos < 64) { |
723 | 628 #ifdef VLC_DEBUG |
629 printf("start %d:%d\n", mb_index, j); | |
630 #endif | |
1887
85fe2f4633ec
* DV decoding/encoding now supports MultiThreading for up to 324 CPUs ;-)
romansh
parents:
1886
diff
changeset
|
631 dv_decode_ac(&gb, mb, block); |
723 | 632 } |
2979 | 633 if (mb->pos >= 64 && mb->pos < 127) |
634 av_log(NULL, AV_LOG_ERROR, "AC EOB marker is absent pos=%d\n", mb->pos); | |
723 | 635 block += 64; |
725 | 636 mb++; |
723 | 637 } |
638 } | |
2967 | 639 |
723 | 640 /* compute idct and place blocks */ |
1887
85fe2f4633ec
* DV decoding/encoding now supports MultiThreading for up to 324 CPUs ;-)
romansh
parents:
1886
diff
changeset
|
641 block = &sblock[0][0]; |
8051 | 642 mb = mb_data; |
643 for (mb_index = 0; mb_index < 5; mb_index++) { | |
8118
890df98a7848
implementing more efficient (and direct) allocation of work for DV codec workers
romansh
parents:
8088
diff
changeset
|
644 dv_calculate_mb_xy(s, work_chunk, mb_index, &mb_x, &mb_y); |
7715
e8f71784062e
Intial implementation of the DV100 (AKA DVCPRO HD) decoder and demuxer as
romansh
parents:
7708
diff
changeset
|
645 |
e8f71784062e
Intial implementation of the DV100 (AKA DVCPRO HD) decoder and demuxer as
romansh
parents:
7708
diff
changeset
|
646 /* idct_put'ting luminance */ |
e8f71784062e
Intial implementation of the DV100 (AKA DVCPRO HD) decoder and demuxer as
romansh
parents:
7708
diff
changeset
|
647 if ((s->sys->pix_fmt == PIX_FMT_YUV420P) || |
e8f71784062e
Intial implementation of the DV100 (AKA DVCPRO HD) decoder and demuxer as
romansh
parents:
7708
diff
changeset
|
648 (s->sys->pix_fmt == PIX_FMT_YUV411P && mb_x >= (704 / 8)) || |
e8f71784062e
Intial implementation of the DV100 (AKA DVCPRO HD) decoder and demuxer as
romansh
parents:
7708
diff
changeset
|
649 (s->sys->height >= 720 && mb_y != 134)) { |
8051 | 650 y_stride = (s->picture.linesize[0] << ((!is_field_mode[mb_index]) * log2_blocksize)); |
7715
e8f71784062e
Intial implementation of the DV100 (AKA DVCPRO HD) decoder and demuxer as
romansh
parents:
7708
diff
changeset
|
651 } else { |
8051 | 652 y_stride = (2 << log2_blocksize); |
7715
e8f71784062e
Intial implementation of the DV100 (AKA DVCPRO HD) decoder and demuxer as
romansh
parents:
7708
diff
changeset
|
653 } |
8051 | 654 y_ptr = s->picture.data[0] + ((mb_y * s->picture.linesize[0] + mb_x) << log2_blocksize); |
655 linesize = s->picture.linesize[0] << is_field_mode[mb_index]; | |
656 mb[0] .idct_put(y_ptr , linesize, block + 0*64); | |
8011 | 657 if (s->sys->video_stype == 4) { /* SD 422 */ |
8051 | 658 mb[2].idct_put(y_ptr + (1 << log2_blocksize) , linesize, block + 2*64); |
8011 | 659 } else { |
8051 | 660 mb[1].idct_put(y_ptr + (1 << log2_blocksize) , linesize, block + 1*64); |
661 mb[2].idct_put(y_ptr + y_stride, linesize, block + 2*64); | |
662 mb[3].idct_put(y_ptr + (1 << log2_blocksize) + y_stride, linesize, block + 3*64); | |
7715
e8f71784062e
Intial implementation of the DV100 (AKA DVCPRO HD) decoder and demuxer as
romansh
parents:
7708
diff
changeset
|
663 } |
8011 | 664 mb += 4; |
665 block += 4*64; | |
7715
e8f71784062e
Intial implementation of the DV100 (AKA DVCPRO HD) decoder and demuxer as
romansh
parents:
7708
diff
changeset
|
666 |
e8f71784062e
Intial implementation of the DV100 (AKA DVCPRO HD) decoder and demuxer as
romansh
parents:
7708
diff
changeset
|
667 /* idct_put'ting chrominance */ |
8051 | 668 c_offset = (((mb_y >> (s->sys->pix_fmt == PIX_FMT_YUV420P)) * s->picture.linesize[1] + |
669 (mb_x >> ((s->sys->pix_fmt == PIX_FMT_YUV411P) ? 2 : 1))) << log2_blocksize); | |
670 for (j = 2; j; j--) { | |
7715
e8f71784062e
Intial implementation of the DV100 (AKA DVCPRO HD) decoder and demuxer as
romansh
parents:
7708
diff
changeset
|
671 uint8_t *c_ptr = s->picture.data[j] + c_offset; |
e8f71784062e
Intial implementation of the DV100 (AKA DVCPRO HD) decoder and demuxer as
romansh
parents:
7708
diff
changeset
|
672 if (s->sys->pix_fmt == PIX_FMT_YUV411P && mb_x >= (704 / 8)) { |
e8f71784062e
Intial implementation of the DV100 (AKA DVCPRO HD) decoder and demuxer as
romansh
parents:
7708
diff
changeset
|
673 uint64_t aligned_pixels[64/8]; |
e8f71784062e
Intial implementation of the DV100 (AKA DVCPRO HD) decoder and demuxer as
romansh
parents:
7708
diff
changeset
|
674 uint8_t *pixels = (uint8_t*)aligned_pixels; |
e8f71784062e
Intial implementation of the DV100 (AKA DVCPRO HD) decoder and demuxer as
romansh
parents:
7708
diff
changeset
|
675 uint8_t *c_ptr1, *ptr1; |
e8f71784062e
Intial implementation of the DV100 (AKA DVCPRO HD) decoder and demuxer as
romansh
parents:
7708
diff
changeset
|
676 int x, y; |
e8f71784062e
Intial implementation of the DV100 (AKA DVCPRO HD) decoder and demuxer as
romansh
parents:
7708
diff
changeset
|
677 mb->idct_put(pixels, 8, block); |
8051 | 678 for (y = 0; y < (1 << log2_blocksize); y++, c_ptr += s->picture.linesize[j], pixels += 8) { |
679 ptr1 = pixels + (1 << (log2_blocksize - 1)); | |
680 c_ptr1 = c_ptr + (s->picture.linesize[j] << log2_blocksize); | |
681 for (x = 0; x < (1 << (log2_blocksize - 1)); x++) { | |
682 c_ptr[x] = pixels[x]; | |
683 c_ptr1[x] = ptr1[x]; | |
7715
e8f71784062e
Intial implementation of the DV100 (AKA DVCPRO HD) decoder and demuxer as
romansh
parents:
7708
diff
changeset
|
684 } |
e8f71784062e
Intial implementation of the DV100 (AKA DVCPRO HD) decoder and demuxer as
romansh
parents:
7708
diff
changeset
|
685 } |
e8f71784062e
Intial implementation of the DV100 (AKA DVCPRO HD) decoder and demuxer as
romansh
parents:
7708
diff
changeset
|
686 block += 64; mb++; |
e8f71784062e
Intial implementation of the DV100 (AKA DVCPRO HD) decoder and demuxer as
romansh
parents:
7708
diff
changeset
|
687 } else { |
8051 | 688 y_stride = (mb_y == 134) ? (1 << log2_blocksize) : |
689 s->picture.linesize[j] << ((!is_field_mode[mb_index]) * log2_blocksize); | |
690 linesize = s->picture.linesize[j] << is_field_mode[mb_index]; | |
691 (mb++)-> idct_put(c_ptr , linesize, block); block += 64; | |
8011 | 692 if (s->sys->bpm == 8) { |
8051 | 693 (mb++)->idct_put(c_ptr + y_stride, linesize, block); block += 64; |
8011 | 694 } |
723 | 695 } |
696 } | |
697 } | |
8163 | 698 return 0; |
723 | 699 } |
700 | |
8596
68e959302527
replace all occurrence of ENABLE_ by the corresponding CONFIG_, HAVE_ or ARCH_
aurel
parents:
8590
diff
changeset
|
701 #if CONFIG_SMALL |
1493
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
702 /* Converts run and level (where level != 0) pair into vlc, returning bit size */ |
4283
d6f83e2f8804
rename always_inline to av_always_inline and move to common.h
mru
parents:
4001
diff
changeset
|
703 static av_always_inline int dv_rl2vlc(int run, int level, int sign, uint32_t* vlc) |
1493
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
704 { |
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
705 int size; |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
706 if (run < DV_VLC_MAP_RUN_SIZE && level < DV_VLC_MAP_LEV_SIZE) { |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
707 *vlc = dv_vlc_map[run][level].vlc | sign; |
2979 | 708 size = dv_vlc_map[run][level].size; |
1493
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
709 } |
2967 | 710 else { |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
711 if (level < DV_VLC_MAP_LEV_SIZE) { |
2979 | 712 *vlc = dv_vlc_map[0][level].vlc | sign; |
713 size = dv_vlc_map[0][level].size; | |
714 } else { | |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
715 *vlc = 0xfe00 | (level << 1) | sign; |
2979 | 716 size = 16; |
717 } | |
718 if (run) { | |
719 *vlc |= ((run < 16) ? dv_vlc_map[run-1][0].vlc : | |
720 (0x1f80 | (run - 1))) << size; | |
8051 | 721 size += (run < 16) ? dv_vlc_map[run-1][0].size : 13; |
2979 | 722 } |
1493
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
723 } |
2967 | 724 |
1493
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
725 return size; |
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
726 } |
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
727 |
4283
d6f83e2f8804
rename always_inline to av_always_inline and move to common.h
mru
parents:
4001
diff
changeset
|
728 static av_always_inline int dv_rl2vlc_size(int run, int level) |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
729 { |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
730 int size; |
2967 | 731 |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
732 if (run < DV_VLC_MAP_RUN_SIZE && level < DV_VLC_MAP_LEV_SIZE) { |
2979 | 733 size = dv_vlc_map[run][level].size; |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
734 } |
2967 | 735 else { |
2979 | 736 size = (level < DV_VLC_MAP_LEV_SIZE) ? dv_vlc_map[0][level].size : 16; |
737 if (run) { | |
738 size += (run < 16) ? dv_vlc_map[run-1][0].size : 13; | |
739 } | |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
740 } |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
741 return size; |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
742 } |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
743 #else |
4283
d6f83e2f8804
rename always_inline to av_always_inline and move to common.h
mru
parents:
4001
diff
changeset
|
744 static av_always_inline int dv_rl2vlc(int run, int l, int sign, uint32_t* vlc) |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
745 { |
2847 | 746 *vlc = dv_vlc_map[run][l].vlc | sign; |
747 return dv_vlc_map[run][l].size; | |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
748 } |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
749 |
4283
d6f83e2f8804
rename always_inline to av_always_inline and move to common.h
mru
parents:
4001
diff
changeset
|
750 static av_always_inline int dv_rl2vlc_size(int run, int l) |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
751 { |
2847 | 752 return dv_vlc_map[run][l].size; |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
753 } |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
754 #endif |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
755 |
1493
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
756 typedef struct EncBlockInfo { |
8051 | 757 int area_q[4]; |
758 int bit_size[4]; | |
759 int prev[5]; | |
760 int cur_ac; | |
761 int cno; | |
762 int dct_mode; | |
763 DCTELEM mb[64]; | |
764 uint8_t next[64]; | |
765 uint8_t sign[64]; | |
766 uint8_t partial_bit_count; | |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
767 uint32_t partial_bit_buffer; /* we can't use uint16_t here */ |
1493
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
768 } EncBlockInfo; |
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
769 |
8051 | 770 static av_always_inline PutBitContext* dv_encode_ac(EncBlockInfo* bi, |
771 PutBitContext* pb_pool, | |
772 PutBitContext* pb_end) | |
1493
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
773 { |
8051 | 774 int prev, bits_left; |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
775 PutBitContext* pb = pb_pool; |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
776 int size = bi->partial_bit_count; |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
777 uint32_t vlc = bi->partial_bit_buffer; |
2847 | 778 |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
779 bi->partial_bit_count = bi->partial_bit_buffer = 0; |
8051 | 780 for (;;){ |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
781 /* Find suitable storage space */ |
1875
45a1592dadca
* moving some of the commonly used bit reading/writing functions
romansh
parents:
1726
diff
changeset
|
782 for (; size > (bits_left = put_bits_left(pb)); pb++) { |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
783 if (bits_left) { |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
784 size -= bits_left; |
2979 | 785 put_bits(pb, bits_left, vlc >> size); |
8051 | 786 vlc = vlc & ((1 << size) - 1); |
2979 | 787 } |
788 if (pb + 1 >= pb_end) { | |
8051 | 789 bi->partial_bit_count = size; |
2979 | 790 bi->partial_bit_buffer = vlc; |
791 return pb; | |
792 } | |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
793 } |
2967 | 794 |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
795 /* Store VLC */ |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
796 put_bits(pb, size, vlc); |
2967 | 797 |
8051 | 798 if (bi->cur_ac >= 64) |
2847 | 799 break; |
2967 | 800 |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
801 /* Construct the next VLC */ |
8051 | 802 prev = bi->cur_ac; |
2847 | 803 bi->cur_ac = bi->next[prev]; |
8051 | 804 if (bi->cur_ac < 64){ |
2847 | 805 size = dv_rl2vlc(bi->cur_ac - prev - 1, bi->mb[bi->cur_ac], bi->sign[bi->cur_ac], &vlc); |
806 } else { | |
807 size = 4; vlc = 6; /* End Of Block stamp */ | |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
808 } |
2847 | 809 } |
810 return pb; | |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
811 } |
1493
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
812 |
8979
5337b260a70d
transitioning dv_guess_dct_mode to dsputil cmp function
romansh
parents:
8954
diff
changeset
|
813 static av_always_inline int dv_guess_dct_mode(DVVideoContext *s, uint8_t *data, int linesize) { |
5337b260a70d
transitioning dv_guess_dct_mode to dsputil cmp function
romansh
parents:
8954
diff
changeset
|
814 if (s->avctx->flags & CODEC_FLAG_INTERLACED_DCT) { |
5337b260a70d
transitioning dv_guess_dct_mode to dsputil cmp function
romansh
parents:
8954
diff
changeset
|
815 int ps = s->ildct_cmp(NULL, data, NULL, linesize, 8) - 400; |
5337b260a70d
transitioning dv_guess_dct_mode to dsputil cmp function
romansh
parents:
8954
diff
changeset
|
816 if (ps > 0) { |
5337b260a70d
transitioning dv_guess_dct_mode to dsputil cmp function
romansh
parents:
8954
diff
changeset
|
817 int is = s->ildct_cmp(NULL, data , NULL, linesize<<1, 4) + |
5337b260a70d
transitioning dv_guess_dct_mode to dsputil cmp function
romansh
parents:
8954
diff
changeset
|
818 s->ildct_cmp(NULL, data + linesize, NULL, linesize<<1, 4); |
5337b260a70d
transitioning dv_guess_dct_mode to dsputil cmp function
romansh
parents:
8954
diff
changeset
|
819 return (ps > is); |
5337b260a70d
transitioning dv_guess_dct_mode to dsputil cmp function
romansh
parents:
8954
diff
changeset
|
820 } |
8990 | 821 } |
822 | |
823 return 0; | |
8703 | 824 } |
825 | |
8705 | 826 static av_always_inline int dv_init_enc_block(EncBlockInfo* bi, uint8_t *data, int linesize, DVVideoContext *s, int bias) |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
827 { |
8705 | 828 const int *weight; |
829 const uint8_t* zigzag_scan; | |
830 DECLARE_ALIGNED_16(DCTELEM, blk[64]); | |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
831 int i, area; |
3152
28a087ad41d1
Assign class 2 to most macroblocks by default, instead of a more conservative
romansh
parents:
3150
diff
changeset
|
832 /* We offer two different methods for class number assignment: the |
28a087ad41d1
Assign class 2 to most macroblocks by default, instead of a more conservative
romansh
parents:
3150
diff
changeset
|
833 method suggested in SMPTE 314M Table 22, and an improved |
28a087ad41d1
Assign class 2 to most macroblocks by default, instead of a more conservative
romansh
parents:
3150
diff
changeset
|
834 method. The SMPTE method is very conservative; it assigns class |
28a087ad41d1
Assign class 2 to most macroblocks by default, instead of a more conservative
romansh
parents:
3150
diff
changeset
|
835 3 (i.e. severe quantization) to any block where the largest AC |
7980 | 836 component is greater than 36. FFmpeg's DV encoder tracks AC bit |
3152
28a087ad41d1
Assign class 2 to most macroblocks by default, instead of a more conservative
romansh
parents:
3150
diff
changeset
|
837 consumption precisely, so there is no need to bias most blocks |
28a087ad41d1
Assign class 2 to most macroblocks by default, instead of a more conservative
romansh
parents:
3150
diff
changeset
|
838 towards strongly lossy compression. Instead, we assign class 2 |
28a087ad41d1
Assign class 2 to most macroblocks by default, instead of a more conservative
romansh
parents:
3150
diff
changeset
|
839 to most blocks, and use class 3 only when strictly necessary |
28a087ad41d1
Assign class 2 to most macroblocks by default, instead of a more conservative
romansh
parents:
3150
diff
changeset
|
840 (for blocks whose largest AC component exceeds 255). */ |
28a087ad41d1
Assign class 2 to most macroblocks by default, instead of a more conservative
romansh
parents:
3150
diff
changeset
|
841 |
28a087ad41d1
Assign class 2 to most macroblocks by default, instead of a more conservative
romansh
parents:
3150
diff
changeset
|
842 #if 0 /* SMPTE spec method */ |
2847 | 843 static const int classes[] = {12, 24, 36, 0xffff}; |
7980 | 844 #else /* improved FFmpeg method */ |
3152
28a087ad41d1
Assign class 2 to most macroblocks by default, instead of a more conservative
romansh
parents:
3150
diff
changeset
|
845 static const int classes[] = {-1, -1, 255, 0xffff}; |
28a087ad41d1
Assign class 2 to most macroblocks by default, instead of a more conservative
romansh
parents:
3150
diff
changeset
|
846 #endif |
8051 | 847 int max = classes[0]; |
848 int prev = 0; | |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
849 |
8705 | 850 assert((((int)blk) & 15) == 0); |
851 | |
852 bi->area_q[0] = bi->area_q[1] = bi->area_q[2] = bi->area_q[3] = 0; | |
853 bi->partial_bit_count = 0; | |
854 bi->partial_bit_buffer = 0; | |
855 bi->cur_ac = 0; | |
856 if (data) { | |
8979
5337b260a70d
transitioning dv_guess_dct_mode to dsputil cmp function
romansh
parents:
8954
diff
changeset
|
857 bi->dct_mode = dv_guess_dct_mode(s, data, linesize); |
8705 | 858 s->get_pixels(blk, data, linesize); |
859 s->fdct[bi->dct_mode](blk); | |
860 } else { | |
861 /* We rely on the fact that encoding all zeros leads to an immediate EOB, | |
862 which is precisely what the spec calls for in the "dummy" blocks. */ | |
863 memset(blk, 0, sizeof(blk)); | |
864 bi->dct_mode = 0; | |
865 } | |
2967 | 866 bi->mb[0] = blk[0]; |
867 | |
8705 | 868 zigzag_scan = bi->dct_mode ? ff_zigzag248_direct : ff_zigzag_direct; |
869 weight = bi->dct_mode ? dv_weight_248 : dv_weight_88; | |
870 | |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
871 for (area = 0; area < 4; area++) { |
8051 | 872 bi->prev[area] = prev; |
2847 | 873 bi->bit_size[area] = 1; // 4 areas 4 bits for EOB :) |
8051 | 874 for (i = mb_area_start[area]; i < mb_area_start[area+1]; i++) { |
2847 | 875 int level = blk[zigzag_scan[i]]; |
2967 | 876 |
8051 | 877 if (level + 15 > 30U) { |
878 bi->sign[i] = (level >> 31) & 1; | |
3149
2679184e8be0
AC coefficient weighing (per SMPTE 314M) for the DV encoder and decoder. The
romansh
parents:
3148
diff
changeset
|
879 /* weigh it and and shift down into range, adding for rounding */ |
2679184e8be0
AC coefficient weighing (per SMPTE 314M) for the DV encoder and decoder. The
romansh
parents:
3148
diff
changeset
|
880 /* the extra division by a factor of 2^4 reverses the 8x expansion of the DCT |
2679184e8be0
AC coefficient weighing (per SMPTE 314M) for the DV encoder and decoder. The
romansh
parents:
3148
diff
changeset
|
881 AND the 2x doubling of the weights */ |
8051 | 882 level = (FFABS(level) * weight[i] + (1 << (dv_weight_bits+3))) >> (dv_weight_bits+4); |
3149
2679184e8be0
AC coefficient weighing (per SMPTE 314M) for the DV encoder and decoder. The
romansh
parents:
3148
diff
changeset
|
883 bi->mb[i] = level; |
8051 | 884 if (level > max) |
885 max = level; | |
2847 | 886 bi->bit_size[area] += dv_rl2vlc_size(i - prev - 1, level); |
887 bi->next[prev]= i; | |
8051 | 888 prev = i; |
2847 | 889 } |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
890 } |
1493
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
891 } |
2847 | 892 bi->next[prev]= i; |
8051 | 893 for (bi->cno = 0; max > classes[bi->cno]; bi->cno++); |
2847 | 894 |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
895 bi->cno += bias; |
2967 | 896 |
2847 | 897 if (bi->cno >= 3) { |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
898 bi->cno = 3; |
8051 | 899 prev = 0; |
900 i = bi->next[prev]; | |
2847 | 901 for (area = 0; area < 4; area++) { |
8051 | 902 bi->prev[area] = prev; |
2847 | 903 bi->bit_size[area] = 1; // 4 areas 4 bits for EOB :) |
8051 | 904 for (; i < mb_area_start[area+1]; i = bi->next[i]) { |
905 bi->mb[i] >>= 1; | |
2967 | 906 |
2847 | 907 if (bi->mb[i]) { |
908 bi->bit_size[area] += dv_rl2vlc_size(i - prev - 1, bi->mb[i]); | |
909 bi->next[prev]= i; | |
8051 | 910 prev = i; |
2847 | 911 } |
912 } | |
913 } | |
914 bi->next[prev]= i; | |
1493
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
915 } |
8705 | 916 |
917 return bi->bit_size[0] + bi->bit_size[1] + bi->bit_size[2] + bi->bit_size[3]; | |
1493
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
918 } |
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
919 |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
920 static inline void dv_guess_qnos(EncBlockInfo* blks, int* qnos) |
1493
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
921 { |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
922 int size[5]; |
3140 | 923 int i, j, k, a, prev, a2; |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
924 EncBlockInfo* b; |
2847 | 925 |
8051 | 926 size[0] = size[1] = size[2] = size[3] = size[4] = 1 << 24; |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
927 do { |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
928 b = blks; |
8051 | 929 for (i = 0; i < 5; i++) { |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
930 if (!qnos[i]) |
2979 | 931 continue; |
2967 | 932 |
2979 | 933 qnos[i]--; |
934 size[i] = 0; | |
8051 | 935 for (j = 0; j < 6; j++, b++) { |
936 for (a = 0; a < 4; a++) { | |
2979 | 937 if (b->area_q[a] != dv_quant_shifts[qnos[i] + dv_quant_offset[b->cno]][a]) { |
938 b->bit_size[a] = 1; // 4 areas 4 bits for EOB :) | |
939 b->area_q[a]++; | |
8051 | 940 prev = b->prev[a]; |
3147 | 941 assert(b->next[prev] >= mb_area_start[a+1] || b->mb[prev]); |
8051 | 942 for (k = b->next[prev] ; k < mb_area_start[a+1]; k = b->next[k]) { |
2979 | 943 b->mb[k] >>= 1; |
944 if (b->mb[k]) { | |
2847 | 945 b->bit_size[a] += dv_rl2vlc_size(k - prev - 1, b->mb[k]); |
8051 | 946 prev = k; |
2847 | 947 } else { |
8051 | 948 if (b->next[k] >= mb_area_start[a+1] && b->next[k]<64){ |
949 for (a2 = a + 1; b->next[k] >= mb_area_start[a2+1]; a2++) | |
3146
dcae1bde37ac
size[0-3] are not initialized (and can get random negative trash
michael
parents:
3143
diff
changeset
|
950 b->prev[a2] = prev; |
8051 | 951 assert(a2 < 4); |
3140 | 952 assert(b->mb[b->next[k]]); |
953 b->bit_size[a2] += dv_rl2vlc_size(b->next[k] - prev - 1, b->mb[b->next[k]]) | |
954 -dv_rl2vlc_size(b->next[k] - k - 1, b->mb[b->next[k]]); | |
8051 | 955 assert(b->prev[a2] == k && (a2 + 1 >= 4 || b->prev[a2+1] != k)); |
3147 | 956 b->prev[a2] = prev; |
3140 | 957 } |
2847 | 958 b->next[prev] = b->next[k]; |
959 } | |
2979 | 960 } |
2847 | 961 b->prev[a+1]= prev; |
2979 | 962 } |
963 size[i] += b->bit_size[a]; | |
964 } | |
965 } | |
8051 | 966 if (vs_total_ac_bits >= size[0] + size[1] + size[2] + size[3] + size[4]) |
3142 | 967 return; |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
968 } |
3140 | 969 } while (qnos[0]|qnos[1]|qnos[2]|qnos[3]|qnos[4]); |
970 | |
971 | |
8051 | 972 for (a = 2; a == 2 || vs_total_ac_bits < size[0]; a += a){ |
3140 | 973 b = blks; |
8051 | 974 size[0] = 5 * 6 * 4; //EOB |
975 for (j = 0; j < 6 *5; j++, b++) { | |
976 prev = b->prev[0]; | |
977 for (k = b->next[prev]; k < 64; k = b->next[k]) { | |
978 if (b->mb[k] < a && b->mb[k] > -a){ | |
3140 | 979 b->next[prev] = b->next[k]; |
980 }else{ | |
981 size[0] += dv_rl2vlc_size(k - prev - 1, b->mb[k]); | |
8051 | 982 prev = k; |
3140 | 983 } |
984 } | |
985 } | |
986 } | |
1567 | 987 } |
988 | |
8716 | 989 static int dv_encode_video_segment(AVCodecContext *avctx, void *arg) |
1493
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
990 { |
8163 | 991 DVVideoContext *s = avctx->priv_data; |
8716 | 992 DVwork_chunk *work_chunk = arg; |
8118
890df98a7848
implementing more efficient (and direct) allocation of work for DV codec workers
romansh
parents:
8088
diff
changeset
|
993 int mb_index, i, j; |
8709 | 994 int mb_x, mb_y, c_offset, linesize, y_stride; |
1493
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
995 uint8_t* y_ptr; |
8118
890df98a7848
implementing more efficient (and direct) allocation of work for DV codec workers
romansh
parents:
8088
diff
changeset
|
996 uint8_t* dif; |
8705 | 997 uint8_t scratch[64]; |
8702 | 998 EncBlockInfo enc_blks[5*DV_MAX_BPM]; |
999 PutBitContext pbs[5*DV_MAX_BPM]; | |
2967 | 1000 PutBitContext* pb; |
1493
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
1001 EncBlockInfo* enc_blk; |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
1002 int vs_bit_size = 0; |
8708 | 1003 int qnos[5] = {15, 15, 15, 15, 15}; /* No quantization */ |
8707 | 1004 int* qnosp = &qnos[0]; |
2967 | 1005 |
8131 | 1006 dif = &s->buf[work_chunk->buf_offset*80]; |
1567 | 1007 enc_blk = &enc_blks[0]; |
8051 | 1008 for (mb_index = 0; mb_index < 5; mb_index++) { |
8118
890df98a7848
implementing more efficient (and direct) allocation of work for DV codec workers
romansh
parents:
8088
diff
changeset
|
1009 dv_calculate_mb_xy(s, work_chunk, mb_index, &mb_x, &mb_y); |
8709 | 1010 |
1011 /* initializing luminance blocks */ | |
1012 if ((s->sys->pix_fmt == PIX_FMT_YUV420P) || | |
1013 (s->sys->pix_fmt == PIX_FMT_YUV411P && mb_x >= (704 / 8)) || | |
1014 (s->sys->height >= 720 && mb_y != 134)) { | |
1015 y_stride = s->picture.linesize[0] << 3; | |
1016 } else { | |
1017 y_stride = 16; | |
1018 } | |
8051 | 1019 y_ptr = s->picture.data[0] + ((mb_y * s->picture.linesize[0] + mb_x) << 3); |
8709 | 1020 linesize = s->picture.linesize[0]; |
1021 | |
1022 if (s->sys->video_stype == 4) { /* SD 422 */ | |
1023 vs_bit_size += | |
1024 dv_init_enc_block(enc_blk+0, y_ptr , linesize, s, 0) + | |
1025 dv_init_enc_block(enc_blk+1, NULL , linesize, s, 0) + | |
1026 dv_init_enc_block(enc_blk+2, y_ptr + 8 , linesize, s, 0) + | |
1027 dv_init_enc_block(enc_blk+3, NULL , linesize, s, 0); | |
1028 } else { | |
1029 vs_bit_size += | |
1030 dv_init_enc_block(enc_blk+0, y_ptr , linesize, s, 0) + | |
1031 dv_init_enc_block(enc_blk+1, y_ptr + 8 , linesize, s, 0) + | |
1032 dv_init_enc_block(enc_blk+2, y_ptr + y_stride, linesize, s, 0) + | |
1033 dv_init_enc_block(enc_blk+3, y_ptr + 8 + y_stride, linesize, s, 0); | |
1034 } | |
1035 enc_blk += 4; | |
1036 | |
1037 /* initializing chrominance blocks */ | |
8051 | 1038 c_offset = (((mb_y >> (s->sys->pix_fmt == PIX_FMT_YUV420P)) * s->picture.linesize[1] + |
1039 (mb_x >> ((s->sys->pix_fmt == PIX_FMT_YUV411P) ? 2 : 1))) << 3); | |
8709 | 1040 for (j = 2; j; j--) { |
1041 uint8_t *c_ptr = s->picture.data[j] + c_offset; | |
1042 linesize = s->picture.linesize[j]; | |
1043 y_stride = (mb_y == 134) ? 8 : (s->picture.linesize[j] << 3); | |
8710 | 1044 if (s->sys->pix_fmt == PIX_FMT_YUV411P && mb_x >= (704 / 8)) { |
1045 uint8_t* d; | |
1046 uint8_t* b = scratch; | |
1047 for (i = 0; i < 8; i++) { | |
1048 d = c_ptr + (linesize << 3); | |
1049 b[0] = c_ptr[0]; b[1] = c_ptr[1]; b[2] = c_ptr[2]; b[3] = c_ptr[3]; | |
1050 b[4] = d[0]; b[5] = d[1]; b[6] = d[2]; b[7] = d[3]; | |
1051 c_ptr += linesize; | |
1052 b += 8; | |
1053 } | |
1054 c_ptr = scratch; | |
1055 linesize = 8; | |
1056 } | |
8709 | 1057 |
1058 vs_bit_size += dv_init_enc_block( enc_blk++, c_ptr , linesize, s, 1); | |
1059 if (s->sys->bpm == 8) { | |
1060 vs_bit_size += dv_init_enc_block(enc_blk++, c_ptr + y_stride, linesize, s, 1); | |
2979 | 1061 } |
1493
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
1062 } |
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
1063 } |
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
1064 |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
1065 if (vs_total_ac_bits < vs_bit_size) |
8707 | 1066 dv_guess_qnos(&enc_blks[0], qnosp); |
1067 | |
1068 /* DIF encoding process */ | |
1069 for (j=0; j<5*s->sys->bpm;) { | |
1070 int start_mb = j; | |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
1071 |
8707 | 1072 dif[3] = *qnosp++; |
1073 dif += 4; | |
1074 | |
1075 /* First pass over individual cells only */ | |
1076 for (i=0; i<s->sys->bpm; i++, j++) { | |
1077 int sz = s->sys->block_sizes[i]>>3; | |
1493
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
1078 |
8707 | 1079 init_put_bits(&pbs[j], dif, sz); |
9741
e52891e48ceb
remove cast and use put_sbits, fix assertion in put_bits
bcoudurier
parents:
9626
diff
changeset
|
1080 put_sbits(&pbs[j], 9, ((enc_blks[j].mb[0] >> 3) - 1024 + 2) >> 2); |
8707 | 1081 put_bits(&pbs[j], 1, enc_blks[j].dct_mode); |
1082 put_bits(&pbs[j], 2, enc_blks[j].cno); | |
1493
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
1083 |
8707 | 1084 dv_encode_ac(&enc_blks[j], &pbs[j], &pbs[j+1]); |
1085 dif += sz; | |
1086 } | |
1087 | |
1088 /* Second pass over each MB space */ | |
1089 pb = &pbs[start_mb]; | |
8702 | 1090 for (i=0; i<s->sys->bpm; i++) { |
8707 | 1091 if (enc_blks[start_mb+i].partial_bit_count) |
1092 pb = dv_encode_ac(&enc_blks[start_mb+i], pb, &pbs[start_mb+s->sys->bpm]); | |
2847 | 1093 } |
1493
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
1094 } |
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
1095 |
8050 | 1096 /* Third and final pass over the whole video segment space */ |
8051 | 1097 pb = &pbs[0]; |
8702 | 1098 for (j=0; j<5*s->sys->bpm; j++) { |
2847 | 1099 if (enc_blks[j].partial_bit_count) |
8702 | 1100 pb = dv_encode_ac(&enc_blks[j], pb, &pbs[s->sys->bpm*5]); |
3139
e58fb7ffbb4f
print a big warning if we mess up and run out of space ...
michael
parents:
3089
diff
changeset
|
1101 if (enc_blks[j].partial_bit_count) |
e58fb7ffbb4f
print a big warning if we mess up and run out of space ...
michael
parents:
3089
diff
changeset
|
1102 av_log(NULL, AV_LOG_ERROR, "ac bitstream overflow\n"); |
1493
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
1103 } |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
1104 |
10320
44f31c1c9acc
Make sure that dv encoder initializes all encoded packet data.
reimar
parents:
10146
diff
changeset
|
1105 for (j=0; j<5*s->sys->bpm; j++) { |
44f31c1c9acc
Make sure that dv encoder initializes all encoded packet data.
reimar
parents:
10146
diff
changeset
|
1106 int pos; |
44f31c1c9acc
Make sure that dv encoder initializes all encoded packet data.
reimar
parents:
10146
diff
changeset
|
1107 int size = pbs[j].size_in_bits >> 3; |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
1108 flush_put_bits(&pbs[j]); |
10320
44f31c1c9acc
Make sure that dv encoder initializes all encoded packet data.
reimar
parents:
10146
diff
changeset
|
1109 pos = put_bits_count(&pbs[j]) >> 3; |
44f31c1c9acc
Make sure that dv encoder initializes all encoded packet data.
reimar
parents:
10146
diff
changeset
|
1110 if (pos > size) { |
44f31c1c9acc
Make sure that dv encoder initializes all encoded packet data.
reimar
parents:
10146
diff
changeset
|
1111 av_log(avctx, AV_LOG_ERROR, "bitstream written beyond buffer size\n"); |
44f31c1c9acc
Make sure that dv encoder initializes all encoded packet data.
reimar
parents:
10146
diff
changeset
|
1112 return -1; |
44f31c1c9acc
Make sure that dv encoder initializes all encoded packet data.
reimar
parents:
10146
diff
changeset
|
1113 } |
44f31c1c9acc
Make sure that dv encoder initializes all encoded packet data.
reimar
parents:
10146
diff
changeset
|
1114 memset(pbs[j].buf + pos, 0xff, size - pos); |
44f31c1c9acc
Make sure that dv encoder initializes all encoded packet data.
reimar
parents:
10146
diff
changeset
|
1115 } |
1493
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
1116 |
1887
85fe2f4633ec
* DV decoding/encoding now supports MultiThreading for up to 324 CPUs ;-)
romansh
parents:
1886
diff
changeset
|
1117 return 0; |
85fe2f4633ec
* DV decoding/encoding now supports MultiThreading for up to 324 CPUs ;-)
romansh
parents:
1886
diff
changeset
|
1118 } |
85fe2f4633ec
* DV decoding/encoding now supports MultiThreading for up to 324 CPUs ;-)
romansh
parents:
1886
diff
changeset
|
1119 |
8590 | 1120 #if CONFIG_DVVIDEO_DECODER |
723 | 1121 /* NOTE: exactly one frame must be given (120000 bytes for NTSC, |
3167 | 1122 144000 bytes for PAL - or twice those for 50Mbps) */ |
2967 | 1123 static int dvvideo_decode_frame(AVCodecContext *avctx, |
723 | 1124 void *data, int *data_size, |
9355
54bc8a2727b0
Implement avcodec_decode_video2(), _audio3() and _subtitle2() which takes an
rbultje
parents:
8990
diff
changeset
|
1125 AVPacket *avpkt) |
723 | 1126 { |
9355
54bc8a2727b0
Implement avcodec_decode_video2(), _audio3() and _subtitle2() which takes an
rbultje
parents:
8990
diff
changeset
|
1127 const uint8_t *buf = avpkt->data; |
54bc8a2727b0
Implement avcodec_decode_video2(), _audio3() and _subtitle2() which takes an
rbultje
parents:
8990
diff
changeset
|
1128 int buf_size = avpkt->size; |
1887
85fe2f4633ec
* DV decoding/encoding now supports MultiThreading for up to 324 CPUs ;-)
romansh
parents:
1886
diff
changeset
|
1129 DVVideoContext *s = avctx->priv_data; |
2967 | 1130 |
9855
756ac43c7fd9
check if frame size matches old sys and assumes corrupted input, fixes #1192
bcoudurier
parents:
9741
diff
changeset
|
1131 s->sys = dv_frame_profile(s->sys, buf, buf_size); |
9856
ff2358195bc7
print error when dv frame profile cannot be found
bcoudurier
parents:
9855
diff
changeset
|
1132 if (!s->sys || buf_size < s->sys->frame_size || dv_init_dynamic_tables(s->sys)) { |
ff2358195bc7
print error when dv frame profile cannot be found
bcoudurier
parents:
9855
diff
changeset
|
1133 av_log(avctx, AV_LOG_ERROR, "could not find dv frame profile\n"); |
1489
337d13aee605
* DV handling was streamlined for both muxing/demuxing and
romansh
parents:
1416
diff
changeset
|
1134 return -1; /* NOTE: we only accept several full frames */ |
9856
ff2358195bc7
print error when dv frame profile cannot be found
bcoudurier
parents:
9855
diff
changeset
|
1135 } |
723 | 1136 |
8051 | 1137 if (s->picture.data[0]) |
1228 | 1138 avctx->release_buffer(avctx, &s->picture); |
2967 | 1139 |
1489
337d13aee605
* DV handling was streamlined for both muxing/demuxing and
romansh
parents:
1416
diff
changeset
|
1140 s->picture.reference = 0; |
2822
fdedaa2e6da4
DV video encoder/decoder doesn't set keyframe and picture type properties patch by (Edward Hervey:bilboed,gmail com)
michael
parents:
2661
diff
changeset
|
1141 s->picture.key_frame = 1; |
fdedaa2e6da4
DV video encoder/decoder doesn't set keyframe and picture type properties patch by (Edward Hervey:bilboed,gmail com)
michael
parents:
2661
diff
changeset
|
1142 s->picture.pict_type = FF_I_TYPE; |
8051 | 1143 avctx->pix_fmt = s->sys->pix_fmt; |
8014
07d8986fbea7
replacing frame_rate and frame_rate_base with an AVRational time_base
romansh
parents:
8011
diff
changeset
|
1144 avctx->time_base = s->sys->time_base; |
2849 | 1145 avcodec_set_dimensions(avctx, s->sys->width, s->sys->height); |
8051 | 1146 if (avctx->get_buffer(avctx, &s->picture) < 0) { |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1567
diff
changeset
|
1147 av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n"); |
903 | 1148 return -1; |
835 | 1149 } |
1543
7542cb99b950
* providing MPEG codecs with a generic fields in AVFrame to use.
romansh
parents:
1540
diff
changeset
|
1150 s->picture.interlaced_frame = 1; |
8051 | 1151 s->picture.top_field_first = 0; |
835 | 1152 |
1887
85fe2f4633ec
* DV decoding/encoding now supports MultiThreading for up to 324 CPUs ;-)
romansh
parents:
1886
diff
changeset
|
1153 s->buf = buf; |
8163 | 1154 avctx->execute(avctx, dv_decode_video_segment, s->sys->work_chunks, NULL, |
8131 | 1155 dv_work_pool_size(s->sys), sizeof(DVwork_chunk)); |
2967 | 1156 |
734
2d6b3e3d6c6f
10l - MMX/FPU state was not restored, causing nonsense fpu behaviour in caller (mplayer)
arpi_esp
parents:
733
diff
changeset
|
1157 emms_c(); |
2d6b3e3d6c6f
10l - MMX/FPU state was not restored, causing nonsense fpu behaviour in caller (mplayer)
arpi_esp
parents:
733
diff
changeset
|
1158 |
723 | 1159 /* return image */ |
925 | 1160 *data_size = sizeof(AVFrame); |
8051 | 1161 *(AVFrame*)data = s->picture; |
2967 | 1162 |
1489
337d13aee605
* DV handling was streamlined for both muxing/demuxing and
romansh
parents:
1416
diff
changeset
|
1163 return s->sys->frame_size; |
723 | 1164 } |
7776
dbcdd0165e55
Replace generic CONFIG_DECODERS preprocessor conditionals by more specific
diego
parents:
7715
diff
changeset
|
1165 #endif /* CONFIG_DVVIDEO_DECODER */ |
723 | 1166 |
3671
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1167 |
8051 | 1168 static inline int dv_write_pack(enum dv_pack_type pack_id, DVVideoContext *c, |
1169 uint8_t* buf) | |
3671
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1170 { |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1171 /* |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1172 * Here's what SMPTE314M says about these two: |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1173 * (page 6) APTn, AP1n, AP2n, AP3n: These data shall be identical |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1174 * as track application IDs (APTn = 001, AP1n = |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1175 * 001, AP2n = 001, AP3n = 001), if the source signal |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1176 * comes from a digital VCR. If the signal source is |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1177 * unknown, all bits for these data shall be set to 1. |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1178 * (page 12) STYPE: STYPE defines a signal type of video signal |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1179 * 00000b = 4:1:1 compression |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1180 * 00100b = 4:2:2 compression |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1181 * XXXXXX = Reserved |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1182 * Now, I've got two problems with these statements: |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1183 * 1. it looks like APT == 111b should be a safe bet, but it isn't. |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1184 * It seems that for PAL as defined in IEC 61834 we have to set |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1185 * APT to 000 and for SMPTE314M to 001. |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1186 * 2. It is not at all clear what STYPE is used for 4:2:0 PAL |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1187 * compression scheme (if any). |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1188 */ |
8051 | 1189 int apt = (c->sys->pix_fmt == PIX_FMT_YUV420P ? 0 : 1); |
3671
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1190 |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1191 uint8_t aspect = 0; |
8714
ba1e52769fc5
assume widescreen when ratio also > 17, patch by Ben Hutchings, ben at decadent dot org dot uk
bcoudurier
parents:
8710
diff
changeset
|
1192 if ((int)(av_q2d(c->avctx->sample_aspect_ratio) * c->avctx->width / c->avctx->height * 10) >= 17) /* 16:9 */ |
3671
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1193 aspect = 0x02; |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1194 |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1195 buf[0] = (uint8_t)pack_id; |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1196 switch (pack_id) { |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1197 case dv_header525: /* I can't imagine why these two weren't defined as real */ |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1198 case dv_header625: /* packs in SMPTE314M -- they definitely look like ones */ |
8051 | 1199 buf[1] = 0xf8 | /* reserved -- always 1 */ |
1200 (apt & 0x07); /* APT: Track application ID */ | |
1201 buf[2] = (0 << 7) | /* TF1: audio data is 0 - valid; 1 - invalid */ | |
3671
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1202 (0x0f << 3) | /* reserved -- always 1 */ |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1203 (apt & 0x07); /* AP1: Audio application ID */ |
8051 | 1204 buf[3] = (0 << 7) | /* TF2: video data is 0 - valid; 1 - invalid */ |
3671
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1205 (0x0f << 3) | /* reserved -- always 1 */ |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1206 (apt & 0x07); /* AP2: Video application ID */ |
8051 | 1207 buf[4] = (0 << 7) | /* TF3: subcode(SSYB) is 0 - valid; 1 - invalid */ |
3671
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1208 (0x0f << 3) | /* reserved -- always 1 */ |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1209 (apt & 0x07); /* AP3: Subcode application ID */ |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1210 break; |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1211 case dv_video_source: |
8051 | 1212 buf[1] = 0xff; /* reserved -- always 1 */ |
3671
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1213 buf[2] = (1 << 7) | /* B/W: 0 - b/w, 1 - color */ |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1214 (1 << 6) | /* following CLF is valid - 0, invalid - 1 */ |
8050 | 1215 (3 << 4) | /* CLF: color frames ID (see ITU-R BT.470-4) */ |
8051 | 1216 0xf; /* reserved -- always 1 */ |
3671
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1217 buf[3] = (3 << 6) | /* reserved -- always 1 */ |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1218 (c->sys->dsf << 5) | /* system: 60fields/50fields */ |
8738 | 1219 c->sys->video_stype; /* signal type video compression */ |
8051 | 1220 buf[4] = 0xff; /* VISC: 0xff -- no information */ |
3671
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1221 break; |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1222 case dv_video_control: |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1223 buf[1] = (0 << 6) | /* Copy generation management (CGMS) 0 -- free */ |
8051 | 1224 0x3f; /* reserved -- always 1 */ |
1225 buf[2] = 0xc8 | /* reserved -- always b11001xxx */ | |
3671
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1226 aspect; |
8050 | 1227 buf[3] = (1 << 7) | /* frame/field flag 1 -- frame, 0 -- field */ |
1228 (1 << 6) | /* first/second field flag 0 -- field 2, 1 -- field 1 */ | |
1229 (1 << 5) | /* frame change flag 0 -- same picture as before, 1 -- different */ | |
3671
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1230 (1 << 4) | /* 1 - interlaced, 0 - noninterlaced */ |
8051 | 1231 0xc; /* reserved -- always b1100 */ |
1232 buf[4] = 0xff; /* reserved -- always 1 */ | |
3671
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1233 break; |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1234 default: |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1235 buf[1] = buf[2] = buf[3] = buf[4] = 0xff; |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1236 } |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1237 return 5; |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1238 } |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1239 |
8590 | 1240 #if CONFIG_DVVIDEO_ENCODER |
3671
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1241 static void dv_format_frame(DVVideoContext* c, uint8_t* buf) |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1242 { |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1243 int chan, i, j, k; |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1244 |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1245 for (chan = 0; chan < c->sys->n_difchan; chan++) { |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1246 for (i = 0; i < c->sys->difseg_size; i++) { |
8050 | 1247 memset(buf, 0xff, 80 * 6); /* first 6 DIF blocks are for control data */ |
3671
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1248 |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1249 /* DV header: 1DIF */ |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1250 buf += dv_write_dif_id(dv_sect_header, chan, i, 0, buf); |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1251 buf += dv_write_pack((c->sys->dsf ? dv_header625 : dv_header525), c, buf); |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1252 buf += 72; /* unused bytes */ |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1253 |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1254 /* DV subcode: 2DIFs */ |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1255 for (j = 0; j < 2; j++) { |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1256 buf += dv_write_dif_id(dv_sect_subcode, chan, i, j, buf); |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1257 for (k = 0; k < 6; k++) |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1258 buf += dv_write_ssyb_id(k, (i < c->sys->difseg_size/2), buf) + 5; |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1259 buf += 29; /* unused bytes */ |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1260 } |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1261 |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1262 /* DV VAUX: 3DIFS */ |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1263 for (j = 0; j < 3; j++) { |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1264 buf += dv_write_dif_id(dv_sect_vaux, chan, i, j, buf); |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1265 buf += dv_write_pack(dv_video_source, c, buf); |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1266 buf += dv_write_pack(dv_video_control, c, buf); |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1267 buf += 7*5; |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1268 buf += dv_write_pack(dv_video_source, c, buf); |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1269 buf += dv_write_pack(dv_video_control, c, buf); |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1270 buf += 4*5 + 2; /* unused bytes */ |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1271 } |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1272 |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1273 /* DV Audio/Video: 135 Video DIFs + 9 Audio DIFs */ |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1274 for (j = 0; j < 135; j++) { |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1275 if (j%15 == 0) { |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1276 memset(buf, 0xff, 80); |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1277 buf += dv_write_dif_id(dv_sect_audio, chan, i, j/15, buf); |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1278 buf += 77; /* audio control & shuffled PCM audio */ |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1279 } |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1280 buf += dv_write_dif_id(dv_sect_video, chan, i, j, buf); |
7980 | 1281 buf += 77; /* 1 video macroblock: 1 bytes control |
3671
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1282 4 * 14 bytes Y 8x8 data |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1283 10 bytes Cr 8x8 data |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1284 10 bytes Cb 8x8 data */ |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1285 } |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1286 } |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1287 } |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1288 } |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1289 |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1290 |
2967 | 1291 static int dvvideo_encode_frame(AVCodecContext *c, uint8_t *buf, int buf_size, |
1493
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
1292 void *data) |
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
1293 { |
1887
85fe2f4633ec
* DV decoding/encoding now supports MultiThreading for up to 324 CPUs ;-)
romansh
parents:
1886
diff
changeset
|
1294 DVVideoContext *s = c->priv_data; |
1493
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
1295 |
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
1296 s->sys = dv_codec_profile(c); |
8118
890df98a7848
implementing more efficient (and direct) allocation of work for DV codec workers
romansh
parents:
8088
diff
changeset
|
1297 if (!s->sys || buf_size < s->sys->frame_size || dv_init_dynamic_tables(s->sys)) |
2422 | 1298 return -1; |
1299 | |
8051 | 1300 c->pix_fmt = s->sys->pix_fmt; |
1301 s->picture = *((AVFrame *)data); | |
2822
fdedaa2e6da4
DV video encoder/decoder doesn't set keyframe and picture type properties patch by (Edward Hervey:bilboed,gmail com)
michael
parents:
2661
diff
changeset
|
1302 s->picture.key_frame = 1; |
fdedaa2e6da4
DV video encoder/decoder doesn't set keyframe and picture type properties patch by (Edward Hervey:bilboed,gmail com)
michael
parents:
2661
diff
changeset
|
1303 s->picture.pict_type = FF_I_TYPE; |
1493
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
1304 |
1887
85fe2f4633ec
* DV decoding/encoding now supports MultiThreading for up to 324 CPUs ;-)
romansh
parents:
1886
diff
changeset
|
1305 s->buf = buf; |
8163 | 1306 c->execute(c, dv_encode_video_segment, s->sys->work_chunks, NULL, |
8131 | 1307 dv_work_pool_size(s->sys), sizeof(DVwork_chunk)); |
1493
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
1308 |
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
1309 emms_c(); |
3167 | 1310 |
3671
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1311 dv_format_frame(s, buf); |
3167 | 1312 |
1493
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
1313 return s->sys->frame_size; |
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
1314 } |
3806 | 1315 #endif |
1493
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
1316 |
2991
d377b0788381
Fix DV memory leak and allow multiple instances patch by (Burkhard Plaum?)
michael
parents:
2979
diff
changeset
|
1317 static int dvvideo_close(AVCodecContext *c) |
d377b0788381
Fix DV memory leak and allow multiple instances patch by (Burkhard Plaum?)
michael
parents:
2979
diff
changeset
|
1318 { |
4352
0ee71c12734e
* Fixing a bug with incorrect bits set in AAUX source pack
romansh
parents:
4283
diff
changeset
|
1319 DVVideoContext *s = c->priv_data; |
0ee71c12734e
* Fixing a bug with incorrect bits set in AAUX source pack
romansh
parents:
4283
diff
changeset
|
1320 |
8051 | 1321 if (s->picture.data[0]) |
4352
0ee71c12734e
* Fixing a bug with incorrect bits set in AAUX source pack
romansh
parents:
4283
diff
changeset
|
1322 c->release_buffer(c, &s->picture); |
2991
d377b0788381
Fix DV memory leak and allow multiple instances patch by (Burkhard Plaum?)
michael
parents:
2979
diff
changeset
|
1323 |
d377b0788381
Fix DV memory leak and allow multiple instances patch by (Burkhard Plaum?)
michael
parents:
2979
diff
changeset
|
1324 return 0; |
d377b0788381
Fix DV memory leak and allow multiple instances patch by (Burkhard Plaum?)
michael
parents:
2979
diff
changeset
|
1325 } |
d377b0788381
Fix DV memory leak and allow multiple instances patch by (Burkhard Plaum?)
michael
parents:
2979
diff
changeset
|
1326 |
d377b0788381
Fix DV memory leak and allow multiple instances patch by (Burkhard Plaum?)
michael
parents:
2979
diff
changeset
|
1327 |
8590 | 1328 #if CONFIG_DVVIDEO_ENCODER |
1887
85fe2f4633ec
* DV decoding/encoding now supports MultiThreading for up to 324 CPUs ;-)
romansh
parents:
1886
diff
changeset
|
1329 AVCodec dvvideo_encoder = { |
85fe2f4633ec
* DV decoding/encoding now supports MultiThreading for up to 324 CPUs ;-)
romansh
parents:
1886
diff
changeset
|
1330 "dvvideo", |
85fe2f4633ec
* DV decoding/encoding now supports MultiThreading for up to 324 CPUs ;-)
romansh
parents:
1886
diff
changeset
|
1331 CODEC_TYPE_VIDEO, |
85fe2f4633ec
* DV decoding/encoding now supports MultiThreading for up to 324 CPUs ;-)
romansh
parents:
1886
diff
changeset
|
1332 CODEC_ID_DVVIDEO, |
85fe2f4633ec
* DV decoding/encoding now supports MultiThreading for up to 324 CPUs ;-)
romansh
parents:
1886
diff
changeset
|
1333 sizeof(DVVideoContext), |
85fe2f4633ec
* DV decoding/encoding now supports MultiThreading for up to 324 CPUs ;-)
romansh
parents:
1886
diff
changeset
|
1334 dvvideo_init, |
85fe2f4633ec
* DV decoding/encoding now supports MultiThreading for up to 324 CPUs ;-)
romansh
parents:
1886
diff
changeset
|
1335 dvvideo_encode_frame, |
10146
38cfe222e1a4
Mark all pix_fmts and supported_framerates compound literals as const.
reimar
parents:
10093
diff
changeset
|
1336 .pix_fmts = (const enum PixelFormat[]) {PIX_FMT_YUV411P, PIX_FMT_YUV422P, PIX_FMT_YUV420P, PIX_FMT_NONE}, |
7040
e943e1409077
Make AVCodec long_names definition conditional depending on CONFIG_SMALL.
stefano
parents:
7039
diff
changeset
|
1337 .long_name = NULL_IF_CONFIG_SMALL("DV (Digital Video)"), |
1887
85fe2f4633ec
* DV decoding/encoding now supports MultiThreading for up to 324 CPUs ;-)
romansh
parents:
1886
diff
changeset
|
1338 }; |
2661
b2846918585c
a few #ifdef CONFIG_X_ENCODER, patch by (Roine Gustafsson <roine users.sourceforge net]
michael
parents:
2614
diff
changeset
|
1339 #endif // CONFIG_DVVIDEO_ENCODER |
723 | 1340 |
8590 | 1341 #if CONFIG_DVVIDEO_DECODER |
723 | 1342 AVCodec dvvideo_decoder = { |
1343 "dvvideo", | |
1344 CODEC_TYPE_VIDEO, | |
1345 CODEC_ID_DVVIDEO, | |
1887
85fe2f4633ec
* DV decoding/encoding now supports MultiThreading for up to 324 CPUs ;-)
romansh
parents:
1886
diff
changeset
|
1346 sizeof(DVVideoContext), |
1493
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
1347 dvvideo_init, |
1887
85fe2f4633ec
* DV decoding/encoding now supports MultiThreading for up to 324 CPUs ;-)
romansh
parents:
1886
diff
changeset
|
1348 NULL, |
2991
d377b0788381
Fix DV memory leak and allow multiple instances patch by (Burkhard Plaum?)
michael
parents:
2979
diff
changeset
|
1349 dvvideo_close, |
723 | 1350 dvvideo_decode_frame, |
835 | 1351 CODEC_CAP_DR1, |
6717 | 1352 NULL, |
7040
e943e1409077
Make AVCodec long_names definition conditional depending on CONFIG_SMALL.
stefano
parents:
7039
diff
changeset
|
1353 .long_name = NULL_IF_CONFIG_SMALL("DV (Digital Video)"), |
723 | 1354 }; |
3777 | 1355 #endif |