FFmpeg
bethsoftvideo.c
Go to the documentation of this file.
1 /*
2  * Bethesda VID video decoder
3  * Copyright (C) 2007 Nicholas Tung
4  *
5  * This file is part of FFmpeg.
6  *
7  * FFmpeg is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Lesser General Public
9  * License as published by the Free Software Foundation; either
10  * version 2.1 of the License, or (at your option) any later version.
11  *
12  * FFmpeg is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15  * Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with FFmpeg; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20  */
21 
22 /**
23  * @file
24  * @brief Bethesda Softworks VID Video Decoder
25  * @author Nicholas Tung [ntung (at. ntung com] (2007-03)
26  * @see http://wiki.multimedia.cx/index.php?title=Bethsoft_VID
27  * @see http://www.svatopluk.com/andux/docs/dfvid.html
28  */
29 
30 #include "libavutil/common.h"
31 #include "avcodec.h"
32 #include "bethsoftvideo.h"
33 #include "bytestream.h"
34 #include "codec_internal.h"
35 #include "decode.h"
36 
37 typedef struct BethsoftvidContext {
41 
43 {
44  BethsoftvidContext *vid = avctx->priv_data;
45  avctx->pix_fmt = AV_PIX_FMT_PAL8;
46 
47  vid->frame = av_frame_alloc();
48  if (!vid->frame)
49  return AVERROR(ENOMEM);
50 
51  return 0;
52 }
53 
55 {
56  uint32_t *palette = (uint32_t *)ctx->frame->data[1];
57  int a;
58 
60  return AVERROR_INVALIDDATA;
61 
62  for(a = 0; a < 256; a++){
63  palette[a] = 0xFFU << 24 | bytestream2_get_be24u(g) * 4;
64  palette[a] |= palette[a] >> 6 & 0x30303;
65  }
66 #if FF_API_PALETTE_HAS_CHANGED
68  ctx->frame->palette_has_changed = 1;
70 #endif
71  return 0;
72 }
73 
74 static int bethsoftvid_decode_frame(AVCodecContext *avctx, AVFrame *rframe,
75  int *got_frame, AVPacket *avpkt)
76 {
77  BethsoftvidContext * vid = avctx->priv_data;
78  char block_type;
79  uint8_t * dst;
80  uint8_t * frame_end;
81  int remaining = avctx->width; // number of bytes remaining on a line
82  int wrap_to_next_line;
83  int code, ret;
84  int yoffset;
85 
86  bytestream2_init(&vid->g, avpkt->data, avpkt->size);
87  block_type = bytestream2_get_byte(&vid->g);
88  if (block_type < 1 || block_type > 4)
89  return AVERROR_INVALIDDATA;
90 
91  if ((ret = ff_reget_buffer(avctx, vid->frame, 0)) < 0)
92  return ret;
93  wrap_to_next_line = vid->frame->linesize[0] - avctx->width;
94 
95  if (avpkt->side_data_elems > 0 &&
96  avpkt->side_data[0].type == AV_PKT_DATA_PALETTE) {
98  bytestream2_init(&g, avpkt->side_data[0].data,
99  avpkt->side_data[0].size);
100  if ((ret = set_palette(vid, &g)) < 0)
101  return ret;
102  }
103 
104  dst = vid->frame->data[0];
105  frame_end = vid->frame->data[0] + vid->frame->linesize[0] * avctx->height;
106 
107  switch(block_type){
108  case PALETTE_BLOCK: {
109  *got_frame = 0;
110  if ((ret = set_palette(vid, &vid->g)) < 0) {
111  av_log(avctx, AV_LOG_ERROR, "error reading palette\n");
112  return ret;
113  }
114  return bytestream2_tell(&vid->g);
115  }
116  case VIDEO_YOFF_P_FRAME:
117  yoffset = bytestream2_get_le16(&vid->g);
118  if(yoffset >= avctx->height)
119  return AVERROR_INVALIDDATA;
120  dst += vid->frame->linesize[0] * yoffset;
121  case VIDEO_P_FRAME:
122  case VIDEO_I_FRAME:
123  break;
124  default:
125  return AVERROR_INVALIDDATA;
126  }
127 
128  // main code
129  while((code = bytestream2_get_byte(&vid->g))){
130  int length = code & 0x7f;
131 
132  // copy any bytes starting at the current position, and ending at the frame width
133  while(length > remaining){
134  if(code < 0x80)
135  bytestream2_get_buffer(&vid->g, dst, remaining);
136  else if(block_type == VIDEO_I_FRAME)
137  memset(dst, bytestream2_peek_byte(&vid->g), remaining);
138  length -= remaining; // decrement the number of bytes to be copied
139  dst += remaining + wrap_to_next_line; // skip over extra bytes at end of frame
140  remaining = avctx->width;
141  if(dst == frame_end)
142  goto end;
143  }
144 
145  // copy any remaining bytes after / if line overflows
146  if(code < 0x80)
147  bytestream2_get_buffer(&vid->g, dst, length);
148  else if(block_type == VIDEO_I_FRAME)
149  memset(dst, bytestream2_get_byte(&vid->g), length);
150  remaining -= length;
151  dst += length;
152  }
153  end:
154 
155  if ((ret = av_frame_ref(rframe, vid->frame)) < 0)
156  return ret;
157 
158  *got_frame = 1;
159 
160  return avpkt->size;
161 }
162 
164 {
165  BethsoftvidContext * vid = avctx->priv_data;
166  av_frame_free(&vid->frame);
167  return 0;
168 }
169 
171  .p.name = "bethsoftvid",
172  CODEC_LONG_NAME("Bethesda VID video"),
173  .p.type = AVMEDIA_TYPE_VIDEO,
174  .p.id = AV_CODEC_ID_BETHSOFTVID,
175  .priv_data_size = sizeof(BethsoftvidContext),
177  .close = bethsoftvid_decode_end,
179  .p.capabilities = AV_CODEC_CAP_DR1,
180 };
VIDEO_I_FRAME
@ VIDEO_I_FRAME
Definition: bethsoftvideo.h:30
FF_ENABLE_DEPRECATION_WARNINGS
#define FF_ENABLE_DEPRECATION_WARNINGS
Definition: internal.h:73
BethsoftvidContext
Definition: bethsoftvideo.c:37
AVERROR
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions
bethsoftvid_decode_frame
static int bethsoftvid_decode_frame(AVCodecContext *avctx, AVFrame *rframe, int *got_frame, AVPacket *avpkt)
Definition: bethsoftvideo.c:74
GetByteContext
Definition: bytestream.h:33
av_frame_free
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:100
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:340
AVPacket::data
uint8_t * data
Definition: packet.h:522
FFCodec
Definition: codec_internal.h:127
AVFrame::data
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:361
BethsoftvidContext::g
GetByteContext g
Definition: bethsoftvideo.c:39
AVPacketSideData::size
size_t size
Definition: packet.h:375
FFCodec::p
AVCodec p
The public AVCodec.
Definition: codec_internal.h:131
AV_PKT_DATA_PALETTE
@ AV_PKT_DATA_PALETTE
An AV_PKT_DATA_PALETTE side data packet contains exactly AVPALETTE_SIZE bytes worth of palette.
Definition: packet.h:47
BethsoftvidContext::frame
AVFrame * frame
Definition: bethsoftvideo.c:38
frame_end
static int64_t frame_end(const SyncQueue *sq, SyncQueueFrame frame, int nb_samples)
Compute the end timestamp of a frame.
Definition: sync_queue.c:128
PALETTE_BLOCK
@ PALETTE_BLOCK
Definition: bethsoftvideo.h:27
av_frame_alloc
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
Definition: frame.c:88
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
av_cold
#define av_cold
Definition: attributes.h:90
FF_CODEC_DECODE_CB
#define FF_CODEC_DECODE_CB(func)
Definition: codec_internal.h:306
ff_bethsoftvid_decoder
const FFCodec ff_bethsoftvid_decoder
Definition: bethsoftvideo.c:170
g
const char * g
Definition: vf_curves.c:127
AVPacketSideData::data
uint8_t * data
Definition: packet.h:374
ctx
AVFormatContext * ctx
Definition: movenc.c:48
decode.h
CODEC_LONG_NAME
#define CODEC_LONG_NAME(str)
Definition: codec_internal.h:272
if
if(ret)
Definition: filter_design.txt:179
VIDEO_YOFF_P_FRAME
@ VIDEO_YOFF_P_FRAME
Definition: bethsoftvideo.h:32
AVPacketSideData::type
enum AVPacketSideDataType type
Definition: packet.h:376
bytestream2_get_buffer
static av_always_inline unsigned int bytestream2_get_buffer(GetByteContext *g, uint8_t *dst, unsigned int size)
Definition: bytestream.h:267
bytestream2_get_bytes_left
static av_always_inline int bytestream2_get_bytes_left(GetByteContext *g)
Definition: bytestream.h:158
bytestream2_tell
static av_always_inline int bytestream2_tell(GetByteContext *g)
Definition: bytestream.h:192
init
int(* init)(AVBSFContext *ctx)
Definition: dts2pts.c:365
AV_CODEC_CAP_DR1
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() or get_encode_buffer() for allocating buffers and supports custom allocators.
Definition: codec.h:52
AVPacket::size
int size
Definition: packet.h:523
av_frame_ref
int av_frame_ref(AVFrame *dst, const AVFrame *src)
Set up a new reference to the data described by the source frame.
Definition: frame.c:361
codec_internal.h
a
The reader does not expect b to be semantically here and if the code is changed by maybe adding a a division or other the signedness will almost certainly be mistaken To avoid this confusion a new type was SUINT is the C unsigned type but it holds a signed int to use the same example SUINT a
Definition: undefined.txt:41
bethsoftvid_decode_init
static av_cold int bethsoftvid_decode_init(AVCodecContext *avctx)
Definition: bethsoftvideo.c:42
bethsoftvid_decode_end
static av_cold int bethsoftvid_decode_end(AVCodecContext *avctx)
Definition: bethsoftvideo.c:163
code
and forward the test the status of outputs and forward it to the corresponding return FFERROR_NOT_READY If the filters stores internally one or a few frame for some it can consider them to be part of the FIFO and delay acknowledging a status change accordingly Example code
Definition: filter_design.txt:178
common.h
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:194
AV_CODEC_ID_BETHSOFTVID
@ AV_CODEC_ID_BETHSOFTVID
Definition: codec_id.h:155
AVCodecContext::height
int height
Definition: avcodec.h:625
AVCodecContext::pix_fmt
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:662
avcodec.h
AV_PIX_FMT_PAL8
@ AV_PIX_FMT_PAL8
8 bits with AV_PIX_FMT_RGB32 palette
Definition: pixfmt.h:84
ff_reget_buffer
int ff_reget_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Identical in function to ff_get_buffer(), except it reuses the existing buffer if available.
Definition: decode.c:1736
ret
ret
Definition: filter_design.txt:187
AVPacket::side_data
AVPacketSideData * side_data
Additional packet data that can be provided by the container.
Definition: packet.h:533
U
#define U(x)
Definition: vpx_arith.h:37
AVCodecContext
main external API structure.
Definition: avcodec.h:445
bethsoftvideo.h
FF_DISABLE_DEPRECATION_WARNINGS
#define FF_DISABLE_DEPRECATION_WARNINGS
Definition: internal.h:72
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
set_palette
static int set_palette(BethsoftvidContext *ctx, GetByteContext *g)
Definition: bethsoftvideo.c:54
AVPacket
This structure stores compressed data.
Definition: packet.h:499
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:472
AVCodecContext::width
int width
picture width / height.
Definition: avcodec.h:625
bytestream.h
bytestream2_init
static av_always_inline void bytestream2_init(GetByteContext *g, const uint8_t *buf, int buf_size)
Definition: bytestream.h:137
AVFrame::linesize
int linesize[AV_NUM_DATA_POINTERS]
For video, a positive or negative value, which is typically indicating the size in bytes of each pict...
Definition: frame.h:385
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:61
VIDEO_P_FRAME
@ VIDEO_P_FRAME
Definition: bethsoftvideo.h:31
AVPacket::side_data_elems
int side_data_elems
Definition: packet.h:534