avcodec/mpeg_er: fix clearing chroma blocks for 422 and 444
[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
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
38 #include "avcodec.h"
39 #include "bytestream.h"
40 #include "internal.h"
41
42 typedef struct QtrleContext {
43     AVCodecContext *avctx;
44     AVFrame *frame;
45
46     GetByteContext g;
47     uint32_t pal[256];
48 } QtrleContext;
49
50 #define CHECK_PIXEL_PTR(n)                                                            \
51     if ((pixel_ptr + n > pixel_limit) || (pixel_ptr + n < 0)) {                       \
52         av_log (s->avctx, AV_LOG_ERROR, "Problem: pixel_ptr = %d, pixel_limit = %d\n",\
53                 pixel_ptr + n, pixel_limit);                                          \
54         return;                                                                       \
55     }                                                                                 \
56
57 static void qtrle_decode_1bpp(QtrleContext *s, int row_ptr, int lines_to_change)
58 {
59     int rle_code;
60     int pixel_ptr;
61     int row_inc = s->frame->linesize[0];
62     uint8_t pi0, pi1;  /* 2 8-pixel values */
63     uint8_t *rgb = s->frame->data[0];
64     int pixel_limit = s->frame->linesize[0] * s->avctx->height;
65     int skip;
66     /* skip & 0x80 appears to mean 'start a new line', which can be interpreted
67      * as 'go to next line' during the decoding of a frame but is 'go to first
68      * line' at the beginning. Since we always interpret it as 'go to next line'
69      * in the decoding loop (which makes code simpler/faster), the first line
70      * would not be counted, so we count one more.
71      * See: https://trac.ffmpeg.org/ticket/226
72      * In the following decoding loop, row_ptr will be the position of the
73      * current row. */
74
75     row_ptr  -= row_inc;
76     pixel_ptr = row_ptr;
77     lines_to_change++;
78     while (lines_to_change) {
79         skip     =              bytestream2_get_byte(&s->g);
80         rle_code = (int8_t)bytestream2_get_byte(&s->g);
81         if (rle_code == 0)
82             break;
83         if(skip & 0x80) {
84             lines_to_change--;
85             row_ptr += row_inc;
86             pixel_ptr = row_ptr + 2 * 8 * (skip & 0x7f);
87         } else
88             pixel_ptr += 2 * 8 * skip;
89         CHECK_PIXEL_PTR(0);  /* make sure pixel_ptr is positive */
90
91         if(rle_code == -1)
92             continue;
93
94         if (rle_code < 0) {
95             /* decode the run length code */
96             rle_code = -rle_code;
97             /* get the next 2 bytes from the stream, treat them as groups
98              * of 8 pixels, and output them rle_code times */
99
100             pi0 = bytestream2_get_byte(&s->g);
101             pi1 = bytestream2_get_byte(&s->g);
102             CHECK_PIXEL_PTR(rle_code * 2 * 8);
103
104             while (rle_code--) {
105                 rgb[pixel_ptr++] = (pi0 >> 7) & 0x01;
106                 rgb[pixel_ptr++] = (pi0 >> 6) & 0x01;
107                 rgb[pixel_ptr++] = (pi0 >> 5) & 0x01;
108                 rgb[pixel_ptr++] = (pi0 >> 4) & 0x01;
109                 rgb[pixel_ptr++] = (pi0 >> 3) & 0x01;
110                 rgb[pixel_ptr++] = (pi0 >> 2) & 0x01;
111                 rgb[pixel_ptr++] = (pi0 >> 1) & 0x01;
112                 rgb[pixel_ptr++] =  pi0       & 0x01;
113                 rgb[pixel_ptr++] = (pi1 >> 7) & 0x01;
114                 rgb[pixel_ptr++] = (pi1 >> 6) & 0x01;
115                 rgb[pixel_ptr++] = (pi1 >> 5) & 0x01;
116                 rgb[pixel_ptr++] = (pi1 >> 4) & 0x01;
117                 rgb[pixel_ptr++] = (pi1 >> 3) & 0x01;
118                 rgb[pixel_ptr++] = (pi1 >> 2) & 0x01;
119                 rgb[pixel_ptr++] = (pi1 >> 1) & 0x01;
120                 rgb[pixel_ptr++] =  pi1       & 0x01;
121             }
122         } else {
123             /* copy the same pixel directly to output 2 times */
124             rle_code *= 2;
125             CHECK_PIXEL_PTR(rle_code * 8);
126
127             while (rle_code--) {
128                 int x = bytestream2_get_byte(&s->g);
129                 rgb[pixel_ptr++] = (x >> 7) & 0x01;
130                 rgb[pixel_ptr++] = (x >> 6) & 0x01;
131                 rgb[pixel_ptr++] = (x >> 5) & 0x01;
132                 rgb[pixel_ptr++] = (x >> 4) & 0x01;
133                 rgb[pixel_ptr++] = (x >> 3) & 0x01;
134                 rgb[pixel_ptr++] = (x >> 2) & 0x01;
135                 rgb[pixel_ptr++] = (x >> 1) & 0x01;
136                 rgb[pixel_ptr++] =  x       & 0x01;
137             }
138         }
139     }
140 }
141
142 static inline void qtrle_decode_2n4bpp(QtrleContext *s, int row_ptr,
143                                        int lines_to_change, int bpp)
144 {
145     int rle_code, i;
146     int pixel_ptr;
147     int row_inc = s->frame->linesize[0];
148     uint8_t pi[16];  /* 16 palette indices */
149     uint8_t *rgb = s->frame->data[0];
150     int pixel_limit = s->frame->linesize[0] * s->avctx->height;
151     int num_pixels = (bpp == 4) ? 8 : 16;
152
153     while (lines_to_change--) {
154         pixel_ptr = row_ptr + (num_pixels * (bytestream2_get_byte(&s->g) - 1));
155         CHECK_PIXEL_PTR(0);
156
157         while ((rle_code = (int8_t)bytestream2_get_byte(&s->g)) != -1) {
158             if (bytestream2_get_bytes_left(&s->g) < 1)
159                 return;
160             if (rle_code == 0) {
161                 /* there's another skip code in the stream */
162                 pixel_ptr += (num_pixels * (bytestream2_get_byte(&s->g) - 1));
163                 CHECK_PIXEL_PTR(0);  /* make sure pixel_ptr is positive */
164             } else if (rle_code < 0) {
165                 /* decode the run length code */
166                 rle_code = -rle_code;
167                 /* get the next 4 bytes from the stream, treat them as palette
168                  * indexes, and output them rle_code times */
169                 for (i = num_pixels-1; i >= 0; i--) {
170                     pi[num_pixels-1-i] = (bytestream2_peek_byte(&s->g) >> ((i*bpp) & 0x07)) & ((1<<bpp)-1);
171                     bytestream2_skip(&s->g, ((i & ((num_pixels>>2)-1)) == 0));
172                 }
173                 CHECK_PIXEL_PTR(rle_code * num_pixels);
174                 while (rle_code--) {
175                     memcpy(&rgb[pixel_ptr], &pi, num_pixels);
176                     pixel_ptr += num_pixels;
177                 }
178             } else {
179                 /* copy the same pixel directly to output 4 times */
180                 rle_code *= 4;
181                 CHECK_PIXEL_PTR(rle_code*(num_pixels>>2));
182                 while (rle_code--) {
183                     if(bpp == 4) {
184                         int x = bytestream2_get_byte(&s->g);
185                         rgb[pixel_ptr++] = (x >> 4) & 0x0f;
186                         rgb[pixel_ptr++] =  x       & 0x0f;
187                     } else {
188                         int x = bytestream2_get_byte(&s->g);
189                         rgb[pixel_ptr++] = (x >> 6) & 0x03;
190                         rgb[pixel_ptr++] = (x >> 4) & 0x03;
191                         rgb[pixel_ptr++] = (x >> 2) & 0x03;
192                         rgb[pixel_ptr++] =  x       & 0x03;
193                     }
194                 }
195             }
196         }
197         row_ptr += row_inc;
198     }
199 }
200
201 static void qtrle_decode_8bpp(QtrleContext *s, int row_ptr, int lines_to_change)
202 {
203     int rle_code;
204     int pixel_ptr;
205     int row_inc = s->frame->linesize[0];
206     uint8_t pi1, pi2, pi3, pi4;  /* 4 palette indexes */
207     uint8_t *rgb = s->frame->data[0];
208     int pixel_limit = s->frame->linesize[0] * s->avctx->height;
209
210     while (lines_to_change--) {
211         pixel_ptr = row_ptr + (4 * (bytestream2_get_byte(&s->g) - 1));
212         CHECK_PIXEL_PTR(0);
213
214         while ((rle_code = (int8_t)bytestream2_get_byte(&s->g)) != -1) {
215             if (bytestream2_get_bytes_left(&s->g) < 1)
216                 return;
217             if (rle_code == 0) {
218                 /* there's another skip code in the stream */
219                 pixel_ptr += (4 * (bytestream2_get_byte(&s->g) - 1));
220                 CHECK_PIXEL_PTR(0);  /* make sure pixel_ptr is positive */
221             } else if (rle_code < 0) {
222                 /* decode the run length code */
223                 rle_code = -rle_code;
224                 /* get the next 4 bytes from the stream, treat them as palette
225                  * indexes, and output them rle_code times */
226                 pi1 = bytestream2_get_byte(&s->g);
227                 pi2 = bytestream2_get_byte(&s->g);
228                 pi3 = bytestream2_get_byte(&s->g);
229                 pi4 = bytestream2_get_byte(&s->g);
230
231                 CHECK_PIXEL_PTR(rle_code * 4);
232
233                 while (rle_code--) {
234                     rgb[pixel_ptr++] = pi1;
235                     rgb[pixel_ptr++] = pi2;
236                     rgb[pixel_ptr++] = pi3;
237                     rgb[pixel_ptr++] = pi4;
238                 }
239             } else {
240                 /* copy the same pixel directly to output 4 times */
241                 rle_code *= 4;
242                 CHECK_PIXEL_PTR(rle_code);
243
244                 bytestream2_get_buffer(&s->g, &rgb[pixel_ptr], rle_code);
245                 pixel_ptr += rle_code;
246             }
247         }
248         row_ptr += row_inc;
249     }
250 }
251
252 static void qtrle_decode_16bpp(QtrleContext *s, int row_ptr, int lines_to_change)
253 {
254     int rle_code;
255     int pixel_ptr;
256     int row_inc = s->frame->linesize[0];
257     uint16_t rgb16;
258     uint8_t *rgb = s->frame->data[0];
259     int pixel_limit = s->frame->linesize[0] * s->avctx->height;
260
261     while (lines_to_change--) {
262         pixel_ptr = row_ptr + (bytestream2_get_byte(&s->g) - 1) * 2;
263         CHECK_PIXEL_PTR(0);
264
265         while ((rle_code = (int8_t)bytestream2_get_byte(&s->g)) != -1) {
266             if (bytestream2_get_bytes_left(&s->g) < 1)
267                 return;
268             if (rle_code == 0) {
269                 /* there's another skip code in the stream */
270                 pixel_ptr += (bytestream2_get_byte(&s->g) - 1) * 2;
271                 CHECK_PIXEL_PTR(0);  /* make sure pixel_ptr is positive */
272             } else if (rle_code < 0) {
273                 /* decode the run length code */
274                 rle_code = -rle_code;
275                 rgb16 = bytestream2_get_be16(&s->g);
276
277                 CHECK_PIXEL_PTR(rle_code * 2);
278
279                 while (rle_code--) {
280                     *(uint16_t *)(&rgb[pixel_ptr]) = rgb16;
281                     pixel_ptr += 2;
282                 }
283             } else {
284                 CHECK_PIXEL_PTR(rle_code * 2);
285
286                 /* copy pixels directly to output */
287                 while (rle_code--) {
288                     rgb16 = bytestream2_get_be16(&s->g);
289                     *(uint16_t *)(&rgb[pixel_ptr]) = rgb16;
290                     pixel_ptr += 2;
291                 }
292             }
293         }
294         row_ptr += row_inc;
295     }
296 }
297
298 static void qtrle_decode_24bpp(QtrleContext *s, int row_ptr, int lines_to_change)
299 {
300     int rle_code;
301     int pixel_ptr;
302     int row_inc = s->frame->linesize[0];
303     uint8_t r, g, b;
304     uint8_t *rgb = s->frame->data[0];
305     int pixel_limit = s->frame->linesize[0] * s->avctx->height;
306
307     while (lines_to_change--) {
308         pixel_ptr = row_ptr + (bytestream2_get_byte(&s->g) - 1) * 3;
309         CHECK_PIXEL_PTR(0);
310
311         while ((rle_code = (int8_t)bytestream2_get_byte(&s->g)) != -1) {
312             if (bytestream2_get_bytes_left(&s->g) < 1)
313                 return;
314             if (rle_code == 0) {
315                 /* there's another skip code in the stream */
316                 pixel_ptr += (bytestream2_get_byte(&s->g) - 1) * 3;
317                 CHECK_PIXEL_PTR(0);  /* make sure pixel_ptr is positive */
318             } else if (rle_code < 0) {
319                 /* decode the run length code */
320                 rle_code = -rle_code;
321                 r = bytestream2_get_byte(&s->g);
322                 g = bytestream2_get_byte(&s->g);
323                 b = bytestream2_get_byte(&s->g);
324
325                 CHECK_PIXEL_PTR(rle_code * 3);
326
327                 while (rle_code--) {
328                     rgb[pixel_ptr++] = r;
329                     rgb[pixel_ptr++] = g;
330                     rgb[pixel_ptr++] = b;
331                 }
332             } else {
333                 CHECK_PIXEL_PTR(rle_code * 3);
334
335                 /* copy pixels directly to output */
336                 while (rle_code--) {
337                     rgb[pixel_ptr++] = bytestream2_get_byte(&s->g);
338                     rgb[pixel_ptr++] = bytestream2_get_byte(&s->g);
339                     rgb[pixel_ptr++] = bytestream2_get_byte(&s->g);
340                 }
341             }
342         }
343         row_ptr += row_inc;
344     }
345 }
346
347 static void qtrle_decode_32bpp(QtrleContext *s, int row_ptr, int lines_to_change)
348 {
349     int rle_code;
350     int pixel_ptr;
351     int row_inc = s->frame->linesize[0];
352     unsigned int argb;
353     uint8_t *rgb = s->frame->data[0];
354     int pixel_limit = s->frame->linesize[0] * s->avctx->height;
355
356     while (lines_to_change--) {
357         pixel_ptr = row_ptr + (bytestream2_get_byte(&s->g) - 1) * 4;
358         CHECK_PIXEL_PTR(0);
359
360         while ((rle_code = (int8_t)bytestream2_get_byte(&s->g)) != -1) {
361             if (bytestream2_get_bytes_left(&s->g) < 1)
362                 return;
363             if (rle_code == 0) {
364                 /* there's another skip code in the stream */
365                 pixel_ptr += (bytestream2_get_byte(&s->g) - 1) * 4;
366                 CHECK_PIXEL_PTR(0);  /* make sure pixel_ptr is positive */
367             } else if (rle_code < 0) {
368                 /* decode the run length code */
369                 rle_code = -rle_code;
370                 argb = bytestream2_get_be32(&s->g);
371
372                 CHECK_PIXEL_PTR(rle_code * 4);
373
374                 while (rle_code--) {
375                     AV_WN32A(rgb + pixel_ptr, argb);
376                     pixel_ptr += 4;
377                 }
378             } else {
379                 CHECK_PIXEL_PTR(rle_code * 4);
380
381                 /* copy pixels directly to output */
382                 while (rle_code--) {
383                     argb = bytestream2_get_be32(&s->g);
384                     AV_WN32A(rgb + pixel_ptr, argb);
385                     pixel_ptr  += 4;
386                 }
387             }
388         }
389         row_ptr += row_inc;
390     }
391 }
392
393 static av_cold int qtrle_decode_init(AVCodecContext *avctx)
394 {
395     QtrleContext *s = avctx->priv_data;
396
397     s->avctx = avctx;
398     switch (avctx->bits_per_coded_sample) {
399     case 1:
400     case 2:
401     case 4:
402     case 8:
403     case 33:
404     case 34:
405     case 36:
406     case 40:
407         avctx->pix_fmt = AV_PIX_FMT_PAL8;
408         break;
409
410     case 16:
411         avctx->pix_fmt = AV_PIX_FMT_RGB555;
412         break;
413
414     case 24:
415         avctx->pix_fmt = AV_PIX_FMT_RGB24;
416         break;
417
418     case 32:
419         avctx->pix_fmt = AV_PIX_FMT_RGB32;
420         break;
421
422     default:
423         av_log (avctx, AV_LOG_ERROR, "Unsupported colorspace: %d bits/sample?\n",
424             avctx->bits_per_coded_sample);
425         return AVERROR_INVALIDDATA;
426     }
427
428     s->frame = av_frame_alloc();
429     if (!s->frame)
430         return AVERROR(ENOMEM);
431
432     return 0;
433 }
434
435 static int qtrle_decode_frame(AVCodecContext *avctx,
436                               void *data, int *got_frame,
437                               AVPacket *avpkt)
438 {
439     QtrleContext *s = avctx->priv_data;
440     int header, start_line;
441     int height, row_ptr;
442     int has_palette = 0;
443     int ret;
444
445     bytestream2_init(&s->g, avpkt->data, avpkt->size);
446
447     /* check if this frame is even supposed to change */
448     if (avpkt->size < 8)
449         return avpkt->size;
450
451     /* start after the chunk size */
452     bytestream2_seek(&s->g, 4, SEEK_SET);
453
454     /* fetch the header */
455     header = bytestream2_get_be16(&s->g);
456
457     /* if a header is present, fetch additional decoding parameters */
458     if (header & 0x0008) {
459         if (avpkt->size < 14)
460             return avpkt->size;
461         start_line = bytestream2_get_be16(&s->g);
462         bytestream2_skip(&s->g, 2);
463         height     = bytestream2_get_be16(&s->g);
464         bytestream2_skip(&s->g, 2);
465         if (height > s->avctx->height - start_line)
466             return avpkt->size;
467     } else {
468         start_line = 0;
469         height     = s->avctx->height;
470     }
471     if ((ret = ff_reget_buffer(avctx, s->frame)) < 0)
472         return ret;
473
474     row_ptr = s->frame->linesize[0] * start_line;
475
476     switch (avctx->bits_per_coded_sample) {
477     case 1:
478     case 33:
479         qtrle_decode_1bpp(s, row_ptr, height);
480         has_palette = 1;
481         break;
482
483     case 2:
484     case 34:
485         qtrle_decode_2n4bpp(s, row_ptr, height, 2);
486         has_palette = 1;
487         break;
488
489     case 4:
490     case 36:
491         qtrle_decode_2n4bpp(s, row_ptr, height, 4);
492         has_palette = 1;
493         break;
494
495     case 8:
496     case 40:
497         qtrle_decode_8bpp(s, row_ptr, height);
498         has_palette = 1;
499         break;
500
501     case 16:
502         qtrle_decode_16bpp(s, row_ptr, height);
503         break;
504
505     case 24:
506         qtrle_decode_24bpp(s, row_ptr, height);
507         break;
508
509     case 32:
510         qtrle_decode_32bpp(s, row_ptr, height);
511         break;
512
513     default:
514         av_log (s->avctx, AV_LOG_ERROR, "Unsupported colorspace: %d bits/sample?\n",
515             avctx->bits_per_coded_sample);
516         break;
517     }
518
519     if(has_palette) {
520         int size;
521         const uint8_t *pal = av_packet_get_side_data(avpkt, AV_PKT_DATA_PALETTE, &size);
522
523         if (pal && size == AVPALETTE_SIZE) {
524             s->frame->palette_has_changed = 1;
525             memcpy(s->pal, pal, AVPALETTE_SIZE);
526         } else if (pal) {
527             av_log(avctx, AV_LOG_ERROR, "Palette size %d is wrong\n", size);
528         }
529
530         /* make the palette available on the way out */
531         memcpy(s->frame->data[1], s->pal, AVPALETTE_SIZE);
532     }
533
534     if ((ret = av_frame_ref(data, s->frame)) < 0)
535         return ret;
536     *got_frame      = 1;
537
538     /* always report that the buffer was completely consumed */
539     return avpkt->size;
540 }
541
542 static av_cold int qtrle_decode_end(AVCodecContext *avctx)
543 {
544     QtrleContext *s = avctx->priv_data;
545
546     av_frame_free(&s->frame);
547
548     return 0;
549 }
550
551 AVCodec ff_qtrle_decoder = {
552     .name           = "qtrle",
553     .long_name      = NULL_IF_CONFIG_SMALL("QuickTime Animation (RLE) video"),
554     .type           = AVMEDIA_TYPE_VIDEO,
555     .id             = AV_CODEC_ID_QTRLE,
556     .priv_data_size = sizeof(QtrleContext),
557     .init           = qtrle_decode_init,
558     .close          = qtrle_decode_end,
559     .decode         = qtrle_decode_frame,
560     .capabilities   = AV_CODEC_CAP_DR1,
561 };