avcodec/mpegvideo_enc: make edge for interlaced mpeg2 encoding smaller
[ffmpeg.git] / libavcodec / bethsoftvideo.c
index 4ed48c2..37cd22e 100644 (file)
  */
 
 /**
- * @file libavcodec/bethsoftvideo.c
+ * @file
  * @brief Bethesda Softworks VID Video Decoder
  * @author Nicholas Tung [ntung (at. ntung com] (2007-03)
- * @sa http://wiki.multimedia.cx/index.php?title=Bethsoft_VID
- * @sa http://www.svatopluk.com/andux/docs/dfvid.html
+ * @see http://wiki.multimedia.cx/index.php?title=Bethsoft_VID
+ * @see http://www.svatopluk.com/andux/docs/dfvid.html
  */
 
 #include "libavutil/common.h"
-#include "dsputil.h"
+#include "avcodec.h"
 #include "bethsoftvideo.h"
 #include "bytestream.h"
+#include "internal.h"
 
 typedef struct BethsoftvidContext {
-    AVFrame frame;
+    AVFrame *frame;
+    GetByteContext g;
 } BethsoftvidContext;
 
 static av_cold int bethsoftvid_decode_init(AVCodecContext *avctx)
 {
     BethsoftvidContext *vid = avctx->priv_data;
-    vid->frame.reference = 1;
-    vid->frame.buffer_hints = FF_BUFFER_HINTS_VALID |
-        FF_BUFFER_HINTS_PRESERVE | FF_BUFFER_HINTS_REUSABLE;
-    avctx->pix_fmt = PIX_FMT_PAL8;
+    avctx->pix_fmt = AV_PIX_FMT_PAL8;
+
+    vid->frame = av_frame_alloc();
+    if (!vid->frame)
+        return AVERROR(ENOMEM);
+
     return 0;
 }
 
-static void set_palette(AVFrame * frame, const uint8_t * palette_buffer)
+static int set_palette(BethsoftvidContext *ctx)
 {
-    uint32_t * palette = (uint32_t *)frame->data[1];
+    uint32_t *palette = (uint32_t *)ctx->frame->data[1];
     int a;
+
+    if (bytestream2_get_bytes_left(&ctx->g) < 256*3)
+        return AVERROR_INVALIDDATA;
+
     for(a = 0; a < 256; a++){
-        palette[a] = AV_RB24(&palette_buffer[a * 3]) * 4;
+        palette[a] = 0xFFU << 24 | bytestream2_get_be24u(&ctx->g) * 4;
+        palette[a] |= palette[a] >> 6 & 0x30303;
     }
-    frame->palette_has_changed = 1;
+    ctx->frame->palette_has_changed = 1;
+    return 0;
 }
 
 static int bethsoftvid_decode_frame(AVCodecContext *avctx,
-                              void *data, int *data_size,
+                              void *data, int *got_frame,
                               AVPacket *avpkt)
 {
-    const uint8_t *buf = avpkt->data;
-    int buf_size = avpkt->size;
     BethsoftvidContext * vid = avctx->priv_data;
     char block_type;
     uint8_t * dst;
     uint8_t * frame_end;
     int remaining = avctx->width;          // number of bytes remaining on a line
-    const int wrap_to_next_line = vid->frame.linesize[0] - avctx->width;
-    int code;
+    int wrap_to_next_line;
+    int code, ret;
     int yoffset;
 
-    if (avctx->reget_buffer(avctx, &vid->frame)) {
-        av_log(avctx, AV_LOG_ERROR, "reget_buffer() failed\n");
-        return -1;
+    if ((ret = ff_reget_buffer(avctx, vid->frame)) < 0)
+        return ret;
+    wrap_to_next_line = vid->frame->linesize[0] - avctx->width;
+
+    if (avpkt->side_data_elems > 0 &&
+        avpkt->side_data[0].type == AV_PKT_DATA_PALETTE) {
+        bytestream2_init(&vid->g, avpkt->side_data[0].data,
+                         avpkt->side_data[0].size);
+        if ((ret = set_palette(vid)) < 0)
+            return ret;
     }
-    dst = vid->frame.data[0];
-    frame_end = vid->frame.data[0] + vid->frame.linesize[0] * avctx->height;
 
-    switch(block_type = *buf++){
-        case PALETTE_BLOCK:
-            set_palette(&vid->frame, buf);
-            return 0;
+    bytestream2_init(&vid->g, avpkt->data, avpkt->size);
+    dst = vid->frame->data[0];
+    frame_end = vid->frame->data[0] + vid->frame->linesize[0] * avctx->height;
+
+    switch(block_type = bytestream2_get_byte(&vid->g)){
+        case PALETTE_BLOCK: {
+            *got_frame = 0;
+            if ((ret = set_palette(vid)) < 0) {
+                av_log(avctx, AV_LOG_ERROR, "error reading palette\n");
+                return ret;
+            }
+            return bytestream2_tell(&vid->g);
+        }
         case VIDEO_YOFF_P_FRAME:
-            yoffset = bytestream_get_le16(&buf);
+            yoffset = bytestream2_get_le16(&vid->g);
             if(yoffset >= avctx->height)
-                return -1;
-            dst += vid->frame.linesize[0] * yoffset;
+                return AVERROR_INVALIDDATA;
+            dst += vid->frame->linesize[0] * yoffset;
     }
 
     // main code
-    while((code = *buf++)){
+    while((code = bytestream2_get_byte(&vid->g))){
         int length = code & 0x7f;
 
         // copy any bytes starting at the current position, and ending at the frame width
         while(length > remaining){
             if(code < 0x80)
-                bytestream_get_buffer(&buf, dst, remaining);
+                bytestream2_get_buffer(&vid->g, dst, remaining);
             else if(block_type == VIDEO_I_FRAME)
-                memset(dst, buf[0], remaining);
+                memset(dst, bytestream2_peek_byte(&vid->g), remaining);
             length -= remaining;      // decrement the number of bytes to be copied
             dst += remaining + wrap_to_next_line;    // skip over extra bytes at end of frame
             remaining = avctx->width;
@@ -108,36 +130,37 @@ static int bethsoftvid_decode_frame(AVCodecContext *avctx,
 
         // copy any remaining bytes after / if line overflows
         if(code < 0x80)
-            bytestream_get_buffer(&buf, dst, length);
+            bytestream2_get_buffer(&vid->g, dst, length);
         else if(block_type == VIDEO_I_FRAME)
-            memset(dst, *buf++, length);
+            memset(dst, bytestream2_get_byte(&vid->g), length);
         remaining -= length;
         dst += length;
     }
     end:
 
-    *data_size = sizeof(AVFrame);
-    *(AVFrame*)data = vid->frame;
+    if ((ret = av_frame_ref(data, vid->frame)) < 0)
+        return ret;
+
+    *got_frame = 1;
 
-    return buf_size;
+    return avpkt->size;
 }
 
 static av_cold int bethsoftvid_decode_end(AVCodecContext *avctx)
 {
     BethsoftvidContext * vid = avctx->priv_data;
-    if(vid->frame.data[0])
-        avctx->release_buffer(avctx, &vid->frame);
+    av_frame_free(&vid->frame);
     return 0;
 }
 
-AVCodec bethsoftvid_decoder = {
-    .name = "bethsoftvid",
-    .type = AVMEDIA_TYPE_VIDEO,
-    .id = CODEC_ID_BETHSOFTVID,
+AVCodec ff_bethsoftvid_decoder = {
+    .name           = "bethsoftvid",
+    .long_name      = NULL_IF_CONFIG_SMALL("Bethesda VID video"),
+    .type           = AVMEDIA_TYPE_VIDEO,
+    .id             = AV_CODEC_ID_BETHSOFTVID,
     .priv_data_size = sizeof(BethsoftvidContext),
-    .init = bethsoftvid_decode_init,
-    .close = bethsoftvid_decode_end,
-    .decode = bethsoftvid_decode_frame,
-    .capabilities = CODEC_CAP_DR1,
-    .long_name = NULL_IF_CONFIG_SMALL("Bethesda VID video"),
+    .init           = bethsoftvid_decode_init,
+    .close          = bethsoftvid_decode_end,
+    .decode         = bethsoftvid_decode_frame,
+    .capabilities   = CODEC_CAP_DR1,
 };