a35bb2f2ed7ef645c158a17c0af00c6d52ae984d
[libav.git] / libavcodec / dv.c
1 /*
2 * DV decoder
3 * Copyright (c) 2002 Fabrice Bellard
4 * Copyright (c) 2004 Roman Shaposhnik
5 *
6 * DV encoder
7 * Copyright (c) 2003 Roman Shaposhnik
8 *
9 * 50 Mbps (DVCPRO50) support
10 * Copyright (c) 2006 Daniel Maas <dmaas@maasdigital.com>
11 *
12 * 100 Mbps (DVCPRO HD) support
13 * Initial code by Daniel Maas <dmaas@maasdigital.com> (funded by BBC R&D)
14 * Final code by Roman Shaposhnik
15 *
16 * Many thanks to Dan Dennedy <dan@dennedy.org> for providing wealth
17 * of DV technical info.
18 *
19 * This file is part of Libav.
20 *
21 * Libav is free software; you can redistribute it and/or
22 * modify it under the terms of the GNU Lesser General Public
23 * License as published by the Free Software Foundation; either
24 * version 2.1 of the License, or (at your option) any later version.
25 *
26 * Libav is distributed in the hope that it will be useful,
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
32 * License along with Libav; if not, write to the Free Software
33 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
34 */
35
36 /**
37 * @file
38 * DV codec.
39 */
40 #define ALT_BITSTREAM_READER
41 #include "libavutil/pixdesc.h"
42 #include "avcodec.h"
43 #include "dsputil.h"
44 #include "get_bits.h"
45 #include "put_bits.h"
46 #include "simple_idct.h"
47 #include "dvdata.h"
48 #include "dv_tablegen.h"
49
50 //#undef NDEBUG
51 //#include <assert.h>
52
53 typedef struct DVVideoContext {
54 const DVprofile *sys;
55 AVFrame picture;
56 AVCodecContext *avctx;
57 uint8_t *buf;
58
59 uint8_t dv_zigzag[2][64];
60
61 void (*get_pixels)(DCTELEM *block, const uint8_t *pixels, int line_size);
62 void (*fdct[2])(DCTELEM *block);
63 void (*idct_put[2])(uint8_t *dest, int line_size, DCTELEM *block);
64 me_cmp_func ildct_cmp;
65 } DVVideoContext;
66
67 #define TEX_VLC_BITS 9
68
69 /* XXX: also include quantization */
70 static RL_VLC_ELEM dv_rl_vlc[1184];
71
72 static inline int dv_work_pool_size(const DVprofile *d)
73 {
74 int size = d->n_difchan*d->difseg_size*27;
75 if (DV_PROFILE_IS_1080i50(d))
76 size -= 3*27;
77 if (DV_PROFILE_IS_720p50(d))
78 size -= 4*27;
79 return size;
80 }
81
82 static inline void dv_calc_mb_coordinates(const DVprofile *d, int chan, int seq, int slot,
83 uint16_t *tbl)
84 {
85 static const uint8_t off[] = { 2, 6, 8, 0, 4 };
86 static const uint8_t shuf1[] = { 36, 18, 54, 0, 72 };
87 static const uint8_t shuf2[] = { 24, 12, 36, 0, 48 };
88 static const uint8_t shuf3[] = { 18, 9, 27, 0, 36 };
89
90 static const uint8_t l_start[] = {0, 4, 9, 13, 18, 22, 27, 31, 36, 40};
91 static const uint8_t l_start_shuffled[] = { 9, 4, 13, 0, 18 };
92
93 static const uint8_t serpent1[] = {0, 1, 2, 2, 1, 0,
94 0, 1, 2, 2, 1, 0,
95 0, 1, 2, 2, 1, 0,
96 0, 1, 2, 2, 1, 0,
97 0, 1, 2};
98 static const uint8_t serpent2[] = {0, 1, 2, 3, 4, 5, 5, 4, 3, 2, 1, 0,
99 0, 1, 2, 3, 4, 5, 5, 4, 3, 2, 1, 0,
100 0, 1, 2, 3, 4, 5};
101
102 static const uint8_t remap[][2] = {{ 0, 0}, { 0, 0}, { 0, 0}, { 0, 0}, /* dummy */
103 { 0, 0}, { 0, 1}, { 0, 2}, { 0, 3}, {10, 0},
104 {10, 1}, {10, 2}, {10, 3}, {20, 0}, {20, 1},
105 {20, 2}, {20, 3}, {30, 0}, {30, 1}, {30, 2},
106 {30, 3}, {40, 0}, {40, 1}, {40, 2}, {40, 3},
107 {50, 0}, {50, 1}, {50, 2}, {50, 3}, {60, 0},
108 {60, 1}, {60, 2}, {60, 3}, {70, 0}, {70, 1},
109 {70, 2}, {70, 3}, { 0,64}, { 0,65}, { 0,66},
110 {10,64}, {10,65}, {10,66}, {20,64}, {20,65},
111 {20,66}, {30,64}, {30,65}, {30,66}, {40,64},
112 {40,65}, {40,66}, {50,64}, {50,65}, {50,66},
113 {60,64}, {60,65}, {60,66}, {70,64}, {70,65},
114 {70,66}, { 0,67}, {20,67}, {40,67}, {60,67}};
115
116 int i, k, m;
117 int x, y, blk;
118
119 for (m=0; m<5; m++) {
120 switch (d->width) {
121 case 1440:
122 blk = (chan*11+seq)*27+slot;
123
124 if (chan == 0 && seq == 11) {
125 x = m*27+slot;
126 if (x<90) {
127 y = 0;
128 } else {
129 x = (x - 90)*2;
130 y = 67;
131 }
132 } else {
133 i = (4*chan + blk + off[m])%11;
134 k = (blk/11)%27;
135
136 x = shuf1[m] + (chan&1)*9 + k%9;
137 y = (i*3+k/9)*2 + (chan>>1) + 1;
138 }
139 tbl[m] = (x<<1)|(y<<9);
140 break;
141 case 1280:
142 blk = (chan*10+seq)*27+slot;
143
144 i = (4*chan + (seq/5) + 2*blk + off[m])%10;
145 k = (blk/5)%27;
146
147 x = shuf1[m]+(chan&1)*9 + k%9;
148 y = (i*3+k/9)*2 + (chan>>1) + 4;
149
150 if (x >= 80) {
151 x = remap[y][0]+((x-80)<<(y>59));
152 y = remap[y][1];
153 }
154 tbl[m] = (x<<1)|(y<<9);
155 break;
156 case 960:
157 blk = (chan*10+seq)*27+slot;
158
159 i = (4*chan + (seq/5) + 2*blk + off[m])%10;
160 k = (blk/5)%27 + (i&1)*3;
161
162 x = shuf2[m] + k%6 + 6*(chan&1);
163 y = l_start[i] + k/6 + 45*(chan>>1);
164 tbl[m] = (x<<1)|(y<<9);
165 break;
166 case 720:
167 switch (d->pix_fmt) {
168 case PIX_FMT_YUV422P:
169 x = shuf3[m] + slot/3;
170 y = serpent1[slot] +
171 ((((seq + off[m]) % d->difseg_size)<<1) + chan)*3;
172 tbl[m] = (x<<1)|(y<<8);
173 break;
174 case PIX_FMT_YUV420P:
175 x = shuf3[m] + slot/3;
176 y = serpent1[slot] +
177 ((seq + off[m]) % d->difseg_size)*3;
178 tbl[m] = (x<<1)|(y<<9);
179 break;
180 case PIX_FMT_YUV411P:
181 i = (seq + off[m]) % d->difseg_size;
182 k = slot + ((m==1||m==2)?3:0);
183
184 x = l_start_shuffled[m] + k/6;
185 y = serpent2[k] + i*6;
186 if (x>21)
187 y = y*2 - i*6;
188 tbl[m] = (x<<2)|(y<<8);
189 break;
190 }
191 default:
192 break;
193 }
194 }
195 }
196
197 static int dv_init_dynamic_tables(const DVprofile *d)
198 {
199 int j,i,c,s,p;
200 uint32_t *factor1, *factor2;
201 const int *iweight1, *iweight2;
202
203 if (!d->work_chunks[dv_work_pool_size(d)-1].buf_offset) {
204 p = i = 0;
205 for (c=0; c<d->n_difchan; c++) {
206 for (s=0; s<d->difseg_size; s++) {
207 p += 6;
208 for (j=0; j<27; j++) {
209 p += !(j%3);
210 if (!(DV_PROFILE_IS_1080i50(d) && c != 0 && s == 11) &&
211 !(DV_PROFILE_IS_720p50(d) && s > 9)) {
212 dv_calc_mb_coordinates(d, c, s, j, &d->work_chunks[i].mb_coordinates[0]);
213 d->work_chunks[i++].buf_offset = p;
214 }
215 p += 5;
216 }
217 }
218 }
219 }
220
221 if (!d->idct_factor[DV_PROFILE_IS_HD(d)?8191:5631]) {
222 factor1 = &d->idct_factor[0];
223 factor2 = &d->idct_factor[DV_PROFILE_IS_HD(d)?4096:2816];
224 if (d->height == 720) {
225 iweight1 = &dv_iweight_720_y[0];
226 iweight2 = &dv_iweight_720_c[0];
227 } else {
228 iweight1 = &dv_iweight_1080_y[0];
229 iweight2 = &dv_iweight_1080_c[0];
230 }
231 if (DV_PROFILE_IS_HD(d)) {
232 for (c = 0; c < 4; c++) {
233 for (s = 0; s < 16; s++) {
234 for (i = 0; i < 64; i++) {
235 *factor1++ = (dv100_qstep[s] << (c + 9)) * iweight1[i];
236 *factor2++ = (dv100_qstep[s] << (c + 9)) * iweight2[i];
237 }
238 }
239 }
240 } else {
241 iweight1 = &dv_iweight_88[0];
242 for (j = 0; j < 2; j++, iweight1 = &dv_iweight_248[0]) {
243 for (s = 0; s < 22; s++) {
244 for (i = c = 0; c < 4; c++) {
245 for (; i < dv_quant_areas[c]; i++) {
246 *factor1 = iweight1[i] << (dv_quant_shifts[s][c] + 1);
247 *factor2++ = (*factor1++) << 1;
248 }
249 }
250 }
251 }
252 }
253 }
254
255 return 0;
256 }
257
258 static av_cold int dvvideo_init(AVCodecContext *avctx)
259 {
260 DVVideoContext *s = avctx->priv_data;
261 DSPContext dsp;
262 static int done = 0;
263 int i, j;
264
265 if (!done) {
266 VLC dv_vlc;
267 uint16_t new_dv_vlc_bits[NB_DV_VLC*2];
268 uint8_t new_dv_vlc_len[NB_DV_VLC*2];
269 uint8_t new_dv_vlc_run[NB_DV_VLC*2];
270 int16_t new_dv_vlc_level[NB_DV_VLC*2];
271
272 done = 1;
273
274 /* it's faster to include sign bit in a generic VLC parsing scheme */
275 for (i = 0, j = 0; i < NB_DV_VLC; i++, j++) {
276 new_dv_vlc_bits[j] = dv_vlc_bits[i];
277 new_dv_vlc_len[j] = dv_vlc_len[i];
278 new_dv_vlc_run[j] = dv_vlc_run[i];
279 new_dv_vlc_level[j] = dv_vlc_level[i];
280
281 if (dv_vlc_level[i]) {
282 new_dv_vlc_bits[j] <<= 1;
283 new_dv_vlc_len[j]++;
284
285 j++;
286 new_dv_vlc_bits[j] = (dv_vlc_bits[i] << 1) | 1;
287 new_dv_vlc_len[j] = dv_vlc_len[i] + 1;
288 new_dv_vlc_run[j] = dv_vlc_run[i];
289 new_dv_vlc_level[j] = -dv_vlc_level[i];
290 }
291 }
292
293 /* NOTE: as a trick, we use the fact the no codes are unused
294 to accelerate the parsing of partial codes */
295 init_vlc(&dv_vlc, TEX_VLC_BITS, j,
296 new_dv_vlc_len, 1, 1, new_dv_vlc_bits, 2, 2, 0);
297 assert(dv_vlc.table_size == 1184);
298
299 for (i = 0; i < dv_vlc.table_size; i++){
300 int code = dv_vlc.table[i][0];
301 int len = dv_vlc.table[i][1];
302 int level, run;
303
304 if (len < 0){ //more bits needed
305 run = 0;
306 level = code;
307 } else {
308 run = new_dv_vlc_run [code] + 1;
309 level = new_dv_vlc_level[code];
310 }
311 dv_rl_vlc[i].len = len;
312 dv_rl_vlc[i].level = level;
313 dv_rl_vlc[i].run = run;
314 }
315 free_vlc(&dv_vlc);
316
317 dv_vlc_map_tableinit();
318 }
319
320 /* Generic DSP setup */
321 dsputil_init(&dsp, avctx);
322 ff_set_cmp(&dsp, dsp.ildct_cmp, avctx->ildct_cmp);
323 s->get_pixels = dsp.get_pixels;
324 s->ildct_cmp = dsp.ildct_cmp[5];
325
326 /* 88DCT setup */
327 s->fdct[0] = dsp.fdct;
328 s->idct_put[0] = dsp.idct_put;
329 for (i = 0; i < 64; i++)
330 s->dv_zigzag[0][i] = dsp.idct_permutation[ff_zigzag_direct[i]];
331
332 /* 248DCT setup */
333 s->fdct[1] = dsp.fdct248;
334 s->idct_put[1] = ff_simple_idct248_put; // FIXME: need to add it to DSP
335 if (avctx->lowres){
336 for (i = 0; i < 64; i++){
337 int j = ff_zigzag248_direct[i];
338 s->dv_zigzag[1][i] = dsp.idct_permutation[(j & 7) + (j & 8) * 4 + (j & 48) / 2];
339 }
340 }else
341 memcpy(s->dv_zigzag[1], ff_zigzag248_direct, 64);
342
343 avctx->coded_frame = &s->picture;
344 s->avctx = avctx;
345 avctx->chroma_sample_location = AVCHROMA_LOC_TOPLEFT;
346
347 return 0;
348 }
349
350 static av_cold int dvvideo_init_encoder(AVCodecContext *avctx)
351 {
352 if (!ff_dv_codec_profile(avctx)) {
353 av_log(avctx, AV_LOG_ERROR, "Found no DV profile for %ix%i %s video\n",
354 avctx->width, avctx->height, av_get_pix_fmt_name(avctx->pix_fmt));
355 return -1;
356 }
357
358 return dvvideo_init(avctx);
359 }
360
361 typedef struct BlockInfo {
362 const uint32_t *factor_table;
363 const uint8_t *scan_table;
364 uint8_t pos; /* position in block */
365 void (*idct_put)(uint8_t *dest, int line_size, DCTELEM *block);
366 uint8_t partial_bit_count;
367 uint16_t partial_bit_buffer;
368 int shift_offset;
369 } BlockInfo;
370
371 /* bit budget for AC only in 5 MBs */
372 static const int vs_total_ac_bits = (100 * 4 + 68*2) * 5;
373 static const int mb_area_start[5] = { 1, 6, 21, 43, 64 };
374
375 static inline int put_bits_left(PutBitContext* s)
376 {
377 return (s->buf_end - s->buf) * 8 - put_bits_count(s);
378 }
379
380 /* decode AC coefficients */
381 static void dv_decode_ac(GetBitContext *gb, BlockInfo *mb, DCTELEM *block)
382 {
383 int last_index = gb->size_in_bits;
384 const uint8_t *scan_table = mb->scan_table;
385 const uint32_t *factor_table = mb->factor_table;
386 int pos = mb->pos;
387 int partial_bit_count = mb->partial_bit_count;
388 int level, run, vlc_len, index;
389
390 OPEN_READER(re, gb);
391 UPDATE_CACHE(re, gb);
392
393 /* if we must parse a partial VLC, we do it here */
394 if (partial_bit_count > 0) {
395 re_cache = ((unsigned)re_cache >> partial_bit_count) |
396 (mb->partial_bit_buffer << (sizeof(re_cache) * 8 - partial_bit_count));
397 re_index -= partial_bit_count;
398 mb->partial_bit_count = 0;
399 }
400
401 /* get the AC coefficients until last_index is reached */
402 for (;;) {
403 av_dlog(NULL, "%2d: bits=%04x index=%d\n", pos, SHOW_UBITS(re, gb, 16),
404 re_index);
405 /* our own optimized GET_RL_VLC */
406 index = NEG_USR32(re_cache, TEX_VLC_BITS);
407 vlc_len = dv_rl_vlc[index].len;
408 if (vlc_len < 0) {
409 index = NEG_USR32((unsigned)re_cache << TEX_VLC_BITS, -vlc_len) + dv_rl_vlc[index].level;
410 vlc_len = TEX_VLC_BITS - vlc_len;
411 }
412 level = dv_rl_vlc[index].level;
413 run = dv_rl_vlc[index].run;
414
415 /* gotta check if we're still within gb boundaries */
416 if (re_index + vlc_len > last_index) {
417 /* should be < 16 bits otherwise a codeword could have been parsed */
418 mb->partial_bit_count = last_index - re_index;
419 mb->partial_bit_buffer = NEG_USR32(re_cache, mb->partial_bit_count);
420 re_index = last_index;
421 break;
422 }
423 re_index += vlc_len;
424
425 av_dlog(NULL, "run=%d level=%d\n", run, level);
426 pos += run;
427 if (pos >= 64)
428 break;
429
430 level = (level * factor_table[pos] + (1 << (dv_iweight_bits - 1))) >> dv_iweight_bits;
431 block[scan_table[pos]] = level;
432
433 UPDATE_CACHE(re, gb);
434 }
435 CLOSE_READER(re, gb);
436 mb->pos = pos;
437 }
438
439 static inline void bit_copy(PutBitContext *pb, GetBitContext *gb)
440 {
441 int bits_left = get_bits_left(gb);
442 while (bits_left >= MIN_CACHE_BITS) {
443 put_bits(pb, MIN_CACHE_BITS, get_bits(gb, MIN_CACHE_BITS));
444 bits_left -= MIN_CACHE_BITS;
445 }
446 if (bits_left > 0) {
447 put_bits(pb, bits_left, get_bits(gb, bits_left));
448 }
449 }
450
451 static inline void dv_calculate_mb_xy(DVVideoContext *s, DVwork_chunk *work_chunk, int m, int *mb_x, int *mb_y)
452 {
453 *mb_x = work_chunk->mb_coordinates[m] & 0xff;
454 *mb_y = work_chunk->mb_coordinates[m] >> 8;
455
456 /* We work with 720p frames split in half. The odd half-frame (chan==2,3) is displaced :-( */
457 if (s->sys->height == 720 && !(s->buf[1]&0x0C)) {
458 *mb_y -= (*mb_y>17)?18:-72; /* shifting the Y coordinate down by 72/2 macro blocks */
459 }
460 }
461
462 /* mb_x and mb_y are in units of 8 pixels */
463 static int dv_decode_video_segment(AVCodecContext *avctx, void *arg)
464 {
465 DVVideoContext *s = avctx->priv_data;
466 DVwork_chunk *work_chunk = arg;
467 int quant, dc, dct_mode, class1, j;
468 int mb_index, mb_x, mb_y, last_index;
469 int y_stride, linesize;
470 DCTELEM *block, *block1;
471 int c_offset;
472 uint8_t *y_ptr;
473 const uint8_t *buf_ptr;
474 PutBitContext pb, vs_pb;
475 GetBitContext gb;
476 BlockInfo mb_data[5 * DV_MAX_BPM], *mb, *mb1;
477 LOCAL_ALIGNED_16(DCTELEM, sblock, [5*DV_MAX_BPM], [64]);
478 LOCAL_ALIGNED_16(uint8_t, mb_bit_buffer, [ 80 + FF_INPUT_BUFFER_PADDING_SIZE]); /* allow some slack */
479 LOCAL_ALIGNED_16(uint8_t, vs_bit_buffer, [5*80 + FF_INPUT_BUFFER_PADDING_SIZE]); /* allow some slack */
480 const int log2_blocksize = 3-s->avctx->lowres;
481 int is_field_mode[5];
482
483 assert((((int)mb_bit_buffer) & 7) == 0);
484 assert((((int)vs_bit_buffer) & 7) == 0);
485
486 memset(sblock, 0, 5*DV_MAX_BPM*sizeof(*sblock));
487
488 /* pass 1: read DC and AC coefficients in blocks */
489 buf_ptr = &s->buf[work_chunk->buf_offset*80];
490 block1 = &sblock[0][0];
491 mb1 = mb_data;
492 init_put_bits(&vs_pb, vs_bit_buffer, 5 * 80);
493 for (mb_index = 0; mb_index < 5; mb_index++, mb1 += s->sys->bpm, block1 += s->sys->bpm * 64) {
494 /* skip header */
495 quant = buf_ptr[3] & 0x0f;
496 buf_ptr += 4;
497 init_put_bits(&pb, mb_bit_buffer, 80);
498 mb = mb1;
499 block = block1;
500 is_field_mode[mb_index] = 0;
501 for (j = 0; j < s->sys->bpm; j++) {
502 last_index = s->sys->block_sizes[j];
503 init_get_bits(&gb, buf_ptr, last_index);
504
505 /* get the DC */
506 dc = get_sbits(&gb, 9);
507 dct_mode = get_bits1(&gb);
508 class1 = get_bits(&gb, 2);
509 if (DV_PROFILE_IS_HD(s->sys)) {
510 mb->idct_put = s->idct_put[0];
511 mb->scan_table = s->dv_zigzag[0];
512 mb->factor_table = &s->sys->idct_factor[(j >= 4)*4*16*64 + class1*16*64 + quant*64];
513 is_field_mode[mb_index] |= !j && dct_mode;
514 } else {
515 mb->idct_put = s->idct_put[dct_mode && log2_blocksize == 3];
516 mb->scan_table = s->dv_zigzag[dct_mode];
517 mb->factor_table = &s->sys->idct_factor[(class1 == 3)*2*22*64 + dct_mode*22*64 +
518 (quant + dv_quant_offset[class1])*64];
519 }
520 dc = dc << 2;
521 /* convert to unsigned because 128 is not added in the
522 standard IDCT */
523 dc += 1024;
524 block[0] = dc;
525 buf_ptr += last_index >> 3;
526 mb->pos = 0;
527 mb->partial_bit_count = 0;
528
529 av_dlog(avctx, "MB block: %d, %d ", mb_index, j);
530 dv_decode_ac(&gb, mb, block);
531
532 /* write the remaining bits in a new buffer only if the
533 block is finished */
534 if (mb->pos >= 64)
535 bit_copy(&pb, &gb);
536
537 block += 64;
538 mb++;
539 }
540
541 /* pass 2: we can do it just after */
542 av_dlog(avctx, "***pass 2 size=%d MB#=%d\n", put_bits_count(&pb), mb_index);
543 block = block1;
544 mb = mb1;
545 init_get_bits(&gb, mb_bit_buffer, put_bits_count(&pb));
546 put_bits32(&pb, 0); // padding must be zeroed
547 flush_put_bits(&pb);
548 for (j = 0; j < s->sys->bpm; j++, block += 64, mb++) {
549 if (mb->pos < 64 && get_bits_left(&gb) > 0) {
550 dv_decode_ac(&gb, mb, block);
551 /* if still not finished, no need to parse other blocks */
552 if (mb->pos < 64)
553 break;
554 }
555 }
556 /* all blocks are finished, so the extra bytes can be used at
557 the video segment level */
558 if (j >= s->sys->bpm)
559 bit_copy(&vs_pb, &gb);
560 }
561
562 /* we need a pass over the whole video segment */
563 av_dlog(avctx, "***pass 3 size=%d\n", put_bits_count(&vs_pb));
564 block = &sblock[0][0];
565 mb = mb_data;
566 init_get_bits(&gb, vs_bit_buffer, put_bits_count(&vs_pb));
567 put_bits32(&vs_pb, 0); // padding must be zeroed
568 flush_put_bits(&vs_pb);
569 for (mb_index = 0; mb_index < 5; mb_index++) {
570 for (j = 0; j < s->sys->bpm; j++) {
571 if (mb->pos < 64) {
572 av_dlog(avctx, "start %d:%d\n", mb_index, j);
573 dv_decode_ac(&gb, mb, block);
574 }
575 if (mb->pos >= 64 && mb->pos < 127)
576 av_log(avctx, AV_LOG_ERROR, "AC EOB marker is absent pos=%d\n", mb->pos);
577 block += 64;
578 mb++;
579 }
580 }
581
582 /* compute idct and place blocks */
583 block = &sblock[0][0];
584 mb = mb_data;
585 for (mb_index = 0; mb_index < 5; mb_index++) {
586 dv_calculate_mb_xy(s, work_chunk, mb_index, &mb_x, &mb_y);
587
588 /* idct_put'ting luminance */
589 if ((s->sys->pix_fmt == PIX_FMT_YUV420P) ||
590 (s->sys->pix_fmt == PIX_FMT_YUV411P && mb_x >= (704 / 8)) ||
591 (s->sys->height >= 720 && mb_y != 134)) {
592 y_stride = (s->picture.linesize[0] << ((!is_field_mode[mb_index]) * log2_blocksize));
593 } else {
594 y_stride = (2 << log2_blocksize);
595 }
596 y_ptr = s->picture.data[0] + ((mb_y * s->picture.linesize[0] + mb_x) << log2_blocksize);
597 linesize = s->picture.linesize[0] << is_field_mode[mb_index];
598 mb[0] .idct_put(y_ptr , linesize, block + 0*64);
599 if (s->sys->video_stype == 4) { /* SD 422 */
600 mb[2].idct_put(y_ptr + (1 << log2_blocksize) , linesize, block + 2*64);
601 } else {
602 mb[1].idct_put(y_ptr + (1 << log2_blocksize) , linesize, block + 1*64);
603 mb[2].idct_put(y_ptr + y_stride, linesize, block + 2*64);
604 mb[3].idct_put(y_ptr + (1 << log2_blocksize) + y_stride, linesize, block + 3*64);
605 }
606 mb += 4;
607 block += 4*64;
608
609 /* idct_put'ting chrominance */
610 c_offset = (((mb_y >> (s->sys->pix_fmt == PIX_FMT_YUV420P)) * s->picture.linesize[1] +
611 (mb_x >> ((s->sys->pix_fmt == PIX_FMT_YUV411P) ? 2 : 1))) << log2_blocksize);
612 for (j = 2; j; j--) {
613 uint8_t *c_ptr = s->picture.data[j] + c_offset;
614 if (s->sys->pix_fmt == PIX_FMT_YUV411P && mb_x >= (704 / 8)) {
615 uint64_t aligned_pixels[64/8];
616 uint8_t *pixels = (uint8_t*)aligned_pixels;
617 uint8_t *c_ptr1, *ptr1;
618 int x, y;
619 mb->idct_put(pixels, 8, block);
620 for (y = 0; y < (1 << log2_blocksize); y++, c_ptr += s->picture.linesize[j], pixels += 8) {
621 ptr1 = pixels + (1 << (log2_blocksize - 1));
622 c_ptr1 = c_ptr + (s->picture.linesize[j] << log2_blocksize);
623 for (x = 0; x < (1 << (log2_blocksize - 1)); x++) {
624 c_ptr[x] = pixels[x];
625 c_ptr1[x] = ptr1[x];
626 }
627 }
628 block += 64; mb++;
629 } else {
630 y_stride = (mb_y == 134) ? (1 << log2_blocksize) :
631 s->picture.linesize[j] << ((!is_field_mode[mb_index]) * log2_blocksize);
632 linesize = s->picture.linesize[j] << is_field_mode[mb_index];
633 (mb++)-> idct_put(c_ptr , linesize, block); block += 64;
634 if (s->sys->bpm == 8) {
635 (mb++)->idct_put(c_ptr + y_stride, linesize, block); block += 64;
636 }
637 }
638 }
639 }
640 return 0;
641 }
642
643 #if CONFIG_SMALL
644 /* Converts run and level (where level != 0) pair into VLC, returning bit size */
645 static av_always_inline int dv_rl2vlc(int run, int level, int sign, uint32_t* vlc)
646 {
647 int size;
648 if (run < DV_VLC_MAP_RUN_SIZE && level < DV_VLC_MAP_LEV_SIZE) {
649 *vlc = dv_vlc_map[run][level].vlc | sign;
650 size = dv_vlc_map[run][level].size;
651 }
652 else {
653 if (level < DV_VLC_MAP_LEV_SIZE) {
654 *vlc = dv_vlc_map[0][level].vlc | sign;
655 size = dv_vlc_map[0][level].size;
656 } else {
657 *vlc = 0xfe00 | (level << 1) | sign;
658 size = 16;
659 }
660 if (run) {
661 *vlc |= ((run < 16) ? dv_vlc_map[run-1][0].vlc :
662 (0x1f80 | (run - 1))) << size;
663 size += (run < 16) ? dv_vlc_map[run-1][0].size : 13;
664 }
665 }
666
667 return size;
668 }
669
670 static av_always_inline int dv_rl2vlc_size(int run, int level)
671 {
672 int size;
673
674 if (run < DV_VLC_MAP_RUN_SIZE && level < DV_VLC_MAP_LEV_SIZE) {
675 size = dv_vlc_map[run][level].size;
676 }
677 else {
678 size = (level < DV_VLC_MAP_LEV_SIZE) ? dv_vlc_map[0][level].size : 16;
679 if (run) {
680 size += (run < 16) ? dv_vlc_map[run-1][0].size : 13;
681 }
682 }
683 return size;
684 }
685 #else
686 static av_always_inline int dv_rl2vlc(int run, int l, int sign, uint32_t* vlc)
687 {
688 *vlc = dv_vlc_map[run][l].vlc | sign;
689 return dv_vlc_map[run][l].size;
690 }
691
692 static av_always_inline int dv_rl2vlc_size(int run, int l)
693 {
694 return dv_vlc_map[run][l].size;
695 }
696 #endif
697
698 typedef struct EncBlockInfo {
699 int area_q[4];
700 int bit_size[4];
701 int prev[5];
702 int cur_ac;
703 int cno;
704 int dct_mode;
705 DCTELEM mb[64];
706 uint8_t next[64];
707 uint8_t sign[64];
708 uint8_t partial_bit_count;
709 uint32_t partial_bit_buffer; /* we can't use uint16_t here */
710 } EncBlockInfo;
711
712 static av_always_inline PutBitContext* dv_encode_ac(EncBlockInfo* bi,
713 PutBitContext* pb_pool,
714 PutBitContext* pb_end)
715 {
716 int prev, bits_left;
717 PutBitContext* pb = pb_pool;
718 int size = bi->partial_bit_count;
719 uint32_t vlc = bi->partial_bit_buffer;
720
721 bi->partial_bit_count = bi->partial_bit_buffer = 0;
722 for (;;){
723 /* Find suitable storage space */
724 for (; size > (bits_left = put_bits_left(pb)); pb++) {
725 if (bits_left) {
726 size -= bits_left;
727 put_bits(pb, bits_left, vlc >> size);
728 vlc = vlc & ((1 << size) - 1);
729 }
730 if (pb + 1 >= pb_end) {
731 bi->partial_bit_count = size;
732 bi->partial_bit_buffer = vlc;
733 return pb;
734 }
735 }
736
737 /* Store VLC */
738 put_bits(pb, size, vlc);
739
740 if (bi->cur_ac >= 64)
741 break;
742
743 /* Construct the next VLC */
744 prev = bi->cur_ac;
745 bi->cur_ac = bi->next[prev];
746 if (bi->cur_ac < 64){
747 size = dv_rl2vlc(bi->cur_ac - prev - 1, bi->mb[bi->cur_ac], bi->sign[bi->cur_ac], &vlc);
748 } else {
749 size = 4; vlc = 6; /* End Of Block stamp */
750 }
751 }
752 return pb;
753 }
754
755 static av_always_inline int dv_guess_dct_mode(DVVideoContext *s, uint8_t *data, int linesize) {
756 if (s->avctx->flags & CODEC_FLAG_INTERLACED_DCT) {
757 int ps = s->ildct_cmp(NULL, data, NULL, linesize, 8) - 400;
758 if (ps > 0) {
759 int is = s->ildct_cmp(NULL, data , NULL, linesize<<1, 4) +
760 s->ildct_cmp(NULL, data + linesize, NULL, linesize<<1, 4);
761 return (ps > is);
762 }
763 }
764
765 return 0;
766 }
767
768 static av_always_inline int dv_init_enc_block(EncBlockInfo* bi, uint8_t *data, int linesize, DVVideoContext *s, int bias)
769 {
770 const int *weight;
771 const uint8_t* zigzag_scan;
772 LOCAL_ALIGNED_16(DCTELEM, blk, [64]);
773 int i, area;
774 /* We offer two different methods for class number assignment: the
775 method suggested in SMPTE 314M Table 22, and an improved
776 method. The SMPTE method is very conservative; it assigns class
777 3 (i.e. severe quantization) to any block where the largest AC
778 component is greater than 36. Libav's DV encoder tracks AC bit
779 consumption precisely, so there is no need to bias most blocks
780 towards strongly lossy compression. Instead, we assign class 2
781 to most blocks, and use class 3 only when strictly necessary
782 (for blocks whose largest AC component exceeds 255). */
783
784 #if 0 /* SMPTE spec method */
785 static const int classes[] = {12, 24, 36, 0xffff};
786 #else /* improved Libav method */
787 static const int classes[] = {-1, -1, 255, 0xffff};
788 #endif
789 int max = classes[0];
790 int prev = 0;
791
792 assert((((int)blk) & 15) == 0);
793
794 bi->area_q[0] = bi->area_q[1] = bi->area_q[2] = bi->area_q[3] = 0;
795 bi->partial_bit_count = 0;
796 bi->partial_bit_buffer = 0;
797 bi->cur_ac = 0;
798 if (data) {
799 bi->dct_mode = dv_guess_dct_mode(s, data, linesize);
800 s->get_pixels(blk, data, linesize);
801 s->fdct[bi->dct_mode](blk);
802 } else {
803 /* We rely on the fact that encoding all zeros leads to an immediate EOB,
804 which is precisely what the spec calls for in the "dummy" blocks. */
805 memset(blk, 0, 64*sizeof(*blk));
806 bi->dct_mode = 0;
807 }
808 bi->mb[0] = blk[0];
809
810 zigzag_scan = bi->dct_mode ? ff_zigzag248_direct : ff_zigzag_direct;
811 weight = bi->dct_mode ? dv_weight_248 : dv_weight_88;
812
813 for (area = 0; area < 4; area++) {
814 bi->prev[area] = prev;
815 bi->bit_size[area] = 1; // 4 areas 4 bits for EOB :)
816 for (i = mb_area_start[area]; i < mb_area_start[area+1]; i++) {
817 int level = blk[zigzag_scan[i]];
818
819 if (level + 15 > 30U) {
820 bi->sign[i] = (level >> 31) & 1;
821 /* weight it and and shift down into range, adding for rounding */
822 /* the extra division by a factor of 2^4 reverses the 8x expansion of the DCT
823 AND the 2x doubling of the weights */
824 level = (FFABS(level) * weight[i] + (1 << (dv_weight_bits+3))) >> (dv_weight_bits+4);
825 bi->mb[i] = level;
826 if (level > max)
827 max = level;
828 bi->bit_size[area] += dv_rl2vlc_size(i - prev - 1, level);
829 bi->next[prev]= i;
830 prev = i;
831 }
832 }
833 }
834 bi->next[prev]= i;
835 for (bi->cno = 0; max > classes[bi->cno]; bi->cno++);
836
837 bi->cno += bias;
838
839 if (bi->cno >= 3) {
840 bi->cno = 3;
841 prev = 0;
842 i = bi->next[prev];
843 for (area = 0; area < 4; area++) {
844 bi->prev[area] = prev;
845 bi->bit_size[area] = 1; // 4 areas 4 bits for EOB :)
846 for (; i < mb_area_start[area+1]; i = bi->next[i]) {
847 bi->mb[i] >>= 1;
848
849 if (bi->mb[i]) {
850 bi->bit_size[area] += dv_rl2vlc_size(i - prev - 1, bi->mb[i]);
851 bi->next[prev]= i;
852 prev = i;
853 }
854 }
855 }
856 bi->next[prev]= i;
857 }
858
859 return bi->bit_size[0] + bi->bit_size[1] + bi->bit_size[2] + bi->bit_size[3];
860 }
861
862 static inline void dv_guess_qnos(EncBlockInfo* blks, int* qnos)
863 {
864 int size[5];
865 int i, j, k, a, prev, a2;
866 EncBlockInfo* b;
867
868 size[0] = size[1] = size[2] = size[3] = size[4] = 1 << 24;
869 do {
870 b = blks;
871 for (i = 0; i < 5; i++) {
872 if (!qnos[i])
873 continue;
874
875 qnos[i]--;
876 size[i] = 0;
877 for (j = 0; j < 6; j++, b++) {
878 for (a = 0; a < 4; a++) {
879 if (b->area_q[a] != dv_quant_shifts[qnos[i] + dv_quant_offset[b->cno]][a]) {
880 b->bit_size[a] = 1; // 4 areas 4 bits for EOB :)
881 b->area_q[a]++;
882 prev = b->prev[a];
883 assert(b->next[prev] >= mb_area_start[a+1] || b->mb[prev]);
884 for (k = b->next[prev] ; k < mb_area_start[a+1]; k = b->next[k]) {
885 b->mb[k] >>= 1;
886 if (b->mb[k]) {
887 b->bit_size[a] += dv_rl2vlc_size(k - prev - 1, b->mb[k]);
888 prev = k;
889 } else {
890 if (b->next[k] >= mb_area_start[a+1] && b->next[k]<64){
891 for (a2 = a + 1; b->next[k] >= mb_area_start[a2+1]; a2++)
892 b->prev[a2] = prev;
893 assert(a2 < 4);
894 assert(b->mb[b->next[k]]);
895 b->bit_size[a2] += dv_rl2vlc_size(b->next[k] - prev - 1, b->mb[b->next[k]])
896 -dv_rl2vlc_size(b->next[k] - k - 1, b->mb[b->next[k]]);
897 assert(b->prev[a2] == k && (a2 + 1 >= 4 || b->prev[a2+1] != k));
898 b->prev[a2] = prev;
899 }
900 b->next[prev] = b->next[k];
901 }
902 }
903 b->prev[a+1]= prev;
904 }
905 size[i] += b->bit_size[a];
906 }
907 }
908 if (vs_total_ac_bits >= size[0] + size[1] + size[2] + size[3] + size[4])
909 return;
910 }
911 } while (qnos[0]|qnos[1]|qnos[2]|qnos[3]|qnos[4]);
912
913
914 for (a = 2; a == 2 || vs_total_ac_bits < size[0]; a += a){
915 b = blks;
916 size[0] = 5 * 6 * 4; //EOB
917 for (j = 0; j < 6 *5; j++, b++) {
918 prev = b->prev[0];
919 for (k = b->next[prev]; k < 64; k = b->next[k]) {
920 if (b->mb[k] < a && b->mb[k] > -a){
921 b->next[prev] = b->next[k];
922 }else{
923 size[0] += dv_rl2vlc_size(k - prev - 1, b->mb[k]);
924 prev = k;
925 }
926 }
927 }
928 }
929 }
930
931 static int dv_encode_video_segment(AVCodecContext *avctx, void *arg)
932 {
933 DVVideoContext *s = avctx->priv_data;
934 DVwork_chunk *work_chunk = arg;
935 int mb_index, i, j;
936 int mb_x, mb_y, c_offset, linesize, y_stride;
937 uint8_t* y_ptr;
938 uint8_t* dif;
939 LOCAL_ALIGNED_8(uint8_t, scratch, [64]);
940 EncBlockInfo enc_blks[5*DV_MAX_BPM];
941 PutBitContext pbs[5*DV_MAX_BPM];
942 PutBitContext* pb;
943 EncBlockInfo* enc_blk;
944 int vs_bit_size = 0;
945 int qnos[5] = {15, 15, 15, 15, 15}; /* No quantization */
946 int* qnosp = &qnos[0];
947
948 dif = &s->buf[work_chunk->buf_offset*80];
949 enc_blk = &enc_blks[0];
950 for (mb_index = 0; mb_index < 5; mb_index++) {
951 dv_calculate_mb_xy(s, work_chunk, mb_index, &mb_x, &mb_y);
952
953 /* initializing luminance blocks */
954 if ((s->sys->pix_fmt == PIX_FMT_YUV420P) ||
955 (s->sys->pix_fmt == PIX_FMT_YUV411P && mb_x >= (704 / 8)) ||
956 (s->sys->height >= 720 && mb_y != 134)) {
957 y_stride = s->picture.linesize[0] << 3;
958 } else {
959 y_stride = 16;
960 }
961 y_ptr = s->picture.data[0] + ((mb_y * s->picture.linesize[0] + mb_x) << 3);
962 linesize = s->picture.linesize[0];
963
964 if (s->sys->video_stype == 4) { /* SD 422 */
965 vs_bit_size +=
966 dv_init_enc_block(enc_blk+0, y_ptr , linesize, s, 0) +
967 dv_init_enc_block(enc_blk+1, NULL , linesize, s, 0) +
968 dv_init_enc_block(enc_blk+2, y_ptr + 8 , linesize, s, 0) +
969 dv_init_enc_block(enc_blk+3, NULL , linesize, s, 0);
970 } else {
971 vs_bit_size +=
972 dv_init_enc_block(enc_blk+0, y_ptr , linesize, s, 0) +
973 dv_init_enc_block(enc_blk+1, y_ptr + 8 , linesize, s, 0) +
974 dv_init_enc_block(enc_blk+2, y_ptr + y_stride, linesize, s, 0) +
975 dv_init_enc_block(enc_blk+3, y_ptr + 8 + y_stride, linesize, s, 0);
976 }
977 enc_blk += 4;
978
979 /* initializing chrominance blocks */
980 c_offset = (((mb_y >> (s->sys->pix_fmt == PIX_FMT_YUV420P)) * s->picture.linesize[1] +
981 (mb_x >> ((s->sys->pix_fmt == PIX_FMT_YUV411P) ? 2 : 1))) << 3);
982 for (j = 2; j; j--) {
983 uint8_t *c_ptr = s->picture.data[j] + c_offset;
984 linesize = s->picture.linesize[j];
985 y_stride = (mb_y == 134) ? 8 : (s->picture.linesize[j] << 3);
986 if (s->sys->pix_fmt == PIX_FMT_YUV411P && mb_x >= (704 / 8)) {
987 uint8_t* d;
988 uint8_t* b = scratch;
989 for (i = 0; i < 8; i++) {
990 d = c_ptr + (linesize << 3);
991 b[0] = c_ptr[0]; b[1] = c_ptr[1]; b[2] = c_ptr[2]; b[3] = c_ptr[3];
992 b[4] = d[0]; b[5] = d[1]; b[6] = d[2]; b[7] = d[3];
993 c_ptr += linesize;
994 b += 8;
995 }
996 c_ptr = scratch;
997 linesize = 8;
998 }
999
1000 vs_bit_size += dv_init_enc_block( enc_blk++, c_ptr , linesize, s, 1);
1001 if (s->sys->bpm == 8) {
1002 vs_bit_size += dv_init_enc_block(enc_blk++, c_ptr + y_stride, linesize, s, 1);
1003 }
1004 }
1005 }
1006
1007 if (vs_total_ac_bits < vs_bit_size)
1008 dv_guess_qnos(&enc_blks[0], qnosp);
1009
1010 /* DIF encoding process */
1011 for (j=0; j<5*s->sys->bpm;) {
1012 int start_mb = j;
1013
1014 dif[3] = *qnosp++;
1015 dif += 4;
1016
1017 /* First pass over individual cells only */
1018 for (i=0; i<s->sys->bpm; i++, j++) {
1019 int sz = s->sys->block_sizes[i]>>3;
1020
1021 init_put_bits(&pbs[j], dif, sz);
1022 put_sbits(&pbs[j], 9, ((enc_blks[j].mb[0] >> 3) - 1024 + 2) >> 2);
1023 put_bits(&pbs[j], 1, enc_blks[j].dct_mode);
1024 put_bits(&pbs[j], 2, enc_blks[j].cno);
1025
1026 dv_encode_ac(&enc_blks[j], &pbs[j], &pbs[j+1]);
1027 dif += sz;
1028 }
1029
1030 /* Second pass over each MB space */
1031 pb = &pbs[start_mb];
1032 for (i=0; i<s->sys->bpm; i++) {
1033 if (enc_blks[start_mb+i].partial_bit_count)
1034 pb = dv_encode_ac(&enc_blks[start_mb+i], pb, &pbs[start_mb+s->sys->bpm]);
1035 }
1036 }
1037
1038 /* Third and final pass over the whole video segment space */
1039 pb = &pbs[0];
1040 for (j=0; j<5*s->sys->bpm; j++) {
1041 if (enc_blks[j].partial_bit_count)
1042 pb = dv_encode_ac(&enc_blks[j], pb, &pbs[s->sys->bpm*5]);
1043 if (enc_blks[j].partial_bit_count)
1044 av_log(avctx, AV_LOG_ERROR, "ac bitstream overflow\n");
1045 }
1046
1047 for (j=0; j<5*s->sys->bpm; j++) {
1048 int pos;
1049 int size = pbs[j].size_in_bits >> 3;
1050 flush_put_bits(&pbs[j]);
1051 pos = put_bits_count(&pbs[j]) >> 3;
1052 if (pos > size) {
1053 av_log(avctx, AV_LOG_ERROR, "bitstream written beyond buffer size\n");
1054 return -1;
1055 }
1056 memset(pbs[j].buf + pos, 0xff, size - pos);
1057 }
1058
1059 return 0;
1060 }
1061
1062 #if CONFIG_DVVIDEO_DECODER
1063 /* NOTE: exactly one frame must be given (120000 bytes for NTSC,
1064 144000 bytes for PAL - or twice those for 50Mbps) */
1065 static int dvvideo_decode_frame(AVCodecContext *avctx,
1066 void *data, int *data_size,
1067 AVPacket *avpkt)
1068 {
1069 const uint8_t *buf = avpkt->data;
1070 int buf_size = avpkt->size;
1071 DVVideoContext *s = avctx->priv_data;
1072 const uint8_t* vsc_pack;
1073 int apt, is16_9;
1074
1075 s->sys = ff_dv_frame_profile(s->sys, buf, buf_size);
1076 if (!s->sys || buf_size < s->sys->frame_size || dv_init_dynamic_tables(s->sys)) {
1077 av_log(avctx, AV_LOG_ERROR, "could not find dv frame profile\n");
1078 return -1; /* NOTE: we only accept several full frames */
1079 }
1080
1081 if (s->picture.data[0])
1082 avctx->release_buffer(avctx, &s->picture);
1083
1084 s->picture.reference = 0;
1085 s->picture.key_frame = 1;
1086 s->picture.pict_type = AV_PICTURE_TYPE_I;
1087 avctx->pix_fmt = s->sys->pix_fmt;
1088 avctx->time_base = s->sys->time_base;
1089 avcodec_set_dimensions(avctx, s->sys->width, s->sys->height);
1090 if (avctx->get_buffer(avctx, &s->picture) < 0) {
1091 av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
1092 return -1;
1093 }
1094 s->picture.interlaced_frame = 1;
1095 s->picture.top_field_first = 0;
1096
1097 s->buf = buf;
1098 avctx->execute(avctx, dv_decode_video_segment, s->sys->work_chunks, NULL,
1099 dv_work_pool_size(s->sys), sizeof(DVwork_chunk));
1100
1101 emms_c();
1102
1103 /* return image */
1104 *data_size = sizeof(AVFrame);
1105 *(AVFrame*)data = s->picture;
1106
1107 /* Determine the codec's sample_aspect ratio from the packet */
1108 vsc_pack = buf + 80*5 + 48 + 5;
1109 if ( *vsc_pack == dv_video_control ) {
1110 apt = buf[4] & 0x07;
1111 is16_9 = (vsc_pack && ((vsc_pack[2] & 0x07) == 0x02 || (!apt && (vsc_pack[2] & 0x07) == 0x07)));
1112 avctx->sample_aspect_ratio = s->sys->sar[is16_9];
1113 }
1114
1115 return s->sys->frame_size;
1116 }
1117 #endif /* CONFIG_DVVIDEO_DECODER */
1118
1119
1120 static inline int dv_write_pack(enum dv_pack_type pack_id, DVVideoContext *c,
1121 uint8_t* buf)
1122 {
1123 /*
1124 * Here's what SMPTE314M says about these two:
1125 * (page 6) APTn, AP1n, AP2n, AP3n: These data shall be identical
1126 * as track application IDs (APTn = 001, AP1n =
1127 * 001, AP2n = 001, AP3n = 001), if the source signal
1128 * comes from a digital VCR. If the signal source is
1129 * unknown, all bits for these data shall be set to 1.
1130 * (page 12) STYPE: STYPE defines a signal type of video signal
1131 * 00000b = 4:1:1 compression
1132 * 00100b = 4:2:2 compression
1133 * XXXXXX = Reserved
1134 * Now, I've got two problems with these statements:
1135 * 1. it looks like APT == 111b should be a safe bet, but it isn't.
1136 * It seems that for PAL as defined in IEC 61834 we have to set
1137 * APT to 000 and for SMPTE314M to 001.
1138 * 2. It is not at all clear what STYPE is used for 4:2:0 PAL
1139 * compression scheme (if any).
1140 */
1141 int apt = (c->sys->pix_fmt == PIX_FMT_YUV420P ? 0 : 1);
1142
1143 uint8_t aspect = 0;
1144 if ((int)(av_q2d(c->avctx->sample_aspect_ratio) * c->avctx->width / c->avctx->height * 10) >= 17) /* 16:9 */
1145 aspect = 0x02;
1146
1147 buf[0] = (uint8_t)pack_id;
1148 switch (pack_id) {
1149 case dv_header525: /* I can't imagine why these two weren't defined as real */
1150 case dv_header625: /* packs in SMPTE314M -- they definitely look like ones */
1151 buf[1] = 0xf8 | /* reserved -- always 1 */
1152 (apt & 0x07); /* APT: Track application ID */
1153 buf[2] = (0 << 7) | /* TF1: audio data is 0 - valid; 1 - invalid */
1154 (0x0f << 3) | /* reserved -- always 1 */
1155 (apt & 0x07); /* AP1: Audio application ID */
1156 buf[3] = (0 << 7) | /* TF2: video data is 0 - valid; 1 - invalid */
1157 (0x0f << 3) | /* reserved -- always 1 */
1158 (apt & 0x07); /* AP2: Video application ID */
1159 buf[4] = (0 << 7) | /* TF3: subcode(SSYB) is 0 - valid; 1 - invalid */
1160 (0x0f << 3) | /* reserved -- always 1 */
1161 (apt & 0x07); /* AP3: Subcode application ID */
1162 break;
1163 case dv_video_source:
1164 buf[1] = 0xff; /* reserved -- always 1 */
1165 buf[2] = (1 << 7) | /* B/W: 0 - b/w, 1 - color */
1166 (1 << 6) | /* following CLF is valid - 0, invalid - 1 */
1167 (3 << 4) | /* CLF: color frames ID (see ITU-R BT.470-4) */
1168 0xf; /* reserved -- always 1 */
1169 buf[3] = (3 << 6) | /* reserved -- always 1 */
1170 (c->sys->dsf << 5) | /* system: 60fields/50fields */
1171 c->sys->video_stype; /* signal type video compression */
1172 buf[4] = 0xff; /* VISC: 0xff -- no information */
1173 break;
1174 case dv_video_control:
1175 buf[1] = (0 << 6) | /* Copy generation management (CGMS) 0 -- free */
1176 0x3f; /* reserved -- always 1 */
1177 buf[2] = 0xc8 | /* reserved -- always b11001xxx */
1178 aspect;
1179 buf[3] = (1 << 7) | /* frame/field flag 1 -- frame, 0 -- field */
1180 (1 << 6) | /* first/second field flag 0 -- field 2, 1 -- field 1 */
1181 (1 << 5) | /* frame change flag 0 -- same picture as before, 1 -- different */
1182 (1 << 4) | /* 1 - interlaced, 0 - noninterlaced */
1183 0xc; /* reserved -- always b1100 */
1184 buf[4] = 0xff; /* reserved -- always 1 */
1185 break;
1186 default:
1187 buf[1] = buf[2] = buf[3] = buf[4] = 0xff;
1188 }
1189 return 5;
1190 }
1191
1192 #if CONFIG_DVVIDEO_ENCODER
1193 static void dv_format_frame(DVVideoContext* c, uint8_t* buf)
1194 {
1195 int chan, i, j, k;
1196
1197 for (chan = 0; chan < c->sys->n_difchan; chan++) {
1198 for (i = 0; i < c->sys->difseg_size; i++) {
1199 memset(buf, 0xff, 80 * 6); /* first 6 DIF blocks are for control data */
1200
1201 /* DV header: 1DIF */
1202 buf += dv_write_dif_id(dv_sect_header, chan, i, 0, buf);
1203 buf += dv_write_pack((c->sys->dsf ? dv_header625 : dv_header525), c, buf);
1204 buf += 72; /* unused bytes */
1205
1206 /* DV subcode: 2DIFs */
1207 for (j = 0; j < 2; j++) {
1208 buf += dv_write_dif_id(dv_sect_subcode, chan, i, j, buf);
1209 for (k = 0; k < 6; k++)
1210 buf += dv_write_ssyb_id(k, (i < c->sys->difseg_size/2), buf) + 5;
1211 buf += 29; /* unused bytes */
1212 }
1213
1214 /* DV VAUX: 3DIFS */
1215 for (j = 0; j < 3; j++) {
1216 buf += dv_write_dif_id(dv_sect_vaux, chan, i, j, buf);
1217 buf += dv_write_pack(dv_video_source, c, buf);
1218 buf += dv_write_pack(dv_video_control, c, buf);
1219 buf += 7*5;
1220 buf += dv_write_pack(dv_video_source, c, buf);
1221 buf += dv_write_pack(dv_video_control, c, buf);
1222 buf += 4*5 + 2; /* unused bytes */
1223 }
1224
1225 /* DV Audio/Video: 135 Video DIFs + 9 Audio DIFs */
1226 for (j = 0; j < 135; j++) {
1227 if (j%15 == 0) {
1228 memset(buf, 0xff, 80);
1229 buf += dv_write_dif_id(dv_sect_audio, chan, i, j/15, buf);
1230 buf += 77; /* audio control & shuffled PCM audio */
1231 }
1232 buf += dv_write_dif_id(dv_sect_video, chan, i, j, buf);
1233 buf += 77; /* 1 video macroblock: 1 bytes control
1234 4 * 14 bytes Y 8x8 data
1235 10 bytes Cr 8x8 data
1236 10 bytes Cb 8x8 data */
1237 }
1238 }
1239 }
1240 }
1241
1242
1243 static int dvvideo_encode_frame(AVCodecContext *c, uint8_t *buf, int buf_size,
1244 void *data)
1245 {
1246 DVVideoContext *s = c->priv_data;
1247
1248 s->sys = ff_dv_codec_profile(c);
1249 if (!s->sys || buf_size < s->sys->frame_size || dv_init_dynamic_tables(s->sys))
1250 return -1;
1251
1252 c->pix_fmt = s->sys->pix_fmt;
1253 s->picture = *((AVFrame *)data);
1254 s->picture.key_frame = 1;
1255 s->picture.pict_type = AV_PICTURE_TYPE_I;
1256
1257 s->buf = buf;
1258 c->execute(c, dv_encode_video_segment, s->sys->work_chunks, NULL,
1259 dv_work_pool_size(s->sys), sizeof(DVwork_chunk));
1260
1261 emms_c();
1262
1263 dv_format_frame(s, buf);
1264
1265 return s->sys->frame_size;
1266 }
1267 #endif
1268
1269 static int dvvideo_close(AVCodecContext *c)
1270 {
1271 DVVideoContext *s = c->priv_data;
1272
1273 if (s->picture.data[0])
1274 c->release_buffer(c, &s->picture);
1275
1276 return 0;
1277 }
1278
1279
1280 #if CONFIG_DVVIDEO_ENCODER
1281 AVCodec ff_dvvideo_encoder = {
1282 "dvvideo",
1283 AVMEDIA_TYPE_VIDEO,
1284 CODEC_ID_DVVIDEO,
1285 sizeof(DVVideoContext),
1286 dvvideo_init_encoder,
1287 dvvideo_encode_frame,
1288 .capabilities = CODEC_CAP_SLICE_THREADS,
1289 .pix_fmts = (const enum PixelFormat[]) {PIX_FMT_YUV411P, PIX_FMT_YUV422P, PIX_FMT_YUV420P, PIX_FMT_NONE},
1290 .long_name = NULL_IF_CONFIG_SMALL("DV (Digital Video)"),
1291 };
1292 #endif // CONFIG_DVVIDEO_ENCODER
1293
1294 #if CONFIG_DVVIDEO_DECODER
1295 AVCodec ff_dvvideo_decoder = {
1296 "dvvideo",
1297 AVMEDIA_TYPE_VIDEO,
1298 CODEC_ID_DVVIDEO,
1299 sizeof(DVVideoContext),
1300 dvvideo_init,
1301 NULL,
1302 dvvideo_close,
1303 dvvideo_decode_frame,
1304 CODEC_CAP_DR1 | CODEC_CAP_SLICE_THREADS,
1305 NULL,
1306 .max_lowres = 3,
1307 .long_name = NULL_IF_CONFIG_SMALL("DV (Digital Video)"),
1308 };
1309 #endif