libavcodec/dv.c

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