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