Merge commit '89ef08c992c484a46711b1a68a988303679c288e'
authorMichael Niedermayer <michaelni@gmx.at>
Fri, 11 Apr 2014 12:04:10 +0000 (14:04 +0200)
committerMichael Niedermayer <michaelni@gmx.at>
Fri, 11 Apr 2014 12:04:10 +0000 (14:04 +0200)
* commit '89ef08c992c484a46711b1a68a988303679c288e':
  DNxHD: K&R formatting cosmetics

Conflicts:
libavcodec/dnxhd_parser.c
libavcodec/dnxhddec.c
libavcodec/dnxhdenc.c

Merged-by: Michael Niedermayer <michaelni@gmx.at>
1  2 
libavcodec/dnxhd_parser.c
libavcodec/dnxhddata.c
libavcodec/dnxhddec.c
libavcodec/dnxhdenc.c

@@@ -46,12 -37,10 +46,12 @@@ static int dnxhd_find_frame_end(DNXHDPa
  
      if (!pic_found) {
          for (i = 0; i < buf_size; i++) {
-             state = (state<<8) | buf[i];
+             state = (state << 8) | buf[i];
 -            if ((state & 0xffffffffffLL) == DNXHD_HEADER_PREFIX) {
 +            if ((state & 0xffffffffff00LL) == DNXHD_HEADER_PREFIX) {
                  i++;
                  pic_found = 1;
 +                interlaced = (state&2)>>1; /* byte following the 5-byte header prefix */
 +                cur_field = state&1;
                  break;
              }
          }
          if (!buf_size) /* EOF considered as end of frame */
              return 0;
          for (; i < buf_size; i++) {
-             state = (state<<8) | buf[i];
+             state = (state << 8) | buf[i];
 -            if ((state & 0xffffffffffLL) == DNXHD_HEADER_PREFIX) {
 -                pc->frame_start_found = 0;
 -                pc->state64 = -1;
 -                return i - 4;
 +            if ((state & 0xffffffffff00LL) == DNXHD_HEADER_PREFIX) {
 +                if (!interlaced || dctx->cur_field) {
 +                    pc->frame_start_found = 0;
 +                    pc->state64 = -1;
 +                    dctx->interlaced = interlaced;
 +                    dctx->cur_field = 0;
-                     return i-5;
++                    return i - 5;
 +                } else {
 +                    /* continue, to get the second field */
 +                    dctx->interlaced = interlaced = (state&2)>>1;
 +                    dctx->cur_field = cur_field = state&1;
 +                }
              }
          }
      }
@@@ -96,9 -74,9 +96,9 @@@ static int dnxhd_parse(AVCodecParserCon
      if (s->flags & PARSER_FLAG_COMPLETE_FRAMES) {
          next = buf_size;
      } else {
 -        next = dnxhd_find_frame_end(pc, buf, buf_size);
 +        next = dnxhd_find_frame_end(dctx, buf, buf_size);
          if (ff_combine_frame(pc, next, &buf, &buf_size) < 0) {
-             *poutbuf = NULL;
+             *poutbuf      = NULL;
              *poutbuf_size = 0;
              return buf_size;
          }
Simple merge
@@@ -185,9 -184,9 +193,9 @@@ static int dnxhd_decode_header(DNXHDCon
      }
  
      for (i = 0; i < ctx->mb_height; i++) {
-         ctx->mb_scan_index[i] = AV_RB32(buf + 0x170 + (i<<2));
+         ctx->mb_scan_index[i] = AV_RB32(buf + 0x170 + (i << 2));
          av_dlog(ctx->avctx, "mb scan index %d\n", ctx->mb_scan_index[i]);
 -        if (buf_size < ctx->mb_scan_index[i] + 0x280) {
 +        if (buf_size < ctx->mb_scan_index[i] + 0x280LL) {
              av_log(ctx->avctx, AV_LOG_ERROR, "invalid mb scan index\n");
              return AVERROR_INVALIDDATA;
          }
@@@ -213,13 -208,11 +221,13 @@@ static av_always_inline void dnxhd_deco
      OPEN_READER(bs, &ctx->gb);
  
      if (!ctx->is_444) {
-         if (n&2) {
-             component = 1 + (n&1);
+         if (n & 2) {
+             component     = 1 + (n & 1);
 +            scale = ctx->chroma_scale;
              weight_matrix = ctx->cid_table->chroma_weight;
          } else {
-             component = 0;
+             component     = 0;
 +            scale = ctx->luma_scale;
              weight_matrix = ctx->cid_table->luma_weight;
          }
      } else {
              break;
          }
  
-         j = ctx->scantable.permutated[i];
+         j     = ctx->scantable.permutated[i];
 -        level = (2 * level + 1) * qscale * weight_matrix[i];
 +        level *= scale[i];
          if (level_bias < 32 || weight_matrix[i] != level_bias)
              level += level_bias;
          level >>= level_shift;
  
-         block[j] = (level^sign) - sign;
+         block[j] = (level ^ sign) - sign;
 +
 +        UPDATE_CACHE(bs, &ctx->gb);
 +        GET_VLC(index1, bs, &ctx->gb, ctx->ac_vlc.table,
 +                DNXHD_VLC_BITS, 2);
      }
  
      CLOSE_READER(bs, &ctx->gb);
  #include "mpegvideo.h"
  #include "dnxhdenc.h"
  
- #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
- #define DNX10BIT_QMAT_SHIFT 18 // The largest value that will not lead to overflow for 10bit samples.
 +
- static const AVOption options[]={
-     {"nitris_compat", "encode with Avid Nitris compatibility", offsetof(DNXHDEncContext, nitris_compat), AV_OPT_TYPE_INT, {.i64 = 0}, 0, 1, VE},
- {NULL}
+ // The largest value that will not lead to overflow for 10bit samples.
+ #define DNX10BIT_QMAT_SHIFT 18
+ #define RC_VARIANCE 1 // use variance or ssd for fast rc
+ #define LAMBDA_FRAC_BITS 10
+ #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
+ static const AVOption options[] = {
+     { "nitris_compat", "encode with Avid Nitris compatibility",
+         offsetof(DNXHDEncContext, nitris_compat), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, VE },
+     { NULL }
  };
  
 -static const AVClass class = {
 -    "dnxhd",
 -    av_default_item_name,
 -    options,
 -    LIBAVUTIL_VERSION_INT
 +static const AVClass dnxhd_class = {
 +    .class_name = "dnxhd",
 +    .item_name  = av_default_item_name,
 +    .option     = options,
 +    .version    = LIBAVUTIL_VERSION_INT,
  };
  
- #define LAMBDA_FRAC_BITS 10
- static void dnxhd_8bit_get_pixels_8x4_sym(int16_t *av_restrict block, const uint8_t *pixels, ptrdiff_t line_size)
 -static void dnxhd_8bit_get_pixels_8x4_sym(int16_t *restrict block,
++static void dnxhd_8bit_get_pixels_8x4_sym(int16_t *av_restrict block,
+                                           const uint8_t *pixels,
 -                                          int line_size)
++                                          ptrdiff_t line_size)
  {
      int i;
      for (i = 0; i < 4; i++) {
      memcpy(block + 24, block - 32, sizeof(*block) * 8);
  }
  
- static av_always_inline void dnxhd_10bit_get_pixels_8x4_sym(int16_t *av_restrict block, const uint8_t *pixels, ptrdiff_t line_size)
+ static av_always_inline
 -void dnxhd_10bit_get_pixels_8x4_sym(int16_t *restrict block,
++void dnxhd_10bit_get_pixels_8x4_sym(int16_t *av_restrict block,
+                                     const uint8_t *pixels,
 -                                    int line_size)
++                                    ptrdiff_t line_size)
  {
      int i;
 -
 -    block += 32;
 +    const uint16_t* pixels16 = (const uint16_t*)pixels;
 +    line_size >>= 1;
  
      for (i = 0; i < 4; i++) {
 -        memcpy(block + i * 8, pixels + i * line_size, 8 * sizeof(*block));
 -        memcpy(block - (i + 1) * 8, pixels + i * line_size, 8 * sizeof(*block));
 +        block[0] = pixels16[0]; block[1] = pixels16[1];
 +        block[2] = pixels16[2]; block[3] = pixels16[3];
 +        block[4] = pixels16[4]; block[5] = pixels16[5];
 +        block[6] = pixels16[6]; block[7] = pixels16[7];
 +        pixels16 += line_size;
 +        block += 8;
      }
 +    memcpy(block,      block -  8, sizeof(*block) * 8);
 +    memcpy(block +  8, block - 16, sizeof(*block) * 8);
 +    memcpy(block + 16, block - 24, sizeof(*block) * 8);
 +    memcpy(block + 24, block - 32, sizeof(*block) * 8);
  }
  
  static int dnxhd_10bit_dct_quantize(MpegEncContext *ctx, int16_t *block,
@@@ -134,39 -140,41 +149,41 @@@ static av_cold int dnxhd_init_vlc(DNXHD
  
              MASK_ABS(sign, alevel);
              if (alevel > 64) {
-                 offset = (alevel-1)>>6;
-                 alevel -= offset<<6;
+                 offset  = (alevel - 1) >> 6;
+                 alevel -= offset << 6;
              }
              for (j = 0; j < 257; j++) {
 -                if (ctx->cid_table->ac_level[j] == alevel &&
 -                    (!offset || (ctx->cid_table->ac_index_flag[j] && offset)) &&
 -                    (!run    || (ctx->cid_table->ac_run_flag  [j] && run))) {
 -                    assert(!ctx->vlc_codes[index]);
 +                if (ctx->cid_table->ac_level[j] >> 1 == alevel &&
 +                    (!offset || (ctx->cid_table->ac_flags[j] & 1) && offset) &&
 +                    (!run    || (ctx->cid_table->ac_flags[j] & 2) && run)) {
 +                    av_assert1(!ctx->vlc_codes[index]);
                      if (alevel) {
-                         ctx->vlc_codes[index] = (ctx->cid_table->ac_codes[j]<<1)|(sign&1);
-                         ctx->vlc_bits [index] = ctx->cid_table->ac_bits[j]+1;
+                         ctx->vlc_codes[index] =
+                             (ctx->cid_table->ac_codes[j] << 1) | (sign & 1);
+                         ctx->vlc_bits[index] = ctx->cid_table->ac_bits[j] + 1;
                      } else {
                          ctx->vlc_codes[index] = ctx->cid_table->ac_codes[j];
-                         ctx->vlc_bits [index] = ctx->cid_table->ac_bits [j];
+                         ctx->vlc_bits[index]  = ctx->cid_table->ac_bits[j];
                      }
                      break;
                  }
              }
 -            assert(!alevel || j < 257);
 +            av_assert0(!alevel || j < 257);
              if (offset) {
-                 ctx->vlc_codes[index] = (ctx->vlc_codes[index]<<ctx->cid_table->index_bits)|offset;
-                 ctx->vlc_bits [index]+= ctx->cid_table->index_bits;
+                 ctx->vlc_codes[index] =
+                     (ctx->vlc_codes[index] << ctx->cid_table->index_bits) | offset;
+                 ctx->vlc_bits[index] += ctx->cid_table->index_bits;
              }
          }
      }
      for (i = 0; i < 62; i++) {
          int run = ctx->cid_table->run[i];
 -        assert(run < 63);
 +        av_assert0(run < 63);
          ctx->run_codes[run] = ctx->cid_table->run_codes[i];
-         ctx->run_bits [run] = ctx->cid_table->run_bits[i];
+         ctx->run_bits[run]  = ctx->cid_table->run_bits[i];
      }
      return 0;
 fail:
+ fail:
      return AVERROR(ENOMEM);
  }
  
@@@ -224,27 -248,25 +257,29 @@@ static av_cold int dnxhd_init_qmat(DNXH
          }
      }
  
 +    ctx->m.q_chroma_intra_matrix16 = ctx->qmatrix_c16;
 +    ctx->m.q_chroma_intra_matrix   = ctx->qmatrix_c;
 +    ctx->m.q_intra_matrix16        = ctx->qmatrix_l16;
 +    ctx->m.q_intra_matrix          = ctx->qmatrix_l;
 +
      return 0;
 fail:
+ fail:
      return AVERROR(ENOMEM);
  }
  
  static av_cold int dnxhd_init_rc(DNXHDEncContext *ctx)
  {
-     FF_ALLOCZ_OR_GOTO(ctx->m.avctx, ctx->mb_rc, 8160*(ctx->m.avctx->qmax + 1)*sizeof(RCEntry), fail);
 -    FF_ALLOCZ_OR_GOTO(ctx->m.avctx, ctx->mb_rc,
 -                      8160 * ctx->m.avctx->qmax * sizeof(RCEntry), fail);
++    FF_ALLOCZ_OR_GOTO(ctx->m.avctx, ctx->mb_rc, 8160 * (ctx->m.avctx->qmax + 1) * sizeof(RCEntry), fail);
      if (ctx->m.avctx->mb_decision != FF_MB_DECISION_RD)
-         FF_ALLOCZ_OR_GOTO(ctx->m.avctx, ctx->mb_cmp, ctx->m.mb_num*sizeof(RCCMPEntry), fail);
+         FF_ALLOCZ_OR_GOTO(ctx->m.avctx, ctx->mb_cmp,
+                           ctx->m.mb_num * sizeof(RCCMPEntry), fail);
  
-     ctx->frame_bits = (ctx->cid_table->coding_unit_size - 640 - 4 - ctx->min_padding) * 8;
+     ctx->frame_bits = (ctx->cid_table->coding_unit_size -
+                        640 - 4 - ctx->min_padding) * 8;
      ctx->qscale = 1;
-     ctx->lambda = 2<<LAMBDA_FRAC_BITS; // qscale 2
+     ctx->lambda = 2 << LAMBDA_FRAC_BITS; // qscale 2
      return 0;
 fail:
+ fail:
      return AVERROR(ENOMEM);
  }
  
@@@ -267,17 -290,16 +303,18 @@@ static av_cold int dnxhd_encode_init(AV
  
      ctx->cid = ff_dnxhd_find_cid(avctx, bit_depth);
      if (!ctx->cid) {
-         av_log(avctx, AV_LOG_ERROR, "video parameters incompatible with DNxHD. Valid DNxHD profiles:\n");
+         av_log(avctx, AV_LOG_ERROR,
 -               "video parameters incompatible with DNxHD\n");
++               "video parameters incompatible with DNxHD. Valid DNxHD profiles:\n");
 +        ff_dnxhd_print_profiles(avctx, AV_LOG_ERROR);
          return AVERROR(EINVAL);
      }
      av_log(avctx, AV_LOG_DEBUG, "cid %d\n", ctx->cid);
  
      index = ff_dnxhd_get_cid_table(ctx->cid);
 +    av_assert0(index >= 0);
      ctx->cid_table = &ff_dnxhd_cid_table[index];
  
-     ctx->m.avctx = avctx;
+     ctx->m.avctx    = avctx;
      ctx->m.mb_intra = 1;
      ctx->m.h263_aic = 1;
  
          return AVERROR(EINVAL);
      }
  
 +    if (avctx->qmax <= 1) {
 +        av_log(avctx, AV_LOG_ERROR, "qmax must be at least 2\n");
 +        return AVERROR(EINVAL);
 +    }
 +
      ctx->thread[0] = ctx;
      for (i = 1; i < avctx->thread_count; i++) {
-         ctx->thread[i] =  av_malloc(sizeof(DNXHDEncContext));
+         ctx->thread[i] = av_malloc(sizeof(DNXHDEncContext));
          memcpy(ctx->thread[i], ctx, sizeof(DNXHDEncContext));
      }
  
@@@ -361,7 -383,7 +404,7 @@@ fail:  // for FF_ALLOCZ_OR_GOT
  static int dnxhd_write_header(AVCodecContext *avctx, uint8_t *buf)
  {
      DNXHDEncContext *ctx = avctx->priv_data;
-     static const uint8_t header_prefix[5] = { 0x00,0x00,0x02,0x80,0x01 };
 -    const uint8_t header_prefix[5] = { 0x00, 0x00, 0x02, 0x80, 0x01 };
++    static const uint8_t header_prefix[5] = { 0x00, 0x00, 0x02, 0x80, 0x01 };
  
      memset(buf, 0, 640);
  
@@@ -526,13 -573,22 +594,15 @@@ void dnxhd_get_blocks(DNXHDEncContext *
      }
  }
  
- static av_always_inline int dnxhd_switch_matrix(DNXHDEncContext *ctx, int i)
+ static av_always_inline
+ int dnxhd_switch_matrix(DNXHDEncContext *ctx, int i)
  {
 -    if (i & 2) {
 -        ctx->m.q_intra_matrix16 = ctx->qmatrix_c16;
 -        ctx->m.q_intra_matrix   = ctx->qmatrix_c;
 -        return 1 + (i & 1);
 -    } else {
 -        ctx->m.q_intra_matrix16 = ctx->qmatrix_l16;
 -        ctx->m.q_intra_matrix   = ctx->qmatrix_l;
 -        return 0;
 -    }
 +    const static uint8_t component[8]={0,0,1,2,0,0,1,2};
 +    return component[i];
  }
  
- static int dnxhd_calc_bits_thread(AVCodecContext *avctx, void *arg, int jobnr, int threadnr)
+ static int dnxhd_calc_bits_thread(AVCodecContext *avctx, void *arg,
+                                   int jobnr, int threadnr)
  {
      DNXHDEncContext *ctx = avctx->priv_data;
      int mb_y = jobnr, mb_x;
              int overflow, nbits, diff, last_index;
              int n = dnxhd_switch_matrix(ctx, i);
  
-             memcpy(block, src_block, 64*sizeof(*block));
-             last_index = ctx->m.dct_quantize(&ctx->m, block, 4&(2*i), qscale, &overflow);
-             ac_bits += dnxhd_calc_ac_bits(ctx, block, last_index);
+             memcpy(block, src_block, 64 * sizeof(*block));
 -            last_index = ctx->m.dct_quantize(&ctx->m, block, i,
++            last_index = ctx->m.dct_quantize(&ctx->m, block, 4 & (2*i),
+                                              qscale, &overflow);
+             ac_bits   += dnxhd_calc_ac_bits(ctx, block, last_index);
  
              diff = block[0] - ctx->m.last_dc[n];
-             if (diff < 0) nbits = av_log2_16bit(-2*diff);
-             else          nbits = av_log2_16bit( 2*diff);
+             if (diff < 0)
+                 nbits = av_log2_16bit(-2 * diff);
+             else
+                 nbits = av_log2_16bit(2 * diff);
  
 -            assert(nbits < ctx->cid_table->bit_depth + 4);
 +            av_assert1(nbits < ctx->cid_table->bit_depth + 4);
              dc_bits += ctx->cid_table->dc_bits[nbits] + nbits;
  
              ctx->m.last_dc[n] = block[0];
@@@ -605,14 -667,15 +681,15 @@@ static int dnxhd_encode_thread(AVCodecC
          for (i = 0; i < 8; i++) {
              int16_t *block = ctx->blocks[i];
              int overflow, n = dnxhd_switch_matrix(ctx, i);
-             int last_index = ctx->m.dct_quantize(&ctx->m, block, 4&(2*i), qscale, &overflow);
-             //START_TIMER;
 -            int last_index = ctx->m.dct_quantize(&ctx->m, block, i,
++            int last_index = ctx->m.dct_quantize(&ctx->m, block, 4 & (2*i),
+                                                  qscale, &overflow);
+             // START_TIMER;
              dnxhd_encode_block(ctx, block, last_index, n);
-             //STOP_TIMER("encode_block");
+             // STOP_TIMER("encode_block");
          }
      }
-     if (put_bits_count(&ctx->m.pb)&31)
-         put_bits(&ctx->m.pb, 32-(put_bits_count(&ctx->m.pb)&31), 0);
+     if (put_bits_count(&ctx->m.pb) & 31)
+         put_bits(&ctx->m.pb, 32 - (put_bits_count(&ctx->m.pb) & 31), 0);
      flush_put_bits(&ctx->m.pb);
      return 0;
  }
@@@ -986,8 -1066,9 +1077,9 @@@ encode_coding_unit
  
      avctx->execute2(avctx, dnxhd_encode_thread, buf, NULL, ctx->m.mb_height);
  
 -    assert(640 + offset + 4 <= ctx->cid_table->coding_unit_size);
 +    av_assert1(640 + offset + 4 <= ctx->cid_table->coding_unit_size);
-     memset(buf + 640 + offset, 0, ctx->cid_table->coding_unit_size - 4 - offset - 640);
+     memset(buf + 640 + offset, 0,
+            ctx->cid_table->coding_unit_size - 4 - offset - 640);
  
      AV_WB32(buf + ctx->cid_table->coding_unit_size - 4, 0x600DC0DE); // EOF
  
@@@ -1051,9 -1127,10 +1143,11 @@@ AVCodec ff_dnxhd_encoder = 
      .encode2        = dnxhd_encode_picture,
      .close          = dnxhd_encode_end,
      .capabilities   = CODEC_CAP_SLICE_THREADS,
-     .pix_fmts       = (const enum AVPixelFormat[]){ AV_PIX_FMT_YUV422P,
-                                                   AV_PIX_FMT_YUV422P10,
-                                                   AV_PIX_FMT_NONE },
+     .pix_fmts       = (const enum AVPixelFormat[]) {
+         AV_PIX_FMT_YUV422P,
+         AV_PIX_FMT_YUV422P10,
+         AV_PIX_FMT_NONE
+     },
 -    .priv_class     = &class,
 +    .priv_class     = &dnxhd_class,
 +    .defaults       = dnxhd_defaults,
  };