From 447cec835567e7a9e20ad03b1ce50ca65547d367 Mon Sep 17 00:00:00 2001 From: Anders Jenbo Date: Tue, 19 Feb 2019 19:28:28 +0100 Subject: [PATCH] Implement video playback via libsmacker --- 3rdParty/libsmacker/COPYING | 64 ++ 3rdParty/libsmacker/README | 57 ++ 3rdParty/libsmacker/smacker.c | 1423 +++++++++++++++++++++++++++ 3rdParty/libsmacker/smacker.h | 110 +++ 3rdParty/libsmacker/smk_bitstream.c | 119 +++ 3rdParty/libsmacker/smk_bitstream.h | 50 + 3rdParty/libsmacker/smk_hufftree.c | 425 ++++++++ 3rdParty/libsmacker/smk_hufftree.h | 88 ++ 3rdParty/libsmacker/smk_malloc.h | 77 ++ CMake/32bit.cmake | 1 + CMakeLists.txt | 4 + Stub/DiabloUI/diabloui.cpp | 3 - Stub/init.cpp | 2 +- Stub/movie.cpp | 117 ++- Stub/sound.cpp | 8 - Stub/sound.h | 1 - types.h | 1 - 17 files changed, 2535 insertions(+), 15 deletions(-) create mode 100644 3rdParty/libsmacker/COPYING create mode 100644 3rdParty/libsmacker/README create mode 100644 3rdParty/libsmacker/smacker.c create mode 100644 3rdParty/libsmacker/smacker.h create mode 100644 3rdParty/libsmacker/smk_bitstream.c create mode 100644 3rdParty/libsmacker/smk_bitstream.h create mode 100644 3rdParty/libsmacker/smk_hufftree.c create mode 100644 3rdParty/libsmacker/smk_hufftree.h create mode 100644 3rdParty/libsmacker/smk_malloc.h delete mode 100644 Stub/sound.h diff --git a/3rdParty/libsmacker/COPYING b/3rdParty/libsmacker/COPYING new file mode 100644 index 000000000..c1ead452b --- /dev/null +++ b/3rdParty/libsmacker/COPYING @@ -0,0 +1,64 @@ +Attribution-NonCommercial 2.0 +CREATIVE COMMONS CORPORATION IS NOT A LAW FIRM AND DOES NOT PROVIDE LEGAL SERVICES. DISTRIBUTION OF THIS LICENSE DOES NOT CREATE AN ATTORNEY-CLIENT RELATIONSHIP. CREATIVE COMMONS PROVIDES THIS INFORMATION ON AN "AS-IS" BASIS. CREATIVE COMMONS MAKES NO WARRANTIES REGARDING THE INFORMATION PROVIDED, AND DISCLAIMS LIABILITY FOR DAMAGES RESULTING FROM ITS USE. + +License + +THE WORK (AS DEFINED BELOW) IS PROVIDED UNDER THE TERMS OF THIS CREATIVE COMMONS PUBLIC LICENSE ("CCPL" OR "LICENSE"). THE WORK IS PROTECTED BY COPYRIGHT AND/OR OTHER APPLICABLE LAW. ANY USE OF THE WORK OTHER THAN AS AUTHORIZED UNDER THIS LICENSE OR COPYRIGHT LAW IS PROHIBITED. + +BY EXERCISING ANY RIGHTS TO THE WORK PROVIDED HERE, YOU ACCEPT AND AGREE TO BE BOUND BY THE TERMS OF THIS LICENSE. THE LICENSOR GRANTS YOU THE RIGHTS CONTAINED HERE IN CONSIDERATION OF YOUR ACCEPTANCE OF SUCH TERMS AND CONDITIONS. + +1. Definitions + + "Collective Work" means a work, such as a periodical issue, anthology or encyclopedia, in which the Work in its entirety in unmodified form, along with a number of other contributions, constituting separate and independent works in themselves, are assembled into a collective whole. A work that constitutes a Collective Work will not be considered a Derivative Work (as defined below) for the purposes of this License. + "Derivative Work" means a work based upon the Work or upon the Work and other pre-existing works, such as a translation, musical arrangement, dramatization, fictionalization, motion picture version, sound recording, art reproduction, abridgment, condensation, or any other form in which the Work may be recast, transformed, or adapted, except that a work that constitutes a Collective Work will not be considered a Derivative Work for the purpose of this License. For the avoidance of doubt, where the Work is a musical composition or sound recording, the synchronization of the Work in timed-relation with a moving image ("synching") will be considered a Derivative Work for the purpose of this License. + "Licensor" means the individual or entity that offers the Work under the terms of this License. + "Original Author" means the individual or entity who created the Work. + "Work" means the copyrightable work of authorship offered under the terms of this License. + "You" means an individual or entity exercising rights under this License who has not previously violated the terms of this License with respect to the Work, or who has received express permission from the Licensor to exercise rights under this License despite a previous violation. + +2. Fair Use Rights. Nothing in this license is intended to reduce, limit, or restrict any rights arising from fair use, first sale or other limitations on the exclusive rights of the copyright owner under copyright law or other applicable laws. + +3. License Grant. Subject to the terms and conditions of this License, Licensor hereby grants You a worldwide, royalty-free, non-exclusive, perpetual (for the duration of the applicable copyright) license to exercise the rights in the Work as stated below: + + to reproduce the Work, to incorporate the Work into one or more Collective Works, and to reproduce the Work as incorporated in the Collective Works; + to create and reproduce Derivative Works; + to distribute copies or phonorecords of, display publicly, perform publicly, and perform publicly by means of a digital audio transmission the Work including as incorporated in Collective Works; + to distribute copies or phonorecords of, display publicly, perform publicly, and perform publicly by means of a digital audio transmission Derivative Works; + +The above rights may be exercised in all media and formats whether now known or hereafter devised. The above rights include the right to make such modifications as are technically necessary to exercise the rights in other media and formats. All rights not expressly granted by Licensor are hereby reserved, including but not limited to the rights set forth in Sections 4(d) and 4(e). + +4. Restrictions. The license granted in Section 3 above is expressly made subject to and limited by the following restrictions: + + You may distribute, publicly display, publicly perform, or publicly digitally perform the Work only under the terms of this License, and You must include a copy of, or the Uniform Resource Identifier for, this License with every copy or phonorecord of the Work You distribute, publicly display, publicly perform, or publicly digitally perform. You may not offer or impose any terms on the Work that alter or restrict the terms of this License or the recipients' exercise of the rights granted hereunder. You may not sublicense the Work. You must keep intact all notices that refer to this License and to the disclaimer of warranties. You may not distribute, publicly display, publicly perform, or publicly digitally perform the Work with any technological measures that control access or use of the Work in a manner inconsistent with the terms of this License Agreement. The above applies to the Work as incorporated in a Collective Work, but this does not require the Collective Work apart from the Work itself to be made subject to the terms of this License. If You create a Collective Work, upon notice from any Licensor You must, to the extent practicable, remove from the Collective Work any reference to such Licensor or the Original Author, as requested. If You create a Derivative Work, upon notice from any Licensor You must, to the extent practicable, remove from the Derivative Work any reference to such Licensor or the Original Author, as requested. + You may not exercise any of the rights granted to You in Section 3 above in any manner that is primarily intended for or directed toward commercial advantage or private monetary compensation. The exchange of the Work for other copyrighted works by means of digital file-sharing or otherwise shall not be considered to be intended for or directed toward commercial advantage or private monetary compensation, provided there is no payment of any monetary compensation in connection with the exchange of copyrighted works. + If you distribute, publicly display, publicly perform, or publicly digitally perform the Work or any Derivative Works or Collective Works, You must keep intact all copyright notices for the Work and give the Original Author credit reasonable to the medium or means You are utilizing by conveying the name (or pseudonym if applicable) of the Original Author if supplied; the title of the Work if supplied; to the extent reasonably practicable, the Uniform Resource Identifier, if any, that Licensor specifies to be associated with the Work, unless such URI does not refer to the copyright notice or licensing information for the Work; and in the case of a Derivative Work, a credit identifying the use of the Work in the Derivative Work (e.g., "French translation of the Work by Original Author," or "Screenplay based on original Work by Original Author"). Such credit may be implemented in any reasonable manner; provided, however, that in the case of a Derivative Work or Collective Work, at a minimum such credit will appear where any other comparable authorship credit appears and in a manner at least as prominent as such other comparable authorship credit. + + For the avoidance of doubt, where the Work is a musical composition: + Performance Royalties Under Blanket Licenses. Licensor reserves the exclusive right to collect, whether individually or via a performance rights society (e.g. ASCAP, BMI, SESAC), royalties for the public performance or public digital performance (e.g. webcast) of the Work if that performance is primarily intended for or directed toward commercial advantage or private monetary compensation. + Mechanical Rights and Statutory Royalties. Licensor reserves the exclusive right to collect, whether individually or via a music rights agency or designated agent (e.g. Harry Fox Agency), royalties for any phonorecord You create from the Work ("cover version") and distribute, subject to the compulsory license created by 17 USC Section 115 of the US Copyright Act (or the equivalent in other jurisdictions), if Your distribution of such cover version is primarily intended for or directed toward commercial advantage or private monetary compensation. + Webcasting Rights and Statutory Royalties. For the avoidance of doubt, where the Work is a sound recording, Licensor reserves the exclusive right to collect, whether individually or via a performance-rights society (e.g. SoundExchange), royalties for the public digital performance (e.g. webcast) of the Work, subject to the compulsory license created by 17 USC Section 114 of the US Copyright Act (or the equivalent in other jurisdictions), if Your public digital performance is primarily intended for or directed toward commercial advantage or private monetary compensation. + +5. Representations, Warranties and Disclaimer + +UNLESS OTHERWISE MUTUALLY AGREED TO BY THE PARTIES IN WRITING, LICENSOR OFFERS THE WORK AS-IS AND MAKES NO REPRESENTATIONS OR WARRANTIES OF ANY KIND CONCERNING THE WORK, EXPRESS, IMPLIED, STATUTORY OR OTHERWISE, INCLUDING, WITHOUT LIMITATION, WARRANTIES OF TITLE, MERCHANTIBILITY, FITNESS FOR A PARTICULAR PURPOSE, NONINFRINGEMENT, OR THE ABSENCE OF LATENT OR OTHER DEFECTS, ACCURACY, OR THE PRESENCE OF ABSENCE OF ERRORS, WHETHER OR NOT DISCOVERABLE. SOME JURISDICTIONS DO NOT ALLOW THE EXCLUSION OF IMPLIED WARRANTIES, SO SUCH EXCLUSION MAY NOT APPLY TO YOU. + +6. Limitation on Liability. EXCEPT TO THE EXTENT REQUIRED BY APPLICABLE LAW, IN NO EVENT WILL LICENSOR BE LIABLE TO YOU ON ANY LEGAL THEORY FOR ANY SPECIAL, INCIDENTAL, CONSEQUENTIAL, PUNITIVE OR EXEMPLARY DAMAGES ARISING OUT OF THIS LICENSE OR THE USE OF THE WORK, EVEN IF LICENSOR HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. + +7. Termination + + This License and the rights granted hereunder will terminate automatically upon any breach by You of the terms of this License. Individuals or entities who have received Derivative Works or Collective Works from You under this License, however, will not have their licenses terminated provided such individuals or entities remain in full compliance with those licenses. Sections 1, 2, 5, 6, 7, and 8 will survive any termination of this License. + Subject to the above terms and conditions, the license granted here is perpetual (for the duration of the applicable copyright in the Work). Notwithstanding the above, Licensor reserves the right to release the Work under different license terms or to stop distributing the Work at any time; provided, however that any such election will not serve to withdraw this License (or any other license that has been, or is required to be, granted under the terms of this License), and this License will continue in full force and effect unless terminated as stated above. + +8. Miscellaneous + + Each time You distribute or publicly digitally perform the Work or a Collective Work, the Licensor offers to the recipient a license to the Work on the same terms and conditions as the license granted to You under this License. + Each time You distribute or publicly digitally perform a Derivative Work, Licensor offers to the recipient a license to the original Work on the same terms and conditions as the license granted to You under this License. + If any provision of this License is invalid or unenforceable under applicable law, it shall not affect the validity or enforceability of the remainder of the terms of this License, and without further action by the parties to this agreement, such provision shall be reformed to the minimum extent necessary to make such provision valid and enforceable. + No term or provision of this License shall be deemed waived and no breach consented to unless such waiver or consent shall be in writing and signed by the party to be charged with such waiver or consent. + This License constitutes the entire agreement between the parties with respect to the Work licensed here. There are no understandings, agreements or representations with respect to the Work not specified here. Licensor shall not be bound by any additional provisions that may appear in any communication from You. This License may not be modified without the mutual written agreement of the Licensor and You. + +Creative Commons is not a party to this License, and makes no warranty whatsoever in connection with the Work. Creative Commons will not be liable to You or any party on any legal theory for any damages whatsoever, including without limitation any general, special, incidental or consequential damages arising in connection to this license. Notwithstanding the foregoing two (2) sentences, if Creative Commons has expressly identified itself as the Licensor hereunder, it shall have all rights and obligations of Licensor. + +Except for the limited purpose of indicating to the public that the Work is licensed under the CCPL, neither party will use the trademark "Creative Commons" or any related trademark or logo of Creative Commons without the prior written consent of Creative Commons. Any permitted use will be in compliance with Creative Commons' then-current trademark usage guidelines, as may be published on its website or otherwise made available upon request from time to time. + +Creative Commons may be contacted at https://creativecommons.org/. diff --git a/3rdParty/libsmacker/README b/3rdParty/libsmacker/README new file mode 100644 index 000000000..bfb011faf --- /dev/null +++ b/3rdParty/libsmacker/README @@ -0,0 +1,57 @@ +libsmacker +A C library for decoding .smk Smacker Video files + +version 1.1 +2017-01-27 + +(c) Greg Kennedy 2013-2017 +http://libsmacker.sourceforge.net +---- + +--- +Introduction +--- +libsmacker is a cross-platform C library which can be used for decoding Smacker Video files produced by RAD Game Tools. Smacker Video was the king of video middleware in the 1990s, and its 256-color compressed video format was used in over 2600 software titles. + +libsmacker implements the minimum feature set required from smackw32.dll to get an smk off a disk and the frames / audio into a buffer in the correct order. + +--- +License +--- +libsmacker is released under a Creative Commons Attribution Non-Commercial License V2.0. This means, first, that projects using libsmacker must indicate somewhere that they use libsmacker in the code. Also: the Non-Commercial tag means exactly what it suggests: LIBSMACKER MAY NOT BE USED IN ANY COMMERCIAL PROJECT. PERIOD. Non-commercial DOES NOT mean simply "non-profit": commercial includes for-profit, but may also encompass other non-profit activites as well. + +Static- or dynamic-linking against unmodified libsmacker does not automatically re-license your code. If you alter the library code (.c, .h files), your changes become a Derivative Work and are subject to the conditions outlined in the license. Unmodified redistributions of binary libsmacker in your own projects must meet the conditions of this license. + +A human-readable summary of the license is available online: +http://creativecommons.org/licenses/by-nc/2.0/ + +The complete license text is here: +http://creativecommons.org/licenses/by-nc/2.0/legalcode + +--- +Usage +--- +See the webpage for sample code and function documentation. The source package additionally includes a pair of driver programs: +* driver.c - dumps all frames of a file to a bmp/ subdirectory, and all audio as raw streams to out_*.raw files in CWD +* smk2avi.c - converts smk file(s) to AVI files - uncompressed 24-bit color and PCM audio stream. + +Though the libraries are "bulletproofed" the sample apps are not: be cautious if you plan to implement in some critical environment. + +--- +Changelog +--- +1.1 +* Switch to autotools-based build +* Incorporates patches from Dalerank Slim, Gennady Trafimenkov, and Bianca van Schaik +* Performance improvements and code cleanup / safety. +1.0 +* Initial revision + +--- +Contact +--- +Questions/comments: +* by email: kennedy.greg@gmail.com +* by website: http://libsmacker.sourceforge.net + +Enjoy! diff --git a/3rdParty/libsmacker/smacker.c b/3rdParty/libsmacker/smacker.c new file mode 100644 index 000000000..0581500c1 --- /dev/null +++ b/3rdParty/libsmacker/smacker.c @@ -0,0 +1,1423 @@ +/** + libsmacker - A C library for decoding .smk Smacker Video files + Copyright (C) 2012-2017 Greg Kennedy + + See smacker.h for more information. + + smacker.c + Main implementation file of libsmacker. + Open, close, query, render, advance and seek an smk +*/ + +#include "smacker.h" + +/* safe malloc and free */ +#include "smk_malloc.h" + +/* data structures */ +#include "smk_bitstream.h" +#include "smk_hufftree.h" + +/* GLOBALS */ +/* tree processing order */ +#define SMK_TREE_MMAP 0 +#define SMK_TREE_MCLR 1 +#define SMK_TREE_FULL 2 +#define SMK_TREE_TYPE 3 + +/* SMACKER DATA STRUCTURES */ +struct smk_t +{ + /* meta-info */ + /* file mode: see flags, smacker.h */ + unsigned char mode; + + /* microsec per frame - stored as a double to handle scaling + (large positive millisec / frame values may overflow a ul) */ + double usf; + + /* total frames */ + unsigned long f; + /* does file have a ring frame? (in other words, does file loop?) */ + unsigned char ring_frame; + + /* Index of current frame */ + unsigned long cur_frame; + + /* SOURCE union. + Where the data is going to be read from (or be stored), + depending on the file mode. */ + union + { + struct + { + /* on-disk mode */ + FILE* fp; + unsigned long* chunk_offset; + } file; + + /* in-memory mode: unprocessed chunks */ + unsigned char** chunk_data; + } source; + + /* shared array of "chunk sizes"*/ + unsigned long* chunk_size; + + /* Holds per-frame flags (i.e. 'keyframe') */ + unsigned char* keyframe; + /* Holds per-frame type mask (e.g. 'audio track 3, 2, and palette swap') */ + unsigned char* frame_type; + + /* video and audio structures */ + /* Video data type: enable/disable decode switch, + video info and flags, + pointer to last-decoded-palette */ + struct smk_video_t + { + /* enable/disable decode switch */ + unsigned char enable; + + /* video info */ + unsigned long w; + unsigned long h; + /* Y scale mode (constants defined in smacker.h) + 0: unscaled + 1: doubled + 2: interlaced */ + unsigned char y_scale_mode; + + /* version ('2' or '4') */ + unsigned char v; + + /* Huffman trees */ + /* unsigned long tree_size[4]; */ + struct smk_huff16_t* tree[4]; + + /* Palette data type: pointer to last-decoded-palette */ + unsigned char palette[256][3]; + /* Last-unpacked frame */ + unsigned char* frame; + } video; + + /* audio structure */ + struct smk_audio_t + { + /* set if track exists in file */ + unsigned char exists; + + /* enable/disable switch (per track) */ + unsigned char enable; + + /* Info */ + unsigned char channels; + unsigned char bitdepth; + unsigned long rate; + long max_buffer; + + /* compression type + 0: raw PCM + 1: SMK DPCM + 2: Bink (Perceptual), unsupported */ + unsigned char compress; + + /* pointer to last-decoded-audio-buffer */ + void* buffer; + unsigned long buffer_size; + } audio[7]; +}; + +union smk_read_t +{ + FILE* file; + unsigned char* ram; +}; + +/* An fread wrapper: consumes N bytes, or returns -1 + on failure (when size doesn't match expected) */ +static char smk_read_file(void* buf, const size_t size, FILE* fp) +{ + /* don't bother checking buf or fp, fread does it for us */ + size_t bytesRead = fread(buf,1,size,fp); + if (bytesRead != size) + { + fprintf(stderr, "libsmacker::smk_read_file(buf,%lu,fp) - ERROR: Short read, %lu bytes returned\n\tReason: %s\n", (unsigned long)size, (unsigned long)bytesRead, strerror(errno)); + return -1; + } + return 0; +} + +/* A memcpy wrapper: consumes N bytes, or returns -1 + on failure (when size too low) */ +static char smk_read_memory(void* buf, const unsigned long size, unsigned char** p, unsigned long* p_size) +{ + if (size > *p_size) + { + fprintf(stderr,"libsmacker::smk_read_memory(buf,%lu,p,%lu) - ERROR: Short read\n",(unsigned long)size, (unsigned long)*p_size); + return -1; + } + memcpy(buf,*p,size); + *p += size; + *p_size -= size; + return 0; +} + +/* Helper functions to do the reading, plus + byteswap from LE to host order */ +/* read n bytes from (source) into ret */ +#define smk_read(ret,n) \ +{ \ + if (m) \ + { \ + r = (smk_read_file(ret,n,fp.file)); \ + } \ + else \ + { \ + r = (smk_read_memory(ret,n,&fp.ram,&size)); \ + } \ + if (r < 0) \ + { \ + fprintf(stderr,"libsmacker::smk_read(...) - Errors encountered on read, bailing out (file: %s, line: %lu)\n", __FILE__, (unsigned long)__LINE__); \ + goto error; \ + } \ +} + +/* Calls smk_read, but returns a ul */ +#define smk_read_ul(p) \ +{ \ + smk_read(buf,4); \ + p = ((unsigned long) buf[3] << 24) | \ + ((unsigned long) buf[2] << 16) | \ + ((unsigned long) buf[1] << 8) | \ + ((unsigned long) buf[0]); \ +} + +/* PUBLIC FUNCTIONS */ +/* open an smk (from a generic Source) */ +static smk smk_open_generic(const unsigned char m, union smk_read_t fp, unsigned long size, const unsigned char process_mode) +{ + smk s = NULL; + + /* Temporary variables */ + long temp_l; + unsigned long temp_u; + + /* r is used by macros above for return code */ + char r; + unsigned char buf[4] = {'\0'}; + + /* video hufftrees are stored as a large chunk (bitstream) + these vars are used to load, then decode them */ + unsigned char* hufftree_chunk = NULL; + unsigned long tree_size; + /* a bitstream struct */ + struct smk_bit_t* bs = NULL; + + /* safe malloc the structure */ + smk_malloc(s,sizeof (struct smk_t)); + + /* Check for a valid signature */ + smk_read(buf,3); + if (buf[0] != 'S' || buf[1] != 'M' || buf[2] != 'K') + { + fprintf(stderr,"libsmacker::smk_open_generic - ERROR: invalid SMKn signature (got: %s)\n",buf); + goto error; + } + + /* Read .smk file version */ + smk_read(&s->video.v,1); + if (s->video.v != '2' && s->video.v != '4') + { + fprintf(stderr,"libsmacker::smk_open_generic - Warning: invalid SMK version %c (expected: 2 or 4)\n",s->video.v); + /* take a guess */ + if (s->video.v < '4') + s->video.v = '2'; + else + s->video.v = '4'; + fprintf(stderr,"\tProcessing will continue as type %c\n",s->video.v); + } + + /* width, height, total num frames */ + smk_read_ul(s->video.w); + smk_read_ul(s->video.h); + + smk_read_ul(s->f); + + /* frames per second calculation */ + smk_read_ul(temp_u); + temp_l = (int)temp_u; + if (temp_l > 0) + { + /* millisec per frame */ + s->usf = temp_l * 1000; + } + else if (temp_l < 0) + { + /* 10 microsec per frame */ + s->usf = temp_l * -10; + } + else + { + /* defaults to 10 usf (= 100000 microseconds) */ + s->usf = 100000; + } + + /* Video flags follow. + Ring frame is important to libsmacker. + Y scale / Y interlace go in the Video flags. + The user should scale appropriately. */ + smk_read_ul(temp_u); + if (temp_u & 0x01) + { + s->ring_frame = 1; + } + if (temp_u & 0x02) + { + s->video.y_scale_mode = SMK_FLAG_Y_DOUBLE; + } + if (temp_u & 0x04) + { + if (s->video.y_scale_mode == SMK_FLAG_Y_DOUBLE) + { + fputs("libsmacker::smk_open_generic - Warning: SMK file specifies both Y-Double AND Y-Interlace.\n",stderr); + } + s->video.y_scale_mode = SMK_FLAG_Y_INTERLACE; + } + + /* Max buffer size for each audio track - used to pre-allocate buffers */ + for (temp_l = 0; temp_l < 7; temp_l ++) + { + smk_read_ul(s->audio[temp_l].max_buffer); + } + + /* Read size of "hufftree chunk" - save for later. */ + smk_read_ul(tree_size); + + /* "unpacked" sizes of each huff tree - we don't use + but calling application might. */ + for (temp_l = 0; temp_l < 4; temp_l ++) + { +/* smk_read_ul(s->video.tree_size[temp_u]); */ + smk_read_ul(temp_u); + } + + /* read audio rate data */ + for (temp_l = 0; temp_l < 7; temp_l ++) + { + smk_read_ul(temp_u); + if (temp_u & 0x40000000) + { + /* Audio track specifies "exists" flag, malloc structure and copy components. */ + s->audio[temp_l].exists = 1; + + /* and for all audio tracks */ + smk_malloc(s->audio[temp_l].buffer, s->audio[temp_l].max_buffer); + + if (temp_u & 0x80000000) + { + s->audio[temp_l].compress = 1; + } + s->audio[temp_l].bitdepth = ((temp_u & 0x20000000) ? 16 : 8); + s->audio[temp_l].channels = ((temp_u & 0x10000000) ? 2 : 1); + if (temp_u & 0x0c000000) + { + fprintf(stderr,"libsmacker::smk_open_generic - Warning: audio track %ld is compressed with Bink (perceptual) Audio Codec: this is currently unsupported by libsmacker\n",temp_l); + s->audio[temp_l].compress = 2; + } + /* Bits 25 & 24 are unused. */ + s->audio[temp_l].rate = (temp_u & 0x00FFFFFF); + } + } + + /* Skip over Dummy field */ + smk_read_ul(temp_u); + + /* FrameSizes and Keyframe marker are stored together. */ + smk_malloc(s->keyframe,(s->f + s->ring_frame)); + smk_malloc(s->chunk_size,(s->f + s->ring_frame) * sizeof(unsigned long)); + + for (temp_u = 0; temp_u < (s->f + s->ring_frame); temp_u ++) + { + smk_read_ul(s->chunk_size[temp_u]); + + /* Set Keyframe */ + if (s->chunk_size[temp_u] & 0x01) + { + s->keyframe[temp_u] = 1; + } + /* Bits 1 is used, but the purpose is unknown. */ + s->chunk_size[temp_u] &= 0xFFFFFFFC; + } + + /* That was easy... Now read FrameTypes! */ + smk_malloc(s->frame_type,(s->f + s->ring_frame)); + for (temp_u = 0; temp_u < (s->f + s->ring_frame); temp_u ++) + { + smk_read(&s->frame_type[temp_u],1); + } + + /* HuffmanTrees + We know the sizes already: read and assemble into + something actually parse-able at run-time */ + smk_malloc(hufftree_chunk,tree_size); + smk_read(hufftree_chunk,tree_size); + + /* set up a Bitstream */ + bs = smk_bs_init(hufftree_chunk, tree_size); + /* create some tables */ + for (temp_u = 0; temp_u < 4; temp_u ++) + { + smk_huff16_build(bs,s->video.tree[temp_u]); + } + + /* clean up */ + smk_free(bs); + smk_free(hufftree_chunk); + + /* Go ahead and malloc storage for the video frame */ + smk_malloc(s->video.frame,s->video.w * s->video.h); + + /* final processing: depending on ProcessMode, handle what to do with rest of file data */ + s->mode = process_mode; + + /* Handle the rest of the data. + For MODE_MEMORY, read the chunks and store */ + if (s->mode == SMK_MODE_MEMORY) + { + smk_malloc(s->source.chunk_data,(s->f + s->ring_frame) * sizeof(unsigned char*)); + for (temp_u = 0; temp_u < (s->f + s->ring_frame); temp_u ++) + { + smk_malloc(s->source.chunk_data[temp_u],s->chunk_size[temp_u]); + smk_read(s->source.chunk_data[temp_u],s->chunk_size[temp_u]); + } + } + else + { + /* MODE_STREAM: don't read anything now, just precompute offsets. + use fseek to verify that the file is "complete" */ + smk_malloc(s->source.file.chunk_offset,(s->f + s->ring_frame) * sizeof(unsigned long)); + for (temp_u = 0; temp_u < (s->f + s->ring_frame); temp_u ++) + { + s->source.file.chunk_offset[temp_u] = ftell(fp.file); + if (fseek(fp.file,s->chunk_size[temp_u],SEEK_CUR)) + { + fprintf(stderr,"libsmacker::smk_open - ERROR: fseek to frame %lu not OK.\n",temp_u); + perror ("\tError reported was"); + goto error; + } + } + } + + return s; + +error: + smk_free(bs); + smk_free(hufftree_chunk); + smk_close(s); + return NULL; +} + +/* open an smk (from a memory buffer) */ +smk smk_open_memory(const unsigned char* buffer, const unsigned long size) +{ + smk s = NULL; + + union smk_read_t fp; + + smk_assert(buffer); + + /* set up the read union for Memory mode */ + fp.ram = (unsigned char*)buffer; + + if (!(s = smk_open_generic(0,fp,size,SMK_MODE_MEMORY))) + { + fprintf(stderr,"libsmacker::smk_open_memory(buffer,%lu) - ERROR: Fatal error in smk_open_generic, returning NULL.\n",size); + } + + /* fall through, return s or null */ +error: + return s; +} + +/* open an smk (from a file) */ +smk smk_open_filepointer(FILE* file, const unsigned char mode) +{ + smk s = NULL; + union smk_read_t fp; + + smk_assert(file); + + /* Copy file ptr to internal union */ + fp.file = file; + + if (!(s = smk_open_generic(1,fp,0,mode))) + { + fprintf(stderr,"libsmacker::smk_open_filepointer(file,%u) - ERROR: Fatal error in smk_open_generic, returning NULL.\n",mode); + fclose(fp.file); + goto error; + } + + if (mode == SMK_MODE_MEMORY) + { + fclose(fp.file); + } + else + { + s->source.file.fp = fp.file; + } + + /* fall through, return s or null */ +error: + return s; +} + +/* open an smk (from a file) */ +smk smk_open_file(const char* filename, const unsigned char mode) +{ + FILE* fp; + + smk_assert(filename); + + if (!(fp = fopen(filename,"rb"))) + { + fprintf(stderr,"libsmacker::smk_open_file(%s,%u) - ERROR: could not open file (errno: %d)\n",filename,mode,errno); + perror ("\tError reported was"); + goto error; + } + + /* kick processing to smk_open_filepointer */ + return smk_open_filepointer(fp,mode); + + /* fall through, return s or null */ +error: + return NULL; +} + +/* close out an smk file and clean up memory */ +void smk_close(smk s) +{ + unsigned long u; + + smk_assert(s); + + /* free video sub-components */ + { + for (u = 0; u < 4; u ++) + { + if (s->video.tree[u]) smk_huff16_free(s->video.tree[u]); + } + smk_free(s->video.frame); + } + + /* free audio sub-components */ + for (u=0; u<7; u++) + { + smk_free(s->audio[u].buffer); + } + + smk_free(s->keyframe); + smk_free(s->frame_type); + + if (s->mode == SMK_MODE_DISK) + { + /* disk-mode */ + if (s->source.file.fp) + { + fclose(s->source.file.fp); + } + smk_free(s->source.file.chunk_offset); + } + else + { + /* mem-mode */ + if (s->source.chunk_data != NULL) + { + for (u=0; u<(s->f + s->ring_frame); u++) + { + smk_free(s->source.chunk_data[u]); + } + smk_free(s->source.chunk_data); + } + } + smk_free(s->chunk_size); + + smk_free(s); + +error: ; +} + +/* tell some info about the file */ +char smk_info_all(const smk object, unsigned long* frame, unsigned long* frame_count, double* usf) +{ + /* sanity check */ + smk_assert(object); + if (!frame && !frame_count && !usf) { + fputs("libsmacker::smk_info_all(object,frame,frame_count,usf) - ERROR: Request for info with all-NULL return references\n",stderr); + goto error; + } + if (frame) + *frame = (object->cur_frame % object->f); + + if (frame_count) + *frame_count = object->f; + + if (usf) + *usf = object->usf; + + return 0; + +error: + return -1; +} + +char smk_info_video(const smk object, unsigned long* w, unsigned long* h, unsigned char* y_scale_mode) +{ + /* sanity check */ + smk_assert(object); + if (!w && !h && !y_scale_mode) + { + fputs("libsmacker::smk_info_all(object,w,h,y_scale_mode) - ERROR: Request for info with all-NULL return references\n",stderr); + return -1; + } + + if (w) + *w = object->video.w; + + if (h) + *h = object->video.h; + + if (y_scale_mode) + *y_scale_mode = object->video.y_scale_mode; + + return 0; + +error: + return -1; +} + +char smk_info_audio(const smk object, unsigned char* track_mask, unsigned char channels[7], unsigned char bitdepth[7], unsigned long audio_rate[7]) +{ + unsigned char i; + + /* sanity check */ + smk_assert(object); + + if (!track_mask && !channels && !bitdepth && !audio_rate) + { + fputs("libsmacker::smk_info_audio(object,track_mask,channels,bitdepth,audio_rate) - ERROR: Request for info with all-NULL return references\n",stderr); + return -1; + } + if (track_mask) + { + *track_mask = ( (object->audio[0].exists) | + ( (object->audio[1].exists) << 1 ) | + ( (object->audio[2].exists) << 2 ) | + ( (object->audio[3].exists) << 3 ) | + ( (object->audio[4].exists) << 4 ) | + ( (object->audio[5].exists) << 5 ) | + ( (object->audio[6].exists) << 6 ) ); + } + if (channels) + { + for (i = 0; i < 7; i ++) + { + channels[i] = object->audio[i].channels; + } + } + if (bitdepth) + { + for (i = 0; i < 7; i ++) + { + bitdepth[i] = object->audio[i].bitdepth; + } + } + if (audio_rate) + { + for (i = 0; i < 7; i ++) + { + audio_rate[i] = object->audio[i].rate; + } + } + return 0; + +error: + return -1; +} + +/* Enable-disable switches */ +char smk_enable_all(smk object, const unsigned char mask) +{ + unsigned char i; + + /* sanity check */ + smk_assert(object); + + /* set video-enable */ + object->video.enable = (mask & 0x80); + + for (i = 0; i < 7; i ++) + { + if (object->audio[i].exists) + { + object->audio[i].enable = (mask & (1 << i)); + } + } + + return 0; + +error: + return -1; +} + +char smk_enable_video(smk object, const unsigned char enable) +{ + /* sanity check */ + smk_assert(object); + + object->video.enable = enable; + return 0; + +error: + return -1; +} + +char smk_enable_audio(smk object, const unsigned char track, const unsigned char enable) +{ + /* sanity check */ + smk_assert(object); + + object->audio[track].enable = enable; + return 0; + +error: + return -1; +} + +const unsigned char* smk_get_palette(const smk object) +{ + smk_assert(object); + + return (unsigned char*)object->video.palette; + +error: + return NULL; +} +const unsigned char* smk_get_video(const smk object) +{ + smk_assert(object); + + return object->video.frame; + +error: + return NULL; +} +const unsigned char* smk_get_audio(const smk object, const unsigned char t) +{ + smk_assert(object); + + return object->audio[t].buffer; + +error: + return NULL; +} +unsigned long smk_get_audio_size(const smk object, const unsigned char t) +{ + smk_assert(object); + + return object->audio[t].buffer_size; + +error: + return 0; +} + +/* Decompresses a palette-frame. */ +static char smk_render_palette(struct smk_video_t* s, unsigned char* p, unsigned long size) +{ + /* Index into palette */ + unsigned short i = 0; + /* Helper variables */ + unsigned short count, src; + + static unsigned char oldPalette[256][3]; + + /* Smacker palette map: smk colors are 6-bit, this table expands them to 8. */ + const unsigned char palmap[64] = + { + 0x00, 0x04, 0x08, 0x0C, 0x10, 0x14, 0x18, 0x1C, + 0x20, 0x24, 0x28, 0x2C, 0x30, 0x34, 0x38, 0x3C, + 0x41, 0x45, 0x49, 0x4D, 0x51, 0x55, 0x59, 0x5D, + 0x61, 0x65, 0x69, 0x6D, 0x71, 0x75, 0x79, 0x7D, + 0x82, 0x86, 0x8A, 0x8E, 0x92, 0x96, 0x9A, 0x9E, + 0xA2, 0xA6, 0xAA, 0xAE, 0xB2, 0xB6, 0xBA, 0xBE, + 0xC3, 0xC7, 0xCB, 0xCF, 0xD3, 0xD7, 0xDB, 0xDF, + 0xE3, 0xE7, 0xEB, 0xEF, 0xF3, 0xF7, 0xFB, 0xFF + }; + + /* sanity check */ + smk_assert(s); + smk_assert(p); + + // Copy palette to old palette + memcpy(oldPalette, s->palette, 256 * 3); + + /* Loop until palette is complete, or we are out of bytes to process */ + while ( (i < 256) && (size > 0) ) + { + if ((*p) & 0x80) + { + /* 0x80: Skip block + (preserve C+1 palette entries from previous palette) */ + count = ((*p) & 0x7F) + 1; + p ++; size --; + + /* check for overflow condition */ + if (i + count > 256) + { + fprintf(stderr,"libsmacker::palette_render(s,p,size) - ERROR: overflow, 0x80 attempt to skip %d entries from %d\n",count,i); + goto error; + } + + /* finally: advance the index. */ + i += count; + } + else if ((*p) & 0x40) + { + /* 0x40: Color-shift block + Copy (c + 1) color entries of the previous palette, + starting from entry (s), + to the next entries of the new palette. */ + if (size < 2) + { + fputs("libsmacker::palette_render(s,p,size) - ERROR: 0x40 ran out of bytes for copy\n",stderr); + goto error; + } + + /* pick "count" items to copy */ + count = ((*p) & 0x3F) + 1; + p ++; size --; + + /* start offset of old palette */ + src = *p; + p ++; size --; + + /* overflow: see if we write/read beyond 256colors, or overwrite own palette */ + if (i + count > 256 || src + count > 256 || + (src < i && src + count > i) ) + { + fprintf(stderr,"libsmacker::palette_render(s,p,size) - ERROR: overflow, 0x40 attempt to copy %d entries from %d to %d\n",count,src,i); + goto error; + } + + /* OK! Copy the color-palette entries. */ + memmove(&s->palette[i][0],&oldPalette[src][0],count * 3); + + i += count; + } + else + { + /* 0x00: Set Color block + Direct-set the next 3 bytes for palette index */ + if (size < 3) + { + fprintf(stderr,"libsmacker::palette_render - ERROR: 0x3F ran out of bytes for copy, size=%lu\n", size); + goto error; + } + + for (count = 0; count < 3; count ++) + { + if (*p > 0x3F) + { + fprintf(stderr,"libsmacker::palette_render - ERROR: palette index exceeds 0x3F (entry [%u][%u])\n", i, count); + goto error; + } + s->palette[i][count] = palmap[*p]; + p++; size --; + } + i ++; + } + } + + if (i < 256) + { + fprintf(stderr,"libsmacker::palette_render - ERROR: did not completely fill palette (idx=%u)\n",i); + goto error; + } + + return 0; + +error: + /* Error, return -1 + The new palette probably has errors but is preferrable to a black screen */ + return -1; +} + +static char smk_render_video(struct smk_video_t* s, unsigned char* p, unsigned int size) +{ + unsigned char* t = s->frame; + unsigned char s1,s2; + unsigned short temp; + unsigned long i,j,k, row, col,skip; + + /* used for video decoding */ + struct smk_bit_t* bs = NULL; + + /* results from a tree lookup */ + long unpack; + + /* unpack, broken into pieces */ + unsigned char type; + unsigned char blocklen; + unsigned char typedata; + char bit; + + const unsigned short sizetable[64] = { + 1, 2, 3, 4, 5, 6, 7, 8, + 9, 10, 11, 12, 13, 14, 15, 16, + 17, 18, 19, 20, 21, 22, 23, 24, + 25, 26, 27, 28, 29, 30, 31, 32, + 33, 34, 35, 36, 37, 38, 39, 40, + 41, 42, 43, 44, 45, 46, 47, 48, + 49, 50, 51, 52, 53, 54, 55, 56, + 57, 58, 59, 128, 256, 512, 1024, 2048 + }; + + /* sanity check */ + smk_assert(s); + smk_assert(p); + + row = 0; + col = 0; + + /* Set up a bitstream for video unpacking */ + /* We could check the return code but it will only fail if p is null and we already verified that. */ + bs = smk_bs_init (p, size); + + /* Reset the cache on all bigtrees */ + smk_huff16_reset(s->tree[0]); + smk_huff16_reset(s->tree[1]); + smk_huff16_reset(s->tree[2]); + smk_huff16_reset(s->tree[3]); + + while ( row < s->h ) + { + smk_huff16_lookup(bs,s->tree[SMK_TREE_TYPE],unpack); + + type = ((unpack & 0x0003)); + blocklen = ((unpack & 0x00FC) >> 2); + typedata = ((unpack & 0xFF00) >> 8); + + /* support for v4 full-blocks */ + if (type == 1 && s->v == '4') + { + smk_bs_read_1(bs, bit); + if (bit) + { + type = 4; + } else { + smk_bs_read_1(bs, bit); + if (bit) + { + type = 5; + } + } + } + + for (j = 0; (j < sizetable[blocklen]) && (row < s->h); j ++) + { + skip = (row * s->w) + col; + switch(type) + { + case 0: + smk_huff16_lookup(bs,s->tree[SMK_TREE_MCLR],unpack); + s1 = (unpack & 0xFF00) >> 8; + s2 = (unpack & 0x00FF); + smk_huff16_lookup(bs,s->tree[SMK_TREE_MMAP],unpack); + + temp = 0x01; + for (k = 0; k < 4; k ++) + { + for (i = 0; i < 4; i ++) + { + if (unpack & temp) + { + t[skip + i] = s1; + } + else + { + t[skip + i] = s2; + } + temp = temp << 1; + } + skip += s->w; + } + break; + + case 1: /* FULL BLOCK */ + for (k = 0; k < 4; k ++) + { + smk_huff16_lookup(bs,s->tree[SMK_TREE_FULL],unpack); + t[skip + 3] = ((unpack & 0xFF00) >> 8); + t[skip + 2] = (unpack & 0x00FF); + smk_huff16_lookup(bs,s->tree[SMK_TREE_FULL],unpack); + t[skip + 1] = ((unpack & 0xFF00) >> 8); + t[skip] = (unpack & 0x00FF); + skip += s->w; + } + break; + case 2: /* VOID BLOCK */ + /* break; + if (s->frame) + { + memcpy(&t[skip], &s->frame[skip], 4); + skip += s->w; + memcpy(&t[skip], &s->frame[skip], 4); + skip += s->w; + memcpy(&t[skip], &s->frame[skip], 4); + skip += s->w; + memcpy(&t[skip], &s->frame[skip], 4); + } */ + break; + case 3: /* SOLID BLOCK */ + memset(&t[skip],typedata,4); + skip += s->w; + memset(&t[skip],typedata,4); + skip += s->w; + memset(&t[skip],typedata,4); + skip += s->w; + memset(&t[skip],typedata,4); + break; + case 4: /* V4 DOUBLE BLOCK */ + for (k = 0; k < 2; k ++) + { + smk_huff16_lookup(bs,s->tree[SMK_TREE_FULL],unpack); + for (i = 0; i < 2; i ++) + { + memset(&t[skip + 2],(unpack & 0xFF00) >> 8,2); + memset(&t[skip],(unpack & 0x00FF),2); + skip += s->w; + } + } + break; + case 5: /* V4 HALF BLOCK */ + for (k = 0; k < 2; k ++) + { + smk_huff16_lookup(bs,s->tree[SMK_TREE_FULL],unpack); + t[skip + 3] = ((unpack & 0xFF00) >> 8); + t[skip + 2] = (unpack & 0x00FF); + t[skip + s->w + 3] = ((unpack & 0xFF00) >> 8); + t[skip + s->w + 2] = (unpack & 0x00FF); + smk_huff16_lookup(bs,s->tree[SMK_TREE_FULL],unpack); + t[skip + 1] = ((unpack & 0xFF00) >> 8); + t[skip] = (unpack & 0x00FF); + t[skip + s->w + 1] = ((unpack & 0xFF00) >> 8); + t[skip + s->w] = (unpack & 0x00FF); + skip += (s->w << 1); + } + break; + } + col += 4; + if (col >= s->w) + { + col = 0; + row += 4; + } + } + } + + smk_free(bs); + + return 0; + +error: + smk_free(bs); + return -1; +} + +/* Decompress audio track i. */ +static char smk_render_audio(struct smk_audio_t* s, unsigned char* p, unsigned long size) +{ + unsigned int j,k; + unsigned char* t = s->buffer; + struct smk_bit_t* bs = NULL; + + char bit; + short unpack, unpack2; + + /* used for audio decoding */ + struct smk_huff8_t* aud_tree[4] = {NULL,NULL,NULL,NULL}; + + /* sanity check */ + smk_assert(s); + smk_assert(p); + + if (!s->compress) + { + /* Raw PCM data, update buffer size and malloc */ + s->buffer_size = size; + + memcpy(t,p,size); + } + else if (s->compress == 1) + { + /* SMACKER DPCM compression */ + /* need at least 4 bytes to process */ + if (size < 4) + { + fputs("libsmacker::smk_render_audio() - ERROR: need 4 bytes to get unpacked output buffer size.\n",stderr); + goto error; + } + /* chunk is compressed (huff-compressed dpcm), retrieve unpacked buffer size */ + s->buffer_size = ((unsigned int) p[3] << 24) | + ((unsigned int) p[2] << 16) | + ((unsigned int) p[1] << 8) | + ((unsigned int) p[0]); + + p += 4; + size -= 4; + + /* Compressed audio: must unpack here */ + /* Set up a bitstream */ + bs = smk_bs_init (p, size); + + smk_bs_read_1(bs,bit); + + if (!bit) + { + fputs("libsmacker::smk_render_audio - ERROR: initial get_bit returned 0\n",stderr); + goto error; + } + + smk_bs_read_1(bs,bit); + if (s->channels != (bit == 1 ? 2 : 1)) + { + fputs("libsmacker::smk_render - ERROR: mono/stereo mismatch\n",stderr); + } + smk_bs_read_1(bs,bit); + if (s->bitdepth != (bit == 1 ? 16 : 8)) + { + fputs("libsmacker::smk_render - ERROR: 8-/16-bit mismatch\n",stderr); + } + + /* build the trees */ + smk_huff8_build(bs,aud_tree[0]); + j = 1; + k = 1; + if (s->bitdepth == 16) + { + smk_huff8_build(bs,aud_tree[1]); + k = 2; + } + if (s->channels == 2) + { + smk_huff8_build(bs,aud_tree[2]); + j = 2; + k = 2; + if (s->bitdepth == 16) + { + smk_huff8_build(bs,aud_tree[3]); + k = 4; + } + } + + /* read initial sound level */ + if (s->channels == 2) + { + smk_bs_read_8(bs,unpack); + if (s->bitdepth == 16) + { + smk_bs_read_8(bs,((short*)t)[1]) + ((short*)t)[1] |= (unpack << 8); + } + else + { + ((unsigned char*)t)[1] = (unsigned char)unpack; + } + } + smk_bs_read_8(bs,unpack); + if (s->bitdepth == 16) + { + smk_bs_read_8(bs,((short*)t)[0]) + ((short*)t)[0] |= (unpack << 8); + } + else + { + ((unsigned char*)t)[0] = (unsigned char)unpack; + } + + /* All set: let's read some DATA! */ + while (k < s->buffer_size) + { + if (s->bitdepth == 8) + { + smk_huff8_lookup(bs,aud_tree[0],unpack); + ((unsigned char*)t)[j] = (char)unpack + ((unsigned char*)t)[j - s->channels]; + j ++; + k++; + } + else + { + smk_huff8_lookup(bs,aud_tree[0],unpack); + smk_huff8_lookup(bs,aud_tree[1],unpack2); + ((short*)t)[j] = (short) ( unpack | (unpack2 << 8) ) + ((short*)t)[j - s->channels]; + j ++; + k+=2; + } + if (s->channels == 2) + { + if (s->bitdepth == 8) + { + smk_huff8_lookup(bs,aud_tree[2],unpack); + ((unsigned char*)t)[j] = (char)unpack + ((unsigned char*)t)[j - 2]; + j ++; + k++; + } + else + { + smk_huff8_lookup(bs,aud_tree[2],unpack); + smk_huff8_lookup(bs,aud_tree[3],unpack2); + ((short*)t)[j] = (short) ( unpack | (unpack2 << 8) ) + ((short*)t)[j - 2]; + j ++; + k+=2; + } + } + } + + /* All done with the trees, free them. */ + for (j = 0; j < 4; j ++) + { + if (aud_tree[j]) + { + smk_huff8_free(aud_tree[j]); + } + } + + /* free bitstream */ + smk_free(bs); + } + + return 0; + +error: + /* All done with the trees, free them. */ + for (j = 0; j < 4; j ++) + { + if (aud_tree[j]) + { + smk_huff8_free(aud_tree[j]); + } + } + + smk_free(bs); + + return -1; +} + +/* "Renders" (unpacks) the frame at cur_frame + Preps all the image and audio pointers */ +static char smk_render(smk s) +{ + unsigned long i,size; + unsigned char* buffer = NULL,* p,track; + + /* sanity check */ + smk_assert(s); + + /* Retrieve current chunk_size for this frame. */ + if (!(i = s->chunk_size[s->cur_frame])) + { + fprintf(stderr,"libsmacker::smk_render(s) - Warning: frame %lu: chunk_size is 0.\n",s->cur_frame); + goto error; + } + + if (s->mode == SMK_MODE_DISK) + { + /* Skip to frame in file */ + if (fseek(s->source.file.fp,s->source.file.chunk_offset[s->cur_frame],SEEK_SET)) + { + fprintf(stderr,"libsmacker::smk_render(s) - ERROR: fseek to frame %lu (offset %lu) failed.\n",s->cur_frame,s->source.file.chunk_offset[s->cur_frame]); + perror ("\tError reported was"); + goto error; + } + + /* In disk-streaming mode: make way for our incoming chunk buffer */ + smk_malloc(buffer, i); + + /* Read into buffer */ + if ( smk_read_file(buffer,s->chunk_size[s->cur_frame],s->source.file.fp) < 0) + { + fprintf(stderr,"libsmacker::smk_render(s) - ERROR: frame %lu (offset %lu): smk_read had errors.\n",s->cur_frame,s->source.file.chunk_offset[s->cur_frame]); + goto error; + } + } + else + { + /* Just point buffer at the right place */ + if (!s->source.chunk_data[s->cur_frame]) + { + fprintf(stderr,"libsmacker::smk_render(s) - ERROR: frame %lu: memory chunk is a NULL pointer.\n",s->cur_frame); + goto error; + } + buffer = s->source.chunk_data[s->cur_frame]; + } + + p = buffer; + + /* Palette record first */ + if (s->frame_type[s->cur_frame] & 0x01) + { + /* need at least 1 byte to process */ + if (!i) + { + fprintf(stderr,"libsmacker::smk_render(s) - ERROR: frame %lu: insufficient data for a palette rec.\n",s->cur_frame); + goto error; + } + + /* Byte 1 in block, times 4, tells how many + subsequent bytes are present */ + size = 4 * (*p); + + /* If video rendering enabled, kick this off for decode. */ + if (s->video.enable) + { + smk_render_palette(&(s->video),p + 1,size - 1); + } + p += size; + i -= size; + } + + /* Unpack audio chunks */ + for (track = 0; track < 7; track ++) + { + if (s->frame_type[s->cur_frame] & (0x02 << track)) + { + /* need at least 4 byte to process */ + if (i < 4) + { + fprintf(stderr,"libsmacker::smk_render(s) - ERROR: frame %lu: insufficient data for audio[%u] rec.\n",s->cur_frame,track); + goto error; + } + + /* First 4 bytes in block tell how many + subsequent bytes are present */ + size = (((unsigned int) p[3] << 24) | + ((unsigned int) p[2] << 16) | + ((unsigned int) p[1] << 8) | + ((unsigned int) p[0])); + + /* If audio rendering enabled, kick this off for decode. */ + if (s->audio[track].enable) + { + smk_render_audio(&s->audio[track],p + 4,size - 4); + } + p += size; + i -= size; + } + } + + /* Unpack video chunk */ + if (s->video.enable) + { + smk_render_video(&(s->video), p,i); + } + + if (s->mode == SMK_MODE_DISK) + { + /* Remember that buffer we allocated? Trash it */ + smk_free(buffer); + } + + return 0; + +error: + if (s->mode == SMK_MODE_DISK) + { + /* Remember that buffer we allocated? Trash it */ + smk_free(buffer); + } + + return -1; +} + +/* rewind to first frame and unpack */ +char smk_first(smk s) +{ + smk_assert(s); + + s->cur_frame = 0; + if ( smk_render(s) < 0) + { + fprintf(stderr,"libsmacker::smk_first(s) - Warning: frame %lu: smk_render returned errors.\n",s->cur_frame); + goto error; + } + + if (s->f == 1) return SMK_LAST; + return SMK_MORE; + +error: + return -1; +} + +/* advance to next frame */ +char smk_next(smk s) +{ + smk_assert(s); + + if (s->cur_frame + 1 < (s->f + s->ring_frame)) + { + s->cur_frame ++; + if ( smk_render(s) < 0) + { + fprintf(stderr,"libsmacker::smk_next(s) - Warning: frame %lu: smk_render returned errors.\n",s->cur_frame); + goto error; + } + if (s->cur_frame + 1 == (s->f + s->ring_frame)) + { + return SMK_LAST; + } + return SMK_MORE; + } + else if (s->ring_frame) + { + s->cur_frame = 1; + if ( smk_render(s) < 0) + { + fprintf(stderr,"libsmacker::smk_next(s) - Warning: frame %lu: smk_render returned errors.\n",s->cur_frame); + goto error; + } + if (s->cur_frame + 1 == (s->f + s->ring_frame)) + { + return SMK_LAST; + } + return SMK_MORE; + } + return SMK_DONE; + +error: + return -1; +} + +/* seek to a keyframe in an smk */ +char smk_seek_keyframe(smk s, unsigned long f) +{ + smk_assert(s); + + /* rewind (or fast forward!) exactly to f */ + s->cur_frame = f; + + /* roll back to previous keyframe in stream, or 0 if no keyframes exist */ + while (s->cur_frame > 0 && !(s->keyframe[s->cur_frame])) + { + s->cur_frame --; + } + + /* render the frame: we're ready */ + if (smk_render(s) < 0) + { + fprintf(stderr,"libsmacker::smk_seek_keyframe(s,%lu) - Warning: frame %lu: smk_render returned errors.\n",f,s->cur_frame); + goto error; + } + + return 0; + +error: + return -1; +} diff --git a/3rdParty/libsmacker/smacker.h b/3rdParty/libsmacker/smacker.h new file mode 100644 index 000000000..3e769c96a --- /dev/null +++ b/3rdParty/libsmacker/smacker.h @@ -0,0 +1,110 @@ +/** + libsmacker - A C library for decoding .smk Smacker Video files + Copyright (C) 2012-2017 Greg Kennedy + + libsmacker is a cross-platform C library which can be used for + decoding Smacker Video files produced by RAD Game Tools. + + This software is released under the following license: + Creative Commons Attribution-NonCommercial 2.0 (CC BY-NC 2.0) + + You are free: + * to Share - to copy, distribute and transmit the work + * to Remix - to adapt the work + + Under the following conditions: + + * Attribution - You must attribute the work in the manner specified by + the author or licensor (but not in any way that suggests that + they endorse you or your use of the work). + * Noncommercial - You may not use this work for commercial purposes. + + This is a human-readable summary of the Legal Code (the full license). + + You should have received a copy of the full license + along with libsmacker. If not, see + . +*/ + +#ifndef SMACKER_H +#define SMACKER_H + +/* includes - needed for FILE* here */ +#include + +/** forward-declaration for an struct */ +typedef struct smk_t* smk; + +/** a few defines as return codes from smk_next() */ +#define SMK_DONE 0x00 +#define SMK_MORE 0x01 +#define SMK_LAST 0x02 +#define SMK_ERROR -1 + +/** file-processing mode, pass to smk_open_file */ +#define SMK_MODE_DISK 0x00 +#define SMK_MODE_MEMORY 0x01 + +/** Y-scale meanings */ +#define SMK_FLAG_Y_NONE 0x00 +#define SMK_FLAG_Y_INTERLACE 0x01 +#define SMK_FLAG_Y_DOUBLE 0x02 + +/** track mask and enable bits */ +#define SMK_AUDIO_TRACK_0 0x01 +#define SMK_AUDIO_TRACK_1 0x02 +#define SMK_AUDIO_TRACK_2 0x04 +#define SMK_AUDIO_TRACK_3 0x08 +#define SMK_AUDIO_TRACK_4 0x10 +#define SMK_AUDIO_TRACK_5 0x20 +#define SMK_AUDIO_TRACK_6 0x40 +#define SMK_VIDEO_TRACK 0x80 + +/* PUBLIC FUNCTIONS */ +#ifdef __cplusplus +extern "C" { +#endif + +/* OPEN OPERATIONS */ +/** open an smk (from a file) */ +smk smk_open_file(const char* filename, unsigned char mode); +/** open an smk (from a file pointer) */ +smk smk_open_filepointer(FILE* file, unsigned char mode); +/** read an smk (from a memory buffer) */ +smk smk_open_memory(const unsigned char* buffer, unsigned long size); + +/* CLOSE OPERATIONS */ +/** close out an smk file and clean up memory */ +void smk_close(smk object); + +/* GET FILE INFO OPERATIONS */ +char smk_info_all(const smk object, unsigned long* frame, unsigned long* frame_count, double* usf); +char smk_info_video(const smk object, unsigned long* w, unsigned long* h, unsigned char* y_scale_mode); +char smk_info_audio(const smk object, unsigned char* track_mask, unsigned char channels[7], unsigned char bitdepth[7], unsigned long audio_rate[7]); + +/* ENABLE/DISABLE Switches */ +char smk_enable_all(smk object, unsigned char mask); +char smk_enable_video(smk object, unsigned char enable); +char smk_enable_audio(smk object, unsigned char track, unsigned char enable); + +/** Retrieve palette */ +const unsigned char* smk_get_palette(const smk object); +/** Retrieve video frame, as a buffer of size w*h */ +const unsigned char* smk_get_video(const smk object); +/** Retrieve decoded audio chunk, track N */ +const unsigned char* smk_get_audio(const smk object, unsigned char track); +/** Get size of currently pointed decoded audio chunk, track N */ +unsigned long smk_get_audio_size(const smk object, unsigned char track); + +/** rewind to first frame and unpack */ +char smk_first(smk object); +/** advance to next frame and unpack */ +char smk_next(smk object); +/** seek to first keyframe before/at N in an smk */ +char smk_seek_keyframe(smk object, unsigned long frame); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/3rdParty/libsmacker/smk_bitstream.c b/3rdParty/libsmacker/smk_bitstream.c new file mode 100644 index 000000000..35797a747 --- /dev/null +++ b/3rdParty/libsmacker/smk_bitstream.c @@ -0,0 +1,119 @@ +/** + libsmacker - A C library for decoding .smk Smacker Video files + Copyright (C) 2012-2017 Greg Kennedy + + See smacker.h for more information. + + smk_bitstream.c + Implements a bitstream structure, which can extract and + return a bit at a time from a raw block of bytes. +*/ + +#include "smk_bitstream.h" + +/* malloc and friends */ +#include "smk_malloc.h" + +/* + Bitstream structure + Pointer to raw block of data and a size limit. + Maintains internal pointers to byte_num and bit_number. +*/ +struct smk_bit_t +{ + const unsigned char* buffer; + unsigned long size; + + unsigned long byte_num; + char bit_num; +}; + +/* BITSTREAM Functions */ +struct smk_bit_t* smk_bs_init(const unsigned char* b, const unsigned long size) +{ + struct smk_bit_t* ret = NULL; + + /* sanity check */ + smk_assert(b); + + /* allocate a bitstream struct */ + smk_malloc(ret, sizeof(struct smk_bit_t)); + + /* set up the pointer to bitstream, and the size counter */ + ret->buffer = b; + ret->size = size; + + /* point to initial byte: note, smk_malloc already sets these to 0 */ + /* ret->byte_num = 0; + ret->bit_num = 0; */ + + /* return ret or NULL if error : ) */ +error: + return ret; +} + +/* Reads a bit + Returns -1 if error encountered */ +char _smk_bs_read_1(struct smk_bit_t* bs) +{ + unsigned char ret = -1; + + /* sanity check */ + smk_assert(bs); + + /* don't die when running out of bits, but signal */ + if (bs->byte_num >= bs->size) + { + fprintf(stderr, "libsmacker::_smk_bs_read_1(bs): ERROR: bitstream (length=%lu) exhausted.\n", bs->size); + goto error; + } + + /* get next bit and return */ + ret = (((bs->buffer[bs->byte_num]) & (1 << bs->bit_num)) != 0); + + /* advance to next bit */ + bs->bit_num ++; + + /* Out of bits in this byte: next! */ + if (bs->bit_num > 7) + { + bs->byte_num ++; + bs->bit_num = 0; + } + + /* return ret, or (default) -1 if error */ +error: + return ret; +} + +/* Reads a byte + Returns -1 if error. */ +short _smk_bs_read_8(struct smk_bit_t* bs) +{ + unsigned char ret = -1; + + /* sanity check */ + smk_assert(bs); + + /* don't die when running out of bits, but signal */ + if (bs->byte_num + (bs->bit_num > 0) >= bs->size) + { + fprintf(stderr, "libsmacker::_smk_bs_read_8(bs): ERROR: bitstream (length=%lu) exhausted.\n", bs->size); + goto error; + } + + if (bs->bit_num) + { + /* unaligned read */ + ret = bs->buffer[bs->byte_num] >> bs->bit_num; + bs->byte_num ++; + ret |= (bs->buffer[bs->byte_num] << (8 - bs->bit_num)); + } else { + /* aligned read */ + ret = bs->buffer[bs->byte_num ++]; + } + + /* return ret, or (default) -1 if error */ +error: + return ret; +} diff --git a/3rdParty/libsmacker/smk_bitstream.h b/3rdParty/libsmacker/smk_bitstream.h new file mode 100644 index 000000000..3a99e209e --- /dev/null +++ b/3rdParty/libsmacker/smk_bitstream.h @@ -0,0 +1,50 @@ +/** + libsmacker - A C library for decoding .smk Smacker Video files + Copyright (C) 2012-2017 Greg Kennedy + + See smacker.h for more information. + + smk_bitstream.h + SMK bitstream structure. Presents a block of raw bytes one + bit at a time, and protects against over-read. +*/ + +#ifndef SMK_BITSTREAM_H +#define SMK_BITSTREAM_H + +/** Bitstream structure, Forward declaration */ +struct smk_bit_t; + +/* BITSTREAM Functions */ +/** Initialize a bitstream */ +struct smk_bit_t* smk_bs_init(const unsigned char* b, unsigned long size); + +/** This macro checks return code from _smk_bs_read_1 and + jumps to error label if problems occur. */ +#define smk_bs_read_1(t,uc) \ +{ \ + if ((char)(uc = _smk_bs_read_1(t)) < 0) \ + { \ + fprintf(stderr, "libsmacker::smk_bs_read_1(" #t ", " #uc ") - ERROR (file: %s, line: %lu)\n", __FILE__, (unsigned long)__LINE__); \ + goto error; \ + } \ +} +/** Read a single bit from the bitstream, and advance. + Returns -1 on error. */ +char _smk_bs_read_1(struct smk_bit_t* bs); + +/** This macro checks return code from _smk_bs_read_8 and + jumps to error label if problems occur. */ +#define smk_bs_read_8(t,s) \ +{ \ + if ((short)(s = _smk_bs_read_8(t)) < 0) \ + { \ + fprintf(stderr, "libsmacker::smk_bs_read_8(" #t ", " #s ") - ERROR (file: %s, line: %lu)\n", __FILE__, (unsigned long)__LINE__); \ + goto error; \ + } \ +} +/** Read eight bits from the bitstream (one byte), and advance. + Returns -1 on error. */ +short _smk_bs_read_8(struct smk_bit_t* bs); + +#endif diff --git a/3rdParty/libsmacker/smk_hufftree.c b/3rdParty/libsmacker/smk_hufftree.c new file mode 100644 index 000000000..cd6c98d0d --- /dev/null +++ b/3rdParty/libsmacker/smk_hufftree.c @@ -0,0 +1,425 @@ +/** + libsmacker - A C library for decoding .smk Smacker Video files + Copyright (C) 2012-2017 Greg Kennedy + + See smacker.h for more information. + + smk_hufftree.c + Implementation of Smacker Huffman coding trees. +*/ + +#include "smk_hufftree.h" + +/* malloc and friends */ +#include "smk_malloc.h" + +/** + 8-bit Tree node structure. + If b0 is non-null, this is a branch, and b1 from the union should be used. + If b0 is null, this is a leaf, and val / escape code from union should be used. +*/ +struct smk_huff8_t +{ + struct smk_huff8_t* b0; + union + { + struct smk_huff8_t* b1; + struct + { + unsigned short value; + unsigned char escapecode; + } leaf; + } u; +}; + +/** + 16-bit Tree root struct: holds a huff8_t structure, + as well as a cache of three 16-bit values. +*/ +struct smk_huff16_t +{ + struct smk_huff8_t* t; + unsigned short cache[3]; +}; + +/*********************** 8-BIT HUFF-TREE FUNCTIONS ***********************/ +/** safe build with built-in error jump */ +#define smk_huff8_build_rec(bs,p) \ +{ \ + if (!(p = _smk_huff8_build_rec(bs))) \ + { \ + fprintf(stderr, "libsmacker::smk_huff8_build_rec(" #bs ", " #p ") - ERROR (file: %s, line: %lu)\n", __FILE__, (unsigned long)__LINE__); \ + goto error; \ + } \ +} +/** Recursive tree-building function. */ +static struct smk_huff8_t* _smk_huff8_build_rec(struct smk_bit_t* bs) +{ + struct smk_huff8_t* ret = NULL; + char bit; + + /* sanity check - removed: bs cannot be null, because it was checked at smk_huff8_build below */ + /* smk_assert(bs); */ + + /* Read the bit */ + smk_bs_read_1(bs, bit); + + /* Malloc a structure. */ + smk_malloc(ret, sizeof(struct smk_huff8_t)); + + if (bit) + { + /* Bit set: this forms a Branch node. */ + /* Recursively attempt to build the Left branch. */ + smk_huff8_build_rec(bs, ret->b0); + + /* Everything is still OK: attempt to build the Right branch. */ + smk_huff8_build_rec(bs, ret->u.b1); + + /* return branch pointer here */ + return ret; + } + + /* Bit unset signifies a Leaf node. */ + /* Attempt to read value */ + smk_bs_read_8(bs, ret->u.leaf.value); + + /* smk_malloc sets entries to 0 by default */ + /* ret->b0 = NULL; */ + ret->u.leaf.escapecode = 0xFF; + + return ret; + +error: + /* In case of error, undo the subtree we were building, and return NULL. */ + smk_huff8_free(ret); + return NULL; +} + +/* Look up an 8-bit value from a basic huff tree. + Return -1 on error. */ +short _smk_huff8_lookup(struct smk_bit_t* bs, const struct smk_huff8_t* t) +{ + char bit; + + /* sanity check */ + smk_assert(bs); + smk_assert(t); + + if (!t->b0) + { + /* Reached a Leaf node. Return its value. */ + return t->u.leaf.value; + } + + /* Read the next bit from bitstream to determine path */ + smk_bs_read_1(bs, bit); + + if (bit) + { + /* get_bit returned Set, follow Right branch. */ + return _smk_huff8_lookup(bs, t->u.b1); + } + + /* follow Left branch */ + return _smk_huff8_lookup(bs, t->b0); + +error: + return -1; +} + +/** + Entry point for huff8 build. Basically just checks the start/end tags + and calls smk_huff8_build_rec recursive function. +*/ +struct smk_huff8_t* _smk_huff8_build(struct smk_bit_t* bs) +{ + struct smk_huff8_t* ret = NULL; + char bit; + + /* sanity check */ + smk_assert(bs); + + /* Smacker huff trees begin with a set-bit. */ + smk_bs_read_1(bs, bit); + + if (!bit) + { + /* Got a bit, but it was not 1. In theory, there could be a smk file + without this particular tree. */ + fputs("libsmacker::_smk_huff8_build(bs) - Warning: initial get_bit returned 0\n", stderr); + goto error; + } + + /* Begin parsing the tree data. */ + smk_huff8_build_rec(bs, ret); + + /* huff trees end with an unset-bit */ + smk_bs_read_1(bs, bit); + + if (bit) + { + fputs("libsmacker::_smk_huff8_build(bs) - ERROR: final get_bit returned 1\n", stderr); + goto error; + } + + return ret; + +error: + smk_huff8_free(ret); + return NULL; +} + +/* function to recursively delete a huffman tree */ +void smk_huff8_free(struct smk_huff8_t* t) +{ + /* Sanity check: do not double-free */ + smk_assert(t); + + /* If this is not a leaf node, free child trees first */ + if (t->b0) + { + smk_huff8_free(t->b0); + smk_huff8_free(t->u.b1); + } + + /* Safe-delete tree node. */ + smk_free(t); + +error: ; +} + +/*********************** 16-BIT HUFF-TREE FUNCTIONS ***********************/ +/* safe bigtree build with built-in error jump */ +#define smk_huff16_build_rec(bs,cache,low8,hi8,p) \ +{ \ + if (!(p = _smk_huff16_build_rec(bs, cache, low8, hi8))) \ + { \ + fprintf(stderr, "libsmacker::smk_huff16_build_rec(" #bs ", " #cache ", " #low8 ", " #hi8 ", " #p ") - ERROR (file: %s, line: %lu)\n", __FILE__, (unsigned long)__LINE__); \ + goto error; \ + } \ +} +/* Recursively builds a Big tree. */ +static struct smk_huff8_t* _smk_huff16_build_rec(struct smk_bit_t* bs, const unsigned short cache[3], const struct smk_huff8_t* low8, const struct smk_huff8_t* hi8) +{ + struct smk_huff8_t* ret = NULL; + + char bit; + short lowval; + + /* sanity check - removed: these cannot be null, because they were checked at smk_huff16_build below */ + /* smk_assert(bs); + smk_assert(cache); + smk_assert(low8); + smk_assert(hi8); */ + + /* Get the first bit */ + smk_bs_read_1(bs, bit); + + /* Malloc a structure. */ + smk_malloc(ret, sizeof(struct smk_huff8_t)); + + if (bit) + { + /* Recursively attempt to build the Left branch. */ + smk_huff16_build_rec(bs, cache, low8, hi8, ret->b0); + + /* Recursively attempt to build the Left branch. */ + smk_huff16_build_rec(bs, cache, low8, hi8, ret->u.b1); + + /* return branch pointer here */ + return ret; + } + + /* Bit unset signifies a Leaf node. */ + smk_huff8_lookup(bs, low8, lowval); + smk_huff8_lookup(bs, hi8, ret->u.leaf.value); + + /* Looks OK: we got low and hi values. Return a new LEAF */ + /* ret->b0 = NULL; */ + ret->u.leaf.value = lowval | (ret->u.leaf.value << 8); + + /* Last: when building the tree, some Values may correspond to cache positions. + Identify these values and set the Escape code byte accordingly. */ + if (ret->u.leaf.value == cache[0]) + { + ret->u.leaf.escapecode = 0; + } + else if (ret->u.leaf.value == cache[1]) + { + ret->u.leaf.escapecode = 1; + } + else if (ret->u.leaf.value == cache[2]) + { + ret->u.leaf.escapecode = 2; + } + else + { + ret->u.leaf.escapecode = 0xFF; + } + + return ret; + +error: + smk_huff8_free(ret); + return NULL; +} + +/* Entry point for building a big 16-bit tree. */ +struct smk_huff16_t* _smk_huff16_build(struct smk_bit_t* bs) +{ + struct smk_huff16_t* big = NULL; + + struct smk_huff8_t* low8 = NULL; + struct smk_huff8_t* hi8 = NULL; + + short lowval; + + char bit; + unsigned char i; + + /* sanity check */ + smk_assert(bs); + + /* Smacker huff trees begin with a set-bit. */ + smk_bs_read_1(bs, bit); + + if (!bit) + { + fputs("libsmacker::smk_huff16_build(bs) - ERROR: initial get_bit returned 0\n", stderr); + goto error; + } + + /* build low-8-bits tree */ + smk_huff8_build(bs, low8); + /* build hi-8-bits tree */ + smk_huff8_build(bs, hi8); + + /* Everything looks OK so far. Time to malloc structure. */ + smk_malloc(big, sizeof(struct smk_huff16_t)); + + /* Init the escape code cache. */ + for (i = 0; i < 3; i ++) + { + smk_bs_read_8(bs, lowval); + smk_bs_read_8(bs, big->cache[i]); + big->cache[i] = lowval | (big->cache[i] << 8); + } + + /* Finally, call recursive function to retrieve the Bigtree. */ + smk_huff16_build_rec(bs, big->cache, low8, hi8, big->t); + + /* Done with 8-bit hufftrees, free them. */ + smk_huff8_free(hi8); + smk_huff8_free(low8); + + /* Check final end tag. */ + smk_bs_read_1(bs, bit); + + if (bit) + { + fputs("libsmacker::smk_huff16_build(bs) - ERROR: final get_bit returned 1\n", stderr); + goto error; + } + + return big; + +error: + smk_huff16_free(big); + smk_huff8_free(hi8); + smk_huff8_free(low8); + return NULL; +} + +static int _smk_huff16_lookup_rec(struct smk_bit_t* bs, unsigned short cache[3], const struct smk_huff8_t* t) +{ + unsigned short val; + char bit; + + /* sanity check */ + /* smk_assert(bs); + smk_assert(cache); + smk_assert(t); */ + + /* Reached a Leaf node */ + if (!t->b0) + { + if (t->u.leaf.escapecode != 0xFF) + { + /* Found escape code. Retrieve value from Cache. */ + val = cache[t->u.leaf.escapecode]; + } + else + { + /* Use value directly. */ + val = t->u.leaf.value; + } + + if (cache[0] != val) + { + /* Update the cache, by moving val to the front of the queue, + if it isn't already there. */ + cache[2] = cache[1]; + cache[1] = cache[0]; + cache[0] = val; + } + + return val; + } + + /* Read the next bit from bitstream to determine path */ + smk_bs_read_1(bs, bit); + + if (bit) + { + /* get_bit returned Set, follow Right branch. */ + return _smk_huff16_lookup_rec(bs, cache, t->u.b1); + } + + return _smk_huff16_lookup_rec(bs, cache, t->b0); + +error: + return -1; +} + +/* Convenience call-out for recursive bigtree lookup function */ +long _smk_huff16_lookup(struct smk_bit_t* bs, struct smk_huff16_t* big) +{ + /* sanity check */ + smk_assert(bs); + smk_assert(big); + + return _smk_huff16_lookup_rec(bs, big->cache, big->t); + +error: + return -1; +} + +/* Resets a Big hufftree cache */ +void smk_huff16_reset(struct smk_huff16_t* big) +{ + /* sanity check */ + smk_assert(big); + + big->cache[0] = 0; + big->cache[1] = 0; + big->cache[2] = 0; + +error: ; +} + +/* delete a (big) huffman tree */ +void smk_huff16_free(struct smk_huff16_t* big) +{ + /* Sanity check: do not double-free */ + smk_assert(big); + + /* free the subtree */ + if (big->t) + smk_huff8_free(big->t); + + /* free the bigtree */ + smk_free(big); + +error: ; +}; diff --git a/3rdParty/libsmacker/smk_hufftree.h b/3rdParty/libsmacker/smk_hufftree.h new file mode 100644 index 000000000..ff200f88d --- /dev/null +++ b/3rdParty/libsmacker/smk_hufftree.h @@ -0,0 +1,88 @@ +/** + libsmacker - A C library for decoding .smk Smacker Video files + Copyright (C) 2012-2017 Greg Kennedy + + See smacker.h for more information. + + smk_hufftree.h + SMK huffmann trees. There are two types: + - a basic 8-bit tree, and + - a "big" 16-bit tree which includes a cache for recently + searched values. +*/ + +#ifndef SMK_HUFFTREE_H +#define SMK_HUFFTREE_H + +#include "smk_bitstream.h" + +/** Tree node structures - Forward declaration */ +struct smk_huff8_t; +struct smk_huff16_t; + +/*********************** 8-BIT HUFF-TREE FUNCTIONS ***********************/ +/** This macro checks return code from _smk_huff8_build and + jumps to error label if problems occur. */ +#define smk_huff8_build(bs,t) \ +{ \ + if (!(t = _smk_huff8_build(bs))) \ + { \ + fprintf(stderr, "libsmacker::smk_huff8_build(" #bs ", " #t ") - ERROR (file: %s, line: %lu)\n", __FILE__, (unsigned long)__LINE__); \ + goto error; \ + } \ +} +/** Build an 8-bit tree from a bitstream */ +struct smk_huff8_t* _smk_huff8_build(struct smk_bit_t* bs); + +/** This macro checks return code from _smk_huff8_lookup and + jumps to error label if problems occur. */ +#define smk_huff8_lookup(bs,t,s) \ +{ \ + if ((short)(s = _smk_huff8_lookup(bs, t)) < 0) \ + { \ + fprintf(stderr, "libsmacker::smk_huff8_lookup(" #bs ", " #t ", " #s ") - ERROR (file: %s, line: %lu)\n", __FILE__, (unsigned long)__LINE__); \ + goto error; \ + } \ +} +/** Look up an 8-bit value in the referenced tree by following a bitstream + returns -1 on error */ +short _smk_huff8_lookup(struct smk_bit_t* bs, const struct smk_huff8_t* t); + +/** function to recursively delete an 8-bit huffman tree */ +void smk_huff8_free(struct smk_huff8_t* t); + +/************************ 16-BIT HUFF-TREE FUNCTIONS ************************/ +/** This macro checks return code from _smk_huff16_build and + jumps to error label if problems occur. */ +#define smk_huff16_build(bs,t) \ +{ \ + if (!(t = _smk_huff16_build(bs))) \ + { \ + fprintf(stderr, "libsmacker::smk_huff16_build(" #bs ", " #t ") - ERROR (file: %s, line: %lu)\n", __FILE__, (unsigned long)__LINE__); \ + goto error; \ + } \ +} +/** Build a 16-bit tree from a bitstream */ +struct smk_huff16_t* _smk_huff16_build(struct smk_bit_t* bs); + +/** This macro checks return code from smk_huff16_lookup and + jumps to error label if problems occur. */ +#define smk_huff16_lookup(bs,t,s) \ +{ \ + if ((s = _smk_huff16_lookup(bs, t)) < 0) \ + { \ + fprintf(stderr, "libsmacker::smk_huff16_lookup(" #bs ", " #t ", " #s ") - ERROR (file: %s, line: %lu)\n", __FILE__, (unsigned long)__LINE__); \ + goto error; \ + } \ +} +/** Look up a 16-bit value in the bigtree by following a bitstream + returns -1 on error */ +long _smk_huff16_lookup(struct smk_bit_t* bs, struct smk_huff16_t* big); + +/** Reset the cache in a 16-bit tree */ +void smk_huff16_reset(struct smk_huff16_t* big); + +/** function to recursively delete a 16-bit huffman tree */ +void smk_huff16_free(struct smk_huff16_t* big); + +#endif diff --git a/3rdParty/libsmacker/smk_malloc.h b/3rdParty/libsmacker/smk_malloc.h new file mode 100644 index 000000000..ef70cb79a --- /dev/null +++ b/3rdParty/libsmacker/smk_malloc.h @@ -0,0 +1,77 @@ +/** + libsmacker - A C library for decoding .smk Smacker Video files + Copyright (C) 2012-2017 Greg Kennedy + + See smacker.h for more information. + + smk_malloc.h + "Safe" implementations of malloc and free. + Verbose implementation of assert. +*/ + +#ifndef SMK_MALLOC_H +#define SMK_MALLOC_H + +/* calloc */ +#include +/* fprintf */ +#include + +/* Error messages from calloc */ +#include +#include + +/** + Verbose assert: + branches to an error block if pointer is null +*/ +#define smk_assert(p) \ +{ \ + if (!p) \ + { \ + fprintf(stderr, "libsmacker::smk_assert(" #p "): ERROR: NULL POINTER at line %lu, file %s\n", (unsigned long)__LINE__, __FILE__); \ + goto error; \ + } \ +} + +/** + Safe free: attempts to prevent double-free by setting pointer to NULL. + Optionally warns on attempts to free a NULL pointer. +*/ +#define smk_free(p) \ +{ \ + if (p) \ + { \ + free(p); \ + p = NULL; \ + } \ +/* else \ + { \ + fprintf(stderr, "libsmacker::smk_free(" #p ") - Warning: attempt to free NULL pointer (file: %s, line: %lu)\n", __FILE__, (unsigned long)__LINE__); \ + } */ \ +} + +/** + Safe malloc: exits if calloc() returns NULL. + Also initializes blocks to 0. + Optionally warns on attempts to malloc over an existing pointer. + Ideally, one should not exit() in a library. However, if you cannot + calloc(), you probably have bigger problems. +*/ +#define smk_malloc(p, x) \ +{ \ +/* if (p) \ + { \ + fprintf(stderr, "libsmacker::smk_malloc(" #p ", %lu) - Warning: freeing non-NULL pointer before calloc (file: %s, line: %lu)\n", (unsigned long) (x), __FILE__, (unsigned long)__LINE__); \ + free(p); \ + } */ \ + p = calloc(1, x); \ + if (!p) \ + { \ + fprintf(stderr, "libsmacker::smk_malloc(" #p ", %lu) - ERROR: calloc() returned NULL (file: %s, line: %lu)\n\tReason: [%d] %s\n", \ + (unsigned long) (x), __FILE__, (unsigned long)__LINE__, errno, strerror(errno)); \ + exit(EXIT_FAILURE); \ + } \ +} + +#endif diff --git a/CMake/32bit.cmake b/CMake/32bit.cmake index 492d6b1d0..6154df726 100644 --- a/CMake/32bit.cmake +++ b/CMake/32bit.cmake @@ -1,6 +1,7 @@ message(STATUS "Using 32-bit toolchain") set(CMAKE_CXX_FLAGS -m32 CACHE STRING "") +set(CMAKE_C_FLAGS -m32 CACHE STRING "") # Affects pkg-config set_property(GLOBAL PROPERTY FIND_LIBRARY_USE_LIB32_PATHS TRUE) diff --git a/CMakeLists.txt b/CMakeLists.txt index 0685acb9a..7b643dcd5 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -156,6 +156,10 @@ set(STUB_SOURCES Stub/DiabloUI/selhero.cpp Stub/DiabloUI/title.cpp + 3rdParty/libsmacker/smk_bitstream.c + 3rdParty/libsmacker/smk_hufftree.c + 3rdParty/libsmacker/smacker.c + 3rdParty/StormLib/src/FileStream.cpp 3rdParty/StormLib/src/SBaseCommon.cpp 3rdParty/StormLib/src/SBaseFileTable.cpp diff --git a/Stub/DiabloUI/diabloui.cpp b/Stub/DiabloUI/diabloui.cpp index 1371b0890..19caa2708 100644 --- a/Stub/DiabloUI/diabloui.cpp +++ b/Stub/DiabloUI/diabloui.cpp @@ -664,7 +664,6 @@ void LoadBackgroundArt(char *pszFile) { PALETTEENTRY pPal[256]; - fadeValue = 0; LoadArt(pszFile, &ArtBackground, 1, pPal); LoadPalInMem(pPal); ApplyGamma(logical_palette, orig_palette, 256); @@ -720,8 +719,6 @@ void DrawEditBox(UI_Item item) DrawArtStr(&item); } -float freq = SDL_GetPerformanceFrequency(); - void UiRender() { SDL_Event event; diff --git a/Stub/init.cpp b/Stub/init.cpp index e9cae8b5f..ebeb9851d 100644 --- a/Stub/init.cpp +++ b/Stub/init.cpp @@ -95,7 +95,7 @@ void __fastcall init_create_window(int nCmdShow) atexit(TTF_Quit); SDL_Init(SDL_INIT_EVERYTHING); - int flags = SDL_WINDOW_FULLSCREEN_DESKTOP; + int flags = SDL_WINDOW_FULLSCREEN_DESKTOP | SDL_WINDOW_INPUT_GRABBED; if (!fullscreen) { flags = SDL_WINDOW_RESIZABLE; } diff --git a/Stub/movie.cpp b/Stub/movie.cpp index 3ae898d71..87d550185 100644 --- a/Stub/movie.cpp +++ b/Stub/movie.cpp @@ -1,8 +1,123 @@ +#include "../3rdParty/libsmacker/smacker.h" +#include "../3rdParty/libsmackerdec/include/SmackerDecoder.h" #include "../types.h" -BOOL loop_movie; +BYTE movie_playing; +BOOL loop_movie; // TODO void __fastcall play_movie(char *pszMovie, BOOL user_can_close) { DUMMY_PRINT("%s", pszMovie); + + SDL_DestroyTexture(texture); + texture = SDL_CreateTexture(renderer, SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_STREAMING, 320, 156); + SDL_RenderSetLogicalSize(renderer, 320, 156); + void *video_stream; + + movie_playing = TRUE; + //sound_disable_music(TRUE); + sfx_stop(); + effects_play_sound("Sfx\\Misc\\blank.wav"); + + HANDLE directsound; + SFileOpenFile(pszMovie, &directsound); + + char *fileBuffer; + + int bytestoread = SFileGetFileSize(directsound, 0); + fileBuffer = DiabloAllocPtr(bytestoread); + SFileReadFile(directsound, fileBuffer, bytestoread, NULL, 0); + if (Mix_OpenAudio(22050, AUDIO_S16LSB, 1, 512) < 0) { + printf("SDL_mixer could not initialize! SDL_mixer Error: %s\n", Mix_GetError()); + } + + /* file meta-info */ + unsigned int width, height, nFrames; + /* arrays for audio track metadata */ + unsigned char a_trackmask, a_channels[7], a_depth[7]; + unsigned long a_rate[7]; + + unsigned char *palette_data; + + smk smacker; + + smacker = smk_open_memory(fileBuffer, bytestoread); + if (smacker != NULL) { + int now; + double usPerFrame; + + smk_enable_all(smacker, -1); + smk_info_all(smacker, NULL, &nFrames, &usPerFrame); + smk_info_video(smacker, &width, &height, NULL); + smk_info_audio(smacker, &a_trackmask, a_channels, a_depth, a_rate); + + printf("Audio info for track 0: bit-depth %u, channels %u, rate %u\n", a_depth[0], a_channels[0], a_rate[0]); + + smk_first(smacker); + + SDL_Event event; + double frameEnd = SDL_GetTicks() * 1000 + usPerFrame; + for (int f = 0; f < nFrames && movie_playing; f++) { + while (SDL_PollEvent(&event)) { + switch (event.type) { + case SDL_KEYDOWN: + case SDL_MOUSEBUTTONDOWN: + movie_playing = false; + break; + case SDL_QUIT: + exit(0); + } + } + + now = SDL_GetTicks() * 1000; + if (now >= frameEnd) { + continue; // Skip audio and video if the system is to slow + } + + Mix_Chunk *Song = Mix_QuickLoad_RAW(smk_get_audio(smacker, 0), smk_get_audio_size(smacker, 0)); + Mix_PlayChannel(-1, Song, 0); + now = SDL_GetTicks() * 1000; + if (now >= frameEnd) { + continue; // Skip video if system is to slow + } + + /* Retrieve the palette and image */ + palette_data = smk_get_palette(smacker); + for (int i = 0; i < 256; i++) { + orig_palette[i].peFlags = 0; + orig_palette[i].peRed = palette_data[i * 3 + 0]; + orig_palette[i].peGreen = palette_data[i * 3 + 1]; + orig_palette[i].peBlue = palette_data[i * 3 + 2]; + } + ApplyGamma(logical_palette, orig_palette, 256); + + // Copy frame to buffer + BYTE *src = (BYTE *)smk_get_video(smacker); + BYTE *dst = (BYTE *)&gpBuffer->row[0].pixels[0]; + for (int i = 0; i < height && i < SCREEN_HEIGHT; i++, src += width, dst += ROW_PITCH) { + for (int j = 0; j < width && j < SCREEN_WIDTH; j++) { + dst[j] = src[j]; + } + } + + SetFadeLevel(256); // present frame + + smk_next(smacker); // Decode next frame + now = SDL_GetTicks() * 1000; + if (now < frameEnd) { + usleep(frameEnd - now); // wait with next frame if the system is to fast + } + frameEnd += usPerFrame; + } + + smk_close(smacker); + } + + Mix_CloseAudio(); + if (Mix_OpenAudio(44100, AUDIO_S16LSB, 2, 1024) < 0) { + printf("SDL_mixer could not initialize! SDL_mixer Error: %s\n", Mix_GetError()); + } + SDL_DestroyTexture(texture); + texture = SDL_CreateTexture(renderer, SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_STREAMING, SCREEN_WIDTH, SCREEN_HEIGHT); + SDL_RenderSetLogicalSize(renderer, SCREEN_WIDTH, SCREEN_HEIGHT); } diff --git a/Stub/sound.cpp b/Stub/sound.cpp index 1a476e781..656ef9811 100644 --- a/Stub/sound.cpp +++ b/Stub/sound.cpp @@ -6,9 +6,6 @@ BYTE gbDupSounds; unsigned char channels = 8; // defines how many channels, respectively how many *.wav files can be played at the same time UCHAR gbMusicOn; UCHAR gbSoundOn; -Mix_Music *gMusic = NULL; -Mix_Chunk *sample; -Mix_Music *music; char *sgszMusicTracks[6] = { "Music\\DTowne.wav", "Music\\DLvlA.wav", "Music\\DLvlB.wav", "Music\\DLvlC.wav", "Music\\DLvlD.wav", "Music\\Dintro.wav" }; @@ -16,12 +13,7 @@ char *sgszMusicTracks[6] = { "Music\\DTowne.wav", "Music\\DLvlA.wav", "Music\\DL void __fastcall snd_init(HWND hWnd) { DUMMY(); - /* for some reason function __fastcall snd_init seems to be used twice at this time*/ printf("\nSND INIT\n"); - // Initialize SDL. - if (SDL_Init(SDL_INIT_AUDIO) < 0) { - printf("ERROR : %s\n\n", SDL_GetError()); - } /* following function Mix_AllocateChannels allocates the number of channels of simultaneously played sounds.*/ printf("Opened %i sound channels\n\n", Mix_AllocateChannels(channels)); diff --git a/Stub/sound.h b/Stub/sound.h deleted file mode 100644 index f208a872b..000000000 --- a/Stub/sound.h +++ /dev/null @@ -1 +0,0 @@ -extern void IsPlayMusic(); diff --git a/types.h b/types.h index c66ed0d85..029b8328a 100644 --- a/types.h +++ b/types.h @@ -46,7 +46,6 @@ #include "miniwin_sdl.h" #include "stubs.h" #include "DiabloUI/sdlrender.h" -#include "sound.h" #endif #include "defs.h"