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