LCOV - code coverage report
Current view: top level - libavcodec - dvdec.c (source / functions) Hit Total Coverage
Test: coverage.info Lines: 234 264 88.6 %
Date: 2017-12-15 18:13:28 Functions: 6 6 100.0 %

          Line data    Source code
       1             : /*
       2             :  * DV decoder
       3             :  * Copyright (c) 2002 Fabrice Bellard
       4             :  * Copyright (c) 2004 Roman Shaposhnik
       5             :  *
       6             :  * 50 Mbps (DVCPRO50) support
       7             :  * Copyright (c) 2006 Daniel Maas <dmaas@maasdigital.com>
       8             :  *
       9             :  * 100 Mbps (DVCPRO HD) support
      10             :  * Initial code by Daniel Maas <dmaas@maasdigital.com> (funded by BBC R&D)
      11             :  * Final code by Roman Shaposhnik
      12             :  *
      13             :  * Many thanks to Dan Dennedy <dan@dennedy.org> for providing wealth
      14             :  * of DV technical info.
      15             :  *
      16             :  * This file is part of FFmpeg.
      17             :  *
      18             :  * FFmpeg is free software; you can redistribute it and/or
      19             :  * modify it under the terms of the GNU Lesser General Public
      20             :  * License as published by the Free Software Foundation; either
      21             :  * version 2.1 of the License, or (at your option) any later version.
      22             :  *
      23             :  * FFmpeg is distributed in the hope that it will be useful,
      24             :  * but WITHOUT ANY WARRANTY; without even the implied warranty of
      25             :  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
      26             :  * Lesser General Public License for more details.
      27             :  *
      28             :  * You should have received a copy of the GNU Lesser General Public
      29             :  * License along with FFmpeg; if not, write to the Free Software
      30             :  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
      31             :  */
      32             : 
      33             : /**
      34             :  * @file
      35             :  * DV decoder
      36             :  */
      37             : 
      38             : #include "libavutil/avassert.h"
      39             : #include "libavutil/imgutils.h"
      40             : #include "libavutil/internal.h"
      41             : #include "libavutil/pixdesc.h"
      42             : 
      43             : #include "avcodec.h"
      44             : #include "dv.h"
      45             : #include "dv_profile_internal.h"
      46             : #include "dvdata.h"
      47             : #include "get_bits.h"
      48             : #include "idctdsp.h"
      49             : #include "internal.h"
      50             : #include "put_bits.h"
      51             : #include "simple_idct.h"
      52             : 
      53             : typedef struct BlockInfo {
      54             :     const uint32_t *factor_table;
      55             :     const uint8_t *scan_table;
      56             :     uint8_t pos; /* position in block */
      57             :     void (*idct_put)(uint8_t *dest, ptrdiff_t stride, int16_t *block);
      58             :     uint8_t partial_bit_count;
      59             :     uint32_t partial_bit_buffer;
      60             :     int shift_offset;
      61             : } BlockInfo;
      62             : 
      63             : static const int dv_iweight_bits = 14;
      64             : 
      65             : static const uint16_t dv_iweight_88[64] = {
      66             :     32768, 16705, 16705, 17734, 17032, 17734, 18205, 18081,
      67             :     18081, 18205, 18725, 18562, 19195, 18562, 18725, 19266,
      68             :     19091, 19705, 19705, 19091, 19266, 21407, 19643, 20267,
      69             :     20228, 20267, 19643, 21407, 22725, 21826, 20853, 20806,
      70             :     20806, 20853, 21826, 22725, 23170, 23170, 21407, 21400,
      71             :     21407, 23170, 23170, 24598, 23786, 22018, 22018, 23786,
      72             :     24598, 25251, 24465, 22654, 24465, 25251, 25972, 25172,
      73             :     25172, 25972, 26722, 27969, 26722, 29692, 29692, 31521,
      74             : };
      75             : static const uint16_t dv_iweight_248[64] = {
      76             :     32768, 16384, 16705, 16705, 17734, 17734, 17734, 17734,
      77             :     18081, 18081, 18725, 18725, 21407, 21407, 19091, 19091,
      78             :     19195, 19195, 18205, 18205, 18725, 18725, 19705, 19705,
      79             :     20267, 20267, 21826, 21826, 23170, 23170, 20806, 20806,
      80             :     20267, 20267, 19266, 19266, 21407, 21407, 20853, 20853,
      81             :     21400, 21400, 23786, 23786, 24465, 24465, 22018, 22018,
      82             :     23170, 23170, 22725, 22725, 24598, 24598, 24465, 24465,
      83             :     25172, 25172, 27969, 27969, 25972, 25972, 29692, 29692
      84             : };
      85             : 
      86             : /**
      87             :  * The "inverse" DV100 weights are actually just the spec weights (zig-zagged).
      88             :  */
      89             : static const uint16_t dv_iweight_1080_y[64] = {
      90             :     128,  16,  16,  17,  17,  17,  18,  18,
      91             :      18,  18,  18,  18,  19,  18,  18,  19,
      92             :      19,  19,  19,  19,  19,  42,  38,  40,
      93             :      40,  40,  38,  42,  44,  43,  41,  41,
      94             :      41,  41,  43,  44,  45,  45,  42,  42,
      95             :      42,  45,  45,  48,  46,  43,  43,  46,
      96             :      48,  49,  48,  44,  48,  49, 101,  98,
      97             :      98, 101, 104, 109, 104, 116, 116, 123,
      98             : };
      99             : static const uint16_t dv_iweight_1080_c[64] = {
     100             :     128,  16,  16,  17,  17,  17,  25,  25,
     101             :      25,  25,  26,  25,  26,  25,  26,  26,
     102             :      26,  27,  27,  26,  26,  42,  38,  40,
     103             :      40,  40,  38,  42,  44,  43,  41,  41,
     104             :      41,  41,  43,  44,  91,  91,  84,  84,
     105             :      84,  91,  91,  96,  93,  86,  86,  93,
     106             :      96, 197, 191, 177, 191, 197, 203, 197,
     107             :     197, 203, 209, 219, 209, 232, 232, 246,
     108             : };
     109             : static const uint16_t dv_iweight_720_y[64] = {
     110             :     128,  16,  16,  17,  17,  17,  18,  18,
     111             :      18,  18,  18,  18,  19,  18,  18,  19,
     112             :      19,  19,  19,  19,  19,  42,  38,  40,
     113             :      40,  40,  38,  42,  44,  43,  41,  41,
     114             :      41,  41,  43,  44,  68,  68,  63,  63,
     115             :      63,  68,  68,  96,  92,  86,  86,  92,
     116             :      96,  98,  96,  88,  96,  98, 202, 196,
     117             :     196, 202, 208, 218, 208, 232, 232, 246,
     118             : };
     119             : static const uint16_t dv_iweight_720_c[64] = {
     120             :     128,  24,  24,  26,  26,  26,  36,  36,
     121             :      36,  36,  36,  36,  38,  36,  36,  38,
     122             :      38,  38,  38,  38,  38,  84,  76,  80,
     123             :      80,  80,  76,  84,  88,  86,  82,  82,
     124             :      82,  82,  86,  88, 182, 182, 168, 168,
     125             :     168, 182, 182, 192, 186, 192, 172, 186,
     126             :     192, 394, 382, 354, 382, 394, 406, 394,
     127             :     394, 406, 418, 438, 418, 464, 464, 492,
     128             : };
     129             : 
     130          39 : static void dv_init_weight_tables(DVVideoContext *ctx, const AVDVProfile *d)
     131             : {
     132             :     int j, i, c, s;
     133          39 :     uint32_t *factor1 = &ctx->idct_factor[0],
     134          39 :              *factor2 = &ctx->idct_factor[DV_PROFILE_IS_HD(d) ? 4096 : 2816];
     135             : 
     136          39 :     if (DV_PROFILE_IS_HD(d)) {
     137             :         /* quantization quanta by QNO for DV100 */
     138             :         static const uint8_t dv100_qstep[16] = {
     139             :             1, /* QNO = 0 and 1 both have no quantization */
     140             :             1,
     141             :             2, 3, 4, 5, 6, 7, 8, 16, 18, 20, 22, 24, 28, 52
     142             :         };
     143             :         const uint16_t *iweight1, *iweight2;
     144             : 
     145           0 :         if (d->height == 720) {
     146           0 :             iweight1 = &dv_iweight_720_y[0];
     147           0 :             iweight2 = &dv_iweight_720_c[0];
     148             :         } else {
     149           0 :             iweight1 = &dv_iweight_1080_y[0];
     150           0 :             iweight2 = &dv_iweight_1080_c[0];
     151             :         }
     152           0 :         for (c = 0; c < 4; c++) {
     153           0 :             for (s = 0; s < 16; s++) {
     154           0 :                 for (i = 0; i < 64; i++) {
     155           0 :                     *factor1++ = (dv100_qstep[s] << (c + 9)) * iweight1[i];
     156           0 :                     *factor2++ = (dv100_qstep[s] << (c + 9)) * iweight2[i];
     157             :                 }
     158             :             }
     159             :         }
     160             :     } else {
     161             :         static const uint8_t dv_quant_areas[4] = { 6, 21, 43, 64 };
     162          39 :         const uint16_t *iweight1 = &dv_iweight_88[0];
     163         117 :         for (j = 0; j < 2; j++, iweight1 = &dv_iweight_248[0]) {
     164        1794 :             for (s = 0; s < 22; s++) {
     165        8580 :                 for (i = c = 0; c < 4; c++) {
     166      116688 :                     for (; i < dv_quant_areas[c]; i++) {
     167      109824 :                         *factor1   = iweight1[i] << (ff_dv_quant_shifts[s][c] + 1);
     168      109824 :                         *factor2++ = (*factor1++) << 1;
     169             :                     }
     170             :                 }
     171             :             }
     172             :         }
     173             :     }
     174          39 : }
     175             : 
     176          41 : static av_cold int dvvideo_decode_init(AVCodecContext *avctx)
     177             : {
     178          41 :     DVVideoContext *s = avctx->priv_data;
     179             :     IDCTDSPContext idsp;
     180             :     int i;
     181             : 
     182          41 :     memset(&idsp,0, sizeof(idsp));
     183          41 :     ff_idctdsp_init(&idsp, avctx);
     184             : 
     185        2665 :     for (i = 0; i < 64; i++)
     186        2624 :         s->dv_zigzag[0][i] = idsp.idct_permutation[ff_zigzag_direct[i]];
     187             : 
     188          41 :     if (avctx->lowres){
     189           0 :         for (i = 0; i < 64; i++){
     190           0 :             int j = ff_dv_zigzag248_direct[i];
     191           0 :             s->dv_zigzag[1][i] = idsp.idct_permutation[(j & 7) + (j & 8) * 4 + (j & 48) / 2];
     192             :         }
     193             :     }else
     194          41 :         memcpy(s->dv_zigzag[1], ff_dv_zigzag248_direct, sizeof(s->dv_zigzag[1]));
     195             : 
     196          41 :     s->idct_put[0] = idsp.idct_put;
     197          41 :     s->idct_put[1] = ff_simple_idct248_put;
     198             : 
     199          41 :     return ff_dvvideo_init(avctx);
     200             : }
     201             : 
     202             : /* decode AC coefficients */
     203    10720645 : static void dv_decode_ac(GetBitContext *gb, BlockInfo *mb, int16_t *block)
     204             : {
     205    10720645 :     int last_index = gb->size_in_bits;
     206    10720645 :     const uint8_t  *scan_table   = mb->scan_table;
     207    10720645 :     const uint32_t *factor_table = mb->factor_table;
     208    10720645 :     int pos                      = mb->pos;
     209    10720645 :     int partial_bit_count        = mb->partial_bit_count;
     210             :     int level, run, vlc_len, index;
     211             : 
     212    10720645 :     OPEN_READER_NOSIZE(re, gb);
     213    10720645 :     UPDATE_CACHE(re, gb);
     214             : 
     215             :     /* if we must parse a partial VLC, we do it here */
     216    10720645 :     if (partial_bit_count > 0) {
     217     5179646 :         re_cache              = re_cache >> partial_bit_count |
     218     2589823 :                                 mb->partial_bit_buffer;
     219     2589823 :         re_index             -= partial_bit_count;
     220     2589823 :         mb->partial_bit_count = 0;
     221             :     }
     222             : 
     223             :     /* get the AC coefficients until last_index is reached */
     224             :     for (;;) {
     225    86404878 :         ff_dlog(NULL, "%2d: bits=%04"PRIx32" index=%u\n",
     226             :                 pos, SHOW_UBITS(re, gb, 16), re_index);
     227             :         /* our own optimized GET_RL_VLC */
     228    97125523 :         index   = NEG_USR32(re_cache, TEX_VLC_BITS);
     229    97125523 :         vlc_len = ff_dv_rl_vlc[index].len;
     230    97125523 :         if (vlc_len < 0) {
     231    18349874 :             index = NEG_USR32((unsigned) re_cache << TEX_VLC_BITS, -vlc_len) +
     232     9174937 :                     ff_dv_rl_vlc[index].level;
     233     9174937 :             vlc_len = TEX_VLC_BITS - vlc_len;
     234             :         }
     235    97125523 :         level = ff_dv_rl_vlc[index].level;
     236    97125523 :         run   = ff_dv_rl_vlc[index].run;
     237             : 
     238             :         /* gotta check if we're still within gb boundaries */
     239    97125523 :         if (re_index + vlc_len > last_index) {
     240             :             /* should be < 16 bits otherwise a codeword could have been parsed */
     241     3119567 :             mb->partial_bit_count  = last_index - re_index;
     242     3119567 :             mb->partial_bit_buffer = re_cache & ~(-1u >> mb->partial_bit_count);
     243     3119567 :             re_index               = last_index;
     244     3119567 :             break;
     245             :         }
     246    94005956 :         re_index += vlc_len;
     247             : 
     248             :         ff_dlog(NULL, "run=%d level=%d\n", run, level);
     249    94005956 :         pos += run;
     250    94005956 :         if (pos >= 64)
     251     7601078 :             break;
     252             : 
     253    86404878 :         level = (level * factor_table[pos] + (1 << (dv_iweight_bits - 1))) >>
     254             :                 dv_iweight_bits;
     255    86404878 :         block[scan_table[pos]] = level;
     256             : 
     257    86404878 :         UPDATE_CACHE(re, gb);
     258             :     }
     259    10720645 :     CLOSE_READER(re, gb);
     260    10720645 :     mb->pos = pos;
     261    10720645 : }
     262             : 
     263     5755907 : static inline void bit_copy(PutBitContext *pb, GetBitContext *gb)
     264             : {
     265     5755907 :     int bits_left = get_bits_left(gb);
     266    25341508 :     while (bits_left >= MIN_CACHE_BITS) {
     267    13829694 :         put_bits(pb, MIN_CACHE_BITS, get_bits(gb, MIN_CACHE_BITS));
     268    13829694 :         bits_left -= MIN_CACHE_BITS;
     269             :     }
     270     5755907 :     if (bits_left > 0)
     271     5563389 :         put_bits(pb, bits_left, get_bits(gb, bits_left));
     272     5755907 : }
     273             : 
     274             : /* mb_x and mb_y are in units of 8 pixels */
     275      253584 : static int dv_decode_video_segment(AVCodecContext *avctx, void *arg)
     276             : {
     277      253584 :     DVVideoContext *s = avctx->priv_data;
     278      253584 :     DVwork_chunk *work_chunk = arg;
     279             :     int quant, dc, dct_mode, class1, j;
     280             :     int mb_index, mb_x, mb_y, last_index;
     281             :     int y_stride, linesize;
     282             :     int16_t *block, *block1;
     283             :     int c_offset;
     284             :     uint8_t *y_ptr;
     285             :     const uint8_t *buf_ptr;
     286             :     PutBitContext pb, vs_pb;
     287             :     GetBitContext gb;
     288             :     BlockInfo mb_data[5 * DV_MAX_BPM], *mb, *mb1;
     289      253584 :     LOCAL_ALIGNED_16(int16_t, sblock, [5 * DV_MAX_BPM], [64]);
     290      253584 :     LOCAL_ALIGNED_16(uint8_t, mb_bit_buffer, [80     + AV_INPUT_BUFFER_PADDING_SIZE]); /* allow some slack */
     291      253584 :     LOCAL_ALIGNED_16(uint8_t, vs_bit_buffer, [80 * 5 + AV_INPUT_BUFFER_PADDING_SIZE]); /* allow some slack */
     292      253584 :     const int log2_blocksize = 3-s->avctx->lowres;
     293             :     int is_field_mode[5];
     294      253584 :     int vs_bit_buffer_damaged = 0;
     295      253584 :     int mb_bit_buffer_damaged[5] = {0};
     296      253584 :     int retried = 0;
     297             :     int sta;
     298             : 
     299             :     av_assert1((((int) mb_bit_buffer) & 7) == 0);
     300             :     av_assert1((((int) vs_bit_buffer) & 7) == 0);
     301             : 
     302      253585 : retry:
     303             : 
     304      253585 :     memset(sblock, 0, 5 * DV_MAX_BPM * sizeof(*sblock));
     305             : 
     306             :     /* pass 1: read DC and AC coefficients in blocks */
     307      253585 :     buf_ptr = &s->buf[work_chunk->buf_offset * 80];
     308      253585 :     block1  = &sblock[0][0];
     309      253585 :     mb1     = mb_data;
     310      253585 :     init_put_bits(&vs_pb, vs_bit_buffer, 5 * 80);
     311     1521510 :     for (mb_index = 0; mb_index < 5; mb_index++, mb1 += s->sys->bpm, block1 += s->sys->bpm * 64) {
     312             :         /* skip header */
     313     1267925 :         quant    = buf_ptr[3] & 0x0f;
     314     1267925 :         if (avctx->error_concealment) {
     315     1267925 :             if ((buf_ptr[3] >> 4) == 0x0E)
     316           0 :                 vs_bit_buffer_damaged = 1;
     317     1267925 :             if (!mb_index) {
     318      253585 :                 sta = buf_ptr[3] >> 4;
     319     1014340 :             } else if (sta != (buf_ptr[3] >> 4))
     320           0 :                 vs_bit_buffer_damaged = 1;
     321             :         }
     322     1267925 :         buf_ptr += 4;
     323     1267925 :         init_put_bits(&pb, mb_bit_buffer, 80);
     324     1267925 :         mb    = mb1;
     325     1267925 :         block = block1;
     326     1267925 :         is_field_mode[mb_index] = 0;
     327     8875475 :         for (j = 0; j < s->sys->bpm; j++) {
     328     7607550 :             last_index = s->sys->block_sizes[j];
     329     7607550 :             init_get_bits(&gb, buf_ptr, last_index);
     330             : 
     331             :             /* get the DC */
     332     7607550 :             dc       = get_sbits(&gb, 9);
     333     7607550 :             dct_mode = get_bits1(&gb);
     334     7607550 :             class1   = get_bits(&gb, 2);
     335     7607550 :             if (DV_PROFILE_IS_HD(s->sys)) {
     336           0 :                 mb->idct_put     = s->idct_put[0];
     337           0 :                 mb->scan_table   = s->dv_zigzag[0];
     338           0 :                 mb->factor_table = &s->idct_factor[(j >= 4) * 4 * 16 * 64 +
     339           0 :                                                    class1       * 16 * 64 +
     340           0 :                                                    quant             * 64];
     341           0 :                 is_field_mode[mb_index] |= !j && dct_mode;
     342             :             } else {
     343     7607550 :                 mb->idct_put     = s->idct_put[dct_mode && log2_blocksize == 3];
     344     7607550 :                 mb->scan_table   = s->dv_zigzag[dct_mode];
     345     7607550 :                 mb->factor_table =
     346    22822650 :                     &s->idct_factor[(class1 == 3)               * 2 * 22 * 64 +
     347    15215100 :                                     dct_mode                        * 22 * 64 +
     348     7607550 :                                     (quant + ff_dv_quant_offset[class1]) * 64];
     349             :             }
     350     7607550 :             dc = dc * 4;
     351             :             /* convert to unsigned because 128 is not added in the
     352             :              * standard IDCT */
     353     7607550 :             dc                   += 1024;
     354     7607550 :             block[0]              = dc;
     355     7607550 :             buf_ptr              += last_index >> 3;
     356     7607550 :             mb->pos               = 0;
     357     7607550 :             mb->partial_bit_count = 0;
     358             : 
     359             :             ff_dlog(avctx, "MB block: %d, %d ", mb_index, j);
     360     7607550 :             dv_decode_ac(&gb, mb, block);
     361             : 
     362             :             /* write the remaining bits in a new buffer only if the
     363             :              * block is finished */
     364     7607550 :             if (mb->pos >= 64)
     365     4948459 :                 bit_copy(&pb, &gb);
     366     7607550 :             if (mb->pos >= 64 && mb->pos < 127)
     367           0 :                 vs_bit_buffer_damaged = mb_bit_buffer_damaged[mb_index] = 1;
     368             : 
     369     7607550 :             block += 64;
     370     7607550 :             mb++;
     371             :         }
     372             : 
     373     1267925 :         if (mb_bit_buffer_damaged[mb_index] > 0)
     374           1 :             continue;
     375             : 
     376             :         /* pass 2: we can do it just after */
     377             :         ff_dlog(avctx, "***pass 2 size=%d MB#=%d\n", put_bits_count(&pb), mb_index);
     378     1267924 :         block = block1;
     379     1267924 :         mb    = mb1;
     380     1267924 :         init_get_bits(&gb, mb_bit_buffer, put_bits_count(&pb));
     381     1267924 :         put_bits32(&pb, 0); // padding must be zeroed
     382     1267924 :         flush_put_bits(&pb);
     383     6829243 :         for (j = 0; j < s->sys->bpm; j++, block += 64, mb++) {
     384     6021795 :             if (mb->pos < 64 && get_bits_left(&gb) > 0) {
     385     1672370 :                 dv_decode_ac(&gb, mb, block);
     386             :                 /* if still not finished, no need to parse other blocks */
     387     1672370 :                 if (mb->pos < 64)
     388      460476 :                     break;
     389     1211894 :                 if (mb->pos < 127)
     390           2 :                     vs_bit_buffer_damaged = mb_bit_buffer_damaged[mb_index] = 1;
     391             :             }
     392             :         }
     393             :         /* all blocks are finished, so the extra bytes can be used at
     394             :          * the video segment level */
     395     1267924 :         if (j >= s->sys->bpm)
     396      807448 :             bit_copy(&vs_pb, &gb);
     397             :     }
     398             : 
     399             :     /* we need a pass over the whole video segment */
     400             :     ff_dlog(avctx, "***pass 3 size=%d\n", put_bits_count(&vs_pb));
     401      253585 :     block = &sblock[0][0];
     402      253585 :     mb    = mb_data;
     403      253585 :     init_get_bits(&gb, vs_bit_buffer, put_bits_count(&vs_pb));
     404      253585 :     put_bits32(&vs_pb, 0); // padding must be zeroed
     405      253585 :     flush_put_bits(&vs_pb);
     406     1521510 :     for (mb_index = 0; mb_index < 5; mb_index++) {
     407     8875475 :         for (j = 0; j < s->sys->bpm; j++) {
     408     7607550 :             if (mb->pos < 64 && get_bits_left(&gb) > 0 && !vs_bit_buffer_damaged) {
     409             :                 ff_dlog(avctx, "start %d:%d\n", mb_index, j);
     410     1440725 :                 dv_decode_ac(&gb, mb, block);
     411             :             }
     412             : 
     413     7607550 :             if (mb->pos >= 64 && mb->pos < 127) {
     414           2 :                 av_log(avctx, AV_LOG_ERROR,
     415           2 :                        "AC EOB marker is absent pos=%d\n", mb->pos);
     416           2 :                 vs_bit_buffer_damaged = 1;
     417             :             }
     418     7607550 :             block += 64;
     419     7607550 :             mb++;
     420             :         }
     421             :     }
     422      253585 :     if (vs_bit_buffer_damaged && !retried) {
     423           1 :         av_log(avctx, AV_LOG_ERROR, "Concealing bitstream errors\n");
     424           1 :         retried = 1;
     425           1 :         goto retry;
     426             :     }
     427             : 
     428             :     /* compute idct and place blocks */
     429      253584 :     block = &sblock[0][0];
     430      253584 :     mb    = mb_data;
     431     1521504 :     for (mb_index = 0; mb_index < 5; mb_index++) {
     432     1267920 :         dv_calculate_mb_xy(s, work_chunk, mb_index, &mb_x, &mb_y);
     433             : 
     434             :         /* idct_put'ting luminance */
     435     2155140 :         if ((s->sys->pix_fmt == AV_PIX_FMT_YUV420P)                      ||
     436     2068536 :             (s->sys->pix_fmt == AV_PIX_FMT_YUV411P && mb_x >= (704 / 8)) ||
     437      880536 :             (s->sys->height >= 720 && mb_y != 134)) {
     438      774768 :             y_stride = (s->frame->linesize[0] <<
     439      387384 :                         ((!is_field_mode[mb_index]) * log2_blocksize));
     440             :         } else {
     441      880536 :             y_stride = (2 << log2_blocksize);
     442             :         }
     443     2535840 :         y_ptr    = s->frame->data[0] +
     444     1267920 :                    ((mb_y * s->frame->linesize[0] + mb_x) << log2_blocksize);
     445     1267920 :         linesize = s->frame->linesize[0] << is_field_mode[mb_index];
     446     1267920 :         mb[0].idct_put(y_ptr, linesize, block + 0 * 64);
     447     1267920 :         if (s->sys->video_stype == 4) { /* SD 422 */
     448      586440 :             mb[2].idct_put(y_ptr + (1 << log2_blocksize),            linesize, block + 2 * 64);
     449             :         } else {
     450      681480 :             mb[1].idct_put(y_ptr + (1 << log2_blocksize),            linesize, block + 1 * 64);
     451      681480 :             mb[2].idct_put(y_ptr                         + y_stride, linesize, block + 2 * 64);
     452      681480 :             mb[3].idct_put(y_ptr + (1 << log2_blocksize) + y_stride, linesize, block + 3 * 64);
     453             :         }
     454     1267920 :         mb    += 4;
     455     1267920 :         block += 4 * 64;
     456             : 
     457             :         /* idct_put'ting chrominance */
     458     2535840 :         c_offset = (((mb_y >>  (s->sys->pix_fmt == AV_PIX_FMT_YUV420P)) * s->frame->linesize[1] +
     459     1267920 :                      (mb_x >> ((s->sys->pix_fmt == AV_PIX_FMT_YUV411P) ? 2 : 1))) << log2_blocksize);
     460     3803760 :         for (j = 2; j; j--) {
     461     2535840 :             uint8_t *c_ptr = s->frame->data[j] + c_offset;
     462     2549208 :             if (s->sys->pix_fmt == AV_PIX_FMT_YUV411P && mb_x >= (704 / 8)) {
     463             :                 uint64_t aligned_pixels[64 / 8];
     464       13368 :                 uint8_t *pixels = (uint8_t *) aligned_pixels;
     465             :                 uint8_t *c_ptr1, *ptr1;
     466             :                 int x, y;
     467       13368 :                 mb->idct_put(pixels, 8, block);
     468      120312 :                 for (y = 0; y < (1 << log2_blocksize); y++, c_ptr += s->frame->linesize[j], pixels += 8) {
     469      106944 :                     ptr1   = pixels + ((1 << (log2_blocksize))>>1);
     470      106944 :                     c_ptr1 = c_ptr + (s->frame->linesize[j] << log2_blocksize);
     471      534720 :                     for (x = 0; x < (1 << FFMAX(log2_blocksize - 1, 0)); x++) {
     472      427776 :                         c_ptr[x]  = pixels[x];
     473      427776 :                         c_ptr1[x] = ptr1[x];
     474             :                     }
     475             :                 }
     476       13368 :                 block += 64;
     477       13368 :                 mb++;
     478             :             } else {
     479     5044944 :                 y_stride = (mb_y == 134) ? (1 << log2_blocksize) :
     480     2522472 :                            s->frame->linesize[j] << ((!is_field_mode[mb_index]) * log2_blocksize);
     481     2522472 :                 linesize = s->frame->linesize[j] << is_field_mode[mb_index];
     482     2522472 :                 (mb++)->idct_put(c_ptr, linesize, block);
     483     2522472 :                 block += 64;
     484     2522472 :                 if (s->sys->bpm == 8) {
     485           0 :                     (mb++)->idct_put(c_ptr + y_stride, linesize, block);
     486           0 :                     block += 64;
     487             :                 }
     488             :             }
     489             :         }
     490             :     }
     491      253584 :     return 0;
     492             : }
     493             : 
     494             : /* NOTE: exactly one frame must be given (120000 bytes for NTSC,
     495             :  * 144000 bytes for PAL - or twice those for 50Mbps) */
     496         608 : static int dvvideo_decode_frame(AVCodecContext *avctx, void *data,
     497             :                                 int *got_frame, AVPacket *avpkt)
     498             : {
     499         608 :     uint8_t *buf = avpkt->data;
     500         608 :     int buf_size = avpkt->size;
     501         608 :     DVVideoContext *s = avctx->priv_data;
     502         608 :     AVFrame *frame = data;
     503             :     const uint8_t *vsc_pack;
     504             :     int apt, is16_9, ret;
     505             :     const AVDVProfile *sys;
     506             : 
     507         608 :     sys = ff_dv_frame_profile(avctx, s->sys, buf, buf_size);
     508         608 :     if (!sys || buf_size < sys->frame_size) {
     509           0 :         av_log(avctx, AV_LOG_ERROR, "could not find dv frame profile\n");
     510           0 :         return -1; /* NOTE: we only accept several full frames */
     511             :     }
     512             : 
     513         608 :     if (sys != s->sys) {
     514          39 :         ret = ff_dv_init_dynamic_tables(s, sys);
     515          39 :         if (ret < 0) {
     516           0 :             av_log(avctx, AV_LOG_ERROR, "Error initializing the work tables.\n");
     517           0 :             return ret;
     518             :         }
     519          39 :         dv_init_weight_tables(s, sys);
     520          39 :         s->sys = sys;
     521             :     }
     522             : 
     523         608 :     s->frame            = frame;
     524         608 :     frame->key_frame    = 1;
     525         608 :     frame->pict_type    = AV_PICTURE_TYPE_I;
     526         608 :     avctx->pix_fmt      = s->sys->pix_fmt;
     527         608 :     avctx->framerate    = av_inv_q(s->sys->time_base);
     528             : 
     529         608 :     ret = ff_set_dimensions(avctx, s->sys->width, s->sys->height);
     530         608 :     if (ret < 0)
     531           0 :         return ret;
     532             : 
     533             :     /* Determine the codec's sample_aspect ratio from the packet */
     534         608 :     vsc_pack = buf + 80 * 5 + 48 + 5;
     535         608 :     if (*vsc_pack == dv_video_control) {
     536         608 :         apt    = buf[4] & 0x07;
     537         635 :         is16_9 = (vsc_pack[2] & 0x07) == 0x02 ||
     538         243 :                  (!apt && (vsc_pack[2] & 0x07) == 0x07);
     539         608 :         ff_set_sar(avctx, s->sys->sar[is16_9]);
     540             :     }
     541             : 
     542         608 :     if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
     543           0 :         return ret;
     544         608 :     frame->interlaced_frame = 1;
     545         608 :     frame->top_field_first  = 0;
     546             : 
     547             :     /* Determine the codec's field order from the packet */
     548         608 :     if ( *vsc_pack == dv_video_control ) {
     549         608 :         frame->top_field_first = !(vsc_pack[3] & 0x40);
     550             :     }
     551             : 
     552         608 :     s->buf = buf;
     553         608 :     avctx->execute(avctx, dv_decode_video_segment, s->work_chunks, NULL,
     554             :                    dv_work_pool_size(s->sys), sizeof(DVwork_chunk));
     555             : 
     556         608 :     emms_c();
     557             : 
     558             :     /* return image */
     559         608 :     *got_frame = 1;
     560             : 
     561         608 :     return s->sys->frame_size;
     562             : }
     563             : 
     564             : AVCodec ff_dvvideo_decoder = {
     565             :     .name           = "dvvideo",
     566             :     .long_name      = NULL_IF_CONFIG_SMALL("DV (Digital Video)"),
     567             :     .type           = AVMEDIA_TYPE_VIDEO,
     568             :     .id             = AV_CODEC_ID_DVVIDEO,
     569             :     .priv_data_size = sizeof(DVVideoContext),
     570             :     .init           = dvvideo_decode_init,
     571             :     .decode         = dvvideo_decode_frame,
     572             :     .capabilities   = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_SLICE_THREADS,
     573             :     .max_lowres     = 3,
     574             : };

Generated by: LCOV version 1.13