3 * Copyright (C) 2008 Konstantin Shishkov
5 * This file is part of FFmpeg.
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.
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.
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
24 * MS RLE Decoder based on decoder by Mike Melanson and my own for TSCC
25 * For more information about the MS RLE format, visit:
26 * http://www.multimedia.cx/msrle.txt
31 #define FETCH_NEXT_STREAM_BYTE() \
32 if (stream_ptr >= data_size) \
34 av_log(avctx, AV_LOG_ERROR, " MS RLE: stream ptr just went out of bounds (1)\n"); \
37 stream_byte = data[stream_ptr++];
39 static int msrle_decode_pal4(AVCodecContext
*avctx
, AVPicture
*pic
,
40 const uint8_t *data
, int data_size
)
43 unsigned char rle_code
;
44 unsigned char extra_byte
, odd_pixel
;
45 unsigned char stream_byte
;
47 int row_dec
= pic
->linesize
[0];
48 int row_ptr
= (avctx
->height
- 1) * row_dec
;
49 int frame_size
= row_dec
* avctx
->height
;
52 while (row_ptr
>= 0) {
53 FETCH_NEXT_STREAM_BYTE();
54 rle_code
= stream_byte
;
56 /* fetch the next byte to see how to handle escape code */
57 FETCH_NEXT_STREAM_BYTE();
58 if (stream_byte
== 0) {
59 /* line is done, goto the next one */
62 } else if (stream_byte
== 1) {
65 } else if (stream_byte
== 2) {
66 /* reposition frame decode coordinates */
67 FETCH_NEXT_STREAM_BYTE();
68 pixel_ptr
+= stream_byte
;
69 FETCH_NEXT_STREAM_BYTE();
70 row_ptr
-= stream_byte
* row_dec
;
72 // copy pixels from encoded stream
73 odd_pixel
= stream_byte
& 1;
74 rle_code
= (stream_byte
+ 1) / 2;
75 extra_byte
= rle_code
& 0x01;
76 if ((row_ptr
+ pixel_ptr
+ stream_byte
> frame_size
) ||
78 av_log(avctx
, AV_LOG_ERROR
, " MS RLE: frame ptr just went out of bounds (1)\n");
82 for (i
= 0; i
< rle_code
; i
++) {
83 if (pixel_ptr
>= avctx
->width
)
85 FETCH_NEXT_STREAM_BYTE();
86 pic
->data
[0][row_ptr
+ pixel_ptr
] = stream_byte
>> 4;
88 if (i
+ 1 == rle_code
&& odd_pixel
)
90 if (pixel_ptr
>= avctx
->width
)
92 pic
->data
[0][row_ptr
+ pixel_ptr
] = stream_byte
& 0x0F;
96 // if the RLE code is odd, skip a byte in the stream
101 // decode a run of data
102 if ((row_ptr
+ pixel_ptr
+ stream_byte
> frame_size
) ||
104 av_log(avctx
, AV_LOG_ERROR
, " MS RLE: frame ptr just went out of bounds (1)\n");
107 FETCH_NEXT_STREAM_BYTE();
108 for (i
= 0; i
< rle_code
; i
++) {
109 if (pixel_ptr
>= avctx
->width
)
112 pic
->data
[0][row_ptr
+ pixel_ptr
] = stream_byte
>> 4;
114 pic
->data
[0][row_ptr
+ pixel_ptr
] = stream_byte
& 0x0F;
120 /* one last sanity check on the way out */
121 if (stream_ptr
< data_size
) {
122 av_log(avctx
, AV_LOG_ERROR
, " MS RLE: ended frame decode with bytes left over (%d < %d)\n",
123 stream_ptr
, data_size
);
131 static int msrle_decode_8_16_24_32(AVCodecContext
*avctx
, AVPicture
*pic
, int depth
,
132 const uint8_t *data
, int srcsize
)
134 uint8_t *output
, *output_end
;
135 const uint8_t* src
= data
;
136 int p1
, p2
, line
=avctx
->height
, pos
=0, i
;
140 output
= pic
->data
[0] + (avctx
->height
- 1) * pic
->linesize
[0];
141 output_end
= pic
->data
[0] + (avctx
->height
) * pic
->linesize
[0];
142 while(src
< data
+ srcsize
) {
144 if(p1
== 0) { //Escape code
146 if(p2
== 0) { //End-of-line
147 output
= pic
->data
[0] + (--line
) * pic
->linesize
[0];
152 } else if(p2
== 1) { //End-of-picture
154 } else if(p2
== 2) { //Skip
161 output
= pic
->data
[0] + line
* pic
->linesize
[0] + pos
* (depth
>> 3);
165 if (output
+ p2
* (depth
>> 3) > output_end
) {
166 src
+= p2
* (depth
>> 3);
169 if ((depth
== 8) || (depth
== 24)) {
170 for(i
= 0; i
< p2
* (depth
>> 3); i
++) {
173 // RLE8 copy is actually padded - and runs are not!
174 if(depth
== 8 && (p2
& 1)) {
177 } else if (depth
== 16) {
178 for(i
= 0; i
< p2
; i
++) {
179 pix16
= AV_RL16(src
);
181 *(uint16_t*)output
= pix16
;
184 } else if (depth
== 32) {
185 for(i
= 0; i
< p2
; i
++) {
186 pix32
= AV_RL32(src
);
188 *(uint32_t*)output
= pix32
;
193 } else { //Run of pixels
194 int pix
[4]; //original pixel
196 case 8: pix
[0] = *src
++;
198 case 16: pix16
= AV_RL16(src
);
200 *(uint16_t*)pix
= pix16
;
202 case 24: pix
[0] = *src
++;
206 case 32: pix32
= AV_RL32(src
);
208 *(uint32_t*)pix
= pix32
;
211 if (output
+ p1
* (depth
>> 3) > output_end
)
213 for(i
= 0; i
< p1
; i
++) {
215 case 8: *output
++ = pix
[0];
217 case 16: *(uint16_t*)output
= pix16
;
220 case 24: *output
++ = pix
[0];
224 case 32: *(uint32_t*)output
= pix32
;
233 av_log(avctx
, AV_LOG_WARNING
, "MS RLE warning: no End-of-picture code\n");
238 int ff_msrle_decode(AVCodecContext
*avctx
, AVPicture
*pic
, int depth
,
239 const uint8_t* data
, int data_size
)
243 return msrle_decode_pal4(avctx
, pic
, data
, data_size
);
248 return msrle_decode_8_16_24_32(avctx
, pic
, depth
, data
, data_size
);
250 av_log(avctx
, AV_LOG_ERROR
, "Unknown depth %d\n", depth
);