Merge commit '6a85dfc830f51f1f5c2d36d4182d265c1ea3ba25'
authorMichael Niedermayer <michaelni@gmx.at>
Mon, 20 Apr 2015 01:34:22 +0000 (03:34 +0200)
committerMichael Niedermayer <michaelni@gmx.at>
Mon, 20 Apr 2015 02:10:10 +0000 (04:10 +0200)
* commit '6a85dfc830f51f1f5c2d36d4182d265c1ea3ba25':
  lavc: Replace av_dlog and tprintf with internal macros

Conflicts:
libavcodec/aacdec.c
libavcodec/audio_frame_queue.c
libavcodec/bitstream.c
libavcodec/dcadec.c
libavcodec/dnxhddec.c
libavcodec/dvbsubdec.c
libavcodec/dvdec.c
libavcodec/dvdsubdec.c
libavcodec/get_bits.h
libavcodec/gifdec.c
libavcodec/h264.h
libavcodec/h264_cabac.c
libavcodec/h264_cavlc.c
libavcodec/h264_loopfilter.c
libavcodec/h264_refs.c
libavcodec/imc.c
libavcodec/interplayvideo.c
libavcodec/jpeglsdec.c
libavcodec/libopencore-amr.c
libavcodec/mjpegdec.c
libavcodec/mpeg12dec.c
libavcodec/mpegvideo_enc.c
libavcodec/mpegvideo_parser.c
libavcodec/pngdec.c
libavcodec/ratecontrol.c
libavcodec/rv10.c
libavcodec/svq1dec.c
libavcodec/vqavideo.c
libavcodec/wmadec.c

Merged-by: Michael Niedermayer <michaelni@gmx.at>
75 files changed:
1  2 
libavcodec/aacdec.c
libavcodec/ac3enc.c
libavcodec/alsdec.c
libavcodec/bitstream.c
libavcodec/cook.c
libavcodec/dcadec.c
libavcodec/dnxhddec.c
libavcodec/dnxhdenc.c
libavcodec/dvbsub_parser.c
libavcodec/dvbsubdec.c
libavcodec/dvdec.c
libavcodec/dvdsubdec.c
libavcodec/escape130.c
libavcodec/ffv1dec.c
libavcodec/ffv1enc.c
libavcodec/flashsv.c
libavcodec/flashsvenc.c
libavcodec/flicvideo.c
libavcodec/get_bits.h
libavcodec/gifdec.c
libavcodec/h261dec.c
libavcodec/h263dec.c
libavcodec/h264.c
libavcodec/h264.h
libavcodec/h264_cabac.c
libavcodec/h264_cavlc.c
libavcodec/h264_loopfilter.c
libavcodec/h264_mvpred.h
libavcodec/h264_refs.c
libavcodec/h264_slice.c
libavcodec/indeo3.c
libavcodec/indeo4.c
libavcodec/internal.h
libavcodec/interplayvideo.c
libavcodec/ituh263dec.c
libavcodec/ivi.c
libavcodec/jpegls.c
libavcodec/jpeglsdec.c
libavcodec/libmp3lame.c
libavcodec/libopencore-amr.c
libavcodec/mjpegdec.c
libavcodec/motion_est.c
libavcodec/mpeg12dec.c
libavcodec/mpeg4videodec.c
libavcodec/mpegaudiodec_template.c
libavcodec/mpegaudiodecheader.c
libavcodec/mpegaudioenc_template.c
libavcodec/mpegvideo.c
libavcodec/mpegvideo_enc.c
libavcodec/mpegvideo_parser.c
libavcodec/msmpeg4dec.c
libavcodec/msmpeg4enc.c
libavcodec/parser.c
libavcodec/pcm-bluray.c
libavcodec/pcm-dvd.c
libavcodec/pgssubdec.c
libavcodec/pngdec.c
libavcodec/ratecontrol.c
libavcodec/rv10.c
libavcodec/svq1dec.c
libavcodec/vaapi.c
libavcodec/vaapi_h264.c
libavcodec/vaapi_mpeg2.c
libavcodec/vaapi_mpeg4.c
libavcodec/vaapi_vc1.c
libavcodec/vc1.c
libavcodec/vc1dec.c
libavcodec/vorbisdec.c
libavcodec/vp3.c
libavcodec/vqavideo.c
libavcodec/wma.c
libavcodec/wmadec.c
libavcodec/wmalosslessdec.c
libavcodec/wmaprodec.c
libavcodec/wmv2dec.c

@@@ -943,10 -862,10 +943,10 @@@ static int decode_audio_specific_config
      GetBitContext gb;
      int i, ret;
  
-     av_dlog(avctx, "audio specific config size %d\n", bit_size >> 3);
 -    ff_dlog(avctx, "extradata size %d\n", avctx->extradata_size);
 -    for (i = 0; i < avctx->extradata_size; i++)
 -        ff_dlog(avctx, "%02x ", avctx->extradata[i]);
++    ff_dlog(avctx, "audio specific config size %d\n", bit_size >> 3);
 +    for (i = 0; i < bit_size >> 3; i++)
-         av_dlog(avctx, "%02x ", data[i]);
-     av_dlog(avctx, "\n");
++        ff_dlog(avctx, "%02x ", data[i]);
+     ff_dlog(avctx, "\n");
  
      if ((ret = init_get_bits(&gb, data, bit_size)) < 0)
          return ret;
Simple merge
Simple merge
   * bitstream api.
   */
  
 +#include "libavutil/atomic.h"
 +#include "libavutil/avassert.h"
  #include "avcodec.h"
+ #include "internal.h"
  #include "mathops.h"
  #include "get_bits.h"
  #include "put_bits.h"
@@@ -163,16 -163,19 +164,16 @@@ static int build_table(VLC *vlc, int ta
      int table_size, table_index, index, code_prefix, symbol, subtable_bits;
      int i, j, k, n, nb, inc;
      uint32_t code;
 -    VLC_TYPE (*table)[2];
 +    volatile VLC_TYPE (* volatile table)[2]; // the double volatile is needed to prevent a internal compiler error in gcc 4.2
  
      table_size = 1 << table_nb_bits;
 +    if (table_nb_bits > 30)
 +       return -1;
      table_index = alloc_table(vlc, table_size, flags & INIT_VLC_USE_NEW_STATIC);
-     av_dlog(NULL, "new table index=%d size=%d\n", table_index, table_size);
+     ff_dlog(NULL, "new table index=%d size=%d\n", table_index, table_size);
      if (table_index < 0)
          return table_index;
 -    table = &vlc->table[table_index];
 -
 -    for (i = 0; i < table_size; i++) {
 -        table[i][1] = 0; //bits
 -        table[i][0] = -1; //codes
 -    }
 +    table = (volatile VLC_TYPE (*)[2])&vlc->table[table_index];
  
      /* first pass: map codes and compute auxiliary table sizes */
      for (i = 0; i < nb_codes; i++) {
                  inc = 1 << n;
              }
              for (k = 0; k < nb; k++) {
-                 av_dlog(NULL, "%4x: code=%d n=%d\n", j, i, n);
 +                int bits = table[j][1];
 -                if (table[j][1] /*bits*/ != 0) {
+                 ff_dlog(NULL, "%4x: code=%d n=%d\n", j, i, n);
 +                if (bits != 0 && bits != n) {
                      av_log(NULL, AV_LOG_ERROR, "incorrect codes\n");
                      return AVERROR_INVALIDDATA;
                  }
Simple merge
@@@ -1485,51 -1192,8 +1485,51 @@@ static int dca_decode_frame(AVCodecCont
      /* record number of core channels incase less than max channels are requested */
      num_core_channels = s->prim_channels;
  
-             av_dlog(s->avctx, "Stereo downmix coeffs:\n");
 +    if (s->prim_channels + !!s->lfe > 2 &&
 +        avctx->request_channel_layout == AV_CH_LAYOUT_STEREO) {
 +            /* Stereo downmix coefficients
 +             *
 +             * The decoder can only downmix to 2-channel, so we need to ensure
 +             * embedded downmix coefficients are actually targeting 2-channel.
 +             */
 +            if (s->core_downmix && (s->core_downmix_amode == DCA_STEREO ||
 +                                    s->core_downmix_amode == DCA_STEREO_TOTAL)) {
 +                for (i = 0; i < num_core_channels + !!s->lfe; i++) {
 +                    /* Range checked earlier */
 +                    s->downmix_coef[i][0] = dca_dmix_code(s->core_downmix_codes[i][0]);
 +                    s->downmix_coef[i][1] = dca_dmix_code(s->core_downmix_codes[i][1]);
 +                }
 +                s->output = s->core_downmix_amode;
 +            } else {
 +                int am = s->amode & DCA_CHANNEL_MASK;
 +                if (am >= FF_ARRAY_ELEMS(ff_dca_default_coeffs)) {
 +                    av_log(s->avctx, AV_LOG_ERROR,
 +                           "Invalid channel mode %d\n", am);
 +                    return AVERROR_INVALIDDATA;
 +                }
 +                if (num_core_channels + !!s->lfe >
 +                    FF_ARRAY_ELEMS(ff_dca_default_coeffs[0])) {
 +                    avpriv_request_sample(s->avctx, "Downmixing %d channels",
 +                                          s->prim_channels + !!s->lfe);
 +                    return AVERROR_PATCHWELCOME;
 +                }
 +                for (i = 0; i < num_core_channels + !!s->lfe; i++) {
 +                    s->downmix_coef[i][0] = ff_dca_default_coeffs[am][i][0];
 +                    s->downmix_coef[i][1] = ff_dca_default_coeffs[am][i][1];
 +                }
 +            }
-                 av_dlog(s->avctx, "L, input channel %d = %f\n", i,
++            ff_dlog(s->avctx, "Stereo downmix coeffs:\n");
 +            for (i = 0; i < num_core_channels + !!s->lfe; i++) {
-                 av_dlog(s->avctx, "R, input channel %d = %f\n", i,
++                ff_dlog(s->avctx, "L, input channel %d = %f\n", i,
 +                        s->downmix_coef[i][0]);
-             av_dlog(s->avctx, "\n");
++                ff_dlog(s->avctx, "R, input channel %d = %f\n", i,
 +                        s->downmix_coef[i][1]);
 +            }
++            ff_dlog(s->avctx, "\n");
 +    }
 +
      if (s->ext_coding)
 -        s->core_ext_mask = dca_ext_audio_descr_mask[s->ext_descr];
 +        s->core_ext_mask = ff_dca_ext_audio_descr_mask[s->ext_descr];
      else
          s->core_ext_mask = 0;
  
@@@ -145,8 -132,12 +145,8 @@@ static int dnxhd_decode_header(DNXHDCon
      ctx->height = AV_RB16(buf + 0x18);
      ctx->width  = AV_RB16(buf + 0x1a);
  
-     av_dlog(ctx->avctx, "width %d, height %d\n", ctx->width, ctx->height);
+     ff_dlog(ctx->avctx, "width %d, height %d\n", ctx->width, ctx->height);
  
 -    if (!ctx->bit_depth) {
 -        ff_blockdsp_init(&ctx->bdsp, ctx->avctx);
 -        ff_idctdsp_init(&ctx->idsp, ctx->avctx);
 -    }
      if (buf[0x21] == 0x58) { /* 10 bit */
          ctx->bit_depth = ctx->avctx->bits_per_raw_sample = 10;
  
                 buf[0x21]);
          return AVERROR_INVALIDDATA;
      }
 +    if (ctx->bit_depth != old_bit_depth) {
 +        ff_blockdsp_init(&ctx->bdsp, ctx->avctx);
 +        ff_idctdsp_init(&ctx->idsp, ctx->avctx);
 +    }
  
      cid = AV_RB32(buf + 0x28);
-     av_dlog(ctx->avctx, "compression id %d\n", cid);
+     ff_dlog(ctx->avctx, "compression id %d\n", cid);
  
      if ((ret = dnxhd_init_vlc(ctx, cid)) < 0)
          return ret;
  
      for (i = 0; i < ctx->mb_height; i++) {
          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]);
+         ff_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 (%d < %d).\n",
                     buf_size, ctx->mb_scan_index[i] + 0x280);
Simple merge
@@@ -136,9 -137,9 +137,9 @@@ static int dvbsub_parse(AVCodecParserCo
              } else
                  break;
          } else if (*p == 0xff) {
 -            if (p + 1 < p_end)
 +            if (1 < p_end - p)
              {
-                 av_dlog(avctx, "Junk at end of packet\n");
+                 ff_dlog(avctx, "Junk at end of packet\n");
              }
              pc->packet_index = p - pc->packet_buf;
              pc->in_packet = 0;
@@@ -22,8 -22,8 +22,9 @@@
  #include "avcodec.h"
  #include "get_bits.h"
  #include "bytestream.h"
+ #include "internal.h"
  #include "libavutil/colorspace.h"
 +#include "libavutil/opt.h"
  
  #define DVBSUB_PAGE_SEGMENT     0x10
  #define DVBSUB_REGION_SEGMENT   0x11
@@@ -892,8 -736,7 +893,8 @@@ static void dvbsub_parse_pixel_data_blo
                           0x88, 0x99, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff};
      uint8_t *map_table;
  
-     av_dlog(avctx, "DVB pixel block size %d, %s field:\n", buf_size,
 +#if 0
+     ff_dlog(avctx, "DVB pixel block size %d, %s field:\n", buf_size,
              top_bottom ? "bottom" : "top");
  
      for (i = 0; i < buf_size; i++) {
      }
  
      if (i % 16)
-         av_dlog(avctx, "\n");
+         ff_dlog(avctx, "\n");
 +#endif
  
 -    if (region == 0)
 +    if (!region)
          return;
  
      pbuf = region->pbuf;
@@@ -1073,10 -914,9 +1074,10 @@@ static int dvbsub_parse_clut_segment(AV
      }
  
      if (i % 16)
-         av_dlog(avctx, "\n");
+         ff_dlog(avctx, "\n");
  
      clut_id = *buf++;
 +    version = ((*buf)>>4)&15;
      buf += 1;
  
      clut = get_clut(ctx, clut_id);
          YUV_TO_RGB1_CCIR(cb, cr);
          YUV_TO_RGB2_CCIR(r, g, b, y);
  
-         av_dlog(avctx, "clut %d := (%d,%d,%d,%d)\n", entry_id, r, g, b, alpha);
+         ff_dlog(avctx, "clut %d := (%d,%d,%d,%d)\n", entry_id, r, g, b, alpha);
 +        if (!!(depth & 0x80) + !!(depth & 0x40) + !!(depth & 0x20) > 1) {
-             av_dlog(avctx, "More than one bit level marked: %x\n", depth);
++            ff_dlog(avctx, "More than one bit level marked: %x\n", depth);
 +            if (avctx->strict_std_compliance > FF_COMPLIANCE_NORMAL)
 +                return AVERROR_INVALIDDATA;
 +        }
  
          if (depth & 0x80)
              clut->clut4[entry_id] = RGBA(r,g,b,255 - alpha);
@@@ -1293,26 -1115,13 +1294,26 @@@ static int dvbsub_parse_page_segment(AV
      if (buf_size < 1)
          return AVERROR_INVALIDDATA;
  
 -    ctx->time_out = *buf++;
 +    timeout = *buf++;
 +    version = ((*buf)>>4) & 15;
      page_state = ((*buf++) >> 2) & 3;
  
-     av_dlog(avctx, "Page time out %ds, state %d\n", ctx->time_out, page_state);
 +    if (ctx->version == version) {
 +        return 0;
 +    }
 +
 +    ctx->time_out = timeout;
 +    ctx->version = version;
 +
+     ff_dlog(avctx, "Page time out %ds, state %d\n", ctx->time_out, page_state);
  
 -    if (page_state == 2) {
 -        delete_state(ctx);
 +    if(ctx->compute_edt == 1)
 +        save_subtitle_set(avctx, sub, got_output);
 +
 +    if (page_state == 1 || page_state == 2) {
 +        delete_regions(ctx);
 +        delete_objects(ctx);
 +        delete_cluts(ctx);
      }
  
      tmp_display_list = ctx->display_list;
  
          display->next = ctx->display_list;
          ctx->display_list = display;
 -        ctx->display_list_size++;
  
-         av_dlog(avctx, "Region %d, (%d,%d)\n", region_id, display->x_pos, display->y_pos);
+         ff_dlog(avctx, "Region %d, (%d,%d)\n", region_id, display->x_pos, display->y_pos);
      }
  
      while (tmp_display_list) {
@@@ -1538,15 -1421,13 +1539,15 @@@ static int dvbsub_decode(AVCodecContex
      int page_id;
      int segment_length;
      int i;
 +    int ret = 0;
 +    int got_segment = 0;
  
-     av_dlog(avctx, "DVB sub packet:\n");
+     ff_dlog(avctx, "DVB sub packet:\n");
  
      for (i=0; i < buf_size; i++) {
-         av_dlog(avctx, "%02x ", buf[i]);
+         ff_dlog(avctx, "%02x ", buf[i]);
          if (i % 16 == 15)
-             av_dlog(avctx, "\n");
+             ff_dlog(avctx, "\n");
      }
  
      if (i % 16)
          segment_length = AV_RB16(p);
          p += 2;
  
 +        if (avctx->debug & FF_DEBUG_STARTCODE) {
 +            av_log(avctx, AV_LOG_DEBUG, "segment_type:%d page_id:%d segment_length:%d\n", segment_type, page_id, segment_length);
 +        }
 +
          if (p_end - p < segment_length) {
-             av_dlog(avctx, "incomplete or broken packet");
+             ff_dlog(avctx, "incomplete or broken packet");
 -            return -1;
 +            ret = -1;
 +            goto end;
          }
  
          if (page_id == ctx->composition_id || page_id == ctx->ancillary_id ||
                                                                segment_length);
                  break;
              case DVBSUB_DISPLAY_SEGMENT:
 -                ret = dvbsub_display_end_segment(avctx, p, segment_length, sub);
 -                *data_size = ret;
 +                ret = dvbsub_display_end_segment(avctx, p, segment_length, sub, data_size);
 +                got_segment |= 16;
                  break;
              default:
-                 av_dlog(avctx, "Subtitling segment type 0x%x, page id %d, length %d\n",
+                 ff_dlog(avctx, "Subtitling segment type 0x%x, page id %d, length %d\n",
                          segment_type, page_id, segment_length);
                  break;
              }
@@@ -384,8 -264,8 +384,8 @@@ static int dv_decode_video_segment(AVCo
      flush_put_bits(&vs_pb);
      for (mb_index = 0; mb_index < 5; mb_index++) {
          for (j = 0; j < s->sys->bpm; j++) {
 -            if (mb->pos < 64) {
 +            if (mb->pos < 64 && get_bits_left(&gb) > 0) {
-                 av_dlog(avctx, "start %d:%d\n", mb_index, j);
+                 ff_dlog(avctx, "start %d:%d\n", mb_index, j);
                  dv_decode_ac(&gb, mb, block);
              }
              if (mb->pos >= 64 && mb->pos < 127)
@@@ -562,23 -494,14 +562,23 @@@ static int dvdsub_decode(AVCodecContex
      if (!is_menu && find_smallest_bounding_rectangle(sub) == 0)
          goto no_subtitle;
  
 +    if (ctx->forced_subs_only && !(sub->rects[0]->flags & AV_SUBTITLE_FLAG_FORCED))
 +        goto no_subtitle;
 +
  #if defined(DEBUG)
-     av_dlog(NULL, "start=%d ms end =%d ms\n",
 +    {
 +    char ppm_name[32];
 +
 +    snprintf(ppm_name, sizeof(ppm_name), "/tmp/%05d.ppm", ctx->sub_id++);
+     ff_dlog(NULL, "start=%d ms end =%d ms\n",
              sub->start_display_time,
              sub->end_display_time);
 -    ppm_save("/tmp/a.ppm", sub->rects[0]->pict.data[0],
 -             sub->rects[0]->w, sub->rects[0]->h, sub->rects[0]->pict.data[1]);
 +    ppm_save(ppm_name, sub->rects[0]->pict.data[0],
 +             sub->rects[0]->w, sub->rects[0]->h, (uint32_t*) sub->rects[0]->pict.data[1]);
 +    }
  #endif
  
 +    ctx->buf_size = 0;
      *data_size = 1;
      return buf_size;
  }
Simple merge
@@@ -76,8 -77,10 +76,8 @@@ static inline int get_vlc_symbol(GetBit
          i += i;
      }
  
 -    assert(k <= 8);
 -
      v = get_sr_golomb(gb, k, 12, bits);
-     av_dlog(NULL, "v:%d bias:%d error:%d drift:%d count:%d k:%d",
+     ff_dlog(NULL, "v:%d bias:%d error:%d drift:%d count:%d k:%d",
              v, state->bias, state->error_sum, state->drift, state->count, k);
  
  #if 0 // JPEG LS
@@@ -745,12 -716,8 +745,12 @@@ static int read_header(FFV1Context *f
          av_log(f->avctx, AV_LOG_ERROR, "colorspace not supported\n");
          return AVERROR(ENOSYS);
      }
 +    if (f->avctx->pix_fmt == AV_PIX_FMT_NONE) {
 +        av_log(f->avctx, AV_LOG_ERROR, "format not supported\n");
 +        return AVERROR(ENOSYS);
 +    }
  
-     av_dlog(f->avctx, "%d %d %d\n",
+     ff_dlog(f->avctx, "%d %d %d\n",
              f->chroma_h_shift, f->chroma_v_shift, f->avctx->pix_fmt);
      if (f->version < 2) {
          context_count = read_quant_tables(c, f->quant_table);
Simple merge
@@@ -360,12 -342,12 +360,12 @@@ static int flashsv_decode_frame(AVCodec
          if ((err = av_reallocp(&s->keyframedata, avpkt->size)) < 0)
              return err;
          memcpy(s->keyframedata, avpkt->data, avpkt->size);
 -        if ((err = av_reallocp(&s->blocks, (v_blocks + !!v_part) *
 -                               (h_blocks + !!h_part) * sizeof(s->blocks[0]))) < 0)
 -            return err;
      }
 +    if(s->ver == 2 && !s->blocks)
 +        s->blocks = av_mallocz((v_blocks + !!v_part) * (h_blocks + !!h_part) *
 +                               sizeof(s->blocks[0]));
  
-     av_dlog(avctx, "image: %dx%d block: %dx%d num: %dx%d part: %dx%d\n",
+     ff_dlog(avctx, "image: %dx%d block: %dx%d num: %dx%d part: %dx%d\n",
              s->image_width, s->image_height, s->block_width, s->block_height,
              h_blocks, v_blocks, h_part, v_part);
  
Simple merge
Simple merge
@@@ -685,12 -620,6 +685,8 @@@ static inline int get_xbits_trace(GetBi
  
  #define get_vlc(s, vlc)             get_vlc_trace(s, (vlc)->table, (vlc)->bits,   3, __FILE__, __PRETTY_FUNCTION__, __LINE__)
  #define get_vlc2(s, tab, bits, max) get_vlc_trace(s,          tab,        bits, max, __FILE__, __PRETTY_FUNCTION__, __LINE__)
- #define tprintf(p, ...) av_log(p, AV_LOG_DEBUG, __VA_ARGS__)
 +#else //TRACE
- #define tprintf(p, ...) { }
 +#define GET_RL_VLC GET_RL_VLC_INTERNAL
  #endif
  
  #endif /* AVCODEC_GET_BITS_H */
@@@ -148,34 -74,14 +148,34 @@@ static int gif_read_image(GifState *s, 
      has_local_palette = flags & 0x80;
      bits_per_pixel = (flags & 0x07) + 1;
  
-     av_dlog(s->avctx, "image x=%d y=%d w=%d h=%d\n", left, top, width, height);
 -    ff_dlog(s->avctx, "gif: image x=%d y=%d w=%d h=%d\n", left, top, width, height);
++    ff_dlog(s->avctx, "image x=%d y=%d w=%d h=%d\n", left, top, width, height);
  
      if (has_local_palette) {
 -        bytestream2_get_buffer(&s->gb, s->local_palette, 3 * (1 << bits_per_pixel));
 -        palette = s->local_palette;
 +        pal_size = 1 << bits_per_pixel;
 +
 +        if (bytestream2_get_bytes_left(&s->gb) < pal_size * 3)
 +            return AVERROR_INVALIDDATA;
 +
 +        gif_read_palette(s, s->local_palette, pal_size);
 +        pal = s->local_palette;
      } else {
 -        palette = s->global_palette;
 -        bits_per_pixel = s->bits_per_pixel;
 +        if (!s->has_global_palette) {
 +            av_log(s->avctx, AV_LOG_ERROR, "picture doesn't have either global or local palette.\n");
 +            return AVERROR_INVALIDDATA;
 +        }
 +
 +        pal = s->global_palette;
 +    }
 +
 +    if (s->keyframe) {
 +        if (s->transparent_color_index == -1 && s->has_global_palette) {
 +            /* transparency wasn't set before the first frame, fill with background color */
 +            gif_fill(frame, s->bg_color);
 +        } else {
 +            /* otherwise fill with transparent color.
 +             * this is necessary since by default picture filled with 0x80808080. */
 +            gif_fill(frame, s->trans_color);
 +        }
      }
  
      /* verify that all the image is inside the screen dimensions */
  
  static int gif_read_extension(GifState *s)
  {
 -    int ext_code, ext_len, i, gce_flags, gce_transparent_index;
 +    int ext_code, ext_len, gce_flags, gce_transparent_index;
 +
 +    /* There must be at least 2 bytes:
 +     * 1 for extension label and 1 for extension length. */
 +    if (bytestream2_get_bytes_left(&s->gb) < 2)
 +        return AVERROR_INVALIDDATA;
  
 -    /* extension */
 -    ext_code = bytestream2_get_byte(&s->gb);
 -    ext_len  = bytestream2_get_byte(&s->gb);
 +    ext_code = bytestream2_get_byteu(&s->gb);
 +    ext_len  = bytestream2_get_byteu(&s->gb);
  
-     av_dlog(s->avctx, "ext_code=0x%x len=%d\n", ext_code, ext_len);
 -    ff_dlog(s->avctx, "gif: ext_code=0x%x len=%d\n", ext_code, ext_len);
++    ff_dlog(s->avctx, "ext_code=0x%x len=%d\n", ext_code, ext_len);
  
      switch(ext_code) {
 -    case 0xf9:
 +    case GIF_GCE_EXT_LABEL:
          if (ext_len != 4)
              goto discard_ext;
 -        s->transparent_color_index = -1;
 -        gce_flags    = bytestream2_get_byte(&s->gb);
 -        s->gce_delay = bytestream2_get_le16(&s->gb);
 -        gce_transparent_index = bytestream2_get_byte(&s->gb);
 +
 +        /* We need at least 5 bytes more: 4 is for extension body
 +         * and 1 for next block size. */
 +        if (bytestream2_get_bytes_left(&s->gb) < 5)
 +            return AVERROR_INVALIDDATA;
 +
 +        gce_flags    = bytestream2_get_byteu(&s->gb);
 +        bytestream2_skipu(&s->gb, 2);    // delay during which the frame is shown
 +        gce_transparent_index = bytestream2_get_byteu(&s->gb);
          if (gce_flags & 0x01)
              s->transparent_color_index = gce_transparent_index;
          else
              s->transparent_color_index = -1;
          s->gce_disposal = (gce_flags >> 2) & 0x7;
  
-         av_dlog(s->avctx, "gce_flags=%x tcolor=%d disposal=%d\n",
 -        ff_dlog(s->avctx, "gif: gce_flags=%x delay=%d tcolor=%d disposal=%d\n",
 -               gce_flags, s->gce_delay,
++        ff_dlog(s->avctx, "gce_flags=%x tcolor=%d disposal=%d\n",
 +               gce_flags,
                 s->transparent_color_index, s->gce_disposal);
  
 -        ext_len = bytestream2_get_byte(&s->gb);
 +        if (s->gce_disposal > 3) {
 +            s->gce_disposal = GCE_DISPOSAL_NONE;
-             av_dlog(s->avctx, "invalid value in gce_disposal (%d). Using default value of 0.\n", ext_len);
++            ff_dlog(s->avctx, "invalid value in gce_disposal (%d). Using default value of 0.\n", ext_len);
 +        }
 +
 +        ext_len = bytestream2_get_byteu(&s->gb);
          break;
      }
  
      /* NOTE: many extension blocks can come after */
   discard_ext:
 -    while (ext_len != 0) {
 -        for (i = 0; i < ext_len; i++)
 -            bytestream2_get_byte(&s->gb);
 -        ext_len = bytestream2_get_byte(&s->gb);
 +    while (ext_len) {
 +        /* There must be at least ext_len bytes and 1 for next block size byte. */
 +        if (bytestream2_get_bytes_left(&s->gb) < ext_len + 1)
 +            return AVERROR_INVALIDDATA;
 +
 +        bytestream2_skipu(&s->gb, ext_len);
 +        ext_len = bytestream2_get_byteu(&s->gb);
  
-         av_dlog(s->avctx, "ext_len1=%d\n", ext_len);
 -        ff_dlog(s->avctx, "gif: ext_len1=%d\n", ext_len);
++        ff_dlog(s->avctx, "ext_len1=%d\n", ext_len);
      }
      return 0;
  }
@@@ -381,26 -212,26 +381,26 @@@ static int gif_read_header1(GifState *s
  
      /* read screen header */
      s->transparent_color_index = -1;
 -    s->screen_width  = bytestream2_get_le16(&s->gb);
 -    s->screen_height = bytestream2_get_le16(&s->gb);
 -    if(   (unsigned)s->screen_width  > 32767
 -       || (unsigned)s->screen_height > 32767){
 -        av_log(NULL, AV_LOG_ERROR, "picture size too large\n");
 -        return AVERROR_INVALIDDATA;
 -    }
 +    s->screen_width  = bytestream2_get_le16u(&s->gb);
 +    s->screen_height = bytestream2_get_le16u(&s->gb);
  
 -    v = bytestream2_get_byte(&s->gb);
 +    v = bytestream2_get_byteu(&s->gb);
      s->color_resolution = ((v & 0x70) >> 4) + 1;
 -    has_global_palette = (v & 0x80);
 +    s->has_global_palette = (v & 0x80);
      s->bits_per_pixel = (v & 0x07) + 1;
 -    s->background_color_index = bytestream2_get_byte(&s->gb);
 -    bytestream2_get_byte(&s->gb);                /* ignored */
 +    background_color_index = bytestream2_get_byteu(&s->gb);
 +    n = bytestream2_get_byteu(&s->gb);
 +    if (n) {
 +        s->avctx->sample_aspect_ratio.num = n + 15;
 +        s->avctx->sample_aspect_ratio.den = 64;
 +    }
  
-     av_dlog(s->avctx, "screen_w=%d screen_h=%d bpp=%d global_palette=%d\n",
 -    ff_dlog(s->avctx, "gif: screen_w=%d screen_h=%d bpp=%d global_palette=%d\n",
++    ff_dlog(s->avctx, "screen_w=%d screen_h=%d bpp=%d global_palette=%d\n",
             s->screen_width, s->screen_height, s->bits_per_pixel,
 -           has_global_palette);
 +           s->has_global_palette);
  
 -    if (has_global_palette) {
 +    if (s->has_global_palette) {
 +        s->background_color_index = background_color_index;
          n = 1 << s->bits_per_pixel;
          if (bytestream2_get_bytes_left(&s->gb) < n * 3)
              return AVERROR_INVALIDDATA;
Simple merge
@@@ -241,10 -234,8 +241,10 @@@ static int decode_slice(MpegEncContext 
  
              s->mv_dir  = MV_DIR_FORWARD;
              s->mv_type = MV_TYPE_16X16;
-             av_dlog(s, "%d %d %06X\n",
+             ff_dlog(s, "%d %d %06X\n",
                      ret, get_bits_count(&s->gb), show_bits(&s->gb, 24));
-             tprintf(NULL, "Decoding MB at %dx%d\n", s->mb_x, s->mb_y);
 +
++            ff_tlog(NULL, "Decoding MB at %dx%d\n", s->mb_x, s->mb_y);
              ret = s->decode_mb(s, s->block);
  
              if (s->pict_type != AV_PICTURE_TYPE_B)
Simple merge
Simple merge
@@@ -2073,8 -2071,8 +2073,8 @@@ decode_intra_mb
                      int pred = pred_intra_mode(h, sl, i);
                      sl->intra4x4_pred_mode_cache[scan8[i]] = decode_cabac_mb_intra4x4_pred_mode(sl, pred);
  
-                     av_dlog(h->avctx, "i4x4 pred=%d mode=%d\n", pred,
+                     ff_dlog(h->avctx, "i4x4 pred=%d mode=%d\n", pred,
 -                            h->intra4x4_pred_mode_cache[scan8[i]]);
 +                            sl->intra4x4_pred_mode_cache[scan8[i]]);
                  }
              }
              write_back_intra_pred_mode(h, sl);
@@@ -483,8 -482,8 +483,8 @@@ static int decode_residual(const H264Co
      }
  
      trailing_ones= coeff_token&3;
-     tprintf(h->avctx, "trailing:%d, total:%d\n", trailing_ones, total_coeff);
+     ff_tlog(h->avctx, "trailing:%d, total:%d\n", trailing_ones, total_coeff);
 -    assert(total_coeff<=16);
 +    av_assert2(total_coeff<=16);
  
      i = show_bits(gb, 3);
      skip_bits(gb, trailing_ones);
@@@ -591,9 -593,7 +591,9 @@@ static av_always_inline void filter_mb_
              // value in IPCM macroblocks.
              if(bS[0]+bS[1]+bS[2]+bS[3]){
                  qp = (h->cur_pic.qscale_table[mb_xy] + h->cur_pic.qscale_table[mbm_xy] + 1) >> 1;
-                 //tprintf(h->avctx, "filter mb:%d/%d dir:%d edge:%d, QPy:%d, QPc:%d, QPcn:%d\n", mb_x, mb_y, dir, edge, qp, h->chroma_qp[0], h->cur_pic.qscale_table[mbn_xy]);
-                 tprintf(h->avctx, "filter mb:%d/%d dir:%d edge:%d, QPy:%d ls:%d uvls:%d", mb_x, mb_y, dir, edge, qp, linesize, uvlinesize);
-                 //{ int i; for (i = 0; i < 4; i++) tprintf(h->avctx, " bS[%d]:%d", i, bS[i]); tprintf(h->avctx, "\n"); }
++                //ff_tlog(h->avctx, "filter mb:%d/%d dir:%d edge:%d, QPy:%d, QPc:%d, QPcn:%d\n", mb_x, mb_y, dir, edge, qp, h->chroma_qp[0], h->cur_pic.qscale_table[mbn_xy]);
+                 ff_tlog(h->avctx, "filter mb:%d/%d dir:%d edge:%d, QPy:%d ls:%d uvls:%d", mb_x, mb_y, dir, edge, qp, linesize, uvlinesize);
++                //{ int i; for (i = 0; i < 4; i++) ff_tlog(h->avctx, " bS[%d]:%d", i, bS[i]); ff_tlog(h->avctx, "\n"); }
                  chroma_qp_avg[0] = (sl->chroma_qp[0] + get_chroma_qp(h, 0, h->cur_pic.qscale_table[mbm_xy]) + 1) >> 1;
                  chroma_qp_avg[1] = (sl->chroma_qp[1] + get_chroma_qp(h, 1, h->cur_pic.qscale_table[mbm_xy]) + 1) >> 1;
                  if( dir == 0 ) {
          // Do not use s->qscale as luma quantizer because it has not the same
          // value in IPCM macroblocks.
          qp = h->cur_pic.qscale_table[mb_xy];
-         //tprintf(h->avctx, "filter mb:%d/%d dir:%d edge:%d, QPy:%d, QPc:%d, QPcn:%d\n", mb_x, mb_y, dir, edge, qp, h->chroma_qp[0], h->cur_pic.qscale_table[mbn_xy]);
-         tprintf(h->avctx, "filter mb:%d/%d dir:%d edge:%d, QPy:%d ls:%d uvls:%d", mb_x, mb_y, dir, edge, qp, linesize, uvlinesize);
-         //{ int i; for (i = 0; i < 4; i++) tprintf(h->avctx, " bS[%d]:%d", i, bS[i]); tprintf(h->avctx, "\n"); }
++        //ff_tlog(h->avctx, "filter mb:%d/%d dir:%d edge:%d, QPy:%d, QPc:%d, QPcn:%d\n", mb_x, mb_y, dir, edge, qp, h->chroma_qp[0], h->cur_pic.qscale_table[mbn_xy]);
+         ff_tlog(h->avctx, "filter mb:%d/%d dir:%d edge:%d, QPy:%d ls:%d uvls:%d", mb_x, mb_y, dir, edge, qp, linesize, uvlinesize);
++        //{ int i; for (i = 0; i < 4; i++) ff_tlog(h->avctx, " bS[%d]:%d", i, bS[i]); ff_tlog(h->avctx, "\n"); }
          if( dir == 0 ) {
              filter_mb_edgev( &img_y[4*edge << h->pixel_shift], linesize, bS, qp, a, b, h, 0 );
              if (chroma) {
Simple merge
@@@ -174,17 -169,17 +174,17 @@@ int ff_h264_fill_default_ref_list(H264C
      }
  #ifdef TRACE
      for (i = 0; i < sl->ref_count[0]; i++) {
-         tprintf(h->avctx, "List0: %s fn:%d 0x%p\n",
+         ff_tlog(h->avctx, "List0: %s fn:%d 0x%p\n",
 -                (h->default_ref_list[0][i].long_ref ? "LT" : "ST"),
 +                h->default_ref_list[0][i].parent ? (h->default_ref_list[0][i].parent->long_ref ? "LT" : "ST") : "NULL",
                  h->default_ref_list[0][i].pic_id,
 -                h->default_ref_list[0][i].f.data[0]);
 +                h->default_ref_list[0][i].parent ? h->default_ref_list[0][i].parent->f.data[0] : 0);
      }
      if (sl->slice_type_nos == AV_PICTURE_TYPE_B) {
          for (i = 0; i < sl->ref_count[1]; i++) {
-             tprintf(h->avctx, "List1: %s fn:%d 0x%p\n",
+             ff_tlog(h->avctx, "List1: %s fn:%d 0x%p\n",
 -                    (h->default_ref_list[1][i].long_ref ? "LT" : "ST"),
 +                    h->default_ref_list[1][i].parent ? (h->default_ref_list[1][i].parent->long_ref ? "LT" : "ST") : "NULL",
                      h->default_ref_list[1][i].pic_id,
 -                    h->default_ref_list[1][i].f.data[0]);
 +                    h->default_ref_list[1][i].parent ? h->default_ref_list[1][i].parent->f.data[0] : 0);
          }
      }
  #endif
@@@ -2467,11 -2198,10 +2467,11 @@@ static int decode_slice(struct AVCodecC
                          predict_field_decoding_flag(h, sl);
                  }
                  if (sl->mb_y >= h->mb_height) {
-                     tprintf(h->avctx, "slice end %d %d\n",
+                     ff_tlog(h->avctx, "slice end %d %d\n",
                              get_bits_count(&sl->gb), sl->gb.size_in_bits);
  
 -                    if (get_bits_left(&sl->gb) == 0) {
 +                    if (   get_bits_left(&sl->gb) == 0
 +                        || get_bits_left(&sl->gb) > 0 && !(h->avctx->err_recognition & AV_EF_AGGRESSIVE)) {
                          er_add_slice(sl, sl->resync_mb_x, sl->resync_mb_y,
                                       sl->mb_x - 1, sl->mb_y, ER_MB_END);
  
Simple merge
Simple merge
  #define FF_CODEC_CAP_INIT_CLEANUP           (1 << 1)
  
  
+ #ifdef DEBUG
+ #   define ff_dlog(ctx, ...) av_log(ctx, AV_LOG_DEBUG, __VA_ARGS__)
+ #else
+ #   define ff_dlog(ctx, ...)
+ #endif
+ #ifdef TRACE
+ #   define ff_tlog(ctx, ...) av_log(ctx, AV_LOG_TRACE, __VA_ARGS__)
+ #else
+ #   define ff_tlog(p, ...)
+ #endif
  #define FF_SANE_NB_CHANNELS 63U
  
 -#define FF_SIGNBIT(x) (x >> CHAR_BIT * sizeof(x) - 1)
 +#define FF_SIGNBIT(x) ((x) >> CHAR_BIT * sizeof(x) - 1)
 +
 +#if HAVE_AVX
 +#   define STRIDE_ALIGN 32
 +#elif HAVE_SIMD_ALIGN_16
 +#   define STRIDE_ALIGN 16
 +#else
 +#   define STRIDE_ALIGN 8
 +#endif
  
  typedef struct FramePool {
      /**
@@@ -118,7 -118,7 +118,7 @@@ static int ipvideo_decode_block_opcode_
          y =   8 + ((B - 56) / 29);
      }
  
-     av_dlog(s->avctx, "motion byte = %d, (x, y) = (%d, %d)\n", B, x, y);
 -    ff_dlog(NULL, "    motion byte = %d, (x, y) = (%d, %d)\n", B, x, y);
++    ff_dlog(s->avctx, "motion byte = %d, (x, y) = (%d, %d)\n", B, x, y);
      return copy_from(s, s->second_last_frame, frame, x, y);
  }
  
@@@ -144,7 -144,7 +144,7 @@@ static int ipvideo_decode_block_opcode_
          y = -(  8 + ((B - 56) / 29));
      }
  
-     av_dlog(s->avctx, "motion byte = %d, (x, y) = (%d, %d)\n", B, x, y);
 -    ff_dlog(NULL, "    motion byte = %d, (x, y) = (%d, %d)\n", B, x, y);
++    ff_dlog(s->avctx, "motion byte = %d, (x, y) = (%d, %d)\n", B, x, y);
      return copy_from(s, frame, frame, x, y);
  }
  
@@@ -165,7 -165,7 +165,7 @@@ static int ipvideo_decode_block_opcode_
      x = -8 + BL;
      y = -8 + BH;
  
-     av_dlog(s->avctx, "motion byte = %d, (x, y) = (%d, %d)\n", B, x, y);
 -    ff_dlog(NULL, "    motion byte = %d, (x, y) = (%d, %d)\n", B, x, y);
++    ff_dlog(s->avctx, "motion byte = %d, (x, y) = (%d, %d)\n", B, x, y);
      return copy_from(s, s->last_frame, frame, x, y);
  }
  
@@@ -178,7 -178,7 +178,7 @@@ static int ipvideo_decode_block_opcode_
      x = bytestream2_get_byte(&s->stream_ptr);
      y = bytestream2_get_byte(&s->stream_ptr);
  
-     av_dlog(s->avctx, "motion bytes = %d, %d\n", x, y);
 -    ff_dlog(NULL, "    motion bytes = %d, %d\n", x, y);
++    ff_dlog(s->avctx, "motion bytes = %d, %d\n", x, y);
      return copy_from(s, s->last_frame, frame, x, y);
  }
  
@@@ -553,7 -528,7 +553,7 @@@ static int ipvideo_decode_block_opcode_
      x = bytestream2_get_byte(&s->stream_ptr);
      y = bytestream2_get_byte(&s->stream_ptr);
  
-     av_dlog(s->avctx, "motion bytes = %d, %d\n", x, y);
 -    ff_dlog(NULL, "    motion bytes = %d, %d\n", x, y);
++    ff_dlog(s->avctx, "motion bytes = %d, %d\n", x, y);
      return copy_from(s, s->second_last_frame, frame, x, y);
  }
  
@@@ -1020,9 -1011,9 +1021,9 @@@ int ff_h263_decode_picture_header(MpegE
                  6-14 - reserved
                  */
                  width = (get_bits(&s->gb, 9) + 1) * 4;
 -                skip_bits1(&s->gb);
 +                check_marker(&s->gb, "in dimensions");
                  height = get_bits(&s->gb, 9) * 4;
-                 av_dlog(s->avctx, "\nH.263+ Custom picture: %dx%d\n",width,height);
+                 ff_dlog(s->avctx, "\nH.263+ Custom picture: %dx%d\n",width,height);
                  if (s->aspect_ratio_info == FF_ASPECT_EXTENDED) {
                      /* aspected dimensions */
                      s->avctx->sample_aspect_ratio.num= get_bits(&s->gb, 8);
Simple merge
Simple merge
Simple merge
@@@ -255,11 -248,13 +255,11 @@@ static int mp3lame_encode_frame(AVCodec
          return -1;
      }
      len = hdr.frame_size;
-     av_dlog(avctx, "in:%d packet-len:%d index:%d\n", avctx->frame_size, len,
+     ff_dlog(avctx, "in:%d packet-len:%d index:%d\n", avctx->frame_size, len,
              s->buffer_index);
      if (len <= s->buffer_index) {
 -        if ((ret = ff_alloc_packet(avpkt, len))) {
 -            av_log(avctx, AV_LOG_ERROR, "Error getting output packet\n");
 +        if ((ret = ff_alloc_packet2(avctx, avpkt, len)) < 0)
              return ret;
 -        }
          memcpy(avpkt->data, s->buffer, len);
          s->buffer_index -= len;
          memmove(s->buffer, s->buffer + len, s->buffer_index);
@@@ -265,8 -269,8 +265,8 @@@ static int amr_nb_encode_frame(AVCodecC
  
      written = Encoder_Interface_Encode(s->enc_state, s->enc_mode, samples,
                                         avpkt->data, 0);
-     av_dlog(avctx, "amr_nb_encode_frame encoded %u bytes, bitrate %u, first byte was %#02x\n",
+     ff_dlog(avctx, "amr_nb_encode_frame encoded %u bytes, bitrate %u, first byte was %#02x\n",
 -            written, s->enc_mode, frame[0]);
 +            written, s->enc_mode, avpkt->data[0]);
  
      /* Get the next frame pts/duration */
      ff_af_queue_remove(&s->afq, avctx->frame_size, &avpkt->pts,
@@@ -596,10 -400,10 +596,10 @@@ unk_pixfmt
      s->picture_ptr->key_frame = 1;
      s->got_picture            = 1;
  
 -    for (i = 0; i < 3; i++)
 +    for (i = 0; i < 4; i++)
          s->linesize[i] = s->picture_ptr->linesize[i] << s->interlaced;
  
-     av_dlog(s->avctx, "%d %d %d %d %d %d\n",
+     ff_dlog(s->avctx, "%d %d %d %d %d %d\n",
              s->width, s->height, s->linesize[0], s->linesize[1],
              s->interlaced, s->avctx->height);
  
@@@ -1845,12 -1375,13 +1845,12 @@@ static int find_marker(const uint8_t **
              val = *buf_ptr++;
              goto found;
          }
 -#ifdef DEBUG
          skipped++;
 -#endif
      }
 +    buf_ptr = buf_end;
      val = -1;
  found:
-     av_dlog(NULL, "find_marker skipped %d bytes\n", skipped);
+     ff_dlog(NULL, "find_marker skipped %d bytes\n", skipped);
      *pbuf_ptr = buf_ptr;
      return val;
  }
Simple merge
@@@ -735,9 -713,9 +735,9 @@@ static int mpeg_decode_mb(MpegEncContex
      const int mb_block_count = 4 + (1 << s->chroma_format);
      int ret;
  
-     av_dlog(s->avctx, "decode_mb: x=%d y=%d\n", s->mb_x, s->mb_y);
+     ff_dlog(s->avctx, "decode_mb: x=%d y=%d\n", s->mb_x, s->mb_y);
  
 -    assert(s->mb_skipped == 0);
 +    av_assert2(s->mb_skipped == 0);
  
      if (s->mb_skip_run-- != 0) {
          if (s->pict_type == AV_PICTURE_TYPE_P) {
                                                           s->last_mv[i][j][0]);
                                  s->last_mv[i][j][0] = val;
                                  s->mv[i][j][0]      = val;
-                                 av_dlog(s->avctx, "fmx=%d\n", val);
+                                 ff_dlog(s->avctx, "fmx=%d\n", val);
                                  val = mpeg_decode_motion(s, s->mpeg_f_code[i][1],
                                                           s->last_mv[i][j][1] >> 1);
 -                                s->last_mv[i][j][1] = val << 1;
 +                                s->last_mv[i][j][1] = 2 * val;
                                  s->mv[i][j][1]      = val;
-                                 av_dlog(s->avctx, "fmy=%d\n", val);
+                                 ff_dlog(s->avctx, "fmy=%d\n", val);
                              }
                          }
                      }
@@@ -1273,50 -1227,6 +1273,50 @@@ static int mpeg_decode_postinit(AVCodec
      uint8_t old_permutation[64];
      int ret;
  
-                 av_dlog(avctx, "A %d/%d\n",
 +    if (avctx->codec_id == AV_CODEC_ID_MPEG1VIDEO) {
 +        // MPEG-1 aspect
 +        avctx->sample_aspect_ratio = av_d2q(1.0 / ff_mpeg1_aspect[s->aspect_ratio_info], 255);
 +    } else { // MPEG-2
 +        // MPEG-2 aspect
 +        if (s->aspect_ratio_info > 1) {
 +            AVRational dar =
 +                av_mul_q(av_div_q(ff_mpeg2_aspect[s->aspect_ratio_info],
 +                                  (AVRational) { s1->pan_scan.width,
 +                                                 s1->pan_scan.height }),
 +                         (AVRational) { s->width, s->height });
 +
 +            /* We ignore the spec here and guess a bit as reality does not
 +             * match the spec, see for example res_change_ffmpeg_aspect.ts
 +             * and sequence-display-aspect.mpg.
 +             * issue1613, 621, 562 */
 +            if ((s1->pan_scan.width == 0) || (s1->pan_scan.height == 0) ||
 +                (av_cmp_q(dar, (AVRational) { 4, 3 }) &&
 +                 av_cmp_q(dar, (AVRational) { 16, 9 }))) {
 +                s->avctx->sample_aspect_ratio =
 +                    av_div_q(ff_mpeg2_aspect[s->aspect_ratio_info],
 +                             (AVRational) { s->width, s->height });
 +            } else {
 +                s->avctx->sample_aspect_ratio =
 +                    av_div_q(ff_mpeg2_aspect[s->aspect_ratio_info],
 +                             (AVRational) { s1->pan_scan.width, s1->pan_scan.height });
 +// issue1613 4/3 16/9 -> 16/9
 +// res_change_ffmpeg_aspect.ts 4/3 225/44 ->4/3
 +// widescreen-issue562.mpg 4/3 16/9 -> 16/9
 +//                s->avctx->sample_aspect_ratio = av_mul_q(s->avctx->sample_aspect_ratio, (AVRational) {s->width, s->height});
-                 av_dlog(avctx, "B %d/%d\n", s->avctx->sample_aspect_ratio.num,
++                ff_dlog(avctx, "A %d/%d\n",
 +                        ff_mpeg2_aspect[s->aspect_ratio_info].num,
 +                        ff_mpeg2_aspect[s->aspect_ratio_info].den);
++                ff_dlog(avctx, "B %d/%d\n", s->avctx->sample_aspect_ratio.num,
 +                        s->avctx->sample_aspect_ratio.den);
 +            }
 +        } else {
 +            s->avctx->sample_aspect_ratio =
 +                ff_mpeg2_aspect[s->aspect_ratio_info];
 +        }
 +    } // MPEG-2
 +
 +    ff_set_sar(s->avctx, s->avctx->sample_aspect_ratio);
 +
      if ((s1->mpeg_enc_ctx_allocated == 0)                   ||
          avctx->coded_width       != s->width                ||
          avctx->coded_height      != s->height               ||
@@@ -1992,12 -1951,8 +1992,12 @@@ static int mpeg_decode_slice(MpegEncCon
          }
      }
  eos: // end of slice
 +    if (get_bits_left(&s->gb) < 0) {
 +        av_log(s, AV_LOG_ERROR, "overread %d\n", -get_bits_left(&s->gb));
 +        return AVERROR_INVALIDDATA;
 +    }
      *buf += (get_bits_count(&s->gb) - 1) / 8;
-     av_dlog(s, "y %d %d %d %d\n", s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y);
+     ff_dlog(s, "y %d %d %d %d\n", s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y);
      return 0;
  }
  
@@@ -1169,7 -1136,6 +1169,7 @@@ static inline int mpeg4_decode_block(Mp
                  level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
                  LAST_SKIP_BITS(re, &s->gb, 1);
              }
-             tprintf(s->avctx, "dct[%d][%d] = %- 4d end?:%d\n", scan_table[i&63]&7, scan_table[i&63] >> 3, level, i>62);
++            ff_tlog(s->avctx, "dct[%d][%d] = %- 4d end?:%d\n", scan_table[i&63]&7, scan_table[i&63] >> 3, level, i>62);
              if (i > 62) {
                  i -= 192;
                  if (i & (~63)) {
@@@ -1394,10 -1361,11 +1394,10 @@@ static int mp_decode_layer3(MPADecodeCo
      if (!s->adu_mode) {
          int skip;
          const uint8_t *ptr = s->gb.buffer + (get_bits_count(&s->gb)>>3);
 -        int extrasize = av_clip(get_bits_left(&s->gb) >> 3, 0,
 -                                FFMAX(0, LAST_BUF_SIZE - s->last_buf_size));
 -        assert((get_bits_count(&s->gb) & 7) == 0);
 +        int extrasize = av_clip(get_bits_left(&s->gb) >> 3, 0, EXTRABYTES);
 +        av_assert1((get_bits_count(&s->gb) & 7) == 0);
          /* now we get bits from the main_data_begin offset */
-         av_dlog(s->avctx, "seekback:%d, lastbuf:%d\n",
+         ff_dlog(s->avctx, "seekback:%d, lastbuf:%d\n",
                  main_data_begin, s->last_buf_size);
  
          memcpy(s->last_buf + s->last_buf_size, ptr, extrasize);
Simple merge
index 1bf9471,0000000..5a0897f
mode 100644,000000..100644
--- /dev/null
@@@ -1,785 -1,0 +1,785 @@@
-     av_dlog(avctx, "%d kb/s, %d Hz, frame_size=%d bits, table=%d, padincr=%x\n",
 +/*
 + * The simplest mpeg audio layer 2 encoder
 + * Copyright (c) 2000, 2001 Fabrice Bellard
 + *
 + * This file is part of FFmpeg.
 + *
 + * 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.
 + *
 + * 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 FFmpeg; if not, write to the Free Software
 + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 + */
 +
 +/**
 + * @file
 + * The simplest mpeg audio layer 2 encoder.
 + */
 +
 +#include "libavutil/channel_layout.h"
 +
 +#include "avcodec.h"
 +#include "internal.h"
 +#include "put_bits.h"
 +
 +#define FRAC_BITS   15   /* fractional bits for sb_samples and dct */
 +#define WFRAC_BITS  14   /* fractional bits for window */
 +
 +#include "mpegaudio.h"
 +#include "mpegaudiodsp.h"
 +#include "mpegaudiodata.h"
 +#include "mpegaudiotab.h"
 +
 +/* currently, cannot change these constants (need to modify
 +   quantization stage) */
 +#define MUL(a,b) (((int64_t)(a) * (int64_t)(b)) >> FRAC_BITS)
 +
 +#define SAMPLES_BUF_SIZE 4096
 +
 +typedef struct MpegAudioContext {
 +    PutBitContext pb;
 +    int nb_channels;
 +    int lsf;           /* 1 if mpeg2 low bitrate selected */
 +    int bitrate_index; /* bit rate */
 +    int freq_index;
 +    int frame_size; /* frame size, in bits, without padding */
 +    /* padding computation */
 +    int frame_frac, frame_frac_incr, do_padding;
 +    short samples_buf[MPA_MAX_CHANNELS][SAMPLES_BUF_SIZE]; /* buffer for filter */
 +    int samples_offset[MPA_MAX_CHANNELS];       /* offset in samples_buf */
 +    int sb_samples[MPA_MAX_CHANNELS][3][12][SBLIMIT];
 +    unsigned char scale_factors[MPA_MAX_CHANNELS][SBLIMIT][3]; /* scale factors */
 +    /* code to group 3 scale factors */
 +    unsigned char scale_code[MPA_MAX_CHANNELS][SBLIMIT];
 +    int sblimit; /* number of used subbands */
 +    const unsigned char *alloc_table;
 +    int16_t filter_bank[512];
 +    int scale_factor_table[64];
 +    unsigned char scale_diff_table[128];
 +#if USE_FLOATS
 +    float scale_factor_inv_table[64];
 +#else
 +    int8_t scale_factor_shift[64];
 +    unsigned short scale_factor_mult[64];
 +#endif
 +    unsigned short total_quant_bits[17]; /* total number of bits per allocation group */
 +} MpegAudioContext;
 +
 +static av_cold int MPA_encode_init(AVCodecContext *avctx)
 +{
 +    MpegAudioContext *s = avctx->priv_data;
 +    int freq = avctx->sample_rate;
 +    int bitrate = avctx->bit_rate;
 +    int channels = avctx->channels;
 +    int i, v, table;
 +    float a;
 +
 +    if (channels <= 0 || channels > 2){
 +        av_log(avctx, AV_LOG_ERROR, "encoding %d channel(s) is not allowed in mp2\n", channels);
 +        return AVERROR(EINVAL);
 +    }
 +    bitrate = bitrate / 1000;
 +    s->nb_channels = channels;
 +    avctx->frame_size = MPA_FRAME_SIZE;
 +    avctx->initial_padding = 512 - 32 + 1;
 +
 +    /* encoding freq */
 +    s->lsf = 0;
 +    for(i=0;i<3;i++) {
 +        if (avpriv_mpa_freq_tab[i] == freq)
 +            break;
 +        if ((avpriv_mpa_freq_tab[i] / 2) == freq) {
 +            s->lsf = 1;
 +            break;
 +        }
 +    }
 +    if (i == 3){
 +        av_log(avctx, AV_LOG_ERROR, "Sampling rate %d is not allowed in mp2\n", freq);
 +        return AVERROR(EINVAL);
 +    }
 +    s->freq_index = i;
 +
 +    /* encoding bitrate & frequency */
 +    for(i=1;i<15;i++) {
 +        if (avpriv_mpa_bitrate_tab[s->lsf][1][i] == bitrate)
 +            break;
 +    }
 +    if (i == 15 && !avctx->bit_rate) {
 +        i = 14;
 +        bitrate = avpriv_mpa_bitrate_tab[s->lsf][1][i];
 +        avctx->bit_rate = bitrate * 1000;
 +    }
 +    if (i == 15){
 +        av_log(avctx, AV_LOG_ERROR, "bitrate %d is not allowed in mp2\n", bitrate);
 +        return AVERROR(EINVAL);
 +    }
 +    s->bitrate_index = i;
 +
 +    /* compute total header size & pad bit */
 +
 +    a = (float)(bitrate * 1000 * MPA_FRAME_SIZE) / (freq * 8.0);
 +    s->frame_size = ((int)a) * 8;
 +
 +    /* frame fractional size to compute padding */
 +    s->frame_frac = 0;
 +    s->frame_frac_incr = (int)((a - floor(a)) * 65536.0);
 +
 +    /* select the right allocation table */
 +    table = ff_mpa_l2_select_table(bitrate, s->nb_channels, freq, s->lsf);
 +
 +    /* number of used subbands */
 +    s->sblimit = ff_mpa_sblimit_table[table];
 +    s->alloc_table = ff_mpa_alloc_tables[table];
 +
-             av_dlog(NULL, "%2d:%d in=%x %x %d\n",
++    ff_dlog(avctx, "%d kb/s, %d Hz, frame_size=%d bits, table=%d, padincr=%x\n",
 +            bitrate, freq, s->frame_size, table, s->frame_frac_incr);
 +
 +    for(i=0;i<s->nb_channels;i++)
 +        s->samples_offset[i] = 0;
 +
 +    for(i=0;i<257;i++) {
 +        int v;
 +        v = ff_mpa_enwindow[i];
 +#if WFRAC_BITS != 16
 +        v = (v + (1 << (16 - WFRAC_BITS - 1))) >> (16 - WFRAC_BITS);
 +#endif
 +        s->filter_bank[i] = v;
 +        if ((i & 63) != 0)
 +            v = -v;
 +        if (i != 0)
 +            s->filter_bank[512 - i] = v;
 +    }
 +
 +    for(i=0;i<64;i++) {
 +        v = (int)(exp2((3 - i) / 3.0) * (1 << 20));
 +        if (v <= 0)
 +            v = 1;
 +        s->scale_factor_table[i] = v;
 +#if USE_FLOATS
 +        s->scale_factor_inv_table[i] = exp2(-(3 - i) / 3.0) / (float)(1 << 20);
 +#else
 +#define P 15
 +        s->scale_factor_shift[i] = 21 - P - (i / 3);
 +        s->scale_factor_mult[i] = (1 << P) * exp2((i % 3) / 3.0);
 +#endif
 +    }
 +    for(i=0;i<128;i++) {
 +        v = i - 64;
 +        if (v <= -3)
 +            v = 0;
 +        else if (v < 0)
 +            v = 1;
 +        else if (v == 0)
 +            v = 2;
 +        else if (v < 3)
 +            v = 3;
 +        else
 +            v = 4;
 +        s->scale_diff_table[i] = v;
 +    }
 +
 +    for(i=0;i<17;i++) {
 +        v = ff_mpa_quant_bits[i];
 +        if (v < 0)
 +            v = -v;
 +        else
 +            v = v * 3;
 +        s->total_quant_bits[i] = 12 * v;
 +    }
 +
 +    return 0;
 +}
 +
 +/* 32 point floating point IDCT without 1/sqrt(2) coef zero scaling */
 +static void idct32(int *out, int *tab)
 +{
 +    int i, j;
 +    int *t, *t1, xr;
 +    const int *xp = costab32;
 +
 +    for(j=31;j>=3;j-=2) tab[j] += tab[j - 2];
 +
 +    t = tab + 30;
 +    t1 = tab + 2;
 +    do {
 +        t[0] += t[-4];
 +        t[1] += t[1 - 4];
 +        t -= 4;
 +    } while (t != t1);
 +
 +    t = tab + 28;
 +    t1 = tab + 4;
 +    do {
 +        t[0] += t[-8];
 +        t[1] += t[1-8];
 +        t[2] += t[2-8];
 +        t[3] += t[3-8];
 +        t -= 8;
 +    } while (t != t1);
 +
 +    t = tab;
 +    t1 = tab + 32;
 +    do {
 +        t[ 3] = -t[ 3];
 +        t[ 6] = -t[ 6];
 +
 +        t[11] = -t[11];
 +        t[12] = -t[12];
 +        t[13] = -t[13];
 +        t[15] = -t[15];
 +        t += 16;
 +    } while (t != t1);
 +
 +
 +    t = tab;
 +    t1 = tab + 8;
 +    do {
 +        int x1, x2, x3, x4;
 +
 +        x3 = MUL(t[16], FIX(SQRT2*0.5));
 +        x4 = t[0] - x3;
 +        x3 = t[0] + x3;
 +
 +        x2 = MUL(-(t[24] + t[8]), FIX(SQRT2*0.5));
 +        x1 = MUL((t[8] - x2), xp[0]);
 +        x2 = MUL((t[8] + x2), xp[1]);
 +
 +        t[ 0] = x3 + x1;
 +        t[ 8] = x4 - x2;
 +        t[16] = x4 + x2;
 +        t[24] = x3 - x1;
 +        t++;
 +    } while (t != t1);
 +
 +    xp += 2;
 +    t = tab;
 +    t1 = tab + 4;
 +    do {
 +        xr = MUL(t[28],xp[0]);
 +        t[28] = (t[0] - xr);
 +        t[0] = (t[0] + xr);
 +
 +        xr = MUL(t[4],xp[1]);
 +        t[ 4] = (t[24] - xr);
 +        t[24] = (t[24] + xr);
 +
 +        xr = MUL(t[20],xp[2]);
 +        t[20] = (t[8] - xr);
 +        t[ 8] = (t[8] + xr);
 +
 +        xr = MUL(t[12],xp[3]);
 +        t[12] = (t[16] - xr);
 +        t[16] = (t[16] + xr);
 +        t++;
 +    } while (t != t1);
 +    xp += 4;
 +
 +    for (i = 0; i < 4; i++) {
 +        xr = MUL(tab[30-i*4],xp[0]);
 +        tab[30-i*4] = (tab[i*4] - xr);
 +        tab[   i*4] = (tab[i*4] + xr);
 +
 +        xr = MUL(tab[ 2+i*4],xp[1]);
 +        tab[ 2+i*4] = (tab[28-i*4] - xr);
 +        tab[28-i*4] = (tab[28-i*4] + xr);
 +
 +        xr = MUL(tab[31-i*4],xp[0]);
 +        tab[31-i*4] = (tab[1+i*4] - xr);
 +        tab[ 1+i*4] = (tab[1+i*4] + xr);
 +
 +        xr = MUL(tab[ 3+i*4],xp[1]);
 +        tab[ 3+i*4] = (tab[29-i*4] - xr);
 +        tab[29-i*4] = (tab[29-i*4] + xr);
 +
 +        xp += 2;
 +    }
 +
 +    t = tab + 30;
 +    t1 = tab + 1;
 +    do {
 +        xr = MUL(t1[0], *xp);
 +        t1[0] = (t[0] - xr);
 +        t[0] = (t[0] + xr);
 +        t -= 2;
 +        t1 += 2;
 +        xp++;
 +    } while (t >= tab);
 +
 +    for(i=0;i<32;i++) {
 +        out[i] = tab[bitinv32[i]];
 +    }
 +}
 +
 +#define WSHIFT (WFRAC_BITS + 15 - FRAC_BITS)
 +
 +static void filter(MpegAudioContext *s, int ch, const short *samples, int incr)
 +{
 +    short *p, *q;
 +    int sum, offset, i, j;
 +    int tmp[64];
 +    int tmp1[32];
 +    int *out;
 +
 +    offset = s->samples_offset[ch];
 +    out = &s->sb_samples[ch][0][0][0];
 +    for(j=0;j<36;j++) {
 +        /* 32 samples at once */
 +        for(i=0;i<32;i++) {
 +            s->samples_buf[ch][offset + (31 - i)] = samples[0];
 +            samples += incr;
 +        }
 +
 +        /* filter */
 +        p = s->samples_buf[ch] + offset;
 +        q = s->filter_bank;
 +        /* maxsum = 23169 */
 +        for(i=0;i<64;i++) {
 +            sum = p[0*64] * q[0*64];
 +            sum += p[1*64] * q[1*64];
 +            sum += p[2*64] * q[2*64];
 +            sum += p[3*64] * q[3*64];
 +            sum += p[4*64] * q[4*64];
 +            sum += p[5*64] * q[5*64];
 +            sum += p[6*64] * q[6*64];
 +            sum += p[7*64] * q[7*64];
 +            tmp[i] = sum;
 +            p++;
 +            q++;
 +        }
 +        tmp1[0] = tmp[16] >> WSHIFT;
 +        for( i=1; i<=16; i++ ) tmp1[i] = (tmp[i+16]+tmp[16-i]) >> WSHIFT;
 +        for( i=17; i<=31; i++ ) tmp1[i] = (tmp[i+16]-tmp[80-i]) >> WSHIFT;
 +
 +        idct32(out, tmp1);
 +
 +        /* advance of 32 samples */
 +        offset -= 32;
 +        out += 32;
 +        /* handle the wrap around */
 +        if (offset < 0) {
 +            memmove(s->samples_buf[ch] + SAMPLES_BUF_SIZE - (512 - 32),
 +                    s->samples_buf[ch], (512 - 32) * 2);
 +            offset = SAMPLES_BUF_SIZE - 512;
 +        }
 +    }
 +    s->samples_offset[ch] = offset;
 +}
 +
 +static void compute_scale_factors(MpegAudioContext *s,
 +                                  unsigned char scale_code[SBLIMIT],
 +                                  unsigned char scale_factors[SBLIMIT][3],
 +                                  int sb_samples[3][12][SBLIMIT],
 +                                  int sblimit)
 +{
 +    int *p, vmax, v, n, i, j, k, code;
 +    int index, d1, d2;
 +    unsigned char *sf = &scale_factors[0][0];
 +
 +    for(j=0;j<sblimit;j++) {
 +        for(i=0;i<3;i++) {
 +            /* find the max absolute value */
 +            p = &sb_samples[i][0][j];
 +            vmax = abs(*p);
 +            for(k=1;k<12;k++) {
 +                p += SBLIMIT;
 +                v = abs(*p);
 +                if (v > vmax)
 +                    vmax = v;
 +            }
 +            /* compute the scale factor index using log 2 computations */
 +            if (vmax > 1) {
 +                n = av_log2(vmax);
 +                /* n is the position of the MSB of vmax. now
 +                   use at most 2 compares to find the index */
 +                index = (21 - n) * 3 - 3;
 +                if (index >= 0) {
 +                    while (vmax <= s->scale_factor_table[index+1])
 +                        index++;
 +                } else {
 +                    index = 0; /* very unlikely case of overflow */
 +                }
 +            } else {
 +                index = 62; /* value 63 is not allowed */
 +            }
 +
-         av_dlog(NULL, "%d: %2d %2d %2d %d %d -> %d\n", j,
++            ff_dlog(NULL, "%2d:%d in=%x %x %d\n",
 +                    j, i, vmax, s->scale_factor_table[index], index);
 +            /* store the scale factor */
 +            av_assert2(index >=0 && index <= 63);
 +            sf[i] = index;
 +        }
 +
 +        /* compute the transmission factor : look if the scale factors
 +           are close enough to each other */
 +        d1 = s->scale_diff_table[sf[0] - sf[1] + 64];
 +        d2 = s->scale_diff_table[sf[1] - sf[2] + 64];
 +
 +        /* handle the 25 cases */
 +        switch(d1 * 5 + d2) {
 +        case 0*5+0:
 +        case 0*5+4:
 +        case 3*5+4:
 +        case 4*5+0:
 +        case 4*5+4:
 +            code = 0;
 +            break;
 +        case 0*5+1:
 +        case 0*5+2:
 +        case 4*5+1:
 +        case 4*5+2:
 +            code = 3;
 +            sf[2] = sf[1];
 +            break;
 +        case 0*5+3:
 +        case 4*5+3:
 +            code = 3;
 +            sf[1] = sf[2];
 +            break;
 +        case 1*5+0:
 +        case 1*5+4:
 +        case 2*5+4:
 +            code = 1;
 +            sf[1] = sf[0];
 +            break;
 +        case 1*5+1:
 +        case 1*5+2:
 +        case 2*5+0:
 +        case 2*5+1:
 +        case 2*5+2:
 +            code = 2;
 +            sf[1] = sf[2] = sf[0];
 +            break;
 +        case 2*5+3:
 +        case 3*5+3:
 +            code = 2;
 +            sf[0] = sf[1] = sf[2];
 +            break;
 +        case 3*5+0:
 +        case 3*5+1:
 +        case 3*5+2:
 +            code = 2;
 +            sf[0] = sf[2] = sf[1];
 +            break;
 +        case 1*5+3:
 +            code = 2;
 +            if (sf[0] > sf[2])
 +              sf[0] = sf[2];
 +            sf[1] = sf[2] = sf[0];
 +            break;
 +        default:
 +            av_assert2(0); //cannot happen
 +            code = 0;           /* kill warning */
 +        }
 +
-         av_dlog(NULL, "current=%d max=%d max_sb=%d max_ch=%d alloc=%d\n",
++        ff_dlog(NULL, "%d: %2d %2d %2d %d %d -> %d\n", j,
 +                sf[0], sf[1], sf[2], d1, d2, code);
 +        scale_code[j] = code;
 +        sf += 3;
 +    }
 +}
 +
 +/* The most important function : psycho acoustic module. In this
 +   encoder there is basically none, so this is the worst you can do,
 +   but also this is the simpler. */
 +static void psycho_acoustic_model(MpegAudioContext *s, short smr[SBLIMIT])
 +{
 +    int i;
 +
 +    for(i=0;i<s->sblimit;i++) {
 +        smr[i] = (int)(fixed_smr[i] * 10);
 +    }
 +}
 +
 +
 +#define SB_NOTALLOCATED  0
 +#define SB_ALLOCATED     1
 +#define SB_NOMORE        2
 +
 +/* Try to maximize the smr while using a number of bits inferior to
 +   the frame size. I tried to make the code simpler, faster and
 +   smaller than other encoders :-) */
 +static void compute_bit_allocation(MpegAudioContext *s,
 +                                   short smr1[MPA_MAX_CHANNELS][SBLIMIT],
 +                                   unsigned char bit_alloc[MPA_MAX_CHANNELS][SBLIMIT],
 +                                   int *padding)
 +{
 +    int i, ch, b, max_smr, max_ch, max_sb, current_frame_size, max_frame_size;
 +    int incr;
 +    short smr[MPA_MAX_CHANNELS][SBLIMIT];
 +    unsigned char subband_status[MPA_MAX_CHANNELS][SBLIMIT];
 +    const unsigned char *alloc;
 +
 +    memcpy(smr, smr1, s->nb_channels * sizeof(short) * SBLIMIT);
 +    memset(subband_status, SB_NOTALLOCATED, s->nb_channels * SBLIMIT);
 +    memset(bit_alloc, 0, s->nb_channels * SBLIMIT);
 +
 +    /* compute frame size and padding */
 +    max_frame_size = s->frame_size;
 +    s->frame_frac += s->frame_frac_incr;
 +    if (s->frame_frac >= 65536) {
 +        s->frame_frac -= 65536;
 +        s->do_padding = 1;
 +        max_frame_size += 8;
 +    } else {
 +        s->do_padding = 0;
 +    }
 +
 +    /* compute the header + bit alloc size */
 +    current_frame_size = 32;
 +    alloc = s->alloc_table;
 +    for(i=0;i<s->sblimit;i++) {
 +        incr = alloc[0];
 +        current_frame_size += incr * s->nb_channels;
 +        alloc += 1 << incr;
 +    }
 +    for(;;) {
 +        /* look for the subband with the largest signal to mask ratio */
 +        max_sb = -1;
 +        max_ch = -1;
 +        max_smr = INT_MIN;
 +        for(ch=0;ch<s->nb_channels;ch++) {
 +            for(i=0;i<s->sblimit;i++) {
 +                if (smr[ch][i] > max_smr && subband_status[ch][i] != SB_NOMORE) {
 +                    max_smr = smr[ch][i];
 +                    max_sb = i;
 +                    max_ch = ch;
 +                }
 +            }
 +        }
 +        if (max_sb < 0)
 +            break;
++        ff_dlog(NULL, "current=%d max=%d max_sb=%d max_ch=%d alloc=%d\n",
 +                current_frame_size, max_frame_size, max_sb, max_ch,
 +                bit_alloc[max_ch][max_sb]);
 +
 +        /* find alloc table entry (XXX: not optimal, should use
 +           pointer table) */
 +        alloc = s->alloc_table;
 +        for(i=0;i<max_sb;i++) {
 +            alloc += 1 << alloc[0];
 +        }
 +
 +        if (subband_status[max_ch][max_sb] == SB_NOTALLOCATED) {
 +            /* nothing was coded for this band: add the necessary bits */
 +            incr = 2 + nb_scale_factors[s->scale_code[max_ch][max_sb]] * 6;
 +            incr += s->total_quant_bits[alloc[1]];
 +        } else {
 +            /* increments bit allocation */
 +            b = bit_alloc[max_ch][max_sb];
 +            incr = s->total_quant_bits[alloc[b + 1]] -
 +                s->total_quant_bits[alloc[b]];
 +        }
 +
 +        if (current_frame_size + incr <= max_frame_size) {
 +            /* can increase size */
 +            b = ++bit_alloc[max_ch][max_sb];
 +            current_frame_size += incr;
 +            /* decrease smr by the resolution we added */
 +            smr[max_ch][max_sb] = smr1[max_ch][max_sb] - quant_snr[alloc[b]];
 +            /* max allocation size reached ? */
 +            if (b == ((1 << alloc[0]) - 1))
 +                subband_status[max_ch][max_sb] = SB_NOMORE;
 +            else
 +                subband_status[max_ch][max_sb] = SB_ALLOCATED;
 +        } else {
 +            /* cannot increase the size of this subband */
 +            subband_status[max_ch][max_sb] = SB_NOMORE;
 +        }
 +    }
 +    *padding = max_frame_size - current_frame_size;
 +    av_assert0(*padding >= 0);
 +}
 +
 +/*
 + * Output the mpeg audio layer 2 frame. Note how the code is small
 + * compared to other encoders :-)
 + */
 +static void encode_frame(MpegAudioContext *s,
 +                         unsigned char bit_alloc[MPA_MAX_CHANNELS][SBLIMIT],
 +                         int padding)
 +{
 +    int i, j, k, l, bit_alloc_bits, b, ch;
 +    unsigned char *sf;
 +    int q[3];
 +    PutBitContext *p = &s->pb;
 +
 +    /* header */
 +
 +    put_bits(p, 12, 0xfff);
 +    put_bits(p, 1, 1 - s->lsf); /* 1 = mpeg1 ID, 0 = mpeg2 lsf ID */
 +    put_bits(p, 2, 4-2);  /* layer 2 */
 +    put_bits(p, 1, 1); /* no error protection */
 +    put_bits(p, 4, s->bitrate_index);
 +    put_bits(p, 2, s->freq_index);
 +    put_bits(p, 1, s->do_padding); /* use padding */
 +    put_bits(p, 1, 0);             /* private_bit */
 +    put_bits(p, 2, s->nb_channels == 2 ? MPA_STEREO : MPA_MONO);
 +    put_bits(p, 2, 0); /* mode_ext */
 +    put_bits(p, 1, 0); /* no copyright */
 +    put_bits(p, 1, 1); /* original */
 +    put_bits(p, 2, 0); /* no emphasis */
 +
 +    /* bit allocation */
 +    j = 0;
 +    for(i=0;i<s->sblimit;i++) {
 +        bit_alloc_bits = s->alloc_table[j];
 +        for(ch=0;ch<s->nb_channels;ch++) {
 +            put_bits(p, bit_alloc_bits, bit_alloc[ch][i]);
 +        }
 +        j += 1 << bit_alloc_bits;
 +    }
 +
 +    /* scale codes */
 +    for(i=0;i<s->sblimit;i++) {
 +        for(ch=0;ch<s->nb_channels;ch++) {
 +            if (bit_alloc[ch][i])
 +                put_bits(p, 2, s->scale_code[ch][i]);
 +        }
 +    }
 +
 +    /* scale factors */
 +    for(i=0;i<s->sblimit;i++) {
 +        for(ch=0;ch<s->nb_channels;ch++) {
 +            if (bit_alloc[ch][i]) {
 +                sf = &s->scale_factors[ch][i][0];
 +                switch(s->scale_code[ch][i]) {
 +                case 0:
 +                    put_bits(p, 6, sf[0]);
 +                    put_bits(p, 6, sf[1]);
 +                    put_bits(p, 6, sf[2]);
 +                    break;
 +                case 3:
 +                case 1:
 +                    put_bits(p, 6, sf[0]);
 +                    put_bits(p, 6, sf[2]);
 +                    break;
 +                case 2:
 +                    put_bits(p, 6, sf[0]);
 +                    break;
 +                }
 +            }
 +        }
 +    }
 +
 +    /* quantization & write sub band samples */
 +
 +    for(k=0;k<3;k++) {
 +        for(l=0;l<12;l+=3) {
 +            j = 0;
 +            for(i=0;i<s->sblimit;i++) {
 +                bit_alloc_bits = s->alloc_table[j];
 +                for(ch=0;ch<s->nb_channels;ch++) {
 +                    b = bit_alloc[ch][i];
 +                    if (b) {
 +                        int qindex, steps, m, sample, bits;
 +                        /* we encode 3 sub band samples of the same sub band at a time */
 +                        qindex = s->alloc_table[j+b];
 +                        steps = ff_mpa_quant_steps[qindex];
 +                        for(m=0;m<3;m++) {
 +                            sample = s->sb_samples[ch][k][l + m][i];
 +                            /* divide by scale factor */
 +#if USE_FLOATS
 +                            {
 +                                float a;
 +                                a = (float)sample * s->scale_factor_inv_table[s->scale_factors[ch][i][k]];
 +                                q[m] = (int)((a + 1.0) * steps * 0.5);
 +                            }
 +#else
 +                            {
 +                                int q1, e, shift, mult;
 +                                e = s->scale_factors[ch][i][k];
 +                                shift = s->scale_factor_shift[e];
 +                                mult = s->scale_factor_mult[e];
 +
 +                                /* normalize to P bits */
 +                                if (shift < 0)
 +                                    q1 = sample << (-shift);
 +                                else
 +                                    q1 = sample >> shift;
 +                                q1 = (q1 * mult) >> P;
 +                                q1 += 1 << P;
 +                                if (q1 < 0)
 +                                    q1 = 0;
 +                                q[m] = (q1 * (unsigned)steps) >> (P + 1);
 +                            }
 +#endif
 +                            if (q[m] >= steps)
 +                                q[m] = steps - 1;
 +                            av_assert2(q[m] >= 0 && q[m] < steps);
 +                        }
 +                        bits = ff_mpa_quant_bits[qindex];
 +                        if (bits < 0) {
 +                            /* group the 3 values to save bits */
 +                            put_bits(p, -bits,
 +                                     q[0] + steps * (q[1] + steps * q[2]));
 +                        } else {
 +                            put_bits(p, bits, q[0]);
 +                            put_bits(p, bits, q[1]);
 +                            put_bits(p, bits, q[2]);
 +                        }
 +                    }
 +                }
 +                /* next subband in alloc table */
 +                j += 1 << bit_alloc_bits;
 +            }
 +        }
 +    }
 +
 +    /* padding */
 +    for(i=0;i<padding;i++)
 +        put_bits(p, 1, 0);
 +
 +    /* flush */
 +    flush_put_bits(p);
 +}
 +
 +static int MPA_encode_frame(AVCodecContext *avctx, AVPacket *avpkt,
 +                            const AVFrame *frame, int *got_packet_ptr)
 +{
 +    MpegAudioContext *s = avctx->priv_data;
 +    const int16_t *samples = (const int16_t *)frame->data[0];
 +    short smr[MPA_MAX_CHANNELS][SBLIMIT];
 +    unsigned char bit_alloc[MPA_MAX_CHANNELS][SBLIMIT];
 +    int padding, i, ret;
 +
 +    for(i=0;i<s->nb_channels;i++) {
 +        filter(s, i, samples + i, s->nb_channels);
 +    }
 +
 +    for(i=0;i<s->nb_channels;i++) {
 +        compute_scale_factors(s, s->scale_code[i], s->scale_factors[i],
 +                              s->sb_samples[i], s->sblimit);
 +    }
 +    for(i=0;i<s->nb_channels;i++) {
 +        psycho_acoustic_model(s, smr[i]);
 +    }
 +    compute_bit_allocation(s, smr, bit_alloc, &padding);
 +
 +    if ((ret = ff_alloc_packet2(avctx, avpkt, MPA_MAX_CODED_FRAME_SIZE)) < 0)
 +        return ret;
 +
 +    init_put_bits(&s->pb, avpkt->data, avpkt->size);
 +
 +    encode_frame(s, bit_alloc, padding);
 +
 +    if (frame->pts != AV_NOPTS_VALUE)
 +        avpkt->pts = frame->pts - ff_samples_to_time_base(avctx, avctx->initial_padding);
 +
 +    avpkt->size = put_bits_count(&s->pb) / 8;
 +    *got_packet_ptr = 1;
 +    return 0;
 +}
 +
 +static const AVCodecDefault mp2_defaults[] = {
 +    { "b", "0" },
 +    { NULL },
 +};
 +
Simple merge
@@@ -1125,12 -992,8 +1125,12 @@@ static int load_input_picture(MpegEncCo
              direct = 0;
          if ((s->width & 15) || (s->height & 15))
              direct = 0;
 +        if (((intptr_t)(pic_arg->data[0])) & (STRIDE_ALIGN-1))
 +            direct = 0;
 +        if (s->linesize & (STRIDE_ALIGN-1))
 +            direct = 0;
  
-         av_dlog(s->avctx, "%d %d %"PTRDIFF_SPECIFIER" %"PTRDIFF_SPECIFIER"\n", pic_arg->linesize[0],
 -        ff_dlog(s->avctx, "%d %d %td %td\n", pic_arg->linesize[0],
++        ff_dlog(s->avctx, "%d %d %"PTRDIFF_SPECIFIER" %"PTRDIFF_SPECIFIER"\n", pic_arg->linesize[0],
                  pic_arg->linesize[1], s->linesize, s->uvlinesize);
  
          i = ff_find_unused_picture(s, direct);
@@@ -3566,9 -3337,7 +3566,9 @@@ static int encode_picture(MpegEncContex
          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;
 -        ff_dlog(s, "Scene change detected, encoding as I Frame %d %d\n",
 +        if(s->msmpeg4_version >= 3)
 +            s->no_rounding=1;
-         av_dlog(s, "Scene change detected, encoding as I Frame %"PRId64" %"PRId64"\n",
++        ff_dlog(s, "Scene change detected, encoding as I Frame %"PRId64" %"PRId64"\n",
                  s->current_picture.mb_var_sum, s->current_picture.mc_mb_var_sum);
      }
  
@@@ -186,8 -169,8 +186,8 @@@ static int mpegvideo_parse(AVCodecParse
         to have the full timing information. The time take by this
         function should be negligible for uncorrupted streams */
      mpegvideo_extract_headers(s, avctx, buf, buf_size);
-     av_dlog(NULL, "pict_type=%d frame_rate=%0.3f repeat_pict=%d\n",
+     ff_dlog(NULL, "pict_type=%d frame_rate=%0.3f repeat_pict=%d\n",
 -            s->pict_type, (double)avctx->time_base.den / avctx->time_base.num, s->repeat_pict);
 +            s->pict_type, av_q2d(avctx->framerate), s->repeat_pict);
  
      *poutbuf = buf;
      *poutbuf_size = buf_size;
Simple merge
@@@ -34,7 -34,9 +34,8 @@@
  #include "libavutil/avutil.h"
  #include "libavutil/mem.h"
  #include "mpegvideo.h"
 -#include "msmpeg4.h"
  #include "h263.h"
+ #include "internal.h"
  #include "mpeg4video.h"
  #include "msmpeg4.h"
  #include "msmpeg4data.h"
  #include <stdint.h>
  #include <string.h>
  
 +#include "libavutil/avassert.h"
 +#include "libavutil/atomic.h"
  #include "libavutil/mem.h"
  
+ #include "internal.h"
  #include "parser.h"
 +#include "internal.h"
  
  static AVCodecParser *av_first_parser = NULL;
  
Simple merge
@@@ -70,10 -69,9 +70,10 @@@ static int pcm_dvd_parse_header(AVCodec
      /* early exit if the header didn't change apart from the frame number */
      if (s->last_header == header_int)
          return 0;
 +    s->last_header = -1;
  
      if (avctx->debug & FF_DEBUG_PICT_INFO)
-         av_dlog(avctx, "pcm_dvd_parse_header: header = %02x%02x%02x\n",
+         ff_dlog(avctx, "pcm_dvd_parse_header: header = %02x%02x%02x\n",
                  header[0], header[1], header[2]);
      /*
       * header[0] emphasis (1), muse(1), reserved(1), frame number(5)
Simple merge
@@@ -412,589 -401,43 +412,589 @@@ static int png_decode_idat(PNGDecContex
      return 0;
  }
  
 -static int decode_frame(AVCodecContext *avctx,
 -                        void *data, int *got_frame,
 -                        AVPacket *avpkt)
 +static int decode_zbuf(AVBPrint *bp, const uint8_t *data,
 +                       const uint8_t *data_end)
  {
 -    PNGDecContext *const s = avctx->priv_data;
 -    const uint8_t *buf     = avpkt->data;
 -    int buf_size           = avpkt->size;
 -    AVFrame *p             = data;
 -    uint8_t *crow_buf_base = NULL;
 -    uint32_t tag, length;
 +    z_stream zstream;
 +    unsigned char *buf;
 +    unsigned buf_size;
      int ret;
  
 -    /* check signature */
 -    if (buf_size < 8 ||
 -        (memcmp(buf, ff_pngsig, 8) != 0 && memcmp(buf, ff_mngsig, 8) != 0)) {
 -        av_log(avctx, AV_LOG_ERROR, "Invalid PNG signature (%d).\n", buf_size);
 +    zstream.zalloc = ff_png_zalloc;
 +    zstream.zfree  = ff_png_zfree;
 +    zstream.opaque = NULL;
 +    if (inflateInit(&zstream) != Z_OK)
 +        return AVERROR_EXTERNAL;
 +    zstream.next_in  = (unsigned char *)data;
 +    zstream.avail_in = data_end - data;
 +    av_bprint_init(bp, 0, -1);
 +
 +    while (zstream.avail_in > 0) {
 +        av_bprint_get_buffer(bp, 1, &buf, &buf_size);
 +        if (!buf_size) {
 +            ret = AVERROR(ENOMEM);
 +            goto fail;
 +        }
 +        zstream.next_out  = buf;
 +        zstream.avail_out = buf_size;
 +        ret = inflate(&zstream, Z_PARTIAL_FLUSH);
 +        if (ret != Z_OK && ret != Z_STREAM_END) {
 +            ret = AVERROR_EXTERNAL;
 +            goto fail;
 +        }
 +        bp->len += zstream.next_out - buf;
 +        if (ret == Z_STREAM_END)
 +            break;
 +    }
 +    inflateEnd(&zstream);
 +    bp->str[bp->len] = 0;
 +    return 0;
 +
 +fail:
 +    inflateEnd(&zstream);
 +    av_bprint_finalize(bp, NULL);
 +    return ret;
 +}
 +
 +static uint8_t *iso88591_to_utf8(const uint8_t *in, size_t size_in)
 +{
 +    size_t extra = 0, i;
 +    uint8_t *out, *q;
 +
 +    for (i = 0; i < size_in; i++)
 +        extra += in[i] >= 0x80;
 +    if (size_in == SIZE_MAX || extra > SIZE_MAX - size_in - 1)
 +        return NULL;
 +    q = out = av_malloc(size_in + extra + 1);
 +    if (!out)
 +        return NULL;
 +    for (i = 0; i < size_in; i++) {
 +        if (in[i] >= 0x80) {
 +            *(q++) = 0xC0 | (in[i] >> 6);
 +            *(q++) = 0x80 | (in[i] & 0x3F);
 +        } else {
 +            *(q++) = in[i];
 +        }
 +    }
 +    *(q++) = 0;
 +    return out;
 +}
 +
 +static int decode_text_chunk(PNGDecContext *s, uint32_t length, int compressed,
 +                             AVDictionary **dict)
 +{
 +    int ret, method;
 +    const uint8_t *data        = s->gb.buffer;
 +    const uint8_t *data_end    = data + length;
 +    const uint8_t *keyword     = data;
 +    const uint8_t *keyword_end = memchr(keyword, 0, data_end - keyword);
 +    uint8_t *kw_utf8 = NULL, *text, *txt_utf8 = NULL;
 +    unsigned text_len;
 +    AVBPrint bp;
 +
 +    if (!keyword_end)
          return AVERROR_INVALIDDATA;
 +    data = keyword_end + 1;
 +
 +    if (compressed) {
 +        if (data == data_end)
 +            return AVERROR_INVALIDDATA;
 +        method = *(data++);
 +        if (method)
 +            return AVERROR_INVALIDDATA;
 +        if ((ret = decode_zbuf(&bp, data, data_end)) < 0)
 +            return ret;
 +        text_len = bp.len;
 +        av_bprint_finalize(&bp, (char **)&text);
 +        if (!text)
 +            return AVERROR(ENOMEM);
 +    } else {
 +        text = (uint8_t *)data;
 +        text_len = data_end - text;
      }
  
 -    bytestream2_init(&s->gb, buf + 8, buf_size - 8);
 -    s->y = s->state = 0;
 +    kw_utf8  = iso88591_to_utf8(keyword, keyword_end - keyword);
 +    txt_utf8 = iso88591_to_utf8(text, text_len);
 +    if (text != data)
 +        av_free(text);
 +    if (!(kw_utf8 && txt_utf8)) {
 +        av_free(kw_utf8);
 +        av_free(txt_utf8);
 +        return AVERROR(ENOMEM);
 +    }
 +
 +    av_dict_set(dict, kw_utf8, txt_utf8,
 +                AV_DICT_DONT_STRDUP_KEY | AV_DICT_DONT_STRDUP_VAL);
 +    return 0;
 +}
 +
 +static int decode_ihdr_chunk(AVCodecContext *avctx, PNGDecContext *s,
 +                             uint32_t length)
 +{
 +    if (length != 13)
 +        return AVERROR_INVALIDDATA;
 +
 +    if (s->state & PNG_IDAT) {
 +        av_log(avctx, AV_LOG_ERROR, "IHDR after IDAT\n");
 +        return AVERROR_INVALIDDATA;
 +    }
 +
 +    s->width  = s->cur_w = bytestream2_get_be32(&s->gb);
 +    s->height = s->cur_h = bytestream2_get_be32(&s->gb);
 +    if (av_image_check_size(s->width, s->height, 0, avctx)) {
 +        s->width = s->height = 0;
 +        av_log(avctx, AV_LOG_ERROR, "Invalid image size\n");
 +        return AVERROR_INVALIDDATA;
 +    }
 +    s->bit_depth        = bytestream2_get_byte(&s->gb);
 +    s->color_type       = bytestream2_get_byte(&s->gb);
 +    s->compression_type = bytestream2_get_byte(&s->gb);
 +    s->filter_type      = bytestream2_get_byte(&s->gb);
 +    s->interlace_type   = bytestream2_get_byte(&s->gb);
 +    bytestream2_skip(&s->gb, 4); /* crc */
 +    s->state |= PNG_IHDR;
 +    if (avctx->debug & FF_DEBUG_PICT_INFO)
 +        av_log(avctx, AV_LOG_DEBUG, "width=%d height=%d depth=%d color_type=%d "
 +                "compression_type=%d filter_type=%d interlace_type=%d\n",
 +                s->width, s->height, s->bit_depth, s->color_type,
 +                s->compression_type, s->filter_type, s->interlace_type);
 +
 +    return 0;
 +}
 +
 +static int decode_phys_chunk(AVCodecContext *avctx, PNGDecContext *s)
 +{
 +    if (s->state & PNG_IDAT) {
 +        av_log(avctx, AV_LOG_ERROR, "pHYs after IDAT\n");
 +        return AVERROR_INVALIDDATA;
 +    }
 +    avctx->sample_aspect_ratio.num = bytestream2_get_be32(&s->gb);
 +    avctx->sample_aspect_ratio.den = bytestream2_get_be32(&s->gb);
 +    if (avctx->sample_aspect_ratio.num < 0 || avctx->sample_aspect_ratio.den < 0)
 +        avctx->sample_aspect_ratio = (AVRational){ 0, 1 };
 +    bytestream2_skip(&s->gb, 1); /* unit specifier */
 +    bytestream2_skip(&s->gb, 4); /* crc */
 +
 +    return 0;
 +}
 +
 +static int decode_idat_chunk(AVCodecContext *avctx, PNGDecContext *s,
 +                             uint32_t length, AVFrame *p)
 +{
 +    int ret;
 +
 +    if (!(s->state & PNG_IHDR)) {
 +        av_log(avctx, AV_LOG_ERROR, "IDAT without IHDR\n");
 +        return AVERROR_INVALIDDATA;
 +    }
 +    if (!(s->state & PNG_IDAT)) {
 +        /* init image info */
 +        avctx->width  = s->width;
 +        avctx->height = s->height;
 +
 +        s->channels       = ff_png_get_nb_channels(s->color_type);
 +        s->bits_per_pixel = s->bit_depth * s->channels;
 +        s->bpp            = (s->bits_per_pixel + 7) >> 3;
 +        s->row_size       = (s->cur_w * s->bits_per_pixel + 7) >> 3;
 +
 +        if ((s->bit_depth == 2 || s->bit_depth == 4 || s->bit_depth == 8) &&
 +                s->color_type == PNG_COLOR_TYPE_RGB) {
 +            avctx->pix_fmt = AV_PIX_FMT_RGB24;
 +        } else if ((s->bit_depth == 2 || s->bit_depth == 4 || s->bit_depth == 8) &&
 +                s->color_type == PNG_COLOR_TYPE_RGB_ALPHA) {
 +            avctx->pix_fmt = AV_PIX_FMT_RGBA;
 +        } else if ((s->bit_depth == 2 || s->bit_depth == 4 || s->bit_depth == 8) &&
 +                s->color_type == PNG_COLOR_TYPE_GRAY) {
 +            avctx->pix_fmt = AV_PIX_FMT_GRAY8;
 +        } else if (s->bit_depth == 16 &&
 +                s->color_type == PNG_COLOR_TYPE_GRAY) {
 +            avctx->pix_fmt = AV_PIX_FMT_GRAY16BE;
 +        } else if (s->bit_depth == 16 &&
 +                s->color_type == PNG_COLOR_TYPE_RGB) {
 +            avctx->pix_fmt = AV_PIX_FMT_RGB48BE;
 +        } else if (s->bit_depth == 16 &&
 +                s->color_type == PNG_COLOR_TYPE_RGB_ALPHA) {
 +            avctx->pix_fmt = AV_PIX_FMT_RGBA64BE;
 +        } else if ((s->bits_per_pixel == 1 || s->bits_per_pixel == 2 || s->bits_per_pixel == 4 || s->bits_per_pixel == 8) &&
 +                s->color_type == PNG_COLOR_TYPE_PALETTE) {
 +            avctx->pix_fmt = AV_PIX_FMT_PAL8;
 +        } else if (s->bit_depth == 1 && s->bits_per_pixel == 1) {
 +            avctx->pix_fmt = AV_PIX_FMT_MONOBLACK;
 +        } else if (s->bit_depth == 8 &&
 +                s->color_type == PNG_COLOR_TYPE_GRAY_ALPHA) {
 +            avctx->pix_fmt = AV_PIX_FMT_YA8;
 +        } else if (s->bit_depth == 16 &&
 +                s->color_type == PNG_COLOR_TYPE_GRAY_ALPHA) {
 +            avctx->pix_fmt = AV_PIX_FMT_YA16BE;
 +        } else {
 +            av_log(avctx, AV_LOG_ERROR, "unsupported bit depth %d "
 +                    "and color type %d\n",
 +                    s->bit_depth, s->color_type);
 +            return AVERROR_INVALIDDATA;
 +        }
 +
 +        if ((ret = ff_thread_get_buffer(avctx, &s->picture, AV_GET_BUFFER_FLAG_REF)) < 0)
 +            return ret;
 +        ff_thread_finish_setup(avctx);
 +
 +        p->pict_type        = AV_PICTURE_TYPE_I;
 +        p->key_frame        = 1;
 +        p->interlaced_frame = !!s->interlace_type;
 +
 +        /* compute the compressed row size */
 +        if (!s->interlace_type) {
 +            s->crow_size = s->row_size + 1;
 +        } else {
 +            s->pass          = 0;
 +            s->pass_row_size = ff_png_pass_row_size(s->pass,
 +                    s->bits_per_pixel,
 +                    s->cur_w);
 +            s->crow_size = s->pass_row_size + 1;
 +        }
-         av_dlog(avctx, "row_size=%d crow_size =%d\n",
++        ff_dlog(avctx, "row_size=%d crow_size =%d\n",
 +                s->row_size, s->crow_size);
 +        s->image_buf      = p->data[0];
 +        s->image_linesize = p->linesize[0];
 +        /* copy the palette if needed */
 +        if (avctx->pix_fmt == AV_PIX_FMT_PAL8)
 +            memcpy(p->data[1], s->palette, 256 * sizeof(uint32_t));
 +        /* empty row is used if differencing to the first row */
 +        av_fast_padded_mallocz(&s->last_row, &s->last_row_size, s->row_size);
 +        if (!s->last_row)
 +            return AVERROR_INVALIDDATA;
 +        if (s->interlace_type ||
 +                s->color_type == PNG_COLOR_TYPE_RGB_ALPHA) {
 +            av_fast_padded_malloc(&s->tmp_row, &s->tmp_row_size, s->row_size);
 +            if (!s->tmp_row)
 +                return AVERROR_INVALIDDATA;
 +        }
 +        /* compressed row */
 +        av_fast_padded_malloc(&s->buffer, &s->buffer_size, s->row_size + 16);
 +        if (!s->buffer)
 +            return AVERROR(ENOMEM);
 +
 +        /* we want crow_buf+1 to be 16-byte aligned */
 +        s->crow_buf          = s->buffer + 15;
 +        s->zstream.avail_out = s->crow_size;
 +        s->zstream.next_out  = s->crow_buf;
 +    }
 +    s->state |= PNG_IDAT;
 +    if ((ret = png_decode_idat(s, length)) < 0)
 +        return ret;
 +    bytestream2_skip(&s->gb, 4); /* crc */
 +
 +    return 0;
 +}
 +
 +static int decode_plte_chunk(AVCodecContext *avctx, PNGDecContext *s,
 +                             uint32_t length)
 +{
 +    int n, i, r, g, b;
 +
 +    if ((length % 3) != 0 || length > 256 * 3)
 +        return AVERROR_INVALIDDATA;
 +    /* read the palette */
 +    n = length / 3;
 +    for (i = 0; i < n; i++) {
 +        r = bytestream2_get_byte(&s->gb);
 +        g = bytestream2_get_byte(&s->gb);
 +        b = bytestream2_get_byte(&s->gb);
 +        s->palette[i] = (0xFFU << 24) | (r << 16) | (g << 8) | b;
 +    }
 +    for (; i < 256; i++)
 +        s->palette[i] = (0xFFU << 24);
 +    s->state |= PNG_PLTE;
 +    bytestream2_skip(&s->gb, 4);     /* crc */
 +
 +    return 0;
 +}
 +
 +static int decode_trns_chunk(AVCodecContext *avctx, PNGDecContext *s,
 +                             uint32_t length)
 +{
 +    int v, i;
 +
 +    /* read the transparency. XXX: Only palette mode supported */
 +    if (s->color_type != PNG_COLOR_TYPE_PALETTE ||
 +            length > 256 ||
 +            !(s->state & PNG_PLTE))
 +        return AVERROR_INVALIDDATA;
 +    for (i = 0; i < length; i++) {
 +        v = bytestream2_get_byte(&s->gb);
 +        s->palette[i] = (s->palette[i] & 0x00ffffff) | (v << 24);
 +    }
 +    bytestream2_skip(&s->gb, 4);     /* crc */
 +
 +    return 0;
 +}
 +
 +static void handle_small_bpp(PNGDecContext *s, AVFrame *p)
 +{
 +    if (s->bits_per_pixel == 1 && s->color_type == PNG_COLOR_TYPE_PALETTE) {
 +        int i, j, k;
 +        uint8_t *pd = p->data[0];
 +        for (j = 0; j < s->height; j++) {
 +            i = s->width / 8;
 +            for (k = 7; k >= 1; k--)
 +                if ((s->width&7) >= k)
 +                    pd[8*i + k - 1] = (pd[i]>>8-k) & 1;
 +            for (i--; i >= 0; i--) {
 +                pd[8*i + 7]=  pd[i]     & 1;
 +                pd[8*i + 6]= (pd[i]>>1) & 1;
 +                pd[8*i + 5]= (pd[i]>>2) & 1;
 +                pd[8*i + 4]= (pd[i]>>3) & 1;
 +                pd[8*i + 3]= (pd[i]>>4) & 1;
 +                pd[8*i + 2]= (pd[i]>>5) & 1;
 +                pd[8*i + 1]= (pd[i]>>6) & 1;
 +                pd[8*i + 0]=  pd[i]>>7;
 +            }
 +            pd += s->image_linesize;
 +        }
 +    } else if (s->bits_per_pixel == 2) {
 +        int i, j;
 +        uint8_t *pd = p->data[0];
 +        for (j = 0; j < s->height; j++) {
 +            i = s->width / 4;
 +            if (s->color_type == PNG_COLOR_TYPE_PALETTE) {
 +                if ((s->width&3) >= 3) pd[4*i + 2]= (pd[i] >> 2) & 3;
 +                if ((s->width&3) >= 2) pd[4*i + 1]= (pd[i] >> 4) & 3;
 +                if ((s->width&3) >= 1) pd[4*i + 0]=  pd[i] >> 6;
 +                for (i--; i >= 0; i--) {
 +                    pd[4*i + 3]=  pd[i]     & 3;
 +                    pd[4*i + 2]= (pd[i]>>2) & 3;
 +                    pd[4*i + 1]= (pd[i]>>4) & 3;
 +                    pd[4*i + 0]=  pd[i]>>6;
 +                }
 +            } else {
 +                if ((s->width&3) >= 3) pd[4*i + 2]= ((pd[i]>>2) & 3)*0x55;
 +                if ((s->width&3) >= 2) pd[4*i + 1]= ((pd[i]>>4) & 3)*0x55;
 +                if ((s->width&3) >= 1) pd[4*i + 0]= ( pd[i]>>6     )*0x55;
 +                for (i--; i >= 0; i--) {
 +                    pd[4*i + 3]= ( pd[i]     & 3)*0x55;
 +                    pd[4*i + 2]= ((pd[i]>>2) & 3)*0x55;
 +                    pd[4*i + 1]= ((pd[i]>>4) & 3)*0x55;
 +                    pd[4*i + 0]= ( pd[i]>>6     )*0x55;
 +                }
 +            }
 +            pd += s->image_linesize;
 +        }
 +    } else if (s->bits_per_pixel == 4) {
 +        int i, j;
 +        uint8_t *pd = p->data[0];
 +        for (j = 0; j < s->height; j++) {
 +            i = s->width/2;
 +            if (s->color_type == PNG_COLOR_TYPE_PALETTE) {
 +                if (s->width&1) pd[2*i+0]= pd[i]>>4;
 +                for (i--; i >= 0; i--) {
 +                    pd[2*i + 1] = pd[i] & 15;
 +                    pd[2*i + 0] = pd[i] >> 4;
 +                }
 +            } else {
 +                if (s->width & 1) pd[2*i + 0]= (pd[i] >> 4) * 0x11;
 +                for (i--; i >= 0; i--) {
 +                    pd[2*i + 1] = (pd[i] & 15) * 0x11;
 +                    pd[2*i + 0] = (pd[i] >> 4) * 0x11;
 +                }
 +            }
 +            pd += s->image_linesize;
 +        }
 +    }
 +}
 +
 +static int decode_fctl_chunk(AVCodecContext *avctx, PNGDecContext *s,
 +                             uint32_t length)
 +{
 +    uint32_t sequence_number;
 +
 +    if (length != 26)
 +        return AVERROR_INVALIDDATA;
 +
 +    sequence_number = bytestream2_get_be32(&s->gb);
 +    s->cur_w        = bytestream2_get_be32(&s->gb);
 +    s->cur_h        = bytestream2_get_be32(&s->gb);
 +    s->x_offset     = bytestream2_get_be32(&s->gb);
 +    s->y_offset     = bytestream2_get_be32(&s->gb);
 +    bytestream2_skip(&s->gb, 4); /* delay_num (2), delay_den (2) */
 +    s->dispose_op   = bytestream2_get_byte(&s->gb);
 +    s->blend_op     = bytestream2_get_byte(&s->gb);
 +    bytestream2_skip(&s->gb, 4); /* crc */
 +
 +    if (sequence_number == 0 &&
 +        (s->cur_w != s->width ||
 +         s->cur_h != s->height ||
 +         s->x_offset != 0 ||
 +         s->y_offset != 0) ||
 +        s->cur_w <= 0 || s->cur_h <= 0 ||
 +        s->x_offset < 0 || s->y_offset < 0 ||
 +        s->cur_w > s->width - s->x_offset|| s->cur_h > s->height - s->y_offset)
 +            return AVERROR_INVALIDDATA;
 +
 +    /* always (re)start with a clean frame */
 +    if (sequence_number == 0) {
 +        s->dispose_op = APNG_DISPOSE_OP_BACKGROUND;
 +        s->frame_id = 0;
 +    } else {
 +        s->frame_id++;
 +        if (s->frame_id == 1 && s->dispose_op == APNG_DISPOSE_OP_PREVIOUS)
 +            /* previous for the second frame is the first frame */
 +            s->dispose_op = APNG_DISPOSE_OP_NONE;
 +    }
 +
 +    return 0;
 +}
 +
 +static void handle_p_frame_png(PNGDecContext *s, AVFrame *p)
 +{
 +    int i, j;
 +    uint8_t *pd      = p->data[0];
 +    uint8_t *pd_last = s->last_picture.f->data[0];
 +    int ls = FFMIN(av_image_get_linesize(p->format, s->width, 0), s->width * s->bpp);
 +
 +    ff_thread_await_progress(&s->last_picture, INT_MAX, 0);
 +    for (j = 0; j < s->height; j++) {
 +        for (i = 0; i < ls; i++)
 +            pd[i] += pd_last[i];
 +        pd      += s->image_linesize;
 +        pd_last += s->image_linesize;
 +    }
 +}
 +
 +// divide by 255 and round to nearest
 +// apply a fast variant: (X+127)/255 = ((X+127)*257+257)>>16 = ((X+128)*257)>>16
 +#define FAST_DIV255(x) ((((x) + 128) * 257) >> 16)
 +
 +static int handle_p_frame_apng(AVCodecContext *avctx, PNGDecContext *s,
 +                               AVFrame *p)
 +{
 +    int i, j;
 +    uint8_t *pd      = p->data[0];
 +    uint8_t *pd_last = s->last_picture.f->data[0];
 +    uint8_t *pd_last_region = s->dispose_op == APNG_DISPOSE_OP_PREVIOUS ?
 +                                s->previous_picture.f->data[0] : s->last_picture.f->data[0];
 +    int ls = FFMIN(av_image_get_linesize(p->format, s->width, 0), s->width * s->bpp);
 +
 +    if (ls < 0)
 +        return ls;
 +
 +    if (s->blend_op == APNG_BLEND_OP_OVER &&
 +        avctx->pix_fmt != AV_PIX_FMT_RGBA && avctx->pix_fmt != AV_PIX_FMT_ARGB) {
 +        avpriv_request_sample(avctx, "Blending with pixel format %s",
 +                              av_get_pix_fmt_name(avctx->pix_fmt));
 +        return AVERROR_PATCHWELCOME;
 +    }
 +
 +    ff_thread_await_progress(&s->last_picture, INT_MAX, 0);
 +    if (s->dispose_op == APNG_DISPOSE_OP_PREVIOUS)
 +        ff_thread_await_progress(&s->previous_picture, INT_MAX, 0);
 +
 +    for (j = 0; j < s->y_offset; j++) {
 +        memcpy(pd, pd_last, ls);
 +        pd      += s->image_linesize;
 +        pd_last += s->image_linesize;
 +    }
 +
 +    if (s->dispose_op != APNG_DISPOSE_OP_BACKGROUND && s->blend_op == APNG_BLEND_OP_OVER) {
 +        uint8_t ri, gi, bi, ai;
 +
 +        pd_last_region += s->y_offset * s->image_linesize;
 +        if (avctx->pix_fmt == AV_PIX_FMT_RGBA) {
 +            ri = 0;
 +            gi = 1;
 +            bi = 2;
 +            ai = 3;
 +        } else {
 +            ri = 3;
 +            gi = 2;
 +            bi = 1;
 +            ai = 0;
 +        }
 +
 +        for (j = s->y_offset; j < s->y_offset + s->cur_h; j++) {
 +            i = s->x_offset * s->bpp;
 +            if (i)
 +                memcpy(pd, pd_last, i);
 +            for (; i < (s->x_offset + s->cur_w) * s->bpp; i += s->bpp) {
 +                uint8_t alpha = pd[i+ai];
 +
 +                /* output = alpha * foreground + (1-alpha) * background */
 +                switch (alpha) {
 +                case 0:
 +                    pd[i+ri] = pd_last_region[i+ri];
 +                    pd[i+gi] = pd_last_region[i+gi];
 +                    pd[i+bi] = pd_last_region[i+bi];
 +                    pd[i+ai] = 0xff;
 +                    break;
 +                case 255:
 +                    break;
 +                default:
 +                    pd[i+ri] = FAST_DIV255(alpha * pd[i+ri] + (255 - alpha) * pd_last_region[i+ri]);
 +                    pd[i+gi] = FAST_DIV255(alpha * pd[i+gi] + (255 - alpha) * pd_last_region[i+gi]);
 +                    pd[i+bi] = FAST_DIV255(alpha * pd[i+bi] + (255 - alpha) * pd_last_region[i+bi]);
 +                    pd[i+ai] = 0xff;
 +                    break;
 +                }
 +            }
 +            if (ls - i)
 +                memcpy(pd+i, pd_last+i, ls - i);
 +            pd      += s->image_linesize;
 +            pd_last += s->image_linesize;
 +            pd_last_region += s->image_linesize;
 +        }
 +    } else {
 +        for (j = s->y_offset; j < s->y_offset + s->cur_h; j++) {
 +            int end_offset = (s->x_offset + s->cur_w) * s->bpp;
 +            int end_len    = ls - end_offset;
 +            if (s->x_offset)
 +                memcpy(pd, pd_last, s->x_offset * s->bpp);
 +            if (end_len)
 +                memcpy(pd+end_offset, pd_last+end_offset, end_len);
 +            pd      += s->image_linesize;
 +            pd_last += s->image_linesize;
 +        }
 +    }
 +
 +    for (j = s->y_offset + s->cur_h; j < s->height; j++) {
 +        memcpy(pd, pd_last, ls);
 +        pd      += s->image_linesize;
 +        pd_last += s->image_linesize;
 +    }
 +
 +    return 0;
 +}
 +
 +static int decode_frame_common(AVCodecContext *avctx, PNGDecContext *s,
 +                               AVFrame *p, AVPacket *avpkt)
 +{
 +    AVDictionary *metadata  = NULL;
 +    uint32_t tag, length;
 +    int decode_next_dat = 0;
 +    int ret = AVERROR_INVALIDDATA;
 +    AVFrame *ref;
  
 -    /* init the zlib */
 -    s->zstream.zalloc = ff_png_zalloc;
 -    s->zstream.zfree  = ff_png_zfree;
 -    s->zstream.opaque = NULL;
 -    ret = inflateInit(&s->zstream);
 -    if (ret != Z_OK)
 -        return -1;
      for (;;) {
 -        if (bytestream2_get_bytes_left(&s->gb) <= 0)
 +        length = bytestream2_get_bytes_left(&s->gb);
 +        if (length <= 0) {
 +            if (CONFIG_APNG_DECODER && avctx->codec_id == AV_CODEC_ID_APNG && length == 0) {
 +                if (!(s->state & PNG_IDAT))
 +                    return 0;
 +                else
 +                    goto exit_loop;
 +            }
 +            av_log(avctx, AV_LOG_ERROR, "%d bytes left\n", length);
 +            if (   s->state & PNG_ALLIMAGE
 +                && avctx->strict_std_compliance <= FF_COMPLIANCE_NORMAL)
 +                goto exit_loop;
              goto fail;
 +        }
 +
          length = bytestream2_get_be32(&s->gb);
 -        if (length > 0x7fffffff)
 +        if (length > 0x7fffffff || length > bytestream2_get_bytes_left(&s->gb)) {
 +            av_log(avctx, AV_LOG_ERROR, "chunk too big\n");
              goto fail;
 +        }
          tag = bytestream2_get_le32(&s->gb);
 -        ff_dlog(avctx, "png: tag=%c%c%c%c length=%u\n",
 +        if (avctx->debug & FF_DEBUG_STARTCODE)
 +            av_log(avctx, AV_LOG_DEBUG, "png: tag=%c%c%c%c length=%u\n",
                  (tag & 0xff),
                  ((tag >> 8) & 0xff),
                  ((tag >> 16) & 0xff),
@@@ -815,10 -794,10 +816,10 @@@ float ff_rate_estimate_qscale(MpegEncCo
      short_term_q = 0; /* avoid warning */
      if (s->flags & CODEC_FLAG_PASS2) {
          if (pict_type != AV_PICTURE_TYPE_I)
 -            assert(pict_type == rce->new_pict_type);
 +            av_assert0(pict_type == rce->new_pict_type);
  
          q = rce->new_qscale / br_compensation;
-         av_dlog(s, "%f %f %f last:%d var:%"PRId64" type:%d//\n", q, rce->new_qscale,
 -        ff_dlog(s, "%f %f %f last:%d var:%d type:%d//\n", q, rce->new_qscale,
++        ff_dlog(s, "%f %f %f last:%d var:%"PRId64" type:%d//\n", q, rce->new_qscale,
                  br_compensation, s->frame_bits, var, pict_type);
      } else {
          rce->pict_type     =
@@@ -593,8 -574,7 +593,8 @@@ static int rv10_decode_packet(AVCodecCo
          }
      }
  
-     av_dlog(avctx, "qscale=%d\n", s->qscale);
 +
+     ff_dlog(avctx, "qscale=%d\n", s->qscale);
  
      /* default quantization values */
      if (s->codec_id == AV_CODEC_ID_RV10) {
@@@ -706,9 -686,7 +706,9 @@@ static int rv10_decode_frame(AVCodecCon
      int slice_count;
      const uint8_t *slices_hdr = NULL;
  
-     av_dlog(avctx, "*****frame %d size=%d\n", avctx->frame_number, buf_size);
+     ff_dlog(avctx, "*****frame %d size=%d\n", avctx->frame_number, buf_size);
 +    s->flags  = avctx->flags;
 +    s->flags2 = avctx->flags2;
  
      /* no supplementary picture */
      if (buf_size == 0) {
@@@ -188,8 -191,8 +188,8 @@@ static int svq1_decode_block_intra(GetB
              continue;   /* skip vector */
          }
  
 -        if ((stages > 0 && level >= 4) || stages < 0) {
 +        if ((stages > 0 && level >= 4)) {
-             av_dlog(NULL,
+             ff_dlog(NULL,
                      "Error (svq1_decode_block_intra): invalid vector: stages=%i level=%i\n",
                      stages, level);
              return AVERROR_INVALIDDATA;  /* invalid vector */
@@@ -252,8 -253,8 +252,8 @@@ static int svq1_decode_block_non_intra(
          if (stages == -1)
              continue;           /* skip vector */
  
 -        if ((stages > 0 && level >= 4) || stages < 0) {
 +        if ((stages > 0 && level >= 4)) {
-             av_dlog(NULL,
+             ff_dlog(NULL,
                      "Error (svq1_decode_block_non_intra): invalid vector: stages=%i level=%i\n",
                      stages, level);
              return AVERROR_INVALIDDATA;  /* invalid vector */
@@@ -658,8 -655,9 +658,8 @@@ static int svq1_decode_frame(AVCodecCon
      }
  
      result = svq1_decode_frame_header(avctx, cur);
 -
      if (result != 0) {
-         av_dlog(avctx, "Error in svq1_decode_frame_header %i\n", result);
+         ff_dlog(avctx, "Error in svq1_decode_frame_header %i\n", result);
          return result;
      }
  
Simple merge
Simple merge
@@@ -20,6 -20,6 +20,7 @@@
   * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
   */
  
++#include "internal.h"
  #include "mpegutils.h"
  #include "vaapi_internal.h"
  
@@@ -22,6 -22,6 +22,7 @@@
  
  #include "vaapi_internal.h"
  #include "h263.h"
++#include "internal.h"
  #include "mpeg4video.h"
  
  /** Reconstruct bitstream intra_dc_vlc_thr */
@@@ -122,8 -122,16 +123,8 @@@ static int vaapi_mpeg4_decode_slice(AVC
      MpegEncContext * const s = avctx->priv_data;
      VASliceParameterBufferMPEG4 *slice_param;
  
-     av_dlog(avctx, "vaapi_mpeg4_decode_slice(): buffer %p, size %d\n", buffer, size);
+     ff_dlog(avctx, "vaapi_mpeg4_decode_slice(): buffer %p, size %d\n", buffer, size);
  
 -    /* video_plane_with_short_video_header() contains all GOBs
 -     * in-order, and this is what VA API (Intel backend) expects: only
 -     * a single slice param. So fake macroblock_number for Libav so
 -     * that we don't call vaapi_mpeg4_decode_slice() again
 -     */
 -    if (avctx->codec->id == AV_CODEC_ID_H263)
 -        size = s->gb.buffer_end - buffer;
 -
      /* Fill in VASliceParameterBufferMPEG4 */
      slice_param = (VASliceParameterBufferMPEG4 *)ff_vaapi_alloc_slice(avctx->hwaccel_context, buffer, size);
      if (!slice_param)
Simple merge
Simple merge
Simple merge
@@@ -998,11 -987,8 +998,11 @@@ static int vorbis_parse_id_hdr(vorbis_c
  
      ff_mdct_init(&vc->mdct[0], bl0, 1, -1.0);
      ff_mdct_init(&vc->mdct[1], bl1, 1, -1.0);
 +    vc->fdsp = avpriv_float_dsp_alloc(vc->avctx->flags & CODEC_FLAG_BITEXACT);
 +    if (!vc->fdsp)
 +        return AVERROR(ENOMEM);
  
-     av_dlog(NULL, " vorbis version %d \n audio_channels %d \n audio_samplerate %d \n bitrate_max %d \n bitrate_nom %d \n bitrate_min %d \n blk_0 %d blk_1 %d \n ",
+     ff_dlog(NULL, " vorbis version %d \n audio_channels %d \n audio_samplerate %d \n bitrate_max %d \n bitrate_nom %d \n bitrate_min %d \n blk_0 %d blk_1 %d \n ",
              vc->version, vc->audio_channels, vc->audio_samplerate, vc->bitrate_maximum, vc->bitrate_nominal, vc->bitrate_minimum, vc->blocksize[0], vc->blocksize[1]);
  
  /*
@@@ -1222,16 -1209,16 +1222,16 @@@ static int vorbis_floor1_decode(vorbis_
          csub = (1 << cbits) - 1;
          cval = 0;
  
-         av_dlog(NULL, "Cbits %u\n", cbits);
+         ff_dlog(NULL, "Cbits %u\n", cbits);
  
          if (cbits) // this reads all subclasses for this partition's class
 -            cval = get_vlc2(gb, vc->codebooks[vf->class_masterbook[class]].vlc.table,
 -                            vc->codebooks[vf->class_masterbook[class]].nb_bits, 3);
 +            cval = get_vlc2(gb, vc->codebooks[vf->class_masterbook[partition_class]].vlc.table,
 +                            vc->codebooks[vf->class_masterbook[partition_class]].nb_bits, 3);
  
          for (j = 0; j < cdim; ++j) {
 -            book = vf->subclass_books[class][cval & csub];
 +            book = vf->subclass_books[partition_class][cval & csub];
  
-             av_dlog(NULL, "book %d Cbits %u cval %u  bits:%d\n",
+             ff_dlog(NULL, "book %d Cbits %u cval %u  bits:%d\n",
                      book, cbits, cval, get_bits_count(gb));
  
              cval = cval >> cbits;
@@@ -1335,10 -1317,8 +1335,10 @@@ static av_always_inline int setup_class
              temp = get_vlc2(&vc->gb, codebook->vlc.table,
                                       codebook->nb_bits, 3);
  
-             av_dlog(NULL, "Classword: %u\n", temp);
+             ff_dlog(NULL, "Classword: %u\n", temp);
  
 +            av_assert0(temp < 65536);
 +
              if (temp < 0) {
                  av_log(vc->avctx, AV_LOG_ERROR,
                         "Invalid vlc code decoding %d channel.", j);
@@@ -1391,16 -1368,11 +1391,16 @@@ static av_always_inline int vorbis_resi
      }
  
      if (max_output > ch_left * vlen) {
 -        av_log(vc->avctx, AV_LOG_ERROR, "Insufficient output buffer\n");
 -        return AVERROR_INVALIDDATA;
 +        if (max_output <= ch_left * vlen + vr->partition_size*ch_used/ch) {
 +            ptns_to_read--;
 +            libvorbis_bug = 1;
 +        } else {
 +            av_log(vc->avctx, AV_LOG_ERROR, "Insufficient output buffer\n");
 +            return AVERROR_INVALIDDATA;
 +        }
      }
  
-     av_dlog(NULL, " residue type 0/1/2 decode begin, ch: %d  cpc %d  \n", ch, c_p_c);
+     ff_dlog(NULL, " residue type 0/1/2 decode begin, ch: %d  cpc %d  \n", ch, c_p_c);
  
      for (pass = 0; pass <= vr->maxpass; ++pass) { // FIXME OPTIMIZE?
          int voffset, partition_count, j_times_ptns_to_read;
@@@ -1736,51 -1698,14 +1736,51 @@@ static int vorbis_decode_frame(AVCodecC
      float *channel_ptrs[255];
      int i, len, ret;
  
-     av_dlog(NULL, "packet length %d \n", buf_size);
+     ff_dlog(NULL, "packet length %d \n", buf_size);
  
 +    if (*buf == 1 && buf_size > 7) {
 +        init_get_bits(gb, buf+1, buf_size*8 - 8);
 +        vorbis_free(vc);
 +        if ((ret = vorbis_parse_id_hdr(vc))) {
 +            av_log(avctx, AV_LOG_ERROR, "Id header corrupt.\n");
 +            vorbis_free(vc);
 +            return ret;
 +        }
 +
 +        if (vc->audio_channels > 8)
 +            avctx->channel_layout = 0;
 +        else
 +            avctx->channel_layout = ff_vorbis_channel_layouts[vc->audio_channels - 1];
 +
 +        avctx->channels    = vc->audio_channels;
 +        avctx->sample_rate = vc->audio_samplerate;
 +        return buf_size;
 +    }
 +
 +    if (*buf == 3 && buf_size > 7) {
 +        av_log(avctx, AV_LOG_DEBUG, "Ignoring comment header\n");
 +        return buf_size;
 +    }
 +
 +    if (*buf == 5 && buf_size > 7 && vc->channel_residues && !vc->modes) {
 +        init_get_bits(gb, buf+1, buf_size*8 - 8);
 +        if ((ret = vorbis_parse_setup_hdr(vc))) {
 +            av_log(avctx, AV_LOG_ERROR, "Setup header corrupt.\n");
 +            vorbis_free(vc);
 +            return ret;
 +        }
 +        return buf_size;
 +    }
 +
 +    if (!vc->channel_residues || !vc->modes) {
 +        av_log(avctx, AV_LOG_ERROR, "Data packet before valid headers\n");
 +        return AVERROR_INVALIDDATA;
 +    }
 +
      /* get output buffer */
      frame->nb_samples = vc->blocksize[1] / 2;
 -    if ((ret = ff_get_buffer(avctx, frame, 0)) < 0) {
 -        av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
 +    if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
          return ret;
 -    }
  
      if (vc->audio_channels > 8) {
          for (i = 0; i < vc->audio_channels; i++)
Simple merge
@@@ -231,10 -232,10 +231,10 @@@ static int decode_format80(VqaContext *
      unsigned char color;
      int i;
  
 -    start = bytestream2_tell(gb);
 -    while (bytestream2_tell(gb) - start < src_size) {
 -        opcode = bytestream2_get_byte(gb);
 -        ff_dlog(NULL, "      opcode %02X: ", opcode);
 +    start = bytestream2_tell(&s->gb);
 +    while (bytestream2_tell(&s->gb) - start < src_size) {
 +        opcode = bytestream2_get_byte(&s->gb);
-         av_dlog(s->avctx, "opcode %02X: ", opcode);
++        ff_dlog(s->avctx, "opcode %02X: ", opcode);
  
          /* 0x80 means that frame is finished */
          if (opcode == 0x80)
  
          if (opcode == 0xFF) {
  
 -            count   = bytestream2_get_le16(gb);
 -            src_pos = bytestream2_get_le16(gb);
 -            ff_dlog(NULL, "(1) copy %X bytes from absolute pos %X\n", count, src_pos);
 +            count   = bytestream2_get_le16(&s->gb);
 +            src_pos = bytestream2_get_le16(&s->gb);
-             av_dlog(s->avctx, "(1) copy %X bytes from absolute pos %X\n", count, src_pos);
++            ff_dlog(s->avctx, "(1) copy %X bytes from absolute pos %X\n", count, src_pos);
              CHECK_COUNT();
              CHECK_COPY(src_pos);
              for (i = 0; i < count; i++)
  
          } else if (opcode == 0xFE) {
  
 -            count = bytestream2_get_le16(gb);
 -            color = bytestream2_get_byte(gb);
 -            ff_dlog(NULL, "(2) set %X bytes to %02X\n", count, color);
 +            count = bytestream2_get_le16(&s->gb);
 +            color = bytestream2_get_byte(&s->gb);
-             av_dlog(s->avctx, "(2) set %X bytes to %02X\n", count, color);
++            ff_dlog(s->avctx, "(2) set %X bytes to %02X\n", count, color);
              CHECK_COUNT();
              memset(&dest[dest_index], color, count);
              dest_index += count;
          } else if ((opcode & 0xC0) == 0xC0) {
  
              count = (opcode & 0x3F) + 3;
 -            src_pos = bytestream2_get_le16(gb);
 -            ff_dlog(NULL, "(3) copy %X bytes from absolute pos %X\n", count, src_pos);
 +            src_pos = bytestream2_get_le16(&s->gb);
-             av_dlog(s->avctx, "(3) copy %X bytes from absolute pos %X\n", count, src_pos);
++            ff_dlog(s->avctx, "(3) copy %X bytes from absolute pos %X\n", count, src_pos);
              CHECK_COUNT();
              CHECK_COPY(src_pos);
              for (i = 0; i < count; i++)
          } else if (opcode > 0x80) {
  
              count = opcode & 0x3F;
-             av_dlog(s->avctx, "(4) copy %X bytes from source to dest\n", count);
 -            ff_dlog(NULL, "(4) copy %X bytes from source to dest\n", count);
++            ff_dlog(s->avctx, "(4) copy %X bytes from source to dest\n", count);
              CHECK_COUNT();
 -            bytestream2_get_buffer(gb, &dest[dest_index], count);
 +            bytestream2_get_buffer(&s->gb, &dest[dest_index], count);
              dest_index += count;
  
          } else {
  
              count = ((opcode & 0x70) >> 4) + 3;
 -            src_pos = bytestream2_get_byte(gb) | ((opcode & 0x0F) << 8);
 -            ff_dlog(NULL, "(5) copy %X bytes from relpos %X\n", count, src_pos);
 +            src_pos = bytestream2_get_byte(&s->gb) | ((opcode & 0x0F) << 8);
-             av_dlog(s->avctx, "(5) copy %X bytes from relpos %X\n", count, src_pos);
++            ff_dlog(s->avctx, "(5) copy %X bytes from relpos %X\n", count, src_pos);
              CHECK_COUNT();
              CHECK_COPY(dest_index - src_pos);
              for (i = 0; i < count; i++)
Simple merge
@@@ -944,7 -904,7 +944,7 @@@ static int wma_decode_superframe(AVCode
          samples_offset += s->frame_len;
      }
  
-     av_dlog(s->avctx, "%d %d %d %d outbytes:%"PTRDIFF_SPECIFIER" eaten:%d\n",
 -    ff_dlog(s->avctx, "%d %d %d %d outbytes:%td eaten:%d\n",
++    ff_dlog(s->avctx, "%d %d %d %d outbytes:%"PTRDIFF_SPECIFIER" eaten:%d\n",
              s->frame_len_bits, s->block_len_bits, s->frame_len, s->block_len,
              (int8_t *) samples - (int8_t *) data, avctx->block_align);
  
@@@ -1064,9 -1080,10 +1064,9 @@@ static int decode_frame(WmallDecodeCtx 
          }
      }
  
-     av_dlog(s->avctx, "Frame done\n");
+     ff_dlog(s->avctx, "Frame done\n");
  
 -    if (s->skip_frame)
 -        s->skip_frame = 0;
 +    s->skip_frame = 0;
  
      if (s->len_prefix) {
          if (len != (get_bits_count(gb) - s->frame_offset) + 2) {
Simple merge
Simple merge