1 /* GStreamer
2 * Copyright (C) <1999> Erik Walthinsen <omega@temple-baptist.com>
3 * Copyright (C) <2016> Matthew Waters <matthew@centricular.com>
4 *
5 * This library is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU Library General Public
7 * License as published by the Free Software Foundation; either
8 * version 2 of the License, or (at your option) any later version.
9 *
10 * This library is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 * Library General Public License for more details.
14 *
15 * You should have received a copy of the GNU Library General Public
16 * License along with this library; if not, write to the
17 * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
18 * Boston, MA 02110-1301, USA.
19 */
20 /**
21 * SECTION:element-flxdec
22 *
23 * This element decodes fli/flc/flx-video into raw video
24 */
25 /*
26 * http://www.coolutils.com/Formats/FLI
27 * http://woodshole.er.usgs.gov/operations/modeling/flc.html
28 * http://www.compuphase.com/flic.htm
29 */
30
31 #ifdef HAVE_CONFIG_H
32 #include "config.h"
33 #endif
34 #include <string.h>
35
36 #include "flx_fmt.h"
37 #include "gstflxdec.h"
38 #include <gst/video/video.h>
39
40 #define JIFFIE (GST_SECOND/70)
41
42 GST_DEBUG_CATEGORY_STATIC (flxdec_debug);
43 #define GST_CAT_DEFAULT flxdec_debug
44
45 /* input */
46 static GstStaticPadTemplate sink_factory = GST_STATIC_PAD_TEMPLATE ("sink",
47 GST_PAD_SINK,
48 GST_PAD_ALWAYS,
49 GST_STATIC_CAPS ("video/x-fli")
50 );
51
52 #if G_BYTE_ORDER == G_BIG_ENDIAN
53 #define RGB_ORDER "xRGB"
54 #else
55 #define RGB_ORDER "BGRx"
56 #endif
57
58 /* output */
59 static GstStaticPadTemplate src_video_factory = GST_STATIC_PAD_TEMPLATE ("src",
60 GST_PAD_SRC,
61 GST_PAD_ALWAYS,
62 GST_STATIC_CAPS (GST_VIDEO_CAPS_MAKE (RGB_ORDER))
63 );
64
65 static void gst_flxdec_dispose (GstFlxDec * flxdec);
66
67 static GstFlowReturn gst_flxdec_chain (GstPad * pad, GstObject * parent,
68 GstBuffer * buf);
69 static gboolean gst_flxdec_sink_event_handler (GstPad * pad,
70 GstObject * parent, GstEvent * event);
71
72 static GstStateChangeReturn gst_flxdec_change_state (GstElement * element,
73 GstStateChange transition);
74
75 static gboolean gst_flxdec_src_query_handler (GstPad * pad, GstObject * parent,
76 GstQuery * query);
77
78 static gboolean flx_decode_color (GstFlxDec * flxdec, GstByteReader * reader,
79 GstByteWriter * writer, gint scale);
80 static gboolean flx_decode_brun (GstFlxDec * flxdec,
81 GstByteReader * reader, GstByteWriter * writer);
82 static gboolean flx_decode_delta_fli (GstFlxDec * flxdec,
83 GstByteReader * reader, GstByteWriter * writer);
84 static gboolean flx_decode_delta_flc (GstFlxDec * flxdec,
85 GstByteReader * reader, GstByteWriter * writer);
86
87 #define rndalign(off) ((off) + ((off) & 1))
88
89 #define gst_flxdec_parent_class parent_class
90 G_DEFINE_TYPE (GstFlxDec, gst_flxdec, GST_TYPE_ELEMENT);
91
92 static void
gst_flxdec_class_init(GstFlxDecClass * klass)93 gst_flxdec_class_init (GstFlxDecClass * klass)
94 {
95 GObjectClass *gobject_class;
96 GstElementClass *gstelement_class;
97
98 gobject_class = (GObjectClass *) klass;
99 gstelement_class = (GstElementClass *) klass;
100
101 parent_class = g_type_class_peek_parent (klass);
102
103 gobject_class->dispose = (GObjectFinalizeFunc) gst_flxdec_dispose;
104
105 GST_DEBUG_CATEGORY_INIT (flxdec_debug, "flxdec", 0, "FLX video decoder");
106
107 gstelement_class->change_state = GST_DEBUG_FUNCPTR (gst_flxdec_change_state);
108
109 gst_element_class_set_static_metadata (gstelement_class, "FLX video decoder",
110 "Codec/Decoder/Video",
111 "FLC/FLI/FLX video decoder",
112 "Sepp Wijnands <mrrazz@garbage-coderz.net>, Zeeshan Ali <zeenix@gmail.com>");
113 gst_element_class_add_pad_template (gstelement_class,
114 gst_static_pad_template_get (&sink_factory));
115 gst_element_class_add_pad_template (gstelement_class,
116 gst_static_pad_template_get (&src_video_factory));
117 }
118
119 static void
gst_flxdec_init(GstFlxDec * flxdec)120 gst_flxdec_init (GstFlxDec * flxdec)
121 {
122 flxdec->sinkpad = gst_pad_new_from_static_template (&sink_factory, "sink");
123 gst_element_add_pad (GST_ELEMENT (flxdec), flxdec->sinkpad);
124 gst_pad_set_chain_function (flxdec->sinkpad,
125 GST_DEBUG_FUNCPTR (gst_flxdec_chain));
126 gst_pad_set_event_function (flxdec->sinkpad,
127 GST_DEBUG_FUNCPTR (gst_flxdec_sink_event_handler));
128
129 flxdec->srcpad = gst_pad_new_from_static_template (&src_video_factory, "src");
130 gst_element_add_pad (GST_ELEMENT (flxdec), flxdec->srcpad);
131 gst_pad_set_query_function (flxdec->srcpad,
132 GST_DEBUG_FUNCPTR (gst_flxdec_src_query_handler));
133
134 gst_pad_use_fixed_caps (flxdec->srcpad);
135
136 flxdec->adapter = gst_adapter_new ();
137 }
138
139 static void
gst_flxdec_dispose(GstFlxDec * flxdec)140 gst_flxdec_dispose (GstFlxDec * flxdec)
141 {
142 if (flxdec->adapter) {
143 g_object_unref (flxdec->adapter);
144 flxdec->adapter = NULL;
145 }
146
147 G_OBJECT_CLASS (parent_class)->dispose ((GObject *) flxdec);
148 }
149
150 static gboolean
gst_flxdec_src_query_handler(GstPad * pad,GstObject * parent,GstQuery * query)151 gst_flxdec_src_query_handler (GstPad * pad, GstObject * parent,
152 GstQuery * query)
153 {
154 GstFlxDec *flxdec = (GstFlxDec *) parent;
155 gboolean ret = FALSE;
156
157 switch (GST_QUERY_TYPE (query)) {
158 case GST_QUERY_DURATION:
159 {
160 GstFormat format;
161
162 gst_query_parse_duration (query, &format, NULL);
163
164 if (format != GST_FORMAT_TIME)
165 goto done;
166
167 gst_query_set_duration (query, format, flxdec->duration);
168
169 ret = TRUE;
170 }
171 default:
172 break;
173 }
174 done:
175 if (!ret)
176 ret = gst_pad_query_default (pad, parent, query);
177
178 return ret;
179 }
180
181 static gboolean
gst_flxdec_sink_event_handler(GstPad * pad,GstObject * parent,GstEvent * event)182 gst_flxdec_sink_event_handler (GstPad * pad, GstObject * parent,
183 GstEvent * event)
184 {
185 GstFlxDec *flxdec;
186 gboolean ret;
187
188 flxdec = GST_FLXDEC (parent);
189
190 switch (GST_EVENT_TYPE (event)) {
191 case GST_EVENT_SEGMENT:
192 {
193 gst_event_copy_segment (event, &flxdec->segment);
194 if (flxdec->segment.format != GST_FORMAT_TIME) {
195 GST_DEBUG_OBJECT (flxdec, "generating TIME segment");
196 gst_segment_init (&flxdec->segment, GST_FORMAT_TIME);
197 gst_event_unref (event);
198 event = gst_event_new_segment (&flxdec->segment);
199 }
200
201 if (gst_pad_has_current_caps (flxdec->srcpad)) {
202 ret = gst_pad_event_default (pad, parent, event);
203 } else {
204 flxdec->need_segment = TRUE;
205 gst_event_unref (event);
206 ret = TRUE;
207 }
208 break;
209 }
210 case GST_EVENT_FLUSH_STOP:
211 gst_segment_init (&flxdec->segment, GST_FORMAT_UNDEFINED);
212 ret = gst_pad_event_default (pad, parent, event);
213 break;
214 default:
215 ret = gst_pad_event_default (pad, parent, event);
216 break;
217 }
218
219 return ret;
220 }
221
222 static gboolean
flx_decode_chunks(GstFlxDec * flxdec,gulong n_chunks,GstByteReader * reader,GstByteWriter * writer)223 flx_decode_chunks (GstFlxDec * flxdec, gulong n_chunks, GstByteReader * reader,
224 GstByteWriter * writer)
225 {
226 gboolean ret = TRUE;
227
228 while (n_chunks--) {
229 GstByteReader chunk;
230 guint32 size;
231 guint16 type;
232
233 if (!gst_byte_reader_get_uint32_le (reader, &size))
234 goto parse_error;
235 if (!gst_byte_reader_get_uint16_le (reader, &type))
236 goto parse_error;
237 GST_LOG_OBJECT (flxdec, "chunk has type 0x%02x size %d", type, size);
238
239 if (!gst_byte_reader_get_sub_reader (reader, &chunk,
240 size - FlxFrameChunkSize)) {
241 GST_ERROR_OBJECT (flxdec, "Incorrect size in the chunk header");
242 goto error;
243 }
244
245 switch (type) {
246 case FLX_COLOR64:
247 ret = flx_decode_color (flxdec, &chunk, writer, 2);
248 break;
249
250 case FLX_COLOR256:
251 ret = flx_decode_color (flxdec, &chunk, writer, 0);
252 break;
253
254 case FLX_BRUN:
255 ret = flx_decode_brun (flxdec, &chunk, writer);
256 break;
257
258 case FLX_LC:
259 ret = flx_decode_delta_fli (flxdec, &chunk, writer);
260 break;
261
262 case FLX_SS2:
263 ret = flx_decode_delta_flc (flxdec, &chunk, writer);
264 break;
265
266 case FLX_BLACK:
267 ret = gst_byte_writer_fill (writer, 0, flxdec->size);
268 break;
269
270 case FLX_MINI:
271 break;
272
273 default:
274 GST_WARNING ("Unimplemented chunk type: 0x%02x size: %d - skipping",
275 type, size);
276 break;
277 }
278
279 if (!ret)
280 break;
281 }
282
283 return ret;
284
285 parse_error:
286 GST_ERROR_OBJECT (flxdec, "Failed to decode chunk");
287 error:
288 return FALSE;
289 }
290
291
292 static gboolean
flx_decode_color(GstFlxDec * flxdec,GstByteReader * reader,GstByteWriter * writer,gint scale)293 flx_decode_color (GstFlxDec * flxdec, GstByteReader * reader,
294 GstByteWriter * writer, gint scale)
295 {
296 guint8 count, indx;
297 guint16 packs;
298
299 if (!gst_byte_reader_get_uint16_le (reader, &packs))
300 goto error;
301 indx = 0;
302
303 GST_LOG ("GstFlxDec: cmap packs: %d", (guint) packs);
304 while (packs--) {
305 const guint8 *data;
306 guint16 actual_count;
307
308 /* color map index + skip count */
309 if (!gst_byte_reader_get_uint8 (reader, &indx))
310 goto error;
311
312 /* number of rgb triplets */
313 if (!gst_byte_reader_get_uint8 (reader, &count))
314 goto error;
315
316 actual_count = count == 0 ? 256 : count;
317
318 if (!gst_byte_reader_get_data (reader, count * 3, &data))
319 goto error;
320
321 GST_LOG_OBJECT (flxdec, "cmap count: %d (indx: %d)", actual_count, indx);
322 flx_set_palette_vector (flxdec->converter, indx, actual_count,
323 (guchar *) data, scale);
324 }
325
326 return TRUE;
327
328 error:
329 GST_ERROR_OBJECT (flxdec, "Error decoding color palette");
330 return FALSE;
331 }
332
333 static gboolean
flx_decode_brun(GstFlxDec * flxdec,GstByteReader * reader,GstByteWriter * writer)334 flx_decode_brun (GstFlxDec * flxdec, GstByteReader * reader,
335 GstByteWriter * writer)
336 {
337 gulong lines, row;
338
339 g_return_val_if_fail (flxdec != NULL, FALSE);
340
341 lines = flxdec->hdr.height;
342 while (lines--) {
343 /* packet count.
344 * should not be used anymore, since the flc format can
345 * contain more then 255 RLE packets. we use the frame
346 * width instead.
347 */
348 if (!gst_byte_reader_skip (reader, 1))
349 goto error;
350
351 row = flxdec->hdr.width;
352 while (row) {
353 gint8 count;
354
355 if (!gst_byte_reader_get_int8 (reader, &count))
356 goto error;
357
358 if (count <= 0) {
359 const guint8 *data;
360
361 /* literal run */
362 count = ABS (count);
363
364 GST_LOG_OBJECT (flxdec, "have literal run of size %d", count);
365
366 if (count > row) {
367 GST_ERROR_OBJECT (flxdec, "Invalid BRUN line detected. "
368 "bytes to write exceeds the end of the row");
369 return FALSE;
370 }
371 row -= count;
372
373 if (!gst_byte_reader_get_data (reader, count, &data))
374 goto error;
375 if (!gst_byte_writer_put_data (writer, data, count))
376 goto error;
377 } else {
378 guint8 x;
379
380 GST_LOG_OBJECT (flxdec, "have replicate run of size %d", count);
381
382 if (count > row) {
383 GST_ERROR_OBJECT (flxdec, "Invalid BRUN packet detected."
384 "bytes to write exceeds the end of the row");
385 return FALSE;
386 }
387
388 /* replicate run */
389 row -= count;
390
391 if (!gst_byte_reader_get_uint8 (reader, &x))
392 goto error;
393 if (!gst_byte_writer_fill (writer, x, count))
394 goto error;
395 }
396 }
397 }
398
399 return TRUE;
400
401 error:
402 GST_ERROR_OBJECT (flxdec, "Failed to decode BRUN packet");
403 return FALSE;
404 }
405
406 static gboolean
flx_decode_delta_fli(GstFlxDec * flxdec,GstByteReader * reader,GstByteWriter * writer)407 flx_decode_delta_fli (GstFlxDec * flxdec, GstByteReader * reader,
408 GstByteWriter * writer)
409 {
410 guint16 start_line, lines;
411 guint line_start_i;
412
413 g_return_val_if_fail (flxdec != NULL, FALSE);
414 g_return_val_if_fail (flxdec->delta_data != NULL, FALSE);
415
416 /* use last frame for delta */
417 if (!gst_byte_writer_put_data (writer, flxdec->delta_data, flxdec->size))
418 goto error;
419
420 if (!gst_byte_reader_get_uint16_le (reader, &start_line))
421 goto error;
422 if (!gst_byte_reader_get_uint16_le (reader, &lines))
423 goto error;
424 GST_LOG_OBJECT (flxdec, "height %d start line %d line count %d",
425 flxdec->hdr.height, start_line, lines);
426
427 if (start_line + lines > flxdec->hdr.height) {
428 GST_ERROR_OBJECT (flxdec, "Invalid FLI packet detected. too many lines.");
429 return FALSE;
430 }
431
432 line_start_i = flxdec->hdr.width * start_line;
433 if (!gst_byte_writer_set_pos (writer, line_start_i))
434 goto error;
435
436 while (lines--) {
437 guint8 packets;
438
439 /* packet count */
440 if (!gst_byte_reader_get_uint8 (reader, &packets))
441 goto error;
442 GST_LOG_OBJECT (flxdec, "have %d packets", packets);
443
444 while (packets--) {
445 /* skip count */
446 guint8 skip;
447 gint8 count;
448 if (!gst_byte_reader_get_uint8 (reader, &skip))
449 goto error;
450
451 /* skip bytes */
452 if (!gst_byte_writer_set_pos (writer,
453 gst_byte_writer_get_pos (writer) + skip))
454 goto error;
455
456 /* RLE count */
457 if (!gst_byte_reader_get_int8 (reader, &count))
458 goto error;
459
460 if (count < 0) {
461 guint8 x;
462
463 /* literal run */
464 count = ABS (count);
465 GST_LOG_OBJECT (flxdec, "have literal run of size %d at offset %d",
466 count, skip);
467
468 if (skip + count > flxdec->hdr.width) {
469 GST_ERROR_OBJECT (flxdec, "Invalid FLI packet detected. "
470 "line too long.");
471 return FALSE;
472 }
473
474 if (!gst_byte_reader_get_uint8 (reader, &x))
475 goto error;
476 if (!gst_byte_writer_fill (writer, x, count))
477 goto error;
478 } else {
479 const guint8 *data;
480
481 GST_LOG_OBJECT (flxdec, "have replicate run of size %d at offset %d",
482 count, skip);
483
484 if (skip + count > flxdec->hdr.width) {
485 GST_ERROR_OBJECT (flxdec, "Invalid FLI packet detected. "
486 "line too long.");
487 return FALSE;
488 }
489
490 /* replicate run */
491 if (!gst_byte_reader_get_data (reader, count, &data))
492 goto error;
493 if (!gst_byte_writer_put_data (writer, data, count))
494 goto error;
495 }
496 }
497 line_start_i += flxdec->hdr.width;
498 if (!gst_byte_writer_set_pos (writer, line_start_i))
499 goto error;
500 }
501
502 return TRUE;
503
504 error:
505 GST_ERROR_OBJECT (flxdec, "Failed to decode FLI packet");
506 return FALSE;
507 }
508
509 static gboolean
flx_decode_delta_flc(GstFlxDec * flxdec,GstByteReader * reader,GstByteWriter * writer)510 flx_decode_delta_flc (GstFlxDec * flxdec, GstByteReader * reader,
511 GstByteWriter * writer)
512 {
513 guint16 lines, start_l;
514
515 g_return_val_if_fail (flxdec != NULL, FALSE);
516 g_return_val_if_fail (flxdec->delta_data != NULL, FALSE);
517
518 /* use last frame for delta */
519 if (!gst_byte_writer_put_data (writer, flxdec->delta_data, flxdec->size))
520 goto error;
521 if (!gst_byte_reader_get_uint16_le (reader, &lines))
522 goto error;
523
524 if (lines > flxdec->hdr.height) {
525 GST_ERROR_OBJECT (flxdec, "Invalid FLC packet detected. too many lines.");
526 return FALSE;
527 }
528
529 start_l = lines;
530
531 while (lines) {
532 guint16 opcode;
533
534 if (!gst_byte_writer_set_pos (writer,
535 flxdec->hdr.width * (start_l - lines)))
536 goto error;
537
538 /* process opcode(s) */
539 while (TRUE) {
540 if (!gst_byte_reader_get_uint16_le (reader, &opcode))
541 goto error;
542 if ((opcode & 0xc000) == 0)
543 break;
544
545 if ((opcode & 0xc000) == 0xc000) {
546 /* line skip count */
547 gulong skip = (0x10000 - opcode);
548 if (skip > flxdec->hdr.height) {
549 GST_ERROR_OBJECT (flxdec, "Invalid FLC packet detected. "
550 "skip line count too big.");
551 return FALSE;
552 }
553 start_l += skip;
554 if (!gst_byte_writer_set_pos (writer,
555 gst_byte_writer_get_pos (writer) + flxdec->hdr.width * skip))
556 goto error;
557 } else {
558 /* last pixel */
559 if (!gst_byte_writer_set_pos (writer,
560 gst_byte_writer_get_pos (writer) + flxdec->hdr.width))
561 goto error;
562 if (!gst_byte_writer_put_uint8 (writer, opcode & 0xff))
563 goto error;
564 }
565 }
566
567 /* last opcode is the packet count */
568 GST_LOG_OBJECT (flxdec, "have %d packets", opcode);
569 while (opcode--) {
570 /* skip count */
571 guint8 skip;
572 gint8 count;
573
574 if (!gst_byte_reader_get_uint8 (reader, &skip))
575 goto error;
576 if (!gst_byte_writer_set_pos (writer,
577 gst_byte_writer_get_pos (writer) + skip))
578 goto error;
579
580 /* RLE count */
581 if (!gst_byte_reader_get_int8 (reader, &count))
582 goto error;
583
584 if (count < 0) {
585 guint16 x;
586
587 /* replicate word run */
588 count = ABS (count);
589
590 GST_LOG_OBJECT (flxdec, "have replicate run of size %d at offset %d",
591 count, skip);
592
593 if (skip + count > flxdec->hdr.width) {
594 GST_ERROR_OBJECT (flxdec, "Invalid FLC packet detected. "
595 "line too long.");
596 return FALSE;
597 }
598
599 if (!gst_byte_reader_get_uint16_le (reader, &x))
600 goto error;
601
602 while (count--) {
603 if (!gst_byte_writer_put_uint16_le (writer, x)) {
604 goto error;
605 }
606 }
607 } else {
608 GST_LOG_OBJECT (flxdec, "have literal run of size %d at offset %d",
609 count, skip);
610
611 if (skip + count > flxdec->hdr.width) {
612 GST_ERROR_OBJECT (flxdec, "Invalid FLC packet detected. "
613 "line too long.");
614 return FALSE;
615 }
616
617 while (count--) {
618 guint16 x;
619
620 if (!gst_byte_reader_get_uint16_le (reader, &x))
621 goto error;
622 if (!gst_byte_writer_put_uint16_le (writer, x))
623 goto error;
624 }
625 }
626 }
627 lines--;
628 }
629
630 return TRUE;
631
632 error:
633 GST_ERROR_OBJECT (flxdec, "Failed to decode FLI packet");
634 return FALSE;
635 }
636
637 static gboolean
_read_flx_header(GstFlxDec * flxdec,GstByteReader * reader,FlxHeader * flxh)638 _read_flx_header (GstFlxDec * flxdec, GstByteReader * reader, FlxHeader * flxh)
639 {
640 memset (flxh, 0, sizeof (*flxh));
641
642 if (!gst_byte_reader_get_uint32_le (reader, &flxh->size))
643 goto error;
644 if (flxh->size < FlxHeaderSize) {
645 GST_ERROR_OBJECT (flxdec, "Invalid file size in the header");
646 return FALSE;
647 }
648
649 if (!gst_byte_reader_get_uint16_le (reader, &flxh->type))
650 goto error;
651 if (!gst_byte_reader_get_uint16_le (reader, &flxh->frames))
652 goto error;
653 if (!gst_byte_reader_get_uint16_le (reader, &flxh->width))
654 goto error;
655 if (!gst_byte_reader_get_uint16_le (reader, &flxh->height))
656 goto error;
657 if (!gst_byte_reader_get_uint16_le (reader, &flxh->depth))
658 goto error;
659 if (!gst_byte_reader_get_uint16_le (reader, &flxh->flags))
660 goto error;
661 if (!gst_byte_reader_get_uint32_le (reader, &flxh->speed))
662 goto error;
663 if (!gst_byte_reader_skip (reader, 2)) /* reserved */
664 goto error;
665 /* FLC */
666 if (!gst_byte_reader_get_uint32_le (reader, &flxh->created))
667 goto error;
668 if (!gst_byte_reader_get_uint32_le (reader, &flxh->creator))
669 goto error;
670 if (!gst_byte_reader_get_uint32_le (reader, &flxh->updated))
671 goto error;
672 if (!gst_byte_reader_get_uint32_le (reader, &flxh->updater))
673 goto error;
674 if (!gst_byte_reader_get_uint16_le (reader, &flxh->aspect_dx))
675 goto error;
676 if (!gst_byte_reader_get_uint16_le (reader, &flxh->aspect_dy))
677 goto error;
678 /* EGI */
679 if (!gst_byte_reader_get_uint16_le (reader, &flxh->ext_flags))
680 goto error;
681 if (!gst_byte_reader_get_uint16_le (reader, &flxh->keyframes))
682 goto error;
683 if (!gst_byte_reader_get_uint16_le (reader, &flxh->totalframes))
684 goto error;
685 if (!gst_byte_reader_get_uint32_le (reader, &flxh->req_memory))
686 goto error;
687 if (!gst_byte_reader_get_uint16_le (reader, &flxh->max_regions))
688 goto error;
689 if (!gst_byte_reader_get_uint16_le (reader, &flxh->transp_num))
690 goto error;
691 if (!gst_byte_reader_skip (reader, 24)) /* reserved */
692 goto error;
693 /* FLC */
694 if (!gst_byte_reader_get_uint32_le (reader, &flxh->oframe1))
695 goto error;
696 if (!gst_byte_reader_get_uint32_le (reader, &flxh->oframe2))
697 goto error;
698 if (!gst_byte_reader_skip (reader, 40)) /* reserved */
699 goto error;
700
701 return TRUE;
702
703 error:
704 GST_ERROR_OBJECT (flxdec, "Error reading file header");
705 return FALSE;
706 }
707
708 static GstFlowReturn
gst_flxdec_chain(GstPad * pad,GstObject * parent,GstBuffer * buf)709 gst_flxdec_chain (GstPad * pad, GstObject * parent, GstBuffer * buf)
710 {
711 GstByteReader reader;
712 GstBuffer *input;
713 GstMapInfo map_info;
714 GstCaps *caps;
715 guint available;
716 GstFlowReturn res = GST_FLOW_OK;
717
718 GstFlxDec *flxdec;
719 FlxHeader *flxh;
720
721 g_return_val_if_fail (buf != NULL, GST_FLOW_ERROR);
722 flxdec = (GstFlxDec *) parent;
723 g_return_val_if_fail (flxdec != NULL, GST_FLOW_ERROR);
724
725 gst_adapter_push (flxdec->adapter, buf);
726 available = gst_adapter_available (flxdec->adapter);
727 input = gst_adapter_get_buffer (flxdec->adapter, available);
728 if (!gst_buffer_map (input, &map_info, GST_MAP_READ)) {
729 GST_ELEMENT_ERROR (flxdec, STREAM, DECODE,
730 ("%s", "Failed to map buffer"), (NULL));
731 goto error;
732 }
733 gst_byte_reader_init (&reader, map_info.data, map_info.size);
734
735 if (flxdec->state == GST_FLXDEC_READ_HEADER) {
736 if (available >= FlxHeaderSize) {
737 GstByteReader header;
738 GstCaps *templ;
739
740 if (!gst_byte_reader_get_sub_reader (&reader, &header, FlxHeaderSize)) {
741 GST_ELEMENT_ERROR (flxdec, STREAM, DECODE,
742 ("%s", "Could not read header"), (NULL));
743 goto unmap_input_error;
744 }
745 gst_adapter_flush (flxdec->adapter, FlxHeaderSize);
746 available -= FlxHeaderSize;
747
748 if (!_read_flx_header (flxdec, &header, &flxdec->hdr)) {
749 GST_ELEMENT_ERROR (flxdec, STREAM, DECODE,
750 ("%s", "Failed to parse header"), (NULL));
751 goto unmap_input_error;
752 }
753
754 flxh = &flxdec->hdr;
755
756 /* check header */
757 if (flxh->type != FLX_MAGICHDR_FLI &&
758 flxh->type != FLX_MAGICHDR_FLC && flxh->type != FLX_MAGICHDR_FLX) {
759 GST_ELEMENT_ERROR (flxdec, STREAM, WRONG_TYPE, (NULL),
760 ("not a flx file (type %x)", flxh->type));
761 goto unmap_input_error;
762 }
763
764 GST_INFO_OBJECT (flxdec, "size : %d", flxh->size);
765 GST_INFO_OBJECT (flxdec, "frames : %d", flxh->frames);
766 GST_INFO_OBJECT (flxdec, "width : %d", flxh->width);
767 GST_INFO_OBJECT (flxdec, "height : %d", flxh->height);
768 GST_INFO_OBJECT (flxdec, "depth : %d", flxh->depth);
769 GST_INFO_OBJECT (flxdec, "speed : %d", flxh->speed);
770
771 flxdec->next_time = 0;
772
773 if (flxh->type == FLX_MAGICHDR_FLI) {
774 flxdec->frame_time = JIFFIE * flxh->speed;
775 } else if (flxh->speed == 0) {
776 flxdec->frame_time = GST_SECOND / 70;
777 } else {
778 flxdec->frame_time = flxh->speed * GST_MSECOND;
779 }
780
781 flxdec->duration = flxh->frames * flxdec->frame_time;
782 GST_LOG ("duration : %" GST_TIME_FORMAT,
783 GST_TIME_ARGS (flxdec->duration));
784
785 templ = gst_pad_get_pad_template_caps (flxdec->srcpad);
786 caps = gst_caps_copy (templ);
787 gst_caps_unref (templ);
788 gst_caps_set_simple (caps,
789 "width", G_TYPE_INT, flxh->width,
790 "height", G_TYPE_INT, flxh->height,
791 "framerate", GST_TYPE_FRACTION, (gint) GST_MSECOND,
792 (gint) flxdec->frame_time / 1000, NULL);
793
794 gst_pad_set_caps (flxdec->srcpad, caps);
795 gst_caps_unref (caps);
796
797 if (flxdec->need_segment) {
798 gst_pad_push_event (flxdec->srcpad,
799 gst_event_new_segment (&flxdec->segment));
800 flxdec->need_segment = FALSE;
801 }
802
803 /* zero means 8 */
804 if (flxh->depth == 0)
805 flxh->depth = 8;
806
807 if (flxh->depth != 8) {
808 GST_ELEMENT_ERROR (flxdec, STREAM, WRONG_TYPE,
809 ("%s", "Don't know how to decode non 8 bit depth streams"), (NULL));
810 goto unmap_input_error;
811 }
812
813 flxdec->converter =
814 flx_colorspace_converter_new (flxh->width, flxh->height);
815
816 if (flxh->type == FLX_MAGICHDR_FLC || flxh->type == FLX_MAGICHDR_FLX) {
817 GST_INFO_OBJECT (flxdec, "(FLC) aspect_dx : %d", flxh->aspect_dx);
818 GST_INFO_OBJECT (flxdec, "(FLC) aspect_dy : %d", flxh->aspect_dy);
819 GST_INFO_OBJECT (flxdec, "(FLC) oframe1 : 0x%08x", flxh->oframe1);
820 GST_INFO_OBJECT (flxdec, "(FLC) oframe2 : 0x%08x", flxh->oframe2);
821 }
822
823 flxdec->size = ((guint) flxh->width * (guint) flxh->height);
824 if (flxdec->size >= G_MAXSIZE / 4) {
825 GST_ELEMENT_ERROR (flxdec, STREAM, DECODE,
826 ("%s", "Cannot allocate required memory"), (NULL));
827 goto unmap_input_error;
828 }
829
830 /* create delta and output frame */
831 flxdec->frame_data = g_malloc0 (flxdec->size);
832 flxdec->delta_data = g_malloc0 (flxdec->size);
833
834 flxdec->state = GST_FLXDEC_PLAYING;
835 }
836 } else if (flxdec->state == GST_FLXDEC_PLAYING) {
837 GstBuffer *out;
838
839 /* while we have enough data in the adapter */
840 while (available >= FlxFrameChunkSize && res == GST_FLOW_OK) {
841 guint32 size;
842 guint16 type;
843
844 if (!gst_byte_reader_get_uint32_le (&reader, &size))
845 goto parse_error;
846 if (available < size)
847 goto need_more_data;
848
849 available -= size;
850 gst_adapter_flush (flxdec->adapter, size);
851
852 if (!gst_byte_reader_get_uint16_le (&reader, &type))
853 goto parse_error;
854
855 switch (type) {
856 case FLX_FRAME_TYPE:{
857 GstByteReader chunks;
858 GstByteWriter writer;
859 guint16 n_chunks;
860 GstMapInfo map;
861
862 GST_LOG_OBJECT (flxdec, "Have frame type 0x%02x of size %d", type,
863 size);
864
865 if (!gst_byte_reader_get_sub_reader (&reader, &chunks,
866 size - FlxFrameChunkSize))
867 goto parse_error;
868
869 if (!gst_byte_reader_get_uint16_le (&chunks, &n_chunks))
870 goto parse_error;
871 GST_LOG_OBJECT (flxdec, "Have %d chunks", n_chunks);
872
873 if (n_chunks == 0)
874 break;
875 if (!gst_byte_reader_skip (&chunks, 8)) /* reserved */
876 goto parse_error;
877
878 gst_byte_writer_init_with_data (&writer, flxdec->frame_data,
879 flxdec->size, TRUE);
880
881 /* decode chunks */
882 if (!flx_decode_chunks (flxdec, n_chunks, &chunks, &writer)) {
883 GST_ELEMENT_ERROR (flxdec, STREAM, DECODE,
884 ("%s", "Could not decode chunk"), NULL);
885 goto unmap_input_error;
886 }
887 gst_byte_writer_reset (&writer);
888
889 /* save copy of the current frame for possible delta. */
890 memcpy (flxdec->delta_data, flxdec->frame_data, flxdec->size);
891
892 out = gst_buffer_new_and_alloc (flxdec->size * 4);
893 if (!gst_buffer_map (out, &map, GST_MAP_WRITE)) {
894 GST_ELEMENT_ERROR (flxdec, STREAM, DECODE,
895 ("%s", "Could not map output buffer"), NULL);
896 gst_buffer_unref (out);
897 goto unmap_input_error;
898 }
899
900 /* convert current frame. */
901 flx_colorspace_convert (flxdec->converter, flxdec->frame_data,
902 map.data);
903 gst_buffer_unmap (out, &map);
904
905 GST_BUFFER_TIMESTAMP (out) = flxdec->next_time;
906 flxdec->next_time += flxdec->frame_time;
907
908 res = gst_pad_push (flxdec->srcpad, out);
909 break;
910 }
911 default:
912 GST_DEBUG_OBJECT (flxdec, "Unknown frame type 0x%02x, skipping %d",
913 type, size);
914 if (!gst_byte_reader_skip (&reader, size - FlxFrameChunkSize))
915 goto parse_error;
916 break;
917 }
918 }
919 }
920
921 need_more_data:
922 gst_buffer_unmap (input, &map_info);
923 gst_buffer_unref (input);
924 return res;
925
926 /* ERRORS */
927 parse_error:
928 GST_ELEMENT_ERROR (flxdec, STREAM, DECODE,
929 ("%s", "Failed to parse stream"), (NULL));
930 unmap_input_error:
931 gst_buffer_unmap (input, &map_info);
932 error:
933 gst_buffer_unref (input);
934 return GST_FLOW_ERROR;
935 }
936
937 static GstStateChangeReturn
gst_flxdec_change_state(GstElement * element,GstStateChange transition)938 gst_flxdec_change_state (GstElement * element, GstStateChange transition)
939 {
940 GstFlxDec *flxdec;
941 GstStateChangeReturn ret;
942
943 flxdec = GST_FLXDEC (element);
944
945 switch (transition) {
946 case GST_STATE_CHANGE_NULL_TO_READY:
947 break;
948 case GST_STATE_CHANGE_READY_TO_PAUSED:
949 gst_adapter_clear (flxdec->adapter);
950 flxdec->state = GST_FLXDEC_READ_HEADER;
951 gst_segment_init (&flxdec->segment, GST_FORMAT_UNDEFINED);
952 flxdec->need_segment = TRUE;
953 break;
954 case GST_STATE_CHANGE_PAUSED_TO_PLAYING:
955 break;
956 default:
957 break;
958 }
959
960 ret = GST_ELEMENT_CLASS (parent_class)->change_state (element, transition);
961
962 switch (transition) {
963 case GST_STATE_CHANGE_PLAYING_TO_PAUSED:
964 break;
965 case GST_STATE_CHANGE_PAUSED_TO_READY:
966 if (flxdec->frame_data) {
967 g_free (flxdec->frame_data);
968 flxdec->frame_data = NULL;
969 }
970 if (flxdec->delta_data) {
971 g_free (flxdec->delta_data);
972 flxdec->delta_data = NULL;
973 }
974 if (flxdec->converter) {
975 flx_colorspace_converter_destroy (flxdec->converter);
976 flxdec->converter = NULL;
977 }
978 break;
979 case GST_STATE_CHANGE_READY_TO_NULL:
980 break;
981 default:
982 break;
983 }
984 return ret;
985 }
986
987 static gboolean
plugin_init(GstPlugin * plugin)988 plugin_init (GstPlugin * plugin)
989 {
990 return gst_element_register (plugin, "flxdec",
991 GST_RANK_PRIMARY, GST_TYPE_FLXDEC);
992 }
993
994 GST_PLUGIN_DEFINE (GST_VERSION_MAJOR,
995 GST_VERSION_MINOR,
996 flxdec,
997 "FLC/FLI/FLX video decoder",
998 plugin_init, VERSION, GST_LICENSE, GST_PACKAGE_NAME, GST_PACKAGE_ORIGIN)
999