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 get_bits_size(GetBitContext *s)
 275 {
 276     return s->size_in_bits;
 277 }
 278
 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 */
 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
 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 */
 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 */
 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
 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
 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
 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
 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
 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))
 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
 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
 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
 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
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) */
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
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
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
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
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