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