Merge commit '3360ad995530ea6967b1e83981b4aa8240fbb0ed'
authorMichael Niedermayer <michaelni@gmx.at>
Fri, 6 Dec 2013 10:33:07 +0000 (11:33 +0100)
committerMichael Niedermayer <michaelni@gmx.at>
Fri, 6 Dec 2013 10:33:07 +0000 (11:33 +0100)
* commit '3360ad995530ea6967b1e83981b4aa8240fbb0ed':
  mjpegenc: do not pass MpegEncContext to ff_mjpeg_encode_picture_trailer()

Conflicts:
libavcodec/ljpegenc.c
libavcodec/mjpegenc.c
libavcodec/mjpegenc.h

Merged-by: Michael Niedermayer <michaelni@gmx.at>
1  2 
libavcodec/ljpegenc.c
libavcodec/mjpegenc.c
libavcodec/mjpegenc.h
libavcodec/mpegvideo_enc.c

diff --combined libavcodec/ljpegenc.c
@@@ -8,20 -8,20 +8,20 @@@
   * aspecting, new decode_frame mechanism and apple mjpeg-b support
   *                                  by Alex Beregszaszi
   *
 - * This file is part of Libav.
 + * This file is part of FFmpeg.
   *
 - * Libav is free software; you can redistribute it and/or
 + * FFmpeg is free software; you can redistribute it and/or
   * modify it under the terms of the GNU Lesser General Public
   * License as published by the Free Software Foundation; either
   * version 2.1 of the License, or (at your option) any later version.
   *
 - * Libav is distributed in the hope that it will be useful,
 + * FFmpeg is distributed in the hope that it will be useful,
   * but WITHOUT ANY WARRANTY; without even the implied warranty of
   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   * Lesser General Public License for more details.
   *
   * You should have received a copy of the GNU Lesser General Public
 - * License along with Libav; if not, write to the Free Software
 + * License along with FFmpeg; if not, write to the Free Software
   * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
   */
  
@@@ -56,20 -56,11 +56,20 @@@ static int encode_picture_lossless(AVCo
          max_pkt_size += mb_width * mb_height * 3 * 4
                          * s->mjpeg_hsample[0] * s->mjpeg_vsample[0];
      }
 -    if ((ret = ff_alloc_packet(pkt, max_pkt_size)) < 0) {
 -        av_log(avctx, AV_LOG_ERROR, "Error getting output packet of size %d.\n", max_pkt_size);
 -        return ret;
 +
 +    if (!s->rd_scratchpad) {
 +        int alloc_size = FFALIGN(FFABS(pict->linesize[0]) + 64, 32);
 +        s->me.scratchpad =
 +        s->rd_scratchpad = av_mallocz(alloc_size * 4 * 16 * 2);
 +        if (!s->rd_scratchpad) {
 +            av_log(avctx, AV_LOG_ERROR, "failed to allocate context scratch buffers.\n");
 +            return ret;
 +        }
      }
  
 +    if ((ret = ff_alloc_packet2(avctx, pkt, max_pkt_size)) < 0)
 +        return ret;
 +
      init_put_bits(&s->pb, pkt->data, pkt->size);
  
      av_frame_unref(p);
@@@ -84,9 -75,7 +84,9 @@@
  
      s->header_bits= put_bits_count(&s->pb);
  
 -    if(avctx->pix_fmt == AV_PIX_FMT_BGRA){
 +    if(avctx->pix_fmt == AV_PIX_FMT_BGR0
 +        || avctx->pix_fmt == AV_PIX_FMT_BGRA
 +        || avctx->pix_fmt == AV_PIX_FMT_BGR24){
          int x, y, i;
          const int linesize= p->linesize[0];
          uint16_t (*buffer)[4]= (void *) s->rd_scratchpad;
                  top[i]= left[i]= topleft[i]= buffer[0][i];
              }
              for(x = 0; x < width; x++) {
 +                if(avctx->pix_fmt == AV_PIX_FMT_BGR24){
 +                    buffer[x][1] = ptr[3*x+0] - ptr[3*x+1] + 0x100;
 +                    buffer[x][2] = ptr[3*x+2] - ptr[3*x+1] + 0x100;
 +                    buffer[x][0] = (ptr[3*x+0] + 2*ptr[3*x+1] + ptr[3*x+2])>>2;
 +                }else{
                  buffer[x][1] = ptr[4*x+0] - ptr[4*x+1] + 0x100;
                  buffer[x][2] = ptr[4*x+2] - ptr[4*x+1] + 0x100;
                  buffer[x][0] = (ptr[4*x+0] + 2*ptr[4*x+1] + ptr[4*x+2])>>2;
 +                }
  
                  for(i=0;i<3;i++) {
                      int pred, diff;
      }
  
      emms_c();
-     ff_mjpeg_encode_picture_trailer(s);
 +    av_assert0(s->esc_pos == s->header_bits >> 3);
 +    ff_mjpeg_encode_stuffing(s);
+     ff_mjpeg_encode_picture_trailer(&s->pb, s->header_bits);
      s->picture_number++;
  
      flush_put_bits(&s->pb);
@@@ -233,9 -215,4 +234,9 @@@ AVCodec ff_ljpeg_encoder = { //FIXME av
      .init           = ff_MPV_encode_init,
      .encode2        = encode_picture_lossless,
      .close          = ff_MPV_encode_end,
 +    .pix_fmts       = (const enum AVPixelFormat[]){
 +        AV_PIX_FMT_BGR24, AV_PIX_FMT_BGRA, AV_PIX_FMT_BGR0,
 +        AV_PIX_FMT_YUVJ420P, AV_PIX_FMT_YUVJ444P, AV_PIX_FMT_YUVJ422P,
 +        AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUV444P, AV_PIX_FMT_YUV422P,
 +        AV_PIX_FMT_NONE},
  };
diff --combined libavcodec/mjpegenc.c
@@@ -8,20 -8,20 +8,20 @@@
   * aspecting, new decode_frame mechanism and apple mjpeg-b support
   *                                  by Alex Beregszaszi
   *
 - * This file is part of Libav.
 + * This file is part of FFmpeg.
   *
 - * Libav is free software; you can redistribute it and/or
 + * FFmpeg is free software; you can redistribute it and/or
   * modify it under the terms of the GNU Lesser General Public
   * License as published by the Free Software Foundation; either
   * version 2.1 of the License, or (at your option) any later version.
   *
 - * Libav is distributed in the hope that it will be useful,
 + * FFmpeg is distributed in the hope that it will be useful,
   * but WITHOUT ANY WARRANTY; without even the implied warranty of
   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   * Lesser General Public License for more details.
   *
   * You should have received a copy of the GNU Lesser General Public
 - * License along with Libav; if not, write to the Free Software
 + * License along with FFmpeg; if not, write to the Free Software
   * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
   */
  
@@@ -30,6 -30,8 +30,6 @@@
   * MJPEG encoder.
   */
  
 -#include <assert.h>
 -
  #include "libavutil/pixdesc.h"
  
  #include "avcodec.h"
  #include "mjpeg.h"
  #include "mjpegenc.h"
  
 +/* use two quantizer tables (one for luminance and one for chrominance) */
 +/* not yet working */
 +#undef TWOMATRIXES
 +
 +
  av_cold int ff_mjpeg_encode_init(MpegEncContext *s)
  {
      MJpegContext *m;
  
 +    if (s->width > 65500 || s->height > 65500) {
 +        av_log(s, AV_LOG_ERROR, "JPEG does not support resolutions above 65500x65500\n");
 +        return -1;
 +    }
 +
      m = av_malloc(sizeof(MJpegContext));
      if (!m)
          return -1;
@@@ -106,43 -98,21 +106,43 @@@ static int put_huffman_table(PutBitCont
      return n + 17;
  }
  
 -static void jpeg_table_header(PutBitContext *p, ScanTable *intra_scantable,
 -                              uint16_t intra_matrix[64])
 +static void jpeg_table_header(AVCodecContext *avctx, PutBitContext *p,
 +                              ScanTable *intra_scantable,
 +                              uint16_t intra_matrix[64],
 +                              int hsample[3])
  {
      int i, j, size;
      uint8_t *ptr;
  
 +    if (avctx->codec_id != AV_CODEC_ID_LJPEG) {
      /* quant matrixes */
      put_marker(p, DQT);
 +#ifdef TWOMATRIXES
 +    put_bits(p, 16, 2 + 2 * (1 + 64));
 +#else
      put_bits(p, 16, 2 + 1 * (1 + 64));
 +#endif
      put_bits(p, 4, 0); /* 8 bit precision */
      put_bits(p, 4, 0); /* table 0 */
      for(i=0;i<64;i++) {
          j = intra_scantable->permutated[i];
          put_bits(p, 8, intra_matrix[j]);
      }
 +#ifdef TWOMATRIXES
 +    put_bits(p, 4, 0); /* 8 bit precision */
 +    put_bits(p, 4, 1); /* table 1 */
 +    for(i=0;i<64;i++) {
 +        j = s->intra_scantable.permutated[i];
 +        put_bits(p, 8, s->chroma_intra_matrix[j]);
 +    }
 +#endif
 +    }
 +
 +    if(avctx->active_thread_type & FF_THREAD_SLICE){
 +        put_marker(p, DRI);
 +        put_bits(p, 16, 4);
 +        put_bits(p, 16, (avctx->width-1)/(8*hsample[0]) + 1);
 +    }
  
      /* huffman table */
      put_marker(p, DHT);
@@@ -172,7 -142,7 +172,7 @@@ static void jpeg_put_comments(AVCodecCo
          put_marker(p, APP0);
          put_bits(p, 16, 16);
          avpriv_put_string(p, "JFIF", 1); /* this puts the trailing zero-byte too */
 -        put_bits(p, 16, 0x0201);         /* v 1.02 */
 +        put_bits(p, 16, 0x0102);         /* v 1.02 */
          put_bits(p,  8, 0);              /* units type: 0 - aspect ratio */
          put_bits(p, 16, avctx->sample_aspect_ratio.num);
          put_bits(p, 16, avctx->sample_aspect_ratio.den);
@@@ -211,22 -181,15 +211,22 @@@ void ff_mjpeg_encode_picture_header(AVC
      int chroma_h_shift, chroma_v_shift;
      const int lossless = avctx->codec_id != AV_CODEC_ID_MJPEG;
      int hsample[3], vsample[3];
 +    int i;
 +    MpegEncContext *s = avctx->priv_data;
 +    av_assert0(avctx->codec->priv_data_size == sizeof(MpegEncContext));
  
      av_pix_fmt_get_chroma_sub_sample(avctx->pix_fmt, &chroma_h_shift,
                                       &chroma_v_shift);
 -
      if (avctx->codec->id == AV_CODEC_ID_LJPEG &&
 -        avctx->pix_fmt   == AV_PIX_FMT_BGRA) {
 +        (avctx->pix_fmt == AV_PIX_FMT_BGR0
 +            || s->avctx->pix_fmt == AV_PIX_FMT_BGRA
 +            || s->avctx->pix_fmt == AV_PIX_FMT_BGR24)) {
          vsample[0] = hsample[0] =
          vsample[1] = hsample[1] =
          vsample[2] = hsample[2] = 1;
 +    } else if (avctx->pix_fmt == AV_PIX_FMT_YUV444P || avctx->pix_fmt == AV_PIX_FMT_YUVJ444P) {
 +        vsample[0] = vsample[1] = vsample[2] = 2;
 +        hsample[0] = hsample[1] = hsample[2] = 1;
      } else {
          vsample[0] = 2;
          vsample[1] = 2 >> chroma_v_shift;
  
      put_marker(pb, SOI);
  
 +    // hack for AMV mjpeg format
 +    if(avctx->codec_id == AV_CODEC_ID_AMV) goto end;
 +
      jpeg_put_comments(avctx, pb);
  
 -    jpeg_table_header(pb, intra_scantable, intra_matrix);
 +    jpeg_table_header(avctx, pb, intra_scantable, intra_matrix, hsample);
  
      switch (avctx->codec_id) {
      case AV_CODEC_ID_MJPEG:  put_marker(pb, SOF0 ); break;
      case AV_CODEC_ID_LJPEG:  put_marker(pb, SOF3 ); break;
 -    default: assert(0);
 +    default: av_assert0(0);
      }
  
      put_bits(pb, 16, 17);
 -    if (lossless && avctx->pix_fmt == AV_PIX_FMT_BGRA)
 +    if (lossless && (  avctx->pix_fmt == AV_PIX_FMT_BGR0
 +                    || avctx->pix_fmt == AV_PIX_FMT_BGRA
 +                    || avctx->pix_fmt == AV_PIX_FMT_BGR24))
          put_bits(pb, 8, 9); /* 9 bits/component RCT */
      else
          put_bits(pb, 8, 8); /* 8 bits/component */
      put_bits(pb, 8, 2); /* component number */
      put_bits(pb, 4, hsample[1]); /* H factor */
      put_bits(pb, 4, vsample[1]); /* V factor */
 +#ifdef TWOMATRIXES
 +    put_bits(pb, 8, lossless ? 0 : 1); /* select matrix */
 +#else
      put_bits(pb, 8, 0); /* select matrix */
 +#endif
  
      /* Cr component */
      put_bits(pb, 8, 3); /* component number */
      put_bits(pb, 4, hsample[2]); /* H factor */
      put_bits(pb, 4, vsample[2]); /* V factor */
 +#ifdef TWOMATRIXES
 +    put_bits(pb, 8, lossless ? 0 : 1); /* select matrix */
 +#else
      put_bits(pb, 8, 0); /* select matrix */
 +#endif
  
      /* scan header */
      put_marker(pb, SOS);
      switch (avctx->codec_id) {
      case AV_CODEC_ID_MJPEG:  put_bits(pb, 8, 63); break; /* Se (not used) */
      case AV_CODEC_ID_LJPEG:  put_bits(pb, 8,  0); break; /* not used */
 -    default: assert(0);
 +    default: av_assert0(0);
      }
  
      put_bits(pb, 8, 0); /* Ah/Al (not used) */
 +
 +end:
 +    s->esc_pos = put_bits_count(pb) >> 3;
 +    for(i=1; i<s->slice_context_count; i++)
 +        s->thread_context[i]->esc_pos = 0;
  }
  
- static void escape_FF(MpegEncContext *s, int start)
+ static void escape_FF(PutBitContext *pb, int start)
  {
-     int size= put_bits_count(&s->pb) - start*8;
+     int size = put_bits_count(pb) - start * 8;
      int i, ff_count;
-     uint8_t *buf= s->pb.buf + start;
+     uint8_t *buf = pb->buf + start;
      int align= (-(size_t)(buf))&3;
  
 -    assert((size&7) == 0);
 +    av_assert1((size&7) == 0);
      size >>= 3;
  
      ff_count=0;
  
      if(ff_count==0) return;
  
-     flush_put_bits(&s->pb);
-     skip_put_bytes(&s->pb, ff_count);
+     flush_put_bits(pb);
+     skip_put_bytes(pb, ff_count);
  
      for(i=size-1; ff_count; i--){
          int v= buf[i];
      }
  }
  
 -void ff_mjpeg_encode_stuffing(PutBitContext * pbc)
 +void ff_mjpeg_encode_stuffing(MpegEncContext *s)
  {
 -    int length;
 +    int length, i;
 +    PutBitContext *pbc = &s->pb;
 +    int mb_y = s->mb_y - !s->mb_x;
      length= (-put_bits_count(pbc))&7;
      if(length) put_bits(pbc, length, (1<<length)-1);
-     escape_FF(s, s->esc_pos);
 +
 +    flush_put_bits(&s->pb);
++    escape_FF(&s->pb, s->esc_pos);
 +
 +    if((s->avctx->active_thread_type & FF_THREAD_SLICE) && mb_y < s->mb_height)
 +        put_marker(pbc, RST0 + (mb_y&7));
 +    s->esc_pos = put_bits_count(pbc) >> 3;
 +
 +    for(i=0; i<3; i++)
 +        s->last_dc[i] = 128 << s->intra_dc_precision;
  }
  
- void ff_mjpeg_encode_picture_trailer(MpegEncContext *s)
+ void ff_mjpeg_encode_picture_trailer(PutBitContext *pb, int header_bits)
  {
 -    ff_mjpeg_encode_stuffing(pb);
 -    flush_put_bits(pb);
 -
 -    assert((header_bits & 7) == 0);
 -
 -    escape_FF(pb, header_bits >> 3);
++    av_assert1((header_bits & 7) == 0);
  
-     av_assert1((s->header_bits&7)==0);
-     put_marker(&s->pb, EOI);
+     put_marker(pb, EOI);
  }
  
  void ff_mjpeg_encode_dc(MpegEncContext *s, int val,
@@@ -469,7 -405,7 +467,7 @@@ static void encode_block(MpegEncContex
                  mant--;
              }
  
 -            nbits= av_log2(val) + 1;
 +            nbits= av_log2_16bit(val) + 1;
              code = (run << 4) | nbits;
  
              put_bits(&s->pb, huff_size_ac[code], huff_code_ac[code]);
  void ff_mjpeg_encode_mb(MpegEncContext *s, int16_t block[6][64])
  {
      int i;
 -    for(i=0;i<5;i++) {
 -        encode_block(s, block[i], i);
 -    }
 -    if (s->chroma_format == CHROMA_420) {
 +    if (s->chroma_format == CHROMA_444) {
 +        encode_block(s, block[0], 0);
 +        encode_block(s, block[2], 2);
 +        encode_block(s, block[4], 4);
 +        encode_block(s, block[8], 8);
          encode_block(s, block[5], 5);
 +        encode_block(s, block[9], 9);
 +
 +        if (16*s->mb_x+8 < s->width) {
 +            encode_block(s, block[1], 1);
 +            encode_block(s, block[3], 3);
 +            encode_block(s, block[6], 6);
 +            encode_block(s, block[10], 10);
 +            encode_block(s, block[7], 7);
 +            encode_block(s, block[11], 11);
 +        }
      } else {
 -        encode_block(s, block[6], 6);
 -        encode_block(s, block[5], 5);
 -        encode_block(s, block[7], 7);
 +        for(i=0;i<5;i++) {
 +            encode_block(s, block[i], i);
 +        }
 +        if (s->chroma_format == CHROMA_420) {
 +            encode_block(s, block[5], 5);
 +        } else {
 +            encode_block(s, block[6], 6);
 +            encode_block(s, block[5], 5);
 +            encode_block(s, block[7], 7);
 +        }
      }
  
      s->i_tex_bits += get_bits_diff(s);
  }
  
 +// maximum over s->mjpeg_vsample[i]
 +#define V_MAX 2
 +static int amv_encode_picture(AVCodecContext *avctx, AVPacket *pkt,
 +                              const AVFrame *pic_arg, int *got_packet)
 +
 +{
 +    MpegEncContext *s = avctx->priv_data;
 +    AVFrame pic = *pic_arg;
 +    int i;
 +
 +    //CODEC_FLAG_EMU_EDGE have to be cleared
 +    if(s->avctx->flags & CODEC_FLAG_EMU_EDGE)
 +        return -1;
 +
 +    //picture should be flipped upside-down
 +    for(i=0; i < 3; i++) {
 +        pic.data[i] += (pic.linesize[i] * (s->mjpeg_vsample[i] * (8 * s->mb_height -((s->height/V_MAX)&7)) - 1 ));
 +        pic.linesize[i] *= -1;
 +    }
 +    return ff_MPV_encode_picture(avctx, pkt, &pic, got_packet);
 +}
 +
 +#if CONFIG_MJPEG_ENCODER
  AVCodec ff_mjpeg_encoder = {
      .name           = "mjpeg",
      .long_name      = NULL_IF_CONFIG_SMALL("MJPEG (Motion JPEG)"),
      .init           = ff_MPV_encode_init,
      .encode2        = ff_MPV_encode_picture,
      .close          = ff_MPV_encode_end,
 +    .capabilities   = CODEC_CAP_SLICE_THREADS | CODEC_CAP_FRAME_THREADS | CODEC_CAP_INTRA_ONLY,
 +    .pix_fmts       = (const enum AVPixelFormat[]){
 +        AV_PIX_FMT_YUVJ420P, AV_PIX_FMT_YUVJ422P, AV_PIX_FMT_YUVJ444P, AV_PIX_FMT_NONE
 +    },
 +};
 +#endif
 +#if CONFIG_AMV_ENCODER
 +AVCodec ff_amv_encoder = {
 +    .name           = "amv",
 +    .long_name      = NULL_IF_CONFIG_SMALL("AMV Video"),
 +    .type           = AVMEDIA_TYPE_VIDEO,
 +    .id             = AV_CODEC_ID_AMV,
 +    .priv_data_size = sizeof(MpegEncContext),
 +    .init           = ff_MPV_encode_init,
 +    .encode2        = amv_encode_picture,
 +    .close          = ff_MPV_encode_end,
      .pix_fmts       = (const enum AVPixelFormat[]){
          AV_PIX_FMT_YUVJ420P, AV_PIX_FMT_YUVJ422P, AV_PIX_FMT_NONE
      },
  };
 +#endif
diff --combined libavcodec/mjpegenc.h
@@@ -8,20 -8,20 +8,20 @@@
   * aspecting, new decode_frame mechanism and apple mjpeg-b support
   *                                  by Alex Beregszaszi
   *
 - * This file is part of Libav.
 + * This file is part of FFmpeg.
   *
 - * Libav is free software; you can redistribute it and/or
 + * FFmpeg is free software; you can redistribute it and/or
   * modify it under the terms of the GNU Lesser General Public
   * License as published by the Free Software Foundation; either
   * version 2.1 of the License, or (at your option) any later version.
   *
 - * Libav is distributed in the hope that it will be useful,
 + * FFmpeg is distributed in the hope that it will be useful,
   * but WITHOUT ANY WARRANTY; without even the implied warranty of
   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   * Lesser General Public License for more details.
   *
   * You should have received a copy of the GNU Lesser General Public
 - * License along with Libav; if not, write to the Free Software
 + * License along with FFmpeg; if not, write to the Free Software
   * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
   */
  
@@@ -54,8 -54,8 +54,8 @@@ void ff_mjpeg_encode_close(MpegEncConte
  void ff_mjpeg_encode_picture_header(AVCodecContext *avctx, PutBitContext *pb,
                                      ScanTable *intra_scantable,
                                      uint16_t intra_matrix[64]);
- void ff_mjpeg_encode_picture_trailer(MpegEncContext *s);
+ void ff_mjpeg_encode_picture_trailer(PutBitContext *pb, int header_bits);
 -void ff_mjpeg_encode_stuffing(PutBitContext *pbc);
 +void ff_mjpeg_encode_stuffing(MpegEncContext *s);
  void ff_mjpeg_encode_dc(MpegEncContext *s, int val,
                          uint8_t *huff_size, uint16_t *huff_code);
  void ff_mjpeg_encode_mb(MpegEncContext *s, int16_t block[6][64]);
@@@ -5,20 -5,20 +5,20 @@@
   *
   * 4MV & hq & B-frame encoding stuff by Michael Niedermayer <michaelni@gmx.at>
   *
 - * This file is part of Libav.
 + * This file is part of FFmpeg.
   *
 - * Libav is free software; you can redistribute it and/or
 + * FFmpeg is free software; you can redistribute it and/or
   * modify it under the terms of the GNU Lesser General Public
   * License as published by the Free Software Foundation; either
   * version 2.1 of the License, or (at your option) any later version.
   *
 - * Libav is distributed in the hope that it will be useful,
 + * FFmpeg is distributed in the hope that it will be useful,
   * but WITHOUT ANY WARRANTY; without even the implied warranty of
   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   * Lesser General Public License for more details.
   *
   * You should have received a copy of the GNU Lesser General Public
 - * License along with Libav; if not, write to the Free Software
 + * License along with FFmpeg; if not, write to the Free Software
   * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
   */
  
@@@ -52,7 -52,6 +52,7 @@@
  #include "internal.h"
  #include "bytestream.h"
  #include <limits.h>
 +#include "sp5x.h"
  
  static int encode_picture(MpegEncContext *s, int picture_number);
  static int dct_quantize_refine(MpegEncContext *s, int16_t *block, int16_t *weight, int16_t *orig, int n, int qscale);
@@@ -102,7 -101,8 +102,7 @@@ void ff_convert_matrix(DSPContext *dsp
                   *           3444240 >= (1 << 36) / (x) >= 275 */
  
                  qmat[qscale][i] = (int)((UINT64_C(1) << (QMAT_SHIFT + 14)) /
 -                                        (ff_aanscales[i] * qscale *
 -                                         quant_matrix[j]));
 +                                        (ff_aanscales[i] * (int64_t)qscale * quant_matrix[j]));
              }
          } else {
              for (i = 0; i < 64; i++) {
@@@ -222,22 -222,6 +222,22 @@@ static void MPV_encode_defaults(MpegEnc
      s->picture_in_gop_number = 0;
  }
  
 +av_cold int ff_dct_encode_init(MpegEncContext *s) {
 +    if (ARCH_X86)
 +        ff_dct_encode_init_x86(s);
 +
 +    ff_h263dsp_init(&s->h263dsp);
 +    if (!s->dct_quantize)
 +        s->dct_quantize = ff_dct_quantize_c;
 +    if (!s->denoise_dct)
 +        s->denoise_dct  = denoise_dct_c;
 +    s->fast_dct_quantize = s->dct_quantize;
 +    if (s->avctx->trellis)
 +        s->dct_quantize  = dct_quantize_trellis_c;
 +
 +    return 0;
 +}
 +
  /* init video encoder */
  av_cold int ff_MPV_encode_init(AVCodecContext *avctx)
  {
          if (avctx->pix_fmt != AV_PIX_FMT_YUVJ420P &&
              avctx->pix_fmt != AV_PIX_FMT_YUVJ422P &&
              avctx->pix_fmt != AV_PIX_FMT_YUVJ444P &&
 +            avctx->pix_fmt != AV_PIX_FMT_BGR0     &&
              avctx->pix_fmt != AV_PIX_FMT_BGRA     &&
 +            avctx->pix_fmt != AV_PIX_FMT_BGR24    &&
              ((avctx->pix_fmt != AV_PIX_FMT_YUV420P &&
                avctx->pix_fmt != AV_PIX_FMT_YUV422P &&
                avctx->pix_fmt != AV_PIX_FMT_YUV444P) ||
          }
          break;
      case AV_CODEC_ID_MJPEG:
 +    case AV_CODEC_ID_AMV:
          if (avctx->pix_fmt != AV_PIX_FMT_YUVJ420P &&
              avctx->pix_fmt != AV_PIX_FMT_YUVJ422P &&
 +            avctx->pix_fmt != AV_PIX_FMT_YUVJ444P &&
              ((avctx->pix_fmt != AV_PIX_FMT_YUV420P &&
 -              avctx->pix_fmt != AV_PIX_FMT_YUV422P) ||
 +              avctx->pix_fmt != AV_PIX_FMT_YUV422P &&
 +              avctx->pix_fmt != AV_PIX_FMT_YUV444P) ||
               avctx->strict_std_compliance > FF_COMPLIANCE_UNOFFICIAL)) {
              av_log(avctx, AV_LOG_ERROR, "colorspace not supported in jpeg\n");
              return -1;
      }
  
      switch (avctx->pix_fmt) {
 +    case AV_PIX_FMT_YUVJ444P:
 +    case AV_PIX_FMT_YUV444P:
 +        s->chroma_format = CHROMA_444;
 +        break;
      case AV_PIX_FMT_YUVJ422P:
      case AV_PIX_FMT_YUV422P:
          s->chroma_format = CHROMA_422;
      s->height   = avctx->height;
      if (avctx->gop_size > 600 &&
          avctx->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) {
 -        av_log(avctx, AV_LOG_ERROR,
 -               "Warning keyframe interval too large! reducing it ...\n");
 +        av_log(avctx, AV_LOG_WARNING,
 +               "keyframe interval too large!, reducing it from %d to %d\n",
 +               avctx->gop_size, 600);
          avctx->gop_size = 600;
      }
      s->gop_size     = avctx->gop_size;
      if (avctx->max_b_frames > MAX_B_FRAMES) {
          av_log(avctx, AV_LOG_ERROR, "Too many B-frames requested, maximum "
                 "is %d.\n", MAX_B_FRAMES);
 +        avctx->max_b_frames = MAX_B_FRAMES;
      }
      s->max_b_frames = avctx->max_b_frames;
      s->codec_id     = avctx->codec->id;
      s->loop_filter      = !!(s->flags & CODEC_FLAG_LOOP_FILTER);
  
      if (avctx->rc_max_rate && !avctx->rc_buffer_size) {
 -        av_log(avctx, AV_LOG_ERROR,
 -               "a vbv buffer size is needed, "
 -               "for encoding with a maximum bitrate\n");
 -        return -1;
 +        switch(avctx->codec_id) {
 +        case AV_CODEC_ID_MPEG1VIDEO:
 +        case AV_CODEC_ID_MPEG2VIDEO:
 +            avctx->rc_buffer_size = FFMAX(avctx->rc_max_rate, 15000000) * 112L / 15000000 * 16384;
 +            break;
 +        case AV_CODEC_ID_MPEG4:
 +        case AV_CODEC_ID_MSMPEG4V1:
 +        case AV_CODEC_ID_MSMPEG4V2:
 +        case AV_CODEC_ID_MSMPEG4V3:
 +            if       (avctx->rc_max_rate >= 15000000) {
 +                avctx->rc_buffer_size = 320 + (avctx->rc_max_rate - 15000000L) * (760-320) / (38400000 - 15000000);
 +            } else if(avctx->rc_max_rate >=  2000000) {
 +                avctx->rc_buffer_size =  80 + (avctx->rc_max_rate -  2000000L) * (320- 80) / (15000000 -  2000000);
 +            } else if(avctx->rc_max_rate >=   384000) {
 +                avctx->rc_buffer_size =  40 + (avctx->rc_max_rate -   384000L) * ( 80- 40) / ( 2000000 -   384000);
 +            } else
 +                avctx->rc_buffer_size = 40;
 +            avctx->rc_buffer_size *= 16384;
 +            break;
 +        }
 +        if (avctx->rc_buffer_size) {
 +            av_log(avctx, AV_LOG_INFO, "Automatically choosing VBV buffer size of %d kbyte\n", avctx->rc_buffer_size/8192);
 +        }
 +    }
 +
 +    if ((!avctx->rc_max_rate) != (!avctx->rc_buffer_size)) {
 +        av_log(avctx, AV_LOG_ERROR, "Either both buffer size and max rate or neither must be specified\n");
 +        if (avctx->rc_max_rate && !avctx->rc_buffer_size)
 +            return -1;
      }
  
      if (avctx->rc_min_rate && avctx->rc_max_rate != avctx->rc_min_rate) {
      }
  
      if (avctx->rc_max_rate && avctx->rc_max_rate < avctx->bit_rate) {
 -        av_log(avctx, AV_LOG_INFO, "bitrate above max bitrate\n");
 +        av_log(avctx, AV_LOG_ERROR, "bitrate above max bitrate\n");
          return -1;
      }
  
          av_log(avctx, AV_LOG_ERROR, "b frames not supported by codec\n");
          return -1;
      }
 +    if (s->max_b_frames < 0) {
 +        av_log(avctx, AV_LOG_ERROR,
 +               "max b frames must be 0 or positive for mpegvideo based encoders\n");
 +        return -1;
 +    }
  
      if ((s->codec_id == AV_CODEC_ID_MPEG4 ||
           s->codec_id == AV_CODEC_ID_H263  ||
           s->codec_id == AV_CODEC_ID_H263P) &&
          (avctx->sample_aspect_ratio.num > 255 ||
           avctx->sample_aspect_ratio.den > 255)) {
 -        av_log(avctx, AV_LOG_ERROR,
 -               "Invalid pixel aspect ratio %i/%i, limit is 255/255\n",
 +        av_log(avctx, AV_LOG_WARNING,
 +               "Invalid pixel aspect ratio %i/%i, limit is 255/255 reducing\n",
                 avctx->sample_aspect_ratio.num, avctx->sample_aspect_ratio.den);
 +        av_reduce(&avctx->sample_aspect_ratio.num, &avctx->sample_aspect_ratio.den,
 +                   avctx->sample_aspect_ratio.num,  avctx->sample_aspect_ratio.den, 255);
 +    }
 +
 +    if ((s->codec_id == AV_CODEC_ID_H263  ||
 +         s->codec_id == AV_CODEC_ID_H263P) &&
 +        (avctx->width  > 2048 ||
 +         avctx->height > 1152 )) {
 +        av_log(avctx, AV_LOG_ERROR, "H.263 does not support resolutions above 2048x1152\n");
 +        return -1;
 +    }
 +    if ((s->codec_id == AV_CODEC_ID_H263  ||
 +         s->codec_id == AV_CODEC_ID_H263P) &&
 +        ((avctx->width &3) ||
 +         (avctx->height&3) )) {
 +        av_log(avctx, AV_LOG_ERROR, "w/h must be a multiple of 4\n");
 +        return -1;
 +    }
 +
 +    if (s->codec_id == AV_CODEC_ID_MPEG1VIDEO &&
 +        (avctx->width  > 4095 ||
 +         avctx->height > 4095 )) {
 +        av_log(avctx, AV_LOG_ERROR, "MPEG-1 does not support resolutions above 4095x4095\n");
 +        return -1;
 +    }
 +
 +    if (s->codec_id == AV_CODEC_ID_MPEG2VIDEO &&
 +        (avctx->width  > 16383 ||
 +         avctx->height > 16383 )) {
 +        av_log(avctx, AV_LOG_ERROR, "MPEG-2 does not support resolutions above 16383x16383\n");
          return -1;
      }
  
 +    if (s->codec_id == AV_CODEC_ID_RV10 &&
 +        (avctx->width &15 ||
 +         avctx->height&15 )) {
 +        av_log(avctx, AV_LOG_ERROR, "width and height must be a multiple of 16\n");
 +        return AVERROR(EINVAL);
 +    }
 +
 +    if (s->codec_id == AV_CODEC_ID_RV20 &&
 +        (avctx->width &3 ||
 +         avctx->height&3 )) {
 +        av_log(avctx, AV_LOG_ERROR, "width and height must be a multiple of 4\n");
 +        return AVERROR(EINVAL);
 +    }
 +
 +    if ((s->codec_id == AV_CODEC_ID_WMV1 ||
 +         s->codec_id == AV_CODEC_ID_WMV2) &&
 +         avctx->width & 1) {
 +         av_log(avctx, AV_LOG_ERROR, "width must be multiple of 2\n");
 +         return -1;
 +    }
 +
      if ((s->flags & (CODEC_FLAG_INTERLACED_DCT | CODEC_FLAG_INTERLACED_ME)) &&
          s->codec_id != AV_CODEC_ID_MPEG4 && s->codec_id != AV_CODEC_ID_MPEG2VIDEO) {
          av_log(avctx, AV_LOG_ERROR, "interlacing not supported by codec\n");
      }
  
      // FIXME mpeg2 uses that too
 -    if (s->mpeg_quant && s->codec_id != AV_CODEC_ID_MPEG4) {
 +    if (s->mpeg_quant && (   s->codec_id != AV_CODEC_ID_MPEG4
 +                          && s->codec_id != AV_CODEC_ID_MPEG2VIDEO)) {
          av_log(avctx, AV_LOG_ERROR,
                 "mpeg2 style quantization not supported by codec\n");
          return -1;
          s->codec_id != AV_CODEC_ID_MPEG4      &&
          s->codec_id != AV_CODEC_ID_MPEG1VIDEO &&
          s->codec_id != AV_CODEC_ID_MPEG2VIDEO &&
 +        s->codec_id != AV_CODEC_ID_MJPEG      &&
          (s->codec_id != AV_CODEC_ID_H263P)) {
          av_log(avctx, AV_LOG_ERROR,
                 "multi threaded encoding not supported by codec\n");
  
      if (s->avctx->thread_count < 1) {
          av_log(avctx, AV_LOG_ERROR,
 -               "automatic thread number detection not supported by codec,"
 +               "automatic thread number detection not supported by codec, "
                 "patch welcome\n");
          return -1;
      }
  
 -    if (s->avctx->thread_count > 1)
 +    if (s->avctx->slices > 1 || s->avctx->thread_count > 1)
          s->rtp_mode = 1;
  
 +    if (s->avctx->thread_count > 1 && s->codec_id == AV_CODEC_ID_H263P)
 +        s->h263_slice_structured = 1;
 +
      if (!avctx->time_base.den || !avctx->time_base.num) {
          av_log(avctx, AV_LOG_ERROR, "framerate not set\n");
          return -1;
          //return -1;
      }
  
 -    if (s->mpeg_quant || s->codec_id == AV_CODEC_ID_MPEG1VIDEO ||
 -        s->codec_id == AV_CODEC_ID_MPEG2VIDEO || s->codec_id == AV_CODEC_ID_MJPEG) {
 +    if (s->mpeg_quant || s->codec_id == AV_CODEC_ID_MPEG1VIDEO || s->codec_id == AV_CODEC_ID_MPEG2VIDEO || s->codec_id == AV_CODEC_ID_MJPEG || s->codec_id==AV_CODEC_ID_AMV) {
          // (a + x * 3 / 8) / x
          s->intra_quant_bias = 3 << (QUANT_BIAS_SHIFT - 3);
          s->inter_quant_bias = 0;
          s->inter_quant_bias = -(1 << (QUANT_BIAS_SHIFT - 2));
      }
  
 +    if (avctx->qmin > avctx->qmax || avctx->qmin <= 0) {
 +        av_log(avctx, AV_LOG_ERROR, "qmin and or qmax are invalid, they must be 0 < min <= max\n");
 +        return AVERROR(EINVAL);
 +    }
 +
      if (avctx->intra_quant_bias != FF_DEFAULT_QUANT_BIAS)
          s->intra_quant_bias = avctx->intra_quant_bias;
      if (avctx->inter_quant_bias != FF_DEFAULT_QUANT_BIAS)
          s->inter_quant_bias = avctx->inter_quant_bias;
  
 -    av_pix_fmt_get_chroma_sub_sample(avctx->pix_fmt, &chroma_h_shift,
 -                                     &chroma_v_shift);
 +    av_log(avctx, AV_LOG_DEBUG, "intra_quant_bias = %d inter_quant_bias = %d\n",s->intra_quant_bias,s->inter_quant_bias);
 +
 +    avcodec_get_chroma_sub_sample(avctx->pix_fmt, &chroma_h_shift, &chroma_v_shift);
  
      if (avctx->codec_id == AV_CODEC_ID_MPEG4 &&
          s->avctx->time_base.den > (1 << 16) - 1) {
          break;
      case AV_CODEC_ID_LJPEG:
      case AV_CODEC_ID_MJPEG:
 +    case AV_CODEC_ID_AMV:
          s->out_format = FMT_MJPEG;
          s->intra_only = 1; /* force intra only for jpeg */
          if (avctx->codec->id == AV_CODEC_ID_LJPEG &&
 -            avctx->pix_fmt   == AV_PIX_FMT_BGRA) {
 +            (avctx->pix_fmt == AV_PIX_FMT_BGR0
 +             || s->avctx->pix_fmt == AV_PIX_FMT_BGRA
 +             || s->avctx->pix_fmt == AV_PIX_FMT_BGR24)) {
              s->mjpeg_vsample[0] = s->mjpeg_hsample[0] =
              s->mjpeg_vsample[1] = s->mjpeg_hsample[1] =
              s->mjpeg_vsample[2] = s->mjpeg_hsample[2] = 1;
 +        } else if (avctx->pix_fmt == AV_PIX_FMT_YUV444P || avctx->pix_fmt == AV_PIX_FMT_YUVJ444P) {
 +            s->mjpeg_vsample[0] = s->mjpeg_vsample[1] = s->mjpeg_vsample[2] = 2;
 +            s->mjpeg_hsample[0] = s->mjpeg_hsample[1] = s->mjpeg_hsample[2] = 1;
          } else {
              s->mjpeg_vsample[0] = 2;
              s->mjpeg_vsample[1] = 2 >> chroma_v_shift;
          break;
      case AV_CODEC_ID_H263:
          if (!CONFIG_H263_ENCODER)
 -        return -1;
 +            return -1;
          if (ff_match_2uint16(ff_h263_format, FF_ARRAY_ELEMS(ff_h263_format),
                               s->width, s->height) == 8) {
 -            av_log(avctx, AV_LOG_INFO,
 +            av_log(avctx, AV_LOG_ERROR,
                     "The specified picture size of %dx%d is not valid for "
                     "the H.263 codec.\nValid sizes are 128x96, 176x144, "
 -                   "352x288, 704x576, and 1408x1152."
 +                   "352x288, 704x576, and 1408x1152. "
                     "Try H.263+.\n", s->width, s->height);
              return -1;
          }
      if (ff_MPV_common_init(s) < 0)
          return -1;
  
 -    if (ARCH_X86)
 -        ff_MPV_encode_init_x86(s);
 -
      s->avctx->coded_frame = &s->current_picture.f;
  
      if (s->msmpeg4_version) {
      FF_ALLOCZ_OR_GOTO(s->avctx, s->avctx->stats_out, 256, fail);
  
      FF_ALLOCZ_OR_GOTO(s->avctx, s->q_intra_matrix,   64 * 32 * sizeof(int), fail);
 +    FF_ALLOCZ_OR_GOTO(s->avctx, s->q_chroma_intra_matrix, 64 * 32 * sizeof(int), fail);
      FF_ALLOCZ_OR_GOTO(s->avctx, s->q_inter_matrix,   64 * 32 * sizeof(int), fail);
      FF_ALLOCZ_OR_GOTO(s->avctx, s->q_intra_matrix16, 64 * 32 * 2 * sizeof(uint16_t), fail);
 +    FF_ALLOCZ_OR_GOTO(s->avctx, s->q_chroma_intra_matrix16, 64 * 32 * 2 * sizeof(uint16_t), fail);
      FF_ALLOCZ_OR_GOTO(s->avctx, s->q_inter_matrix16, 64 * 32 * 2 * sizeof(uint16_t), fail);
      FF_ALLOCZ_OR_GOTO(s->avctx, s->input_picture,
                        MAX_PICTURE_COUNT * sizeof(Picture *), fail);
                            2 * 64 * sizeof(uint16_t), fail);
      }
  
 -    ff_h263dsp_init(&s->h263dsp);
 -    if (!s->dct_quantize)
 -        s->dct_quantize = ff_dct_quantize_c;
 -    if (!s->denoise_dct)
 -        s->denoise_dct  = denoise_dct_c;
 -    s->fast_dct_quantize = s->dct_quantize;
 -    if (avctx->trellis)
 -        s->dct_quantize  = dct_quantize_trellis_c;
 +    ff_dct_encode_init(s);
  
      if ((CONFIG_H263P_ENCODER || CONFIG_RV20_ENCODER) && s->modified_quant)
          s->chroma_qscale_table = ff_h263_chroma_qscale_table;
@@@ -969,10 -853,6 +969,10 @@@ av_cold int ff_MPV_encode_end(AVCodecCo
      av_freep(&s->avctx->stats_out);
      av_freep(&s->ac_stats);
  
 +    if(s->q_chroma_intra_matrix   != s->q_intra_matrix  ) av_freep(&s->q_chroma_intra_matrix);
 +    if(s->q_chroma_intra_matrix16 != s->q_intra_matrix16) av_freep(&s->q_chroma_intra_matrix16);
 +    s->q_chroma_intra_matrix=   NULL;
 +    s->q_chroma_intra_matrix16= NULL;
      av_freep(&s->q_intra_matrix);
      av_freep(&s->q_inter_matrix);
      av_freep(&s->q_intra_matrix16);
@@@ -1037,17 -917,18 +1037,17 @@@ static int load_input_picture(MpegEncCo
  
          if (pts != AV_NOPTS_VALUE) {
              if (s->user_specified_pts != AV_NOPTS_VALUE) {
 -                int64_t time = pts;
                  int64_t last = s->user_specified_pts;
  
 -                if (time <= last) {
 +                if (pts <= last) {
                      av_log(s->avctx, AV_LOG_ERROR,
 -                           "Error, Invalid timestamp=%"PRId64", "
 -                           "last=%"PRId64"\n", pts, s->user_specified_pts);
 -                    return -1;
 +                           "Invalid pts (%"PRId64") <= last (%"PRId64")\n",
 +                           pts, last);
 +                    return AVERROR(EINVAL);
                  }
  
                  if (!s->low_delay && display_picture_number == 1)
 -                    s->dts_delta = time - last;
 +                    s->dts_delta = pts - last;
              }
              s->user_specified_pts = pts;
          } else {
      }
  
      if (pic_arg) {
 -        if (!pic_arg->buf[0]);
 +        if (!pic_arg->buf[0])
              direct = 0;
          if (pic_arg->linesize[0] != s->linesize)
              direct = 0;
                      uint8_t *src = pic_arg->data[i];
                      uint8_t *dst = pic->f.data[i];
  
 +                    if (s->codec_id == AV_CODEC_ID_AMV && !(s->avctx->flags & CODEC_FLAG_EMU_EDGE)) {
 +                        h = ((s->height + 15)/16*16) >> v_shift;
 +                    }
 +
                      if (!s->avctx->rc_buffer_size)
                          dst += INPLACE_OFFSET;
  
                      if (src_stride == dst_stride)
                          memcpy(dst, src, src_stride * h);
                      else {
 -                        while (h--) {
 -                            memcpy(dst, src, w);
 -                            dst += dst_stride;
 +                        int h2 = h;
 +                        uint8_t *dst2 = dst;
 +                        while (h2--) {
 +                            memcpy(dst2, src, w);
 +                            dst2 += dst_stride;
                              src += src_stride;
                          }
                      }
 +                    if ((s->width & 15) || (s->height & 15)) {
 +                        s->dsp.draw_edges(dst, dst_stride,
 +                                          w, h,
 +                                          16>>h_shift,
 +                                          16>>v_shift,
 +                                          EDGE_BOTTOM);
 +                    }
                  }
              }
          }
@@@ -1227,7 -1095,7 +1227,7 @@@ static int estimate_best_b_count(MpegEn
      int64_t best_rd  = INT64_MAX;
      int best_b_count = -1;
  
 -    assert(scale >= 0 && scale <= 3);
 +    av_assert0(scale >= 0 && scale <= 3);
  
      //emms_c();
      //s->next_picture_ptr->quality;
@@@ -1515,15 -1383,15 +1515,15 @@@ static void frame_end(MpegEncContext *s
          const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(s->avctx->pix_fmt);
          int hshift = desc->log2_chroma_w;
          int vshift = desc->log2_chroma_h;
 -        s->dsp.draw_edges(s->current_picture.f.data[0], s->linesize,
 +        s->dsp.draw_edges(s->current_picture.f.data[0], s->current_picture.f.linesize[0],
                            s->h_edge_pos, s->v_edge_pos,
                            EDGE_WIDTH, EDGE_WIDTH,
                            EDGE_TOP | EDGE_BOTTOM);
 -        s->dsp.draw_edges(s->current_picture.f.data[1], s->uvlinesize,
 +        s->dsp.draw_edges(s->current_picture.f.data[1], s->current_picture.f.linesize[1],
                            s->h_edge_pos >> hshift, s->v_edge_pos >> vshift,
                            EDGE_WIDTH >> hshift, EDGE_WIDTH >> vshift,
                            EDGE_TOP | EDGE_BOTTOM);
 -        s->dsp.draw_edges(s->current_picture.f.data[2], s->uvlinesize,
 +        s->dsp.draw_edges(s->current_picture.f.data[2], s->current_picture.f.linesize[2],
                            s->h_edge_pos >> hshift, s->v_edge_pos >> vshift,
                            EDGE_WIDTH >> hshift, EDGE_WIDTH >> vshift,
                            EDGE_TOP | EDGE_BOTTOM);
      if (s->pict_type!= AV_PICTURE_TYPE_B)
          s->last_non_b_pict_type = s->pict_type;
  
 -    if (s->encoding) {
 -        /* release non-reference frames */
 -        for (i = 0; i < MAX_PICTURE_COUNT; i++) {
 -            if (!s->picture[i].reference)
 -                ff_mpeg_unref_picture(s, &s->picture[i]);
 -        }
 -    }
 -
      s->avctx->coded_frame = &s->current_picture_ptr->f;
  
  }
  
  int ff_MPV_encode_picture(AVCodecContext *avctx, AVPacket *pkt,
 -                          const AVFrame *pic_arg, int *got_packet)
 +                          AVFrame *pic_arg, int *got_packet)
  {
      MpegEncContext *s = avctx->priv_data;
      int i, stuffing_count, ret;
  
      /* output? */
      if (s->new_picture.f.data[0]) {
 -        if (!pkt->data &&
 -            (ret = ff_alloc_packet(pkt, s->mb_width*s->mb_height*MAX_MB_BYTES)) < 0)
 +        if ((ret = ff_alloc_packet2(avctx, pkt, s->mb_width*s->mb_height*(MAX_MB_BYTES+100)+10000)) < 0)
              return ret;
          if (s->mb_info) {
              s->mb_info_ptr = av_packet_new_side_data(pkt,
  
          s->pict_type = s->new_picture.f.pict_type;
          //emms_c();
 -        ff_MPV_frame_start(s, avctx);
 +        if (ff_MPV_frame_start(s, avctx) < 0)
 +            return -1;
  vbv_retry:
          if (encode_picture(s, s->picture_number) < 0)
              return -1;
          frame_end(s);
  
          if (CONFIG_MJPEG_ENCODER && s->out_format == FMT_MJPEG)
-             ff_mjpeg_encode_picture_trailer(s);
+             ff_mjpeg_encode_picture_trailer(&s->pb, s->header_bits);
  
          if (avctx->rc_buffer_size) {
              RateControlContext *rcc = &s->rc_context;
          s->frame_bits  = put_bits_count(&s->pb);
  
          stuffing_count = ff_vbv_update(s, s->frame_bits);
 +        s->stuffing_bits = 8*stuffing_count;
          if (stuffing_count) {
              if (s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb) >> 3) <
                      stuffing_count + 50) {
  
              vbv_delay = FFMAX(vbv_delay, min_delay);
  
 -            assert(vbv_delay < 0xFFFF);
 +            av_assert0(vbv_delay < 0xFFFF);
  
              s->vbv_delay_ptr[0] &= 0xF8;
              s->vbv_delay_ptr[0] |= vbv_delay >> 13;
          avctx->frame_bits  = s->frame_bits;
  
          pkt->pts = s->current_picture.f.pts;
 -        if (!s->low_delay) {
 +        if (!s->low_delay && s->pict_type != AV_PICTURE_TYPE_B) {
              if (!s->current_picture.f.coded_picture_number)
                  pkt->dts = pkt->pts - s->dts_delta;
              else
                  pkt->dts = s->reordered_pts;
 -            s->reordered_pts = s->input_picture[0]->f.pts;
 +            s->reordered_pts = pkt->pts;
          } else
              pkt->dts = pkt->pts;
          if (s->current_picture.f.key_frame)
      } else {
          s->frame_bits = 0;
      }
 +
 +    /* release non-reference frames */
 +    for (i = 0; i < MAX_PICTURE_COUNT; i++) {
 +        if (!s->picture[i].reference)
 +            ff_mpeg_unref_picture(s, &s->picture[i]);
 +    }
 +
      assert((s->frame_bits & 7) == 0);
  
      pkt->size = s->frame_bits / 8;
@@@ -1868,17 -1736,15 +1868,17 @@@ static void get_visual_weight(int16_t *
  static av_always_inline void encode_mb_internal(MpegEncContext *s,
                                                  int motion_x, int motion_y,
                                                  int mb_block_height,
 +                                                int mb_block_width,
                                                  int mb_block_count)
  {
 -    int16_t weight[8][64];
 -    int16_t orig[8][64];
 +    int16_t weight[12][64];
 +    int16_t orig[12][64];
      const int mb_x = s->mb_x;
      const int mb_y = s->mb_y;
      int i;
 -    int skip_dct[8];
 +    int skip_dct[12];
      int dct_offset = s->linesize * 8; // default for progressive frames
 +    int uv_dct_offset = s->uvlinesize * 8;
      uint8_t *ptr_y, *ptr_cb, *ptr_cr;
      ptrdiff_t wrap_y, wrap_c;
  
      ptr_y  = s->new_picture.f.data[0] +
               (mb_y * 16 * wrap_y)              + mb_x * 16;
      ptr_cb = s->new_picture.f.data[1] +
 -             (mb_y * mb_block_height * wrap_c) + mb_x * 8;
 +             (mb_y * mb_block_height * wrap_c) + mb_x * mb_block_width;
      ptr_cr = s->new_picture.f.data[2] +
 -             (mb_y * mb_block_height * wrap_c) + mb_x * 8;
 +             (mb_y * mb_block_height * wrap_c) + mb_x * mb_block_width;
  
 -    if (mb_x * 16 + 16 > s->width || mb_y * 16 + 16 > s->height) {
 +    if((mb_x * 16 + 16 > s->width || mb_y * 16 + 16 > s->height) && s->codec_id != AV_CODEC_ID_AMV){
          uint8_t *ebuf = s->edge_emu_buffer + 32;
 +        int cw = (s->width  + s->chroma_x_shift) >> s->chroma_x_shift;
 +        int ch = (s->height + s->chroma_y_shift) >> s->chroma_y_shift;
          s->vdsp.emulated_edge_mc(ebuf, ptr_y,
                                   wrap_y, wrap_y,
                                   16, 16, mb_x * 16, mb_y * 16,
          ptr_y = ebuf;
          s->vdsp.emulated_edge_mc(ebuf + 18 * wrap_y, ptr_cb,
                                   wrap_c, wrap_c,
 -                                 8, mb_block_height, mb_x * 8, mb_y * 8,
 -                                 s->width >> 1, s->height >> 1);
 +                                 mb_block_width, mb_block_height,
 +                                 mb_x * mb_block_width, mb_y * mb_block_height,
 +                                 cw, ch);
          ptr_cb = ebuf + 18 * wrap_y;
 -        s->vdsp.emulated_edge_mc(ebuf + 18 * wrap_y + 8, ptr_cr,
 +        s->vdsp.emulated_edge_mc(ebuf + 18 * wrap_y + 16, ptr_cr,
                                   wrap_c, wrap_c,
 -                                 8, mb_block_height, mb_x * 8, mb_y * 8,
 -                                 s->width >> 1, s->height >> 1);
 -        ptr_cr = ebuf + 18 * wrap_y + 8;
 +                                 mb_block_width, mb_block_height,
 +                                 mb_x * mb_block_width, mb_y * mb_block_height,
 +                                 cw, ch);
 +        ptr_cr = ebuf + 18 * wrap_y + 16;
      }
  
      if (s->mb_intra) {
                      s->interlaced_dct = 1;
  
                      dct_offset = wrap_y;
 +                    uv_dct_offset = wrap_c;
                      wrap_y <<= 1;
 -                    if (s->chroma_format == CHROMA_422)
 +                    if (s->chroma_format == CHROMA_422 ||
 +                        s->chroma_format == CHROMA_444)
                          wrap_c <<= 1;
                  }
              }
          } else {
              s->dsp.get_pixels(s->block[4], ptr_cb, wrap_c);
              s->dsp.get_pixels(s->block[5], ptr_cr, wrap_c);
 -            if (!s->chroma_y_shift) { /* 422 */
 -                s->dsp.get_pixels(s->block[6],
 -                                  ptr_cb + (dct_offset >> 1), wrap_c);
 -                s->dsp.get_pixels(s->block[7],
 -                                  ptr_cr + (dct_offset >> 1), wrap_c);
 +            if (!s->chroma_y_shift && s->chroma_x_shift) { /* 422 */
 +                s->dsp.get_pixels(s->block[6], ptr_cb + uv_dct_offset, wrap_c);
 +                s->dsp.get_pixels(s->block[7], ptr_cr + uv_dct_offset, wrap_c);
 +            } else if (!s->chroma_y_shift && !s->chroma_x_shift) { /* 444 */
 +                s->dsp.get_pixels(s->block[6], ptr_cb + 8, wrap_c);
 +                s->dsp.get_pixels(s->block[7], ptr_cr + 8, wrap_c);
 +                s->dsp.get_pixels(s->block[8], ptr_cb + uv_dct_offset, wrap_c);
 +                s->dsp.get_pixels(s->block[9], ptr_cr + uv_dct_offset, wrap_c);
 +                s->dsp.get_pixels(s->block[10], ptr_cb + uv_dct_offset + 8, wrap_c);
 +                s->dsp.get_pixels(s->block[11], ptr_cr + uv_dct_offset + 8, wrap_c);
              }
          }
      } else {
                      s->interlaced_dct = 1;
  
                      dct_offset = wrap_y;
 +                    uv_dct_offset = wrap_c;
                      wrap_y <<= 1;
                      if (s->chroma_format == CHROMA_422)
                          wrap_c <<= 1;
              s->dsp.diff_pixels(s->block[4], ptr_cb, dest_cb, wrap_c);
              s->dsp.diff_pixels(s->block[5], ptr_cr, dest_cr, wrap_c);
              if (!s->chroma_y_shift) { /* 422 */
 -                s->dsp.diff_pixels(s->block[6], ptr_cb + (dct_offset >> 1),
 -                                   dest_cb + (dct_offset >> 1), wrap_c);
 -                s->dsp.diff_pixels(s->block[7], ptr_cr + (dct_offset >> 1),
 -                                   dest_cr + (dct_offset >> 1), wrap_c);
 +                s->dsp.diff_pixels(s->block[6], ptr_cb + uv_dct_offset,
 +                                   dest_cb + uv_dct_offset, wrap_c);
 +                s->dsp.diff_pixels(s->block[7], ptr_cr + uv_dct_offset,
 +                                   dest_cr + uv_dct_offset, wrap_c);
              }
          }
          /* pre quantization */
                                wrap_c, 8) < 20 * s->qscale)
                  skip_dct[5] = 1;
              if (!s->chroma_y_shift) { /* 422 */
 -                if (s->dsp.sad[1](NULL, ptr_cb + (dct_offset >> 1),
 -                                  dest_cb + (dct_offset >> 1),
 +                if (s->dsp.sad[1](NULL, ptr_cb + uv_dct_offset,
 +                                  dest_cb + uv_dct_offset,
                                    wrap_c, 8) < 20 * s->qscale)
                      skip_dct[6] = 1;
 -                if (s->dsp.sad[1](NULL, ptr_cr + (dct_offset >> 1),
 -                                  dest_cr + (dct_offset >> 1),
 +                if (s->dsp.sad[1](NULL, ptr_cr + uv_dct_offset,
 +                                  dest_cr + uv_dct_offset,
                                    wrap_c, 8) < 20 * s->qscale)
                      skip_dct[7] = 1;
              }
              get_visual_weight(weight[5], ptr_cr                , wrap_c);
          if (!s->chroma_y_shift) { /* 422 */
              if (!skip_dct[6])
 -                get_visual_weight(weight[6], ptr_cb + (dct_offset >> 1),
 +                get_visual_weight(weight[6], ptr_cb + uv_dct_offset,
                                    wrap_c);
              if (!skip_dct[7])
 -                get_visual_weight(weight[7], ptr_cr + (dct_offset >> 1),
 +                get_visual_weight(weight[7], ptr_cr + uv_dct_offset,
                                    wrap_c);
          }
          memcpy(orig[0], s->block[0], sizeof(int16_t) * 64 * mb_block_count);
      }
  
      /* DCT & quantize */
 -    assert(s->out_format != FMT_MJPEG || s->qscale == 8);
 +    av_assert2(s->out_format != FMT_MJPEG || s->qscale == 8);
      {
          for (i = 0; i < mb_block_count; i++) {
              if (!skip_dct[i]) {
          s->block_last_index[5] = 0;
          s->block[4][0] =
          s->block[5][0] = (1024 + s->c_dc_scale / 2) / s->c_dc_scale;
 +        if (!s->chroma_y_shift) { /* 422 / 444 */
 +            for (i=6; i<12; i++) {
 +                s->block_last_index[i] = 0;
 +                s->block[i][0] = s->block[4][0];
 +            }
 +        }
      }
  
      // non c quantize code returns incorrect block_last_index FIXME
              ff_h263_encode_mb(s, s->block, motion_x, motion_y);
          break;
      case AV_CODEC_ID_MJPEG:
 +    case AV_CODEC_ID_AMV:
          if (CONFIG_MJPEG_ENCODER)
              ff_mjpeg_encode_mb(s, s->block);
          break;
      default:
 -        assert(0);
 +        av_assert1(0);
      }
  }
  
  static av_always_inline void encode_mb(MpegEncContext *s, int motion_x, int motion_y)
  {
 -    if (s->chroma_format == CHROMA_420) encode_mb_internal(s, motion_x, motion_y,  8, 6);
 -    else                                encode_mb_internal(s, motion_x, motion_y, 16, 8);
 +    if (s->chroma_format == CHROMA_420) encode_mb_internal(s, motion_x, motion_y,  8, 8, 6);
 +    else if (s->chroma_format == CHROMA_422) encode_mb_internal(s, motion_x, motion_y, 16, 8, 8);
 +    else encode_mb_internal(s, motion_x, motion_y, 16, 16, 12);
  }
  
  static inline void copy_context_before_encode(MpegEncContext *d, MpegEncContext *s, int type){
@@@ -2395,7 -2241,7 +2395,7 @@@ static int sse(MpegEncContext *s, uint8
          }
      }
  
 -    assert(acc>=0);
 +    av_assert2(acc>=0);
  
      return acc;
  }
@@@ -2501,7 -2347,7 +2501,7 @@@ static void write_slice_end(MpegEncCont
  
          ff_mpeg4_stuffing(&s->pb);
      }else if(CONFIG_MJPEG_ENCODER && s->out_format == FMT_MJPEG){
 -        ff_mjpeg_encode_stuffing(&s->pb);
 +        ff_mjpeg_encode_stuffing(s);
      }
  
      avpriv_align_put_bits(&s->pb);
@@@ -2590,11 -2436,6 +2590,11 @@@ static int encode_thread(AVCodecContex
  
          s->current_picture.f.error[i] = 0;
      }
 +    if(s->codec_id==AV_CODEC_ID_AMV){
 +        s->last_dc[0] = 128*8/13;
 +        s->last_dc[1] = 128*8/14;
 +        s->last_dc[2] = 128*8/14;
 +    }
      s->mb_skip_run = 0;
      memset(s->last_mv, 0, sizeof(s->last_mv));
  
              if(s->data_partitioning){
                  if(   s->pb2   .buf_end - s->pb2   .buf - (put_bits_count(&s->    pb2)>>3) < MAX_MB_BYTES
                     || s->tex_pb.buf_end - s->tex_pb.buf - (put_bits_count(&s->tex_pb )>>3) < MAX_MB_BYTES){
 -                    av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
 +                    av_log(s->avctx, AV_LOG_ERROR, "encoded partitioned frame too large\n");
                      return -1;
                  }
              }
                  case AV_CODEC_ID_MPEG1VIDEO:
                      if(s->mb_skip_run) is_gob_start=0;
                      break;
 +                case AV_CODEC_ID_MJPEG:
 +                    if(s->mb_x==0 && s->mb_y!=0) is_gob_start=1;
 +                    break;
                  }
  
                  if(is_gob_start){
                          }
                      }
  
 -                    assert((put_bits_count(&s->pb)&7) == 0);
 +                    av_assert2((put_bits_count(&s->pb)&7) == 0);
                      current_packet_size= put_bits_ptr(&s->pb) - s->ptr_lastgob;
  
                      if (s->error_rate && s->resync_mb_x + s->resync_mb_y > 0) {
                          int16_t ac[6][16];
                          const int mvdir= (best_s.mv_dir&MV_DIR_BACKWARD) ? 1 : 0;
                          static const int dquant_tab[4]={-1,1,-2,2};
 +                        int storecoefs = s->mb_intra && s->dc_val[0];
  
 -                        assert(backup_s.dquant == 0);
 +                        av_assert2(backup_s.dquant == 0);
  
                          //FIXME intra
                          s->mv_dir= best_s.mv_dir;
                              if(qp < s->avctx->qmin || qp > s->avctx->qmax)
                                  continue;
                              backup_s.dquant= dquant;
 -                            if(s->mb_intra && s->dc_val[0]){
 +                            if(storecoefs){
                                  for(i=0; i<6; i++){
                                      dc[i]= s->dc_val[0][ s->block_index[i] ];
                                      memcpy(ac[i], s->ac_val[0][s->block_index[i]], sizeof(int16_t)*16);
                              encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER /* wrong but unused */, pb, pb2, tex_pb,
                                           &dmin, &next_block, s->mv[mvdir][0][0], s->mv[mvdir][0][1]);
                              if(best_s.qscale != qp){
 -                                if(s->mb_intra && s->dc_val[0]){
 +                                if(storecoefs){
                                      for(i=0; i<6; i++){
                                          s->dc_val[0][ s->block_index[i] ]= dc[i];
                                          memcpy(s->ac_val[0][s->block_index[i]], ac[i], sizeof(int16_t)*16);
@@@ -3325,13 -3162,6 +3325,13 @@@ static int encode_picture(MpegEncContex
          update_qscale(s);
      }
  
 +    if(s->codec_id != AV_CODEC_ID_AMV){
 +        if(s->q_chroma_intra_matrix   != s->q_intra_matrix  ) av_freep(&s->q_chroma_intra_matrix);
 +        if(s->q_chroma_intra_matrix16 != s->q_intra_matrix16) av_freep(&s->q_chroma_intra_matrix16);
 +        s->q_chroma_intra_matrix   = s->q_intra_matrix;
 +        s->q_chroma_intra_matrix16 = s->q_intra_matrix16;
 +    }
 +
      s->mb_intra=0; //for the rate distortion & bit compare functions
      for(i=1; i<context_count; i++){
          ret = ff_update_duplicate_context(s->thread_context[i], s);
          s->pict_type= AV_PICTURE_TYPE_I;
          for(i=0; i<s->mb_stride*s->mb_height; i++)
              s->mb_type[i]= CANDIDATE_MB_TYPE_INTRA;
 +        if(s->msmpeg4_version >= 3)
 +            s->no_rounding=1;
          av_dlog(s, "Scene change detected, encoding as I Frame %d %d\n",
                  s->current_picture.mb_var_sum, s->current_picture.mc_mb_var_sum);
      }
                         s->intra_matrix, s->intra_quant_bias, 8, 8, 1);
          s->qscale= 8;
      }
 +    if(s->codec_id == AV_CODEC_ID_AMV){
 +        static const uint8_t y[32]={13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13};
 +        static const uint8_t c[32]={14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14};
 +        for(i=1;i<64;i++){
 +            int j= s->dsp.idct_permutation[ff_zigzag_direct[i]];
 +
 +            s->intra_matrix[j] = sp5x_quant_table[5*2+0][i];
 +            s->chroma_intra_matrix[j] = sp5x_quant_table[5*2+1][i];
 +        }
 +        s->y_dc_scale_table= y;
 +        s->c_dc_scale_table= c;
 +        s->intra_matrix[0] = 13;
 +        s->chroma_intra_matrix[0] = 14;
 +        ff_convert_matrix(&s->dsp, s->q_intra_matrix, s->q_intra_matrix16,
 +                       s->intra_matrix, s->intra_quant_bias, 8, 8, 1);
 +        ff_convert_matrix(&s->dsp, s->q_chroma_intra_matrix, s->q_chroma_intra_matrix16,
 +                       s->chroma_intra_matrix, s->intra_quant_bias, 8, 8, 1);
 +        s->qscale= 8;
 +    }
  
      //FIXME var duplication
      s->current_picture_ptr->f.key_frame =
      if (s->current_picture.f.key_frame)
          s->picture_in_gop_number=0;
  
 +    s->mb_x = s->mb_y = 0;
      s->last_bits= put_bits_count(&s->pb);
      switch(s->out_format) {
      case FMT_MJPEG:
              ff_mpeg1_encode_picture_header(s, picture_number);
          break;
      default:
 -        assert(0);
 +        av_assert0(0);
      }
      bits= put_bits_count(&s->pb);
      s->header_bits= bits - s->last_bits;
@@@ -3607,7 -3415,7 +3607,7 @@@ static int dct_quantize_trellis_c(MpegE
          block[0] = (block[0] + (q >> 1)) / q;
          start_i = 1;
          last_non_zero = 0;
 -        qmat = s->q_intra_matrix[qscale];
 +        qmat = n < 4 ? s->q_intra_matrix[qscale] : s->q_chroma_intra_matrix[qscale];
          if(s->mpeg_quant || s->out_format == FMT_MPEG1)
              bias= 1<<(QMAT_SHIFT-1);
          length     = s->intra_ac_vlc_length;
  //                coeff[2][k]= -level+2;
              }
              coeff_count[i]= FFMIN(level, 2);
 -            assert(coeff_count[i]);
 +            av_assert2(coeff_count[i]);
              max |=level;
          }else{
              coeff[0][i]= (level>>31)|1;
              const int alevel= FFABS(level);
              int unquant_coeff;
  
 -            assert(level);
 +            av_assert2(level);
  
 -            if(s->out_format == FMT_H263){
 +            if(s->out_format == FMT_H263 || s->out_format == FMT_H261){
                  unquant_coeff= alevel*qmul + qadd;
              }else{ //MPEG1
                  j= s->dsp.idct_permutation[ scantable[i] ]; //FIXME optimize
                      }
                  }
  
 -                if(s->out_format == FMT_H263){
 +                if(s->out_format == FMT_H263 || s->out_format == FMT_H261){
                      for(j=survivor_count-1; j>=0; j--){
                          int run= i - survivor[j];
                          int score= distortion + last_length[UNI_AC_ENC_INDEX(run, level)]*lambda;
                      }
                  }
  
 -                if(s->out_format == FMT_H263){
 +                if(s->out_format == FMT_H263 || s->out_format == FMT_H261){
                    for(j=survivor_count-1; j>=0; j--){
                          int run= i - survivor[j];
                          int score= distortion + score_tab[i-run];
          survivor[ survivor_count++ ]= i+1;
      }
  
 -    if(s->out_format != FMT_H263){
 +    if(s->out_format != FMT_H263 && s->out_format != FMT_H261){
          last_score= 256*256*256*120;
          for(i= survivor[0]; i<=last_non_zero + 1; i++){
              int score= score_tab[i];
              int alevel= FFABS(level);
              int unquant_coeff, score, distortion;
  
 -            if(s->out_format == FMT_H263){
 +            if(s->out_format == FMT_H263 || s->out_format == FMT_H261){
                      unquant_coeff= (alevel*qmul + qadd)>>3;
              }else{ //MPEG1
                      unquant_coeff = (((  alevel  << 1) + 1) * qscale * ((int) s->inter_matrix[0])) >> 4;
      }
  
      i= last_i;
 -    assert(last_level);
 +    av_assert2(last_level);
  
      block[ perm_scantable[last_non_zero] ]= last_level;
      i -= last_run + 1;
@@@ -3952,8 -3760,8 +3952,8 @@@ STOP_TIMER("memset rem[]")
          weight[i] = w;
  //        w=weight[i] = (63*qns + (w/2)) / w;
  
 -        assert(w>0);
 -        assert(w<(1<<6));
 +        av_assert2(w>0);
 +        av_assert2(w<(1<<6));
          sum += w*w;
      }
      lambda= sum*(uint64_t)s->lambda2 >> (FF_LAMBDA_SHIFT - 6 + 6 + 6 + 6);
@@@ -4019,7 -3827,7 +4019,7 @@@ STOP_TIMER("dct")
              const int level= block[0];
              int change, old_coeff;
  
 -            assert(s->mb_intra);
 +            av_assert2(s->mb_intra);
  
              old_coeff= q*level;
  
              }else{
                  old_coeff=0;
                  run2--;
 -                assert(run2>=0 || i >= last_non_zero );
 +                av_assert2(run2>=0 || i >= last_non_zero );
              }
  
              for(change=-1; change<=1; change+=2){
                                           - last_length[UNI_AC_ENC_INDEX(run, level+64)];
                          }
                      }else{
 -                        assert(FFABS(new_level)==1);
 +                        av_assert2(FFABS(new_level)==1);
  
                          if(analyze_gradient){
                              int g= d1[ scantable[i] ];
                      }
                  }else{
                      new_coeff=0;
 -                    assert(FFABS(level)==1);
 +                    av_assert2(FFABS(level)==1);
  
                      if(i < last_non_zero){
                          int next_i= i + run2 + 1;
                  score *= lambda;
  
                  unquant_change= new_coeff - old_coeff;
 -                assert((score < 100*lambda && score > -100*lambda) || lambda==0);
 +                av_assert2((score < 100*lambda && score > -100*lambda) || lambda==0);
  
                  score+= s->dsp.try_8x8basis(rem, weight, basis[j], unquant_change);
                  if(score<best_score){
@@@ -4183,7 -3991,7 +4183,7 @@@ STOP_TIMER("iterative step")
  
              if(best_coeff > last_non_zero){
                  last_non_zero= best_coeff;
 -                assert(block[j]);
 +                av_assert2(block[j]);
  #ifdef REFINE_STATS
  after_last++;
  #endif
@@@ -4211,7 -4019,7 +4211,7 @@@ if(block[j])
  #ifdef REFINE_STATS
  count++;
  if(256*256*256*64 % count == 0){
 -    printf("after_last:%d to_zero:%d from_zero:%d raise:%d lower:%d sign:%d xyp:%d/%d/%d\n", after_last, to_zero, from_zero, raise, lower, messed_sign, s->mb_x, s->mb_y, s->picture_number);
 +    av_log(s->avctx, AV_LOG_DEBUG, "after_last:%d to_zero:%d from_zero:%d raise:%d lower:%d sign:%d xyp:%d/%d/%d\n", after_last, to_zero, from_zero, raise, lower, messed_sign, s->mb_x, s->mb_y, s->picture_number);
  }
  #endif
              run=0;
@@@ -4274,7 -4082,7 +4274,7 @@@ int ff_dct_quantize_c(MpegEncContext *s
          block[0] = (block[0] + (q >> 1)) / q;
          start_i = 1;
          last_non_zero = 0;
 -        qmat = s->q_intra_matrix[qscale];
 +        qmat = n < 4 ? s->q_intra_matrix[qscale] : s->q_chroma_intra_matrix[qscale];
          bias= s->intra_quant_bias<<(QMAT_SHIFT - QUANT_BIAS_SHIFT);
      } else {
          start_i = 0;