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