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