gst/flx/gstflxdec.c

   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
  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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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)