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