Add long names to AVCodec declarations.
[ffmpeg.git] / libavcodec / qtrle.c
1 /*
2  * Quicktime Animation (RLE) Video Decoder
3  * Copyright (C) 2004 the ffmpeg project
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 qtrle.c
24  * QT RLE Video Decoder by Mike Melanson (melanson@pcisys.net)
25  * For more information about the QT RLE format, visit:
26  *   http://www.pcisys.net/~melanson/codecs/
27  *
28  * The QT RLE decoder has seven modes of operation:
29  * 1, 2, 4, 8, 16, 24, and 32 bits per pixel. For modes 1, 2, 4, and 8
30  * the decoder outputs PAL8 colorspace data. 16-bit data yields RGB555
31  * data. 24-bit data is RGB24 and 32-bit data is RGB32.
32  */
33
34 #include <stdio.h>
35 #include <stdlib.h>
36 #include <string.h>
37 #include <unistd.h>
38
39 #include "avcodec.h"
40
41 typedef struct QtrleContext {
42
43     AVCodecContext *avctx;
44     AVFrame frame;
45
46     const unsigned char *buf;
47     int size;
48
49 } QtrleContext;
50
51 #define CHECK_STREAM_PTR(n) \
52   if ((stream_ptr + n) > s->size) { \
53     av_log (s->avctx, AV_LOG_INFO, "Problem: stream_ptr out of bounds (%d >= %d)\n", \
54       stream_ptr + n, s->size); \
55     return; \
56   }
57
58 #define CHECK_PIXEL_PTR(n) \
59   if ((pixel_ptr + n > pixel_limit) || (pixel_ptr + n < 0)) { \
60     av_log (s->avctx, AV_LOG_INFO, "Problem: pixel_ptr = %d, pixel_limit = %d\n", \
61       pixel_ptr + n, pixel_limit); \
62     return; \
63   } \
64
65 static void qtrle_decode_1bpp(QtrleContext *s)
66 {
67 }
68
69 static void qtrle_decode_2bpp(QtrleContext *s)
70 {
71 }
72
73 static void qtrle_decode_4bpp(QtrleContext *s)
74 {
75     int stream_ptr;
76     int header;
77     int start_line;
78     int lines_to_change;
79     int rle_code;
80     int row_ptr, pixel_ptr;
81     int row_inc = s->frame.linesize[0];
82     unsigned char pi1, pi2, pi3, pi4, pi5, pi6, pi7, pi8;  /* 8 palette indices */
83     unsigned char *rgb = s->frame.data[0];
84     int pixel_limit = s->frame.linesize[0] * s->avctx->height;
85
86     /* check if this frame is even supposed to change */
87     if (s->size < 8)
88         return;
89
90     /* start after the chunk size */
91     stream_ptr = 4;
92
93     /* fetch the header */
94     CHECK_STREAM_PTR(2);
95     header = AV_RB16(&s->buf[stream_ptr]);
96     stream_ptr += 2;
97
98     /* if a header is present, fetch additional decoding parameters */
99     if (header & 0x0008) {
100         CHECK_STREAM_PTR(8);
101         start_line = AV_RB16(&s->buf[stream_ptr]);
102         stream_ptr += 4;
103         lines_to_change = AV_RB16(&s->buf[stream_ptr]);
104         stream_ptr += 4;
105     } else {
106         start_line = 0;
107         lines_to_change = s->avctx->height;
108     }
109
110     row_ptr = row_inc * start_line;
111     while (lines_to_change--) {
112         CHECK_STREAM_PTR(2);
113         pixel_ptr = row_ptr + (8 * (s->buf[stream_ptr++] - 1));
114
115         while ((rle_code = (signed char)s->buf[stream_ptr++]) != -1) {
116             if (rle_code == 0) {
117                 /* there's another skip code in the stream */
118                 CHECK_STREAM_PTR(1);
119                 pixel_ptr += (8 * (s->buf[stream_ptr++] - 1));
120                 CHECK_PIXEL_PTR(0);  /* make sure pixel_ptr is positive */
121             } else if (rle_code < 0) {
122                 /* decode the run length code */
123                 rle_code = -rle_code;
124                 /* get the next 4 bytes from the stream, treat them as palette
125                  * indices, and output them rle_code times */
126                 CHECK_STREAM_PTR(4);
127                 pi1 = ((s->buf[stream_ptr]) >> 4) & 0x0f;
128                 pi2 = (s->buf[stream_ptr++]) & 0x0f;
129                 pi3 = ((s->buf[stream_ptr]) >> 4) & 0x0f;
130                 pi4 = (s->buf[stream_ptr++]) & 0x0f;
131                 pi5 = ((s->buf[stream_ptr]) >> 4) & 0x0f;
132                 pi6 = (s->buf[stream_ptr++]) & 0x0f;
133                 pi7 = ((s->buf[stream_ptr]) >> 4) & 0x0f;
134                 pi8 = (s->buf[stream_ptr++]) & 0x0f;
135
136                 CHECK_PIXEL_PTR(rle_code * 8);
137
138                 while (rle_code--) {
139                     rgb[pixel_ptr++] = pi1;
140                     rgb[pixel_ptr++] = pi2;
141                     rgb[pixel_ptr++] = pi3;
142                     rgb[pixel_ptr++] = pi4;
143                     rgb[pixel_ptr++] = pi5;
144                     rgb[pixel_ptr++] = pi6;
145                     rgb[pixel_ptr++] = pi7;
146                     rgb[pixel_ptr++] = pi8;
147                 }
148             } else {
149                 /* copy the same pixel directly to output 4 times */
150                 rle_code *= 4;
151                 CHECK_STREAM_PTR(rle_code);
152                 CHECK_PIXEL_PTR(rle_code*2);
153
154                 while (rle_code--) {
155                     rgb[pixel_ptr++] = ((s->buf[stream_ptr]) >> 4) & 0x0f;
156                     rgb[pixel_ptr++] = (s->buf[stream_ptr++]) & 0x0f;
157                 }
158             }
159         }
160         row_ptr += row_inc;
161     }
162 }
163
164 static void qtrle_decode_8bpp(QtrleContext *s)
165 {
166     int stream_ptr;
167     int header;
168     int start_line;
169     int lines_to_change;
170     int rle_code;
171     int row_ptr, pixel_ptr;
172     int row_inc = s->frame.linesize[0];
173     unsigned char pi1, pi2, pi3, pi4;  /* 4 palette indices */
174     unsigned char *rgb = s->frame.data[0];
175     int pixel_limit = s->frame.linesize[0] * s->avctx->height;
176
177     /* check if this frame is even supposed to change */
178     if (s->size < 8)
179         return;
180
181     /* start after the chunk size */
182     stream_ptr = 4;
183
184     /* fetch the header */
185     CHECK_STREAM_PTR(2);
186     header = AV_RB16(&s->buf[stream_ptr]);
187     stream_ptr += 2;
188
189     /* if a header is present, fetch additional decoding parameters */
190     if (header & 0x0008) {
191         CHECK_STREAM_PTR(8);
192         start_line = AV_RB16(&s->buf[stream_ptr]);
193         stream_ptr += 4;
194         lines_to_change = AV_RB16(&s->buf[stream_ptr]);
195         stream_ptr += 4;
196     } else {
197         start_line = 0;
198         lines_to_change = s->avctx->height;
199     }
200
201     row_ptr = row_inc * start_line;
202     while (lines_to_change--) {
203         CHECK_STREAM_PTR(2);
204         pixel_ptr = row_ptr + (4 * (s->buf[stream_ptr++] - 1));
205
206         while ((rle_code = (signed char)s->buf[stream_ptr++]) != -1) {
207             if (rle_code == 0) {
208                 /* there's another skip code in the stream */
209                 CHECK_STREAM_PTR(1);
210                 pixel_ptr += (4 * (s->buf[stream_ptr++] - 1));
211                 CHECK_PIXEL_PTR(0);  /* make sure pixel_ptr is positive */
212             } else if (rle_code < 0) {
213                 /* decode the run length code */
214                 rle_code = -rle_code;
215                 /* get the next 4 bytes from the stream, treat them as palette
216                  * indices, and output them rle_code times */
217                 CHECK_STREAM_PTR(4);
218                 pi1 = s->buf[stream_ptr++];
219                 pi2 = s->buf[stream_ptr++];
220                 pi3 = s->buf[stream_ptr++];
221                 pi4 = s->buf[stream_ptr++];
222
223                 CHECK_PIXEL_PTR(rle_code * 4);
224
225                 while (rle_code--) {
226                     rgb[pixel_ptr++] = pi1;
227                     rgb[pixel_ptr++] = pi2;
228                     rgb[pixel_ptr++] = pi3;
229                     rgb[pixel_ptr++] = pi4;
230                 }
231             } else {
232                 /* copy the same pixel directly to output 4 times */
233                 rle_code *= 4;
234                 CHECK_STREAM_PTR(rle_code);
235                 CHECK_PIXEL_PTR(rle_code);
236
237                 while (rle_code--) {
238                     rgb[pixel_ptr++] = s->buf[stream_ptr++];
239                 }
240             }
241         }
242         row_ptr += row_inc;
243     }
244 }
245
246 static void qtrle_decode_16bpp(QtrleContext *s)
247 {
248     int stream_ptr;
249     int header;
250     int start_line;
251     int lines_to_change;
252     int rle_code;
253     int row_ptr, pixel_ptr;
254     int row_inc = s->frame.linesize[0];
255     unsigned short rgb16;
256     unsigned char *rgb = s->frame.data[0];
257     int pixel_limit = s->frame.linesize[0] * s->avctx->height;
258
259     /* check if this frame is even supposed to change */
260     if (s->size < 8)
261         return;
262
263     /* start after the chunk size */
264     stream_ptr = 4;
265
266     /* fetch the header */
267     CHECK_STREAM_PTR(2);
268     header = AV_RB16(&s->buf[stream_ptr]);
269     stream_ptr += 2;
270
271     /* if a header is present, fetch additional decoding parameters */
272     if (header & 0x0008) {
273         CHECK_STREAM_PTR(8);
274         start_line = AV_RB16(&s->buf[stream_ptr]);
275         stream_ptr += 4;
276         lines_to_change = AV_RB16(&s->buf[stream_ptr]);
277         stream_ptr += 4;
278     } else {
279         start_line = 0;
280         lines_to_change = s->avctx->height;
281     }
282
283     row_ptr = row_inc * start_line;
284     while (lines_to_change--) {
285         CHECK_STREAM_PTR(2);
286         pixel_ptr = row_ptr + (s->buf[stream_ptr++] - 1) * 2;
287
288         while ((rle_code = (signed char)s->buf[stream_ptr++]) != -1) {
289             if (rle_code == 0) {
290                 /* there's another skip code in the stream */
291                 CHECK_STREAM_PTR(1);
292                 pixel_ptr += (s->buf[stream_ptr++] - 1) * 2;
293                 CHECK_PIXEL_PTR(0);  /* make sure pixel_ptr is positive */
294             } else if (rle_code < 0) {
295                 /* decode the run length code */
296                 rle_code = -rle_code;
297                 CHECK_STREAM_PTR(2);
298                 rgb16 = AV_RB16(&s->buf[stream_ptr]);
299                 stream_ptr += 2;
300
301                 CHECK_PIXEL_PTR(rle_code * 2);
302
303                 while (rle_code--) {
304                     *(unsigned short *)(&rgb[pixel_ptr]) = rgb16;
305                     pixel_ptr += 2;
306                 }
307             } else {
308                 CHECK_STREAM_PTR(rle_code * 2);
309                 CHECK_PIXEL_PTR(rle_code * 2);
310
311                 /* copy pixels directly to output */
312                 while (rle_code--) {
313                     rgb16 = AV_RB16(&s->buf[stream_ptr]);
314                     stream_ptr += 2;
315                     *(unsigned short *)(&rgb[pixel_ptr]) = rgb16;
316                     pixel_ptr += 2;
317                 }
318             }
319         }
320         row_ptr += row_inc;
321     }
322 }
323
324 static void qtrle_decode_24bpp(QtrleContext *s)
325 {
326     int stream_ptr;
327     int header;
328     int start_line;
329     int lines_to_change;
330     int rle_code;
331     int row_ptr, pixel_ptr;
332     int row_inc = s->frame.linesize[0];
333     unsigned char r, g, b;
334     unsigned char *rgb = s->frame.data[0];
335     int pixel_limit = s->frame.linesize[0] * s->avctx->height;
336
337     /* check if this frame is even supposed to change */
338     if (s->size < 8)
339         return;
340
341     /* start after the chunk size */
342     stream_ptr = 4;
343
344     /* fetch the header */
345     CHECK_STREAM_PTR(2);
346     header = AV_RB16(&s->buf[stream_ptr]);
347     stream_ptr += 2;
348
349     /* if a header is present, fetch additional decoding parameters */
350     if (header & 0x0008) {
351         CHECK_STREAM_PTR(8);
352         start_line = AV_RB16(&s->buf[stream_ptr]);
353         stream_ptr += 4;
354         lines_to_change = AV_RB16(&s->buf[stream_ptr]);
355         stream_ptr += 4;
356     } else {
357         start_line = 0;
358         lines_to_change = s->avctx->height;
359     }
360
361     row_ptr = row_inc * start_line;
362     while (lines_to_change--) {
363         CHECK_STREAM_PTR(2);
364         pixel_ptr = row_ptr + (s->buf[stream_ptr++] - 1) * 3;
365
366         while ((rle_code = (signed char)s->buf[stream_ptr++]) != -1) {
367             if (rle_code == 0) {
368                 /* there's another skip code in the stream */
369                 CHECK_STREAM_PTR(1);
370                 pixel_ptr += (s->buf[stream_ptr++] - 1) * 3;
371                 CHECK_PIXEL_PTR(0);  /* make sure pixel_ptr is positive */
372             } else if (rle_code < 0) {
373                 /* decode the run length code */
374                 rle_code = -rle_code;
375                 CHECK_STREAM_PTR(3);
376                 r = s->buf[stream_ptr++];
377                 g = s->buf[stream_ptr++];
378                 b = s->buf[stream_ptr++];
379
380                 CHECK_PIXEL_PTR(rle_code * 3);
381
382                 while (rle_code--) {
383                     rgb[pixel_ptr++] = r;
384                     rgb[pixel_ptr++] = g;
385                     rgb[pixel_ptr++] = b;
386                 }
387             } else {
388                 CHECK_STREAM_PTR(rle_code * 3);
389                 CHECK_PIXEL_PTR(rle_code * 3);
390
391                 /* copy pixels directly to output */
392                 while (rle_code--) {
393                     rgb[pixel_ptr++] = s->buf[stream_ptr++];
394                     rgb[pixel_ptr++] = s->buf[stream_ptr++];
395                     rgb[pixel_ptr++] = s->buf[stream_ptr++];
396                 }
397             }
398         }
399         row_ptr += row_inc;
400     }
401 }
402
403 static void qtrle_decode_32bpp(QtrleContext *s)
404 {
405     int stream_ptr;
406     int header;
407     int start_line;
408     int lines_to_change;
409     int rle_code;
410     int row_ptr, pixel_ptr;
411     int row_inc = s->frame.linesize[0];
412     unsigned char a, r, g, b;
413     unsigned int argb;
414     unsigned char *rgb = s->frame.data[0];
415     int pixel_limit = s->frame.linesize[0] * s->avctx->height;
416
417     /* check if this frame is even supposed to change */
418     if (s->size < 8)
419         return;
420
421     /* start after the chunk size */
422     stream_ptr = 4;
423
424     /* fetch the header */
425     CHECK_STREAM_PTR(2);
426     header = AV_RB16(&s->buf[stream_ptr]);
427     stream_ptr += 2;
428
429     /* if a header is present, fetch additional decoding parameters */
430     if (header & 0x0008) {
431         CHECK_STREAM_PTR(8);
432         start_line = AV_RB16(&s->buf[stream_ptr]);
433         stream_ptr += 4;
434         lines_to_change = AV_RB16(&s->buf[stream_ptr]);
435         stream_ptr += 4;
436     } else {
437         start_line = 0;
438         lines_to_change = s->avctx->height;
439     }
440
441     row_ptr = row_inc * start_line;
442     while (lines_to_change--) {
443         CHECK_STREAM_PTR(2);
444         pixel_ptr = row_ptr + (s->buf[stream_ptr++] - 1) * 4;
445
446         while ((rle_code = (signed char)s->buf[stream_ptr++]) != -1) {
447             if (rle_code == 0) {
448                 /* there's another skip code in the stream */
449                 CHECK_STREAM_PTR(1);
450                 pixel_ptr += (s->buf[stream_ptr++] - 1) * 4;
451                 CHECK_PIXEL_PTR(0);  /* make sure pixel_ptr is positive */
452             } else if (rle_code < 0) {
453                 /* decode the run length code */
454                 rle_code = -rle_code;
455                 CHECK_STREAM_PTR(4);
456                 a = s->buf[stream_ptr++];
457                 r = s->buf[stream_ptr++];
458                 g = s->buf[stream_ptr++];
459                 b = s->buf[stream_ptr++];
460                 argb = (a << 24) | (r << 16) | (g << 8) | (b << 0);
461
462                 CHECK_PIXEL_PTR(rle_code * 4);
463
464                 while (rle_code--) {
465                     *(unsigned int *)(&rgb[pixel_ptr]) = argb;
466                     pixel_ptr += 4;
467                 }
468             } else {
469                 CHECK_STREAM_PTR(rle_code * 4);
470                 CHECK_PIXEL_PTR(rle_code * 4);
471
472                 /* copy pixels directly to output */
473                 while (rle_code--) {
474                     a = s->buf[stream_ptr++];
475                     r = s->buf[stream_ptr++];
476                     g = s->buf[stream_ptr++];
477                     b = s->buf[stream_ptr++];
478                     argb = (a << 24) | (r << 16) | (g << 8) | (b << 0);
479                     *(unsigned int *)(&rgb[pixel_ptr]) = argb;
480                     pixel_ptr += 4;
481                 }
482             }
483         }
484         row_ptr += row_inc;
485     }
486 }
487
488 static av_cold int qtrle_decode_init(AVCodecContext *avctx)
489 {
490     QtrleContext *s = avctx->priv_data;
491
492     s->avctx = avctx;
493     switch (avctx->bits_per_sample) {
494     case 1:
495     case 2:
496     case 4:
497     case 8:
498     case 33:
499     case 34:
500     case 36:
501     case 40:
502         avctx->pix_fmt = PIX_FMT_PAL8;
503         break;
504
505     case 16:
506         avctx->pix_fmt = PIX_FMT_RGB555;
507         break;
508
509     case 24:
510         avctx->pix_fmt = PIX_FMT_RGB24;
511         break;
512
513     case 32:
514         avctx->pix_fmt = PIX_FMT_RGB32;
515         break;
516
517     default:
518         av_log (avctx, AV_LOG_ERROR, "Unsupported colorspace: %d bits/sample?\n",
519             avctx->bits_per_sample);
520         break;
521     }
522
523     s->frame.data[0] = NULL;
524
525     return 0;
526 }
527
528 static int qtrle_decode_frame(AVCodecContext *avctx,
529                               void *data, int *data_size,
530                               const uint8_t *buf, int buf_size)
531 {
532     QtrleContext *s = avctx->priv_data;
533
534     s->buf = buf;
535     s->size = buf_size;
536
537     s->frame.reference = 1;
538     s->frame.buffer_hints = FF_BUFFER_HINTS_VALID | FF_BUFFER_HINTS_PRESERVE |
539                             FF_BUFFER_HINTS_REUSABLE | FF_BUFFER_HINTS_READABLE;
540     if (avctx->reget_buffer(avctx, &s->frame)) {
541         av_log (s->avctx, AV_LOG_ERROR, "reget_buffer() failed\n");
542         return -1;
543     }
544
545     switch (avctx->bits_per_sample) {
546     case 1:
547     case 33:
548         qtrle_decode_1bpp(s);
549         break;
550
551     case 2:
552     case 34:
553         qtrle_decode_2bpp(s);
554         break;
555
556     case 4:
557     case 36:
558         qtrle_decode_4bpp(s);
559         /* make the palette available on the way out */
560         memcpy(s->frame.data[1], s->avctx->palctrl->palette, AVPALETTE_SIZE);
561         if (s->avctx->palctrl->palette_changed) {
562             s->frame.palette_has_changed = 1;
563             s->avctx->palctrl->palette_changed = 0;
564         }
565         break;
566
567     case 8:
568     case 40:
569         qtrle_decode_8bpp(s);
570         /* make the palette available on the way out */
571         memcpy(s->frame.data[1], s->avctx->palctrl->palette, AVPALETTE_SIZE);
572         if (s->avctx->palctrl->palette_changed) {
573             s->frame.palette_has_changed = 1;
574             s->avctx->palctrl->palette_changed = 0;
575         }
576         break;
577
578     case 16:
579         qtrle_decode_16bpp(s);
580         break;
581
582     case 24:
583         qtrle_decode_24bpp(s);
584         break;
585
586     case 32:
587         qtrle_decode_32bpp(s);
588         break;
589
590     default:
591         av_log (s->avctx, AV_LOG_ERROR, "Unsupported colorspace: %d bits/sample?\n",
592             avctx->bits_per_sample);
593         break;
594     }
595
596     *data_size = sizeof(AVFrame);
597     *(AVFrame*)data = s->frame;
598
599     /* always report that the buffer was completely consumed */
600     return buf_size;
601 }
602
603 static av_cold int qtrle_decode_end(AVCodecContext *avctx)
604 {
605     QtrleContext *s = avctx->priv_data;
606
607     if (s->frame.data[0])
608         avctx->release_buffer(avctx, &s->frame);
609
610     return 0;
611 }
612
613 AVCodec qtrle_decoder = {
614     "qtrle",
615     CODEC_TYPE_VIDEO,
616     CODEC_ID_QTRLE,
617     sizeof(QtrleContext),
618     qtrle_decode_init,
619     NULL,
620     qtrle_decode_end,
621     qtrle_decode_frame,
622     CODEC_CAP_DR1,
623     .long_name = "QuickTime Animation (RLE) video",
624 };
625