Patch by Mohamed Naufal gmailify(naufal11). Originally committed as revision 22724 to svn://svn.ffmpeg.org/ffmpeg/trunk
Unified · Split
| @@ -241,6 +241,7 @@ library: · 240 unmodified lines | |||
| 241 | @item Westwood Studios VQA @tab @tab X | 241 | @item Westwood Studios VQA @tab @tab X |
| 242 | @tab Multimedia format used in Westwood Studios games. | 242 | @tab Multimedia format used in Westwood Studios games. |
| 243 | @item YUV4MPEG pipe @tab X @tab X | 243 | @item YUV4MPEG pipe @tab X @tab X |
| 244 | @item Psygnosis YOP @tab @tab X | ||
| 244 | @end multitable | 245 | @end multitable |
| 245 | 246 | ||
| 246 | @code{X} means that encoding (resp. decoding) is supported. | 247 | @code{X} means that encoding (resp. decoding) is supported. |
| @@ -490,6 +491,7 @@ following image formats are supported: · 243 unmodified lines | |||
| 490 | @item Winnov WNV1 @tab @tab X | 491 | @item Winnov WNV1 @tab @tab X |
| 491 | @item WMV7 @tab X @tab X | 492 | @item WMV7 @tab X @tab X |
| 492 | @item YAMAHA SMAF @tab X @tab X | 493 | @item YAMAHA SMAF @tab X @tab X |
| 494 | @item Psygnosis YOP Video @tab @tab X | ||
| 493 | @item ZLIB @tab X @tab X | 495 | @item ZLIB @tab X @tab X |
| 494 | @tab part of LCL, encoder experimental | 496 | @tab part of LCL, encoder experimental |
| 495 | @item Zip Motion Blocks Video @tab X @tab X | 497 | @item Zip Motion Blocks Video @tab X @tab X |
| @@ -386,6 +386,7 @@ OBJS-$(CONFIG_XAN_WC4_DECODER) += xan.o · 385 unmodified lines | |||
| 386 | OBJS-$(CONFIG_XL_DECODER) += xl.o | 386 | OBJS-$(CONFIG_XL_DECODER) += xl.o |
| 387 | OBJS-$(CONFIG_XSUB_DECODER) += xsubdec.o | 387 | OBJS-$(CONFIG_XSUB_DECODER) += xsubdec.o |
| 388 | OBJS-$(CONFIG_XSUB_ENCODER) += xsubenc.o | 388 | OBJS-$(CONFIG_XSUB_ENCODER) += xsubenc.o |
| 389 | OBJS-$(CONFIG_YOP_DECODER) += yop.o | ||
| 389 | OBJS-$(CONFIG_ZLIB_DECODER) += lcldec.o | 390 | OBJS-$(CONFIG_ZLIB_DECODER) += lcldec.o |
| 390 | OBJS-$(CONFIG_ZLIB_ENCODER) += lclenc.o | 391 | OBJS-$(CONFIG_ZLIB_ENCODER) += lclenc.o |
| 391 | OBJS-$(CONFIG_ZMBV_DECODER) += zmbv.o | 392 | OBJS-$(CONFIG_ZMBV_DECODER) += zmbv.o |
| @@ -207,6 +207,7 @@ void avcodec_register_all(void) · 206 unmodified lines | |||
| 207 | REGISTER_DECODER (WNV1, wnv1); | 207 | REGISTER_DECODER (WNV1, wnv1); |
| 208 | REGISTER_DECODER (XAN_WC3, xan_wc3); | 208 | REGISTER_DECODER (XAN_WC3, xan_wc3); |
| 209 | REGISTER_DECODER (XL, xl); | 209 | REGISTER_DECODER (XL, xl); |
| 210 | REGISTER_DECODER (YOP, yop); | ||
| 210 | REGISTER_ENCDEC (ZLIB, zlib); | 211 | REGISTER_ENCDEC (ZLIB, zlib); |
| 211 | REGISTER_ENCDEC (ZMBV, zmbv); | 212 | REGISTER_ENCDEC (ZMBV, zmbv); |
| 212 | 213 | ||
| @@ -30,7 +30,7 @@ · 29 unmodified lines | |||
| 30 | #include "libavutil/avutil.h" | 30 | #include "libavutil/avutil.h" |
| 31 | 31 | ||
| 32 | #define LIBAVCODEC_VERSION_MAJOR 52 | 32 | #define LIBAVCODEC_VERSION_MAJOR 52 |
| 33 | #define LIBAVCODEC_VERSION_MINOR 61 | 33 | #define LIBAVCODEC_VERSION_MINOR 62 |
| 34 | #define LIBAVCODEC_VERSION_MICRO 0 | 34 | #define LIBAVCODEC_VERSION_MICRO 0 |
| 35 | 35 | ||
| 36 | #define LIBAVCODEC_VERSION_INT AV_VERSION_INT(LIBAVCODEC_VERSION_MAJOR, \ | 36 | #define LIBAVCODEC_VERSION_INT AV_VERSION_INT(LIBAVCODEC_VERSION_MAJOR, \ |
| @@ -209,6 +209,7 @@ enum CodecID { · 172 unmodified lines | |||
| 209 | CODEC_ID_IFF_ILBM, | 209 | CODEC_ID_IFF_ILBM, |
| 210 | CODEC_ID_IFF_BYTERUN1, | 210 | CODEC_ID_IFF_BYTERUN1, |
| 211 | CODEC_ID_KGV1, | 211 | CODEC_ID_KGV1, |
| 212 | CODEC_ID_YOP, | ||
| 212 | 213 | ||
| 213 | /* various PCM "codecs" */ | 214 | /* various PCM "codecs" */ |
| 214 | CODEC_ID_PCM_S16LE= 0x10000, | 215 | CODEC_ID_PCM_S16LE= 0x10000, |
| @@ -0,0 +1,260 @@ | |||
| 1 | /** | ||
| 2 | * @file libavcodec/yop.c | ||
| 3 | * Psygnosis YOP decoder | ||
| 4 | * | ||
| 5 | * Copyright (C) 2010 Mohamed Naufal Basheer <naufal11@gmail.com> | ||
| 6 | * derived from the code by | ||
| 7 | * Copyright (C) 2009 Thomas P. Higdon <thomas.p.higdon@gmail.com> | ||
| 8 | * | ||
| 9 | * This file is part of FFmpeg. | ||
| 10 | * | ||
| 11 | * FFmpeg is free software; you can redistribute it and/or | ||
| 12 | * modify it under the terms of the GNU Lesser General Public | ||
| 13 | * License as published by the Free Software Foundation; either | ||
| 14 | * version 2.1 of the License, or (at your option) any later version. | ||
| 15 | * | ||
| 16 | * FFmpeg is distributed in the hope that it will be useful, | ||
| 17 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | ||
| 18 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | ||
| 19 | * Lesser General Public License for more details. | ||
| 20 | * | ||
| 21 | * You should have received a copy of the GNU Lesser General Public | ||
| 22 | * License along with FFmpeg; if not, write to the Free Software | ||
| 23 | * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA | ||
| 24 | */ | ||
| 25 | |||
| 26 | #include "libavutil/intreadwrite.h" | ||
| 27 | |||
| 28 | #include "avcodec.h" | ||
| 29 | #include "get_bits.h" | ||
| 30 | |||
| 31 | typedef struct YopDecContext { | ||
| 32 | AVFrame frame; | ||
| 33 | AVCodecContext *avctx; | ||
| 34 | |||
| 35 | int num_pal_colors; | ||
| 36 | int first_color[2]; | ||
| 37 | int frame_data_length; | ||
| 38 | int row_pos; | ||
| 39 | |||
| 40 | uint8_t *low_nibble; | ||
| 41 | uint8_t *srcptr; | ||
| 42 | uint8_t *dstptr; | ||
| 43 | uint8_t *dstbuf; | ||
| 44 | } YopDecContext; | ||
| 45 | |||
| 46 | // These tables are taken directly from: | ||
| 47 | // http://wiki.multimedia.cx/index.php?title=Psygnosis_YOP | ||
| 48 | |||
| 49 | /** | ||
| 50 | * Lookup table for painting macroblocks. Bytes 0-2 of each entry contain | ||
| 51 | * the macroblock positions to be painted (taken as (0, B0, B1, B2)). | ||
| 52 | * Byte 3 contains the number of bytes consumed on the input, | ||
| 53 | * equal to max(bytes 0-2) + 1. | ||
| 54 | */ | ||
| 55 | static const uint8_t paint_lut[15][4] = | ||
| 56 | {{1, 2, 3, 4}, {1, 2, 0, 3}, | ||
| 57 | {1, 2, 1, 3}, {1, 2, 2, 3}, | ||
| 58 | {1, 0, 2, 3}, {1, 0, 0, 2}, | ||
| 59 | {1, 0, 1, 2}, {1, 1, 2, 3}, | ||
| 60 | {0, 1, 2, 3}, {0, 1, 0, 2}, | ||
| 61 | {1, 1, 0, 2}, {0, 1, 1, 2}, | ||
| 62 | {0, 0, 1, 2}, {0, 0, 0, 1}, | ||
| 63 | {1, 1, 1, 2}, | ||
| 64 | }; | ||
| 65 | |||
| 66 | /** | ||
| 67 | * Lookup table for copying macroblocks. Each entry contains the respective | ||
| 68 | * x and y pixel offset for the copy source. | ||
| 69 | */ | ||
| 70 | static const int8_t motion_vector[16][2] = | ||
| 71 | {{-4, -4}, {-2, -4}, | ||
| 72 | { 0, -4}, { 2, -4}, | ||
| 73 | {-4, -2}, {-4, 0}, | ||
| 74 | {-3, -3}, {-1, -3}, | ||
| 75 | { 1, -3}, { 3, -3}, | ||
| 76 | {-3, -1}, {-2, -2}, | ||
| 77 | { 0, -2}, { 2, -2}, | ||
| 78 | { 4, -2}, {-2, 0}, | ||
| 79 | }; | ||
| 80 | |||
| 81 | static av_cold int yop_decode_init(AVCodecContext *avctx) | ||
| 82 | { | ||
| 83 | YopDecContext *s = avctx->priv_data; | ||
| 84 | s->avctx = avctx; | ||
| 85 | |||
| 86 | if (avctx->width & 1 || avctx->height & 1 || | ||
| 87 | avcodec_check_dimensions(avctx, avctx->width, avctx->height) < 0) { | ||
| 88 | av_log(avctx, AV_LOG_ERROR, "YOP has invalid dimensions\n"); | ||
| 89 | return -1; | ||
| 90 | } | ||
| 91 | |||
| 92 | avctx->pix_fmt = PIX_FMT_PAL8; | ||
| 93 | |||
| 94 | s->num_pal_colors = avctx->extradata[0]; | ||
| 95 | s->first_color[0] = avctx->extradata[1]; | ||
| 96 | s->first_color[1] = avctx->extradata[2]; | ||
| 97 | |||
| 98 | if (s->num_pal_colors + s->first_color[0] > 256 || | ||
| 99 | s->num_pal_colors + s->first_color[1] > 256) { | ||
| 100 | av_log(avctx, AV_LOG_ERROR, | ||
| 101 | "YOP: palette parameters invalid, header probably corrupt\n"); | ||
| 102 | return AVERROR_INVALIDDATA; | ||
| 103 | } | ||
| 104 | |||
| 105 | return 0; | ||
| 106 | } | ||
| 107 | |||
| 108 | static av_cold int yop_decode_close(AVCodecContext *avctx) | ||
| 109 | { | ||
| 110 | YopDecContext *s = avctx->priv_data; | ||
| 111 | if (s->frame.data[0]) | ||
| 112 | avctx->release_buffer(avctx, &s->frame); | ||
| 113 | return 0; | ||
| 114 | } | ||
| 115 | |||
| 116 | /** | ||
| 117 | * Paints a macroblock using the pattern in paint_lut. | ||
| 118 | * @param s codec context | ||
| 119 | * @param tag the tag that was in the nibble | ||
| 120 | */ | ||
| 121 | static void yop_paint_block(YopDecContext *s, int tag) | ||
| 122 | { | ||
| 123 | s->dstptr[0] = s->srcptr[0]; | ||
| 124 | s->dstptr[1] = s->srcptr[paint_lut[tag][0]]; | ||
| 125 | s->dstptr[s->frame.linesize[0]] = s->srcptr[paint_lut[tag][1]]; | ||
| 126 | s->dstptr[s->frame.linesize[0] + 1] = s->srcptr[paint_lut[tag][2]]; | ||
| 127 | |||
| 128 | // The number of src bytes consumed is in the last part of the lut entry. | ||
| 129 | s->srcptr += paint_lut[tag][3]; | ||
| 130 | } | ||
| 131 | |||
| 132 | /** | ||
| 133 | * Copies a previously painted macroblock to the current_block. | ||
| 134 | * @param copy_tag the tag that was in the nibble | ||
| 135 | */ | ||
| 136 | static int yop_copy_previous_block(YopDecContext *s, int copy_tag) | ||
| 137 | { | ||
| 138 | uint8_t *bufptr; | ||
| 139 | |||
| 140 | // Calculate position for the copy source | ||
| 141 | bufptr = s->dstptr + motion_vector[copy_tag][0] + | ||
| 142 | s->frame.linesize[0] * motion_vector[copy_tag][1]; | ||
| 143 | if (bufptr < s->dstbuf) { | ||
| 144 | av_log(s->avctx, AV_LOG_ERROR, | ||
| 145 | "YOP: cannot decode, file probably corrupt\n"); | ||
| 146 | return AVERROR_INVALIDDATA; | ||
| 147 | } | ||
| 148 | |||
| 149 | s->dstptr[0] = bufptr[0]; | ||
| 150 | s->dstptr[1] = bufptr[1]; | ||
| 151 | s->dstptr[s->frame.linesize[0]] = bufptr[s->frame.linesize[0]]; | ||
| 152 | s->dstptr[s->frame.linesize[0] + 1] = bufptr[s->frame.linesize[0] + 1]; | ||
| 153 | |||
| 154 | return 0; | ||
| 155 | } | ||
| 156 | |||
| 157 | /** | ||
| 158 | * Returns the next nibble in sequence, consuming a new byte on the input | ||
| 159 | * only if necessary. | ||
| 160 | */ | ||
| 161 | static uint8_t yop_get_next_nibble(YopDecContext *s) | ||
| 162 | { | ||
| 163 | int ret; | ||
| 164 | |||
| 165 | if (s->low_nibble) { | ||
| 166 | ret = *s->low_nibble & 0xf; | ||
| 167 | s->low_nibble = NULL; | ||
| 168 | }else { | ||
| 169 | s->low_nibble = s->srcptr++; | ||
| 170 | ret = *s->low_nibble >> 4; | ||
| 171 | } | ||
| 172 | return ret; | ||
| 173 | } | ||
| 174 | |||
| 175 | /** | ||
| 176 | * Takes s->dstptr to the next macroblock in sequence. | ||
| 177 | */ | ||
| 178 | static void yop_next_macroblock(YopDecContext *s) | ||
| 179 | { | ||
| 180 | // If we are advancing to the next row of macroblocks | ||
| 181 | if (s->row_pos == s->frame.linesize[0] - 2) { | ||
| 182 | s->dstptr += s->frame.linesize[0]; | ||
| 183 | s->row_pos = 0; | ||
| 184 | }else { | ||
| 185 | s->row_pos += 2; | ||
| 186 | } | ||
| 187 | s->dstptr += 2; | ||
| 188 | } | ||
| 189 | |||
| 190 | static int yop_decode_frame(AVCodecContext *avctx, void *data, int *data_size, | ||
| 191 | AVPacket *avpkt) | ||
| 192 | { | ||
| 193 | YopDecContext *s = avctx->priv_data; | ||
| 194 | int tag, firstcolor, is_odd_frame; | ||
| 195 | int ret, i; | ||
| 196 | uint32_t *palette; | ||
| 197 | |||
| 198 | if (s->frame.data[0]) | ||
| 199 | avctx->release_buffer(avctx, &s->frame); | ||
| 200 | |||
| 201 | ret = avctx->get_buffer(avctx, &s->frame); | ||
| 202 | if (ret < 0) { | ||
| 203 | av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n"); | ||
| 204 | return ret; | ||
| 205 | } | ||
| 206 | |||
| 207 | s->frame.linesize[0] = avctx->width; | ||
| 208 | |||
| 209 | s->dstbuf = s->frame.data[0]; | ||
| 210 | s->dstptr = s->frame.data[0]; | ||
| 211 | s->srcptr = avpkt->data + 4; | ||
| 212 | s->row_pos = 0; | ||
| 213 | s->low_nibble = NULL; | ||
| 214 | |||
| 215 | is_odd_frame = avpkt->data[0]; | ||
| 216 | firstcolor = s->first_color[is_odd_frame]; | ||
| 217 | palette = (uint32_t *)s->frame.data[1]; | ||
| 218 | |||
| 219 | for (i = 0; i < s->num_pal_colors; i++, s->srcptr += 3) | ||
| 220 | palette[i + firstcolor] = (s->srcptr[0] << 18) | | ||
| 221 | (s->srcptr[1] << 10) | | ||
| 222 | (s->srcptr[2] << 2); | ||
| 223 | |||
| 224 | s->frame.palette_has_changed = 1; | ||
| 225 | |||
| 226 | while (s->dstptr - s->dstbuf < | ||
| 227 | avctx->width * avctx->height && | ||
| 228 | s->srcptr - avpkt->data < avpkt->size) { | ||
| 229 | |||
| 230 | tag = yop_get_next_nibble(s); | ||
| 231 | |||
| 232 | if (tag != 0xf) { | ||
| 233 | yop_paint_block(s, tag); | ||
| 234 | }else { | ||
| 235 | tag = yop_get_next_nibble(s); | ||
| 236 | ret = yop_copy_previous_block(s, tag); | ||
| 237 | if (ret < 0) { | ||
| 238 | avctx->release_buffer(avctx, &s->frame); | ||
| 239 | return ret; | ||
| 240 | } | ||
| 241 | } | ||
| 242 | yop_next_macroblock(s); | ||
| 243 | } | ||
| 244 | |||
| 245 | *data_size = sizeof(AVFrame); | ||
| 246 | *(AVFrame *) data = s->frame; | ||
| 247 | return avpkt->size; | ||
| 248 | } | ||
| 249 | |||
| 250 | AVCodec yop_decoder = { | ||
| 251 | "yop", | ||
| 252 | CODEC_TYPE_VIDEO, | ||
| 253 | CODEC_ID_YOP, | ||
| 254 | sizeof(YopDecContext), | ||
| 255 | yop_decode_init, | ||
| 256 | NULL, | ||
| 257 | yop_decode_close, | ||
| 258 | yop_decode_frame, | ||
| 259 | .long_name = NULL_IF_CONFIG_SMALL("Psygnosis YOP Video"), | ||
| 260 | }; | ||
| @@ -260,6 +260,7 @@ OBJS-$(CONFIG_WSAUD_DEMUXER) += westwood.o · 259 unmodified lines | |||
| 260 | OBJS-$(CONFIG_WSVQA_DEMUXER) += westwood.o | 260 | OBJS-$(CONFIG_WSVQA_DEMUXER) += westwood.o |
| 261 | OBJS-$(CONFIG_WV_DEMUXER) += wv.o apetag.o id3v1.o | 261 | OBJS-$(CONFIG_WV_DEMUXER) += wv.o apetag.o id3v1.o |
| 262 | OBJS-$(CONFIG_XA_DEMUXER) += xa.o | 262 | OBJS-$(CONFIG_XA_DEMUXER) += xa.o |
| 263 | OBJS-$(CONFIG_YOP_DEMUXER) += yop.o | ||
| 263 | OBJS-$(CONFIG_YUV4MPEGPIPE_MUXER) += yuv4mpeg.o | 264 | OBJS-$(CONFIG_YUV4MPEGPIPE_MUXER) += yuv4mpeg.o |
| 264 | OBJS-$(CONFIG_YUV4MPEGPIPE_DEMUXER) += yuv4mpeg.o | 265 | OBJS-$(CONFIG_YUV4MPEGPIPE_DEMUXER) += yuv4mpeg.o |
| 265 | 266 | ||
| @@ -207,6 +207,7 @@ void av_register_all(void) · 206 unmodified lines | |||
| 207 | REGISTER_DEMUXER (WSVQA, wsvqa); | 207 | REGISTER_DEMUXER (WSVQA, wsvqa); |
| 208 | REGISTER_DEMUXER (WV, wv); | 208 | REGISTER_DEMUXER (WV, wv); |
| 209 | REGISTER_DEMUXER (XA, xa); | 209 | REGISTER_DEMUXER (XA, xa); |
| 210 | REGISTER_DEMUXER (YOP, yop); | ||
| 210 | REGISTER_MUXDEMUX (YUV4MPEGPIPE, yuv4mpegpipe); | 211 | REGISTER_MUXDEMUX (YUV4MPEGPIPE, yuv4mpegpipe); |
| 211 | 212 | ||
| 212 | /* external libraries */ | 213 | /* external libraries */ |
| @@ -22,7 +22,7 @@ · 21 unmodified lines | |||
| 22 | #define AVFORMAT_AVFORMAT_H | 22 | #define AVFORMAT_AVFORMAT_H |
| 23 | 23 | ||
| 24 | #define LIBAVFORMAT_VERSION_MAJOR 52 | 24 | #define LIBAVFORMAT_VERSION_MAJOR 52 |
| 25 | #define LIBAVFORMAT_VERSION_MINOR 58 | 25 | #define LIBAVFORMAT_VERSION_MINOR 59 |
| 26 | #define LIBAVFORMAT_VERSION_MICRO 0 | 26 | #define LIBAVFORMAT_VERSION_MICRO 0 |
| 27 | 27 | ||
| 28 | #define LIBAVFORMAT_VERSION_INT AV_VERSION_INT(LIBAVFORMAT_VERSION_MAJOR, \ | 28 | #define LIBAVFORMAT_VERSION_INT AV_VERSION_INT(LIBAVFORMAT_VERSION_MAJOR, \ |
| @@ -0,0 +1,216 @@ | |||
| 1 | /** | ||
| 2 | * @file libavformat/yop.c | ||
| 3 | * Psygnosis YOP demuxer | ||
| 4 | * | ||
| 5 | * Copyright (C) 2010 Mohamed Naufal Basheer <naufal11@gmail.com> | ||
| 6 | * derived from the code by | ||
| 7 | * Copyright (C) 2009 Thomas P. Higdon <thomas.p.higdon@gmail.com> | ||
| 8 | * | ||
| 9 | * This file is part of FFmpeg. | ||
| 10 | * | ||
| 11 | * FFmpeg is free software; you can redistribute it and/or | ||
| 12 | * modify it under the terms of the GNU Lesser General Public | ||
| 13 | * License as published by the Free Software Foundation; either | ||
| 14 | * version 2.1 of the License, or (at your option) any later version. | ||
| 15 | * | ||
| 16 | * FFmpeg is distributed in the hope that it will be useful, | ||
| 17 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | ||
| 18 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | ||
| 19 | * Lesser General Public License for more details. | ||
| 20 | * | ||
| 21 | * You should have received a copy of the GNU Lesser General Public | ||
| 22 | * License along with FFmpeg; if not, write to the Free Software | ||
| 23 | * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA | ||
| 24 | */ | ||
| 25 | |||
| 26 | #include "libavutil/intreadwrite.h" | ||
| 27 | #include "avformat.h" | ||
| 28 | |||
| 29 | typedef struct yop_dec_context { | ||
| 30 | AVPacket video_packet; | ||
| 31 | |||
| 32 | int odd_frame; | ||
| 33 | int frame_size; | ||
| 34 | int audio_block_length; | ||
| 35 | int palette_size; | ||
| 36 | } YopDecContext; | ||
| 37 | |||
| 38 | static int yop_probe(AVProbeData *probe_packet) | ||
| 39 | { | ||
| 40 | if (AV_RB16(probe_packet->buf) == AV_RB16("YO") && | ||
| 41 | probe_packet->buf[6] && | ||
| 42 | probe_packet->buf[7] && | ||
| 43 | !(probe_packet->buf[8] & 1) && | ||
| 44 | !(probe_packet->buf[10] & 1)) | ||
| 45 | return AVPROBE_SCORE_MAX * 3 / 4; | ||
| 46 | |||
| 47 | return 0; | ||
| 48 | } | ||
| 49 | |||
| 50 | static int yop_read_header(AVFormatContext *s, AVFormatParameters *ap) | ||
| 51 | { | ||
| 52 | YopDecContext *yop = s->priv_data; | ||
| 53 | ByteIOContext *pb = s->pb; | ||
| 54 | |||
| 55 | AVCodecContext *audio_dec, *video_dec; | ||
| 56 | AVStream *audio_stream, *video_stream; | ||
| 57 | |||
| 58 | int frame_rate, ret; | ||
| 59 | |||
| 60 | audio_stream = av_new_stream(s, 0); | ||
| 61 | video_stream = av_new_stream(s, 1); | ||
| 62 | |||
| 63 | // Extra data that will be passed to the decoder | ||
| 64 | video_stream->codec->extradata_size = 8; | ||
| 65 | |||
| 66 | video_stream->codec->extradata = av_mallocz(video_stream->codec->extradata_size + | ||
| 67 | FF_INPUT_BUFFER_PADDING_SIZE); | ||
| 68 | |||
| 69 | if (!video_stream->codec->extradata) | ||
| 70 | return AVERROR(ENOMEM); | ||
| 71 | |||
| 72 | // Audio | ||
| 73 | audio_dec = audio_stream->codec; | ||
| 74 | audio_dec->codec_type = CODEC_TYPE_AUDIO; | ||
| 75 | audio_dec->codec_id = CODEC_ID_ADPCM_IMA_WS; | ||
| 76 | audio_dec->channels = 1; | ||
| 77 | audio_dec->sample_rate = 22050; | ||
| 78 | |||
| 79 | // Video | ||
| 80 | video_dec = video_stream->codec; | ||
| 81 | video_dec->codec_type = CODEC_TYPE_VIDEO; | ||
| 82 | video_dec->codec_id = CODEC_ID_YOP; | ||
| 83 | |||
| 84 | url_fskip(pb, 6); | ||
| 85 | |||
| 86 | frame_rate = get_byte(pb); | ||
| 87 | yop->frame_size = get_byte(pb) * 2048; | ||
| 88 | video_dec->width = get_le16(pb); | ||
| 89 | video_dec->height = get_le16(pb); | ||
| 90 | |||
| 91 | video_stream->sample_aspect_ratio = (AVRational){1, 2}; | ||
| 92 | |||
| 93 | ret = get_buffer(pb, video_dec->extradata, 8); | ||
| 94 | if (ret < 8) | ||
| 95 | return ret < 0 ? ret : AVERROR_EOF; | ||
| 96 | |||
| 97 | yop->palette_size = video_dec->extradata[0] * 3 + 4; | ||
| 98 | yop->audio_block_length = AV_RL16(video_dec->extradata + 6); | ||
| 99 | |||
| 100 | // 1840 samples per frame, 1 nibble per sample; hence 1840/2 = 920 | ||
| 101 | if (yop->audio_block_length < 920 || | ||
| 102 | yop->audio_block_length + yop->palette_size >= yop->frame_size) { | ||
| 103 | av_log(s, AV_LOG_ERROR, "YOP has invalid header\n"); | ||
| 104 | return AVERROR_INVALIDDATA; | ||
| 105 | } | ||
| 106 | |||
| 107 | url_fseek(pb, 2048, SEEK_SET); | ||
| 108 | |||
| 109 | av_set_pts_info(video_stream, 32, 1, frame_rate); | ||
| 110 | |||
| 111 | return 0; | ||
| 112 | } | ||
| 113 | |||
| 114 | static int yop_read_packet(AVFormatContext *s, AVPacket *pkt) | ||
| 115 | { | ||
| 116 | YopDecContext *yop = s->priv_data; | ||
| 117 | ByteIOContext *pb = s->pb; | ||
| 118 | |||
| 119 | int ret; | ||
| 120 | int actual_video_data_size = yop->frame_size - | ||
| 121 | yop->audio_block_length - yop->palette_size; | ||
| 122 | |||
| 123 | yop->video_packet.stream_index = 1; | ||
| 124 | |||
| 125 | if (yop->video_packet.data) { | ||
| 126 | *pkt = yop->video_packet; | ||
| 127 | yop->video_packet.data = NULL; | ||
| 128 | yop->video_packet.size = 0; | ||
| 129 | pkt->data[0] = yop->odd_frame; | ||
| 130 | pkt->flags |= PKT_FLAG_KEY; | ||
| 131 | yop->odd_frame ^= 1; | ||
| 132 | return pkt->size; | ||
| 133 | } | ||
| 134 | ret = av_new_packet(&yop->video_packet, | ||
| 135 | yop->frame_size - yop->audio_block_length); | ||
| 136 | if (ret < 0) | ||
| 137 | return ret; | ||
| 138 | |||
| 139 | yop->video_packet.pos = url_ftell(pb); | ||
| 140 | |||
| 141 | ret = get_buffer(pb, yop->video_packet.data, yop->palette_size); | ||
| 142 | if (ret < 0) { | ||
| 143 | goto err_out; | ||
| 144 | }else if (ret < yop->palette_size) { | ||
| 145 | ret = AVERROR_EOF; | ||
| 146 | goto err_out; | ||
| 147 | } | ||
| 148 | |||
| 149 | ret = av_get_packet(pb, pkt, 920); | ||
| 150 | if (ret < 0) | ||
| 151 | goto err_out; | ||
| 152 | |||
| 153 | // Set position to the start of the frame | ||
| 154 | pkt->pos = yop->video_packet.pos; | ||
| 155 | |||
| 156 | url_fskip(pb, yop->audio_block_length - ret); | ||
| 157 | |||
| 158 | ret = get_buffer(pb, yop->video_packet.data + yop->palette_size, | ||
| 159 | actual_video_data_size); | ||
| 160 | if (ret < 0) | ||
| 161 | goto err_out; | ||
| 162 | else if (ret < actual_video_data_size) | ||
| 163 | av_shrink_packet(&yop->video_packet, yop->palette_size + ret); | ||
| 164 | |||
| 165 | // Arbitrarily return the audio data first | ||
| 166 | return yop->audio_block_length; | ||
| 167 | |||
| 168 | err_out: | ||
| 169 | av_free_packet(&yop->video_packet); | ||
| 170 | return ret; | ||
| 171 | } | ||
| 172 | |||
| 173 | static int yop_read_close(AVFormatContext *s) | ||
| 174 | { | ||
| 175 | YopDecContext *yop = s->priv_data; | ||
| 176 | av_free_packet(&yop->video_packet); | ||
| 177 | return 0; | ||
| 178 | } | ||
| 179 | |||
| 180 | static int yop_read_seek(AVFormatContext *s, int stream_index, | ||
| 181 | int64_t timestamp, int flags) | ||
| 182 | { | ||
| 183 | YopDecContext *yop = s->priv_data; | ||
| 184 | int64_t frame_pos, pos_min, pos_max; | ||
| 185 | int frame_count; | ||
| 186 | |||
| 187 | av_free_packet(&yop->video_packet); | ||
| 188 | |||
| 189 | if (!stream_index) | ||
| 190 | return -1; | ||
| 191 | |||
| 192 | pos_min = s->data_offset; | ||
| 193 | pos_max = url_fsize(s->pb) - yop->frame_size; | ||
| 194 | frame_count = (pos_max - pos_min) / yop->frame_size; | ||
| 195 | |||
| 196 | timestamp = FFMAX(0, FFMIN(frame_count, timestamp)); | ||
| 197 | |||
| 198 | frame_pos = timestamp * yop->frame_size + pos_min; | ||
| 199 | yop->odd_frame = timestamp & 1; | ||
| 200 | |||
| 201 | url_fseek(s->pb, frame_pos, SEEK_SET); | ||
| 202 | return 0; | ||
| 203 | } | ||
| 204 | |||
| 205 | AVInputFormat yop_demuxer = { | ||
| 206 | "yop", | ||
| 207 | NULL_IF_CONFIG_SMALL("Psygnosis YOP Format"), | ||
| 208 | sizeof(YopDecContext), | ||
| 209 | yop_probe, | ||
| 210 | yop_read_header, | ||
| 211 | yop_read_packet, | ||
| 212 | yop_read_close, | ||
| 213 | yop_read_seek, | ||
| 214 | .extensions = "yop", | ||
| 215 | .flags = AVFMT_GENERIC_INDEX, | ||
| 216 | }; | ||