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];
149 av_log(avctx
, AV_LOG_ERROR
, "Next line is beyond picture bounds\n");
154 } else if(p2
== 1) { //End-of-picture
156 } else if(p2
== 2) { //Skip
161 av_log(avctx
, AV_LOG_ERROR
, "Skip beyond picture bounds\n");
165 output
= pic
->data
[0] + line
* pic
->linesize
[0] + pos
* (depth
>> 3);
169 if (output
+ p2
* (depth
>> 3) > output_end
) {
170 src
+= p2
* (depth
>> 3);
173 if ((depth
== 8) || (depth
== 24)) {
174 for(i
= 0; i
< p2
* (depth
>> 3); i
++) {
177 // RLE8 copy is actually padded - and runs are not!
178 if(depth
== 8 && (p2
& 1)) {
181 } else if (depth
== 16) {
182 for(i
= 0; i
< p2
; i
++) {
183 pix16
= AV_RL16(src
);
185 *(uint16_t*)output
= pix16
;
188 } else if (depth
== 32) {
189 for(i
= 0; i
< p2
; i
++) {
190 pix32
= AV_RL32(src
);
192 *(uint32_t*)output
= pix32
;
197 } else { //Run of pixels
198 uint8_t pix
[3]; //original pixel
200 case 8: pix
[0] = *src
++;
202 case 16: pix16
= AV_RL16(src
);
205 case 24: pix
[0] = *src
++;
209 case 32: pix32
= AV_RL32(src
);
213 if (output
+ p1
* (depth
>> 3) > output_end
)
215 for(i
= 0; i
< p1
; i
++) {
217 case 8: *output
++ = pix
[0];
219 case 16: *(uint16_t*)output
= pix16
;
222 case 24: *output
++ = pix
[0];
226 case 32: *(uint32_t*)output
= pix32
;
235 av_log(avctx
, AV_LOG_WARNING
, "MS RLE warning: no End-of-picture code\n");
240 int ff_msrle_decode(AVCodecContext
*avctx
, AVPicture
*pic
, int depth
,
241 const uint8_t* data
, int data_size
)
245 return msrle_decode_pal4(avctx
, pic
, data
, data_size
);
250 return msrle_decode_8_16_24_32(avctx
, pic
, depth
, data
, data_size
);
252 av_log(avctx
, AV_LOG_ERROR
, "Unknown depth %d\n", depth
);