Audacious

/*

 * Audacious FFaudio Plugin

 * Copyright © 2009 William Pitcock <nenolod@dereferenced.org>

 *                  Matti Hämäläinen <ccr@tnsp.org>

 * Copyright © 2011 John Lindgren <john.lindgren@tds.net>

 *

 * Redistribution and use in source and binary forms, with or without

 * modification, are permitted provided that the following conditions are met:

 *

 * 1. Redistributions of source code must retain the above copyright notice,

 *    this list of conditions, and the following disclaimer.

 *

 * 2. Redistributions in binary form must reproduce the above copyright notice,

 *    this list of conditions, and the following disclaimer in the documentation

 *    provided with the distribution.

 *

 * This software is provided "as is" and without any warranty, express or

 * implied. In no event shall the authors be liable for any damages arising from

 */

#include <stdlib.h>

#include <stdio.h>

#include <string.h>

#include <pthread.h>

#undef FFAUDIO_DOUBLECHECK  /* Doublecheck probing result for debugging purposes */

#undef FFAUDIO_NO_BLACKLIST /* Don't blacklist any recognized codecs/formats */

#include "ffaudio-stdinc.h"

#include <audacious/audtag.h>

#include <libaudcore/audstrings.h>

#include <libaudcore/i18n.h>

#include <libaudcore/multihash.h>

#include <libaudcore/runtime.h>

#include <stdint.h>

#include "libavutil/common.h"

#include "libavutil/dict.h"

#include "libavutil/log.h"

#include "libavformat/version.h"

#include "libavformat/avio.h"

extern "C" {

#include <libswscale/swscale.h>

}

#include <SDL.h>

#include <SDL_thread.h>

#define SDL_AUDIO_BUFFER_SIZE 4096

#define MAX_AUDIO_FRAME_SIZE 192000

class FFaudio : public InputPlugin

{

public:

    static const char about[];

    static const char * const exts[], * const mimes[];

    static constexpr PluginInfo info = {

        N_("FFmpeg Plugin"),

        PACKAGE,

        about

    };

    static constexpr auto iinfo = InputInfo (FlagWritesTag)

        .with_priority (10) /* lowest priority fallback */

        .with_exts (exts)

        .with_mimes (mimes);

    constexpr FFaudio () : InputPlugin (info, iinfo) {}

    bool init ();

    void cleanup ();

    bool is_our_file (const char * filename, VFSFile & file);

    Tuple read_tuple (const char * filename, VFSFile & file);

    Index<char> read_image (const char * filename, VFSFile & file);

    bool write_tuple (const char * filename, VFSFile & file, const Tuple & tuple);

    bool play (const char * filename, VFSFile & file);

};

EXPORT FFaudio aud_plugin_instance;

static bool play_video;          /* JWT: TRUE IF USER IS CURRENTLY PLAYING VIDEO (KILLINV VID. WINDOW TURNS OFF! */

static bool play_video_wason;    /* JWT: TRUE IF USER WANTS VIDEO PART OF VIDEO FILES DISPLAYED */

static bool fromstdin;           /* JWT: TRUE IF INPUT IS STREAMED IN VIA STDIN, FALSE OTHERWISE */

typedef struct

{

    int stream_idx;

    AVStream * stream;

    AVCodecContext * context;

    AVCodec * codec;

}

CodecInfo;

static CodecInfo cinfo;          /* JWT: SAVE THE AUDIO & VIDEO CODEC STRUCTURES SINCE NOW REFERENCED IN 2 FUNCTIONS: */

static CodecInfo vcinfo;

static SimpleHash<String, AVInputFormat *> extension_dict;

static void create_extension_dict ();

static int lockmgr (void * * mutexp, enum AVLockOp op)

{

    switch (op)

    {

    case AV_LOCK_CREATE:

        * mutexp = new pthread_mutex_t;

        pthread_mutex_init ((pthread_mutex_t *) * mutexp, nullptr);

        break;

    case AV_LOCK_OBTAIN:

        pthread_mutex_lock ((pthread_mutex_t *) * mutexp);

        break;

    case AV_LOCK_RELEASE:

        pthread_mutex_unlock ((pthread_mutex_t *) * mutexp);

        break;

    case AV_LOCK_DESTROY:

        pthread_mutex_destroy ((pthread_mutex_t *) * mutexp);

        delete (pthread_mutex_t *) * mutexp;

        break;

    }

    return 0;

}

static void ffaudio_log_cb (void * avcl, int av_level, const char * fmt, va_list va)

{

    audlog::Level level = audlog::Debug;

    char message [2048];

    switch (av_level)

    {

    case AV_LOG_QUIET:

        return;

    case AV_LOG_PANIC:

    case AV_LOG_FATAL:

    case AV_LOG_ERROR:

        level = audlog::Error;

        break;

    case AV_LOG_WARNING:

        level = audlog::Warning;

        break;

    case AV_LOG_INFO:

        level = audlog::Info;

        break;

    default:

        break;

    }

    AVClass * avc = avcl ? * (AVClass * *) avcl : nullptr;

    vsnprintf (message, sizeof message, fmt, va);

    audlog::log (level, __FILE__, __LINE__, avc ? avc->item_name(avcl) : __FUNCTION__,

                 "<%p> %s", avcl, message);

}

bool FFaudio::init ()

{

    av_register_all();

    av_lockmgr_register (lockmgr);

    create_extension_dict ();

    av_log_set_callback (ffaudio_log_cb);

    play_video_wason = aud_get_bool ("ffaudio", "play_video");

    return true;

}

void FFaudio::cleanup ()

{

    extension_dict.clear ();

    av_lockmgr_register (nullptr);

}

static const char * ffaudio_strerror (int error)

{

    static char buf[256];

    return (! av_strerror (error, buf, sizeof buf)) ? buf : "unknown error";

}

static void create_extension_dict ()

{

    AVInputFormat * f;

    for (f = av_iformat_next (nullptr); f; f = av_iformat_next (f))

    {

        if (! f->extensions)

            continue;

        StringBuf exts = str_tolower (f->extensions);

        Index<String> extlist = str_list_to_index (exts, ",");

        for (auto & ext : extlist)

            extension_dict.add (ext, std::move (f));

    }

}

static AVInputFormat * get_format_by_extension (const char * name)

{

    StringBuf ext = uri_get_extension (name);

    if (! ext)

        return nullptr;

    AUDDBG ("Get format by extension: %s\n", name);

    AVInputFormat * * f = extension_dict.lookup (String (str_tolower (ext)));

    if (f && * f)

        AUDDBG ("Format %s.\n", (* f)->name);

    else

        AUDDBG ("Format unknown.\n");

    return f ? * f : nullptr;

}

static AVInputFormat * get_format_by_content (const char * name, VFSFile & file)

{

    AUDDBG ("Get format by content: %s\n", name);

    AVInputFormat * f = nullptr;

    unsigned char buf[16384 + AVPROBE_PADDING_SIZE];

    int size = 16;

    int filled = 0;

    int target = 100;

    int score = 0;

    while (1)

    {

        if (filled < size)

            filled += file.fread (buf + filled, 1, size - filled);

        memset (buf + filled, 0, AVPROBE_PADDING_SIZE);

        AVProbeData d = {name, buf, filled};

        score = target;

        f = av_probe_input_format2 (& d, true, & score);

        if (f)

            break;

        if (size < 16384 && filled == size)

            size *= 4;

        else if (target > 10)

            target = 10;

        else

            break;

    }

    if (f)

        AUDDBG ("Format %s, buffer size %d, score %d.\n", f->name, filled, score);

    else

        AUDDBG ("Format unknown.\n");

    if (file.fseek (0, VFS_SEEK_SET) < 0)

        ; /* ignore errors here */

    return f;

}

static AVInputFormat * get_format (const char * name, VFSFile & file)

{

    AVInputFormat * f = get_format_by_extension (name);

    return f ? f : get_format_by_content (name, file);

}

bool isFromStdin ()  /* JWT: TRUE IF INPUT IS STREAMED IN VIA STDIN, FALSE OTHERWISE */

{

    return fromstdin;

}

static AVFormatContext * open_input_file (const char * name, VFSFile & file)

{

    AVFormatContext * c = NULL;

    play_video = aud_get_bool ("ffaudio", "play_video");   //JWT:RESET PLAY-VIDEO, CASE TURNED OFF ON PREV. PLAY

    const char * xname = name;

    if (fromstdin)

        xname = "pipe:";

    int ret = avformat_open_input (&c, xname, NULL, NULL);

    if (ret)

    {

        AUDERR ("avformat_open_input failed for %s: %s.\n", xname, ffaudio_strerror (ret));

        return nullptr;

    }

    return c;

}

static void close_input_file (AVFormatContext * c, CodecInfo * cinfo, CodecInfo * vcinfo)

{

    if (play_video_wason) {

        avcodec_close(vcinfo->context);

    }

    play_video_wason = play_video;

    avcodec_close(cinfo->context);

#if CHECK_LIBAVFORMAT_VERSION (53, 25, 0, 53, 17, 0)

    avformat_close_input (&c);

#else

    av_close_input_file (c);

#endif

}

static bool find_codec (AVFormatContext * c, CodecInfo * cinfo, CodecInfo * vcinfo)

{

    avformat_find_stream_info (c, NULL);

    int videoStream=-1;

    int audioStream=-1;

    for (unsigned i = 0; i < c->nb_streams; i++)

    {

        if (c->streams[i]->codec->codec_type==AVMEDIA_TYPE_VIDEO)

            videoStream=i;

        else if (c->streams[i]->codec->codec_type==AVMEDIA_TYPE_AUDIO && audioStream < 0)

            audioStream=i;

    }

    if (audioStream==-1)   //PUNT IF NO AUDIO SINCE AUDACIOUS IS AN *AUDIO* PLAYER!

        return false;

    AVCodec * codec = avcodec_find_decoder (c->streams[audioStream]->codec->codec_id);

    if (codec)

    {

        cinfo->stream_idx = audioStream;

        cinfo->stream = c->streams[audioStream];

        cinfo->context = c->streams[audioStream]->codec;

        cinfo->codec = codec;

        //JWT:NOW SEE IF WE GOT A VIDEO STREAM TOO:

        if (play_video && videoStream >= 0)

        {

            AVCodec * vcodec = avcodec_find_decoder (c->streams[videoStream]->codec->codec_id);

            if (vcodec)

            {

                vcinfo->stream_idx = videoStream;

                vcinfo->stream = c->streams[videoStream];

                vcinfo->context = c->streams[videoStream]->codec;

                vcinfo->codec = vcodec;

            }

        }

        return true;

    }

    return false;

}

bool FFaudio::is_our_file (const char * filename, VFSFile & file)

{

    return (bool) get_format (filename, file);

}

static const struct {

    Tuple::ValueType ttype;  /* Tuple field value type */

    Tuple::Field field;      /* Tuple field constant */

    const char * keys[5];    /* Keys to match (case-insensitive), ended by nullptr */

} metaentries[] = {

    {Tuple::String, Tuple::Artist, {"author", "hor", "artist", nullptr}},

    {Tuple::String, Tuple::Title, {"title", "le", nullptr}},

    {Tuple::String, Tuple::Album, {"album", "WM/AlbumTitle", nullptr}},

    {Tuple::String, Tuple::Performer, {"performer", nullptr}},

    {Tuple::String, Tuple::Copyright, {"copyright", nullptr}},

    {Tuple::String, Tuple::Genre, {"genre", "WM/Genre", nullptr}},

    {Tuple::String, Tuple::Comment, {"comment", nullptr}},

    {Tuple::String, Tuple::Composer, {"composer", nullptr}},

    {Tuple::Int, Tuple::Year, {"year", "WM/Year", "date", nullptr}},

    {Tuple::Int, Tuple::Track, {"track", "WM/TrackNumber", nullptr}},

};

static void read_metadata_dict (Tuple & tuple, AVDictionary * dict)

{

    for (auto & meta : metaentries)

    {

        AVDictionaryEntry * entry = nullptr;

        for (int j = 0; ! entry && meta.keys[j]; j ++)

            entry = av_dict_get (dict, meta.keys[j], nullptr, 0);

        if (entry && entry->value)

        {

            if (meta.ttype == Tuple::String)

                tuple.set_str (meta.field, entry->value);

            else if (meta.ttype == Tuple::Int)

                tuple.set_int (meta.field, atoi (entry->value));

        }

    }

}

Tuple FFaudio::read_tuple (const char * filename, VFSFile & file)

{

    Tuple tuple;

    fromstdin = strstr(filename, "://-.") ? true : false;

    if (fromstdin)

    {

        tuple.set_filename (filename);

    }

    else   /* JWT:THIS STUFF DEFERRED UNTIL PLAY FOR STDIN, BUT SEEMS TO HAVE TO BE HERE FOR DIRECT */

    {

        AVFormatContext * ic = open_input_file (filename, file);

        if (ic)

        {

            if (find_codec (ic, & cinfo, & vcinfo))

            {

                tuple.set_filename (filename);

                tuple.set_int (Tuple::Length, ic->duration / 1000);

                tuple.set_int (Tuple::Bitrate, ic->bit_rate / 1000);

                if (cinfo.codec->long_name)

                    tuple.set_str (Tuple::Codec, cinfo.codec->long_name);

                if (ic->metadata)

                    read_metadata_dict (tuple, ic->metadata);

                if (cinfo.stream->metadata)

                    read_metadata_dict (tuple, cinfo.stream->metadata);

            }

            close_input_file (ic, & cinfo, & vcinfo);

        }

        if (tuple && ! file.fseek (0, VFS_SEEK_SET))

            audtag::tuple_read (tuple, file);

    }

AUDDBG ("---- returning tuple.\n");

    return tuple;

}

bool FFaudio::write_tuple (const char * filename, VFSFile & file, const Tuple & tuple)

{

    if (str_has_suffix_nocase (filename, ".ape"))

        return audtag::tuple_write (tuple, file, audtag::TagType::APE);

    return audtag::tuple_write (tuple, file, audtag::TagType::None);

}

Index<char> FFaudio::read_image (const char * filename, VFSFile & file)

{

    if (str_has_suffix_nocase (filename, ".m4a") || str_has_suffix_nocase (filename, ".mp4"))

        return read_itunes_cover (filename, file);

    return Index<char> ();

}

bool FFaudio::play (const char * filename, VFSFile & file)

{

    AUDDBG ("Playing %s.\n", filename);

    AVPacket pkt = AVPacket();

    int errcount;

    /* bool codec_opened = false; */

    int out_fmt;

    bool planar;

    bool error = false;

  SDL_Overlay     *bmp = nullptr;

  SDL_Surface     *screen = nullptr;

  SDL_Rect        rect;

  SDL_Event       event;

  int video_width = 0;

  int video_height = 0;

  play_video_wason = play_video;

  float video_aspect_ratio = 0;

    struct SwsContext *sws_ctx = NULL;

    Index<char> buf;

    AVFormatContext * ic = open_input_file (filename, file);

    const char * fileext = strrchr (filename, '.');

    if (ic)

    {

        if (fromstdin)  /* JWT:FOR STDIN: TRY TO GET "read_tuple()" STUFF NOW, SINCE FILE COULD NOT BE READ EARLIER IN read_tuple()! */

        {

            Tuple tuple;

AUDDBG ("---- playing from STDIN: get TUPLE stuff now: IC is defined\n");

            if (find_codec (ic, & cinfo, & vcinfo))

            {

                tuple.set_filename (filename);

                tuple.set_int (Tuple::Length, ic->duration / 1000);

                tuple.set_int (Tuple::Bitrate, ic->bit_rate / 1000);

                if (cinfo.codec->long_name)

                    tuple.set_str (Tuple::Codec, cinfo.codec->long_name);

                if (ic->metadata)

                    read_metadata_dict (tuple, ic->metadata);

                if (cinfo.stream->metadata)

                    read_metadata_dict (tuple, cinfo.stream->metadata);

                set_playback_tuple (tuple.ref ());

            }

            else

            {

                AUDERR ("No codec found for %s.\n", filename);

                goto error_exit;

            }

        }

        else

        {

            if (! find_codec (ic, & cinfo, & vcinfo))

            {

                AUDERR ("No codec found for %s.\n", filename);

                goto error_exit;

            }

        }

    }

    else

        return false;

    AUDDBG("got codec %s for stream index %d, opening\n", cinfo.codec->name, cinfo.stream_idx);

    if (avcodec_open2 (cinfo.context, cinfo.codec, NULL) < 0)

        goto error_exit;

    if (play_video)   //JWT:abUSER ALSO WANTS TO PLAY VIDEO, SO SET UP POP-UP VIDEO SCREEN:

    {

        String video_windowtitle;

        int video_sws_scale = 0;

        if (avcodec_open2 (vcinfo.context, vcinfo.codec, NULL) < 0)

            goto error_exit;

        // Allocate a place to put our YUV image on that screen (initialize to video's size,

        // then (later) resize to user's size prefs if specified (must do this way to get video to scale:

#ifndef __DARWIN__

        screen = SDL_SetVideoMode(vcinfo.context->width, vcinfo.context->height, 0, SDL_RESIZABLE);

AUDERR("--DARWIN--\n");

#else

        screen = SDL_SetVideoMode(vcinfo.context->width, vcinfo.context->height, 24, SDL_RESIZABLE);

AUDERR("--NOT Darwin--\n");

#endif

        video_windowtitle = aud_get_str ("ffaudio", "video_windowtitle");

        if (video_windowtitle)

            SDL_WM_SetCaption(video_windowtitle, NULL);

        if (aud_get_int ("ffaudio", "video_sws_scale"))

            video_sws_scale = aud_get_int ("ffaudio", "video_sws_scale");

        else

            video_sws_scale = SWS_BICUBIC;  //default=4

        bmp = SDL_CreateYUVOverlay(

            vcinfo.context->width,

            vcinfo.context->height,

            SDL_YV12_OVERLAY,

            screen

        );

AUDERR("-sws_scale=%d=\n", video_sws_scale);

        sws_ctx = sws_getContext (

                   vcinfo.context->width,

                   vcinfo.context->height,

                   vcinfo.context->pix_fmt,

                   vcinfo.context->width,

                   vcinfo.context->height,

                   PIX_FMT_YUV420P,

                   video_sws_scale,

                   NULL,

                   NULL,

                   NULL

        );

        //NOW CALCULATE THE WIDTH, HEIGHT, & ASPECT BASED ON VIDEO'S SIZE & AND ANY USER PARAMATERS GIVEN:

        video_aspect_ratio = vcinfo.context->height

            ? (float)vcinfo.context->width / (float)vcinfo.context->height : 1.0;

AUDDBG("-BEF: wxh =%d=%d= aspect=%f=\n", vcinfo.context->width, vcinfo.context->height, video_aspect_ratio);

        int vx = aud_get_int ("ffaudio", "video_xsize");

        int vy = aud_get_int ("ffaudio", "video_ysize");

        if (! strcmp_nocase (fileext, ".flv"))   //JWT:FIXME:FLV STREAMS ERROR OUT ON ATTEMPT TO RESIZE?!

            vx = vy = 0;

        if (vx && !vy)   //user specified width only, calc. height based on aspect:

        {

            vcinfo.context->width = video_width = vx;

            vcinfo.context->height = video_height = (int)((float)vx / video_aspect_ratio);

        }

        else if (!vx && vy)   //user specified height only, calc. height based on aspect:

        {

            vcinfo.context->height = video_height = vy;

            vcinfo.context->width = video_width = (int)((float)vy * video_aspect_ratio);

        }

        else if (vx && vy)   //user specified fixed width and height:

        {

            vcinfo.context->width = video_width = vx;

            vcinfo.context->height = video_height = vy;

        }

        else   //user specified nothing, use video's desired wXh:

        {

            video_width = vcinfo.context->width;

            video_height = vcinfo.context->height;

        }

        video_aspect_ratio = video_height

            ? (float)video_width / (float)video_height : 1.0;   //fall thru to square to avoid possibliity of "/0"!

        //NOW "RESIZE" screen to user's wXh, if user set something:

        if (vx || vy)

        {

#ifndef __DARWIN__

            screen = SDL_SetVideoMode(video_width, video_height, 0, SDL_RESIZABLE);

#else

            screen = SDL_SetVideoMode(video_width, video_height, 24, SDL_RESIZABLE);

#endif

AUDDBG("-AFT: wxh =%d=%d= =%d=%d= aspect=%f=\n", vcinfo.context->width, vcinfo.context->height, video_width, video_height, video_aspect_ratio);

            if(!screen) {

                AUDERR("SDL: could not re-set video mode - exiting\n");

                goto error_exit;

            }

        }

        if (SDL_Init(SDL_INIT_VIDEO | SDL_INIT_TIMER)) {

            AUDERR("Could not initialize SDL - %s\n", SDL_GetError());

            goto error_exit;

        }

        rect.x = 0;

        rect.y = 0;

    }

    /* codec_opened = true; */

    switch (cinfo.context->sample_fmt)

    {

        case AV_SAMPLE_FMT_U8: out_fmt = FMT_U8; planar = false; break;

        case AV_SAMPLE_FMT_S16: out_fmt = FMT_S16_NE; planar = false; break;

        case AV_SAMPLE_FMT_S32: out_fmt = FMT_S32_NE; planar = false; break;

        case AV_SAMPLE_FMT_FLT: out_fmt = FMT_FLOAT; planar = false; break;

        case AV_SAMPLE_FMT_U8P: out_fmt = FMT_U8; planar = true; break;

        case AV_SAMPLE_FMT_S16P: out_fmt = FMT_S16_NE; planar = true; break;

        case AV_SAMPLE_FMT_S32P: out_fmt = FMT_S32_NE; planar = true; break;

        case AV_SAMPLE_FMT_FLTP: out_fmt = FMT_FLOAT; planar = true; break;

    default:

        AUDERR ("Unsupported audio format %d\n", (int) cinfo.context->sample_fmt);

        goto error_exit;

    }

    /* Open audio output */

    AUDDBG("opening audio output - bitrate=%d=\n", ic->bit_rate);

    set_stream_bitrate(ic->bit_rate);

    open_audio(out_fmt, cinfo.context->sample_rate, cinfo.context->channels);

    errcount = 0;

//AUDDBG ("--starting loop\n");

    int seek_value, ret, frameFinished, decoded, len, size;

    while (! check_stop ())

    {

        seek_value = check_seek ();

        if (seek_value >= 0)

        {

AUDDBG("-----POSITIVE SEEK (%d)!\n", seek_value);

            SDL_Delay(100);

            if (av_seek_frame (ic, -1, (int64_t) seek_value * AV_TIME_BASE /

             1000, AVSEEK_FLAG_ANY) < 0)

            {

                AUDERR ("error while seeking\n");

            } else

                errcount = 0;

            seek_value = -1;

        }

        AVPacket tmp;

        /* Read next frame (or more) of data */

        if ((ret = av_read_frame(ic, &pkt)) < 0)

        {

            if (ret == (int) AVERROR_EOF)

            {

                AUDDBG("eof reached\n");

                break;

            }

            else

            {

                if (++errcount > 4)

                {

                    AUDERR ("av_read_frame error %d, giving up.\n", ret);

                    break;

                } else

                    continue;

            }

        } else

            errcount = 0;

        /* Ignore any other substreams */

        if (pkt.stream_index != cinfo.stream_idx)

        {

            if (!play_video || pkt.stream_index != vcinfo.stream_idx)

            {

                av_free_packet(&pkt);

                continue;

            }

        }

        /* Decode and play packet/frame */

        memcpy(&tmp, &pkt, sizeof(tmp));

        frameFinished = 0;

        while (tmp.size > 0 && ! check_stop ())

        {

            /* Check for seek request and bail out if we have one */

            if (seek_value < 0) {

                seek_value = check_seek ();

            }

            if (seek_value >= 0) {

AUDDBG("--SEEK_VALUE >= 0 (%d), *** EXEC BREAK! ***\n", seek_value);

                SDL_Delay(50);

                break;

            }

#if CHECK_LIBAVCODEC_VERSION (55, 45, 101, 55, 28, 1)

            AVFrame * frame = av_frame_alloc ();

#else

            AVFrame * frame = avcodec_alloc_frame ();

#endif

            decoded = 0;

            if (pkt.stream_index == cinfo.stream_idx)  //PROCESS AUDIO PACKETS:

            {

//AUDDBG("-audio frame\n");

                len = avcodec_decode_audio4 (cinfo.context, frame, & decoded, & tmp);

                if (len < 0)

                {

                    AUDERR ("decode_audio() failed, code %d\n", len);

                    break;

                }

                tmp.size -= len;

                tmp.data += len;

                if (! decoded)

                {

#if CHECK_LIBAVCODEC_VERSION (55, 45, 101, 55, 28, 1)

                    av_frame_free (& frame);

#elif CHECK_LIBAVCODEC_VERSION (54, 59, 100, 54, 28, 0)

                    avcodec_free_frame (& frame);

#else

                    av_free (frame);

#endif

AUDERR("****** CONTINUING! ******\n");  /* JWT:NOT SURE WHY THIS IS A CONTINUE INSTEAD OF A BREAK?! */

                    continue;

                }

                size = FMT_SIZEOF (out_fmt) * cinfo.context->channels * frame->nb_samples;

                if (planar)

                {

                    if (size > buf.len ())

                        buf.resize (size);

                    audio_interlace ((const void * *) frame->data, out_fmt,

                     cinfo.context->channels, buf.begin (), frame->nb_samples);

                    write_audio (buf.begin (), size);

                }

                else

                    write_audio (frame->data[0], size);

            }

            else    /* JWT:PROCESS VIDEO PACKETS HERE: */

            {

//AUDDBG("-video frame\n");

                len = avcodec_decode_video2(vcinfo.context, frame, &frameFinished, &pkt);

                // Did we get a video frame?

                if (len < 0)

                {

                    AUDERR ("decode_video() failed, code %d\n", len);

                    break;

                }

                if (frameFinished) {

                    SDL_LockYUVOverlay(bmp);

                    AVPicture pict;

                    pict.data[0] = bmp->pixels[0];

                    pict.data[1] = bmp->pixels[2];

                    pict.data[2] = bmp->pixels[1];

                    pict.linesize[0] = bmp->pitches[0];

                    pict.linesize[1] = bmp->pitches[2];

                    pict.linesize[2] = bmp->pitches[1];

                    // Convert the image into YUV format that SDL uses

                    sws_scale(sws_ctx, (uint8_t const * const *)frame->data,

                        frame->linesize, 0, vcinfo.context->height,

                        pict.data, pict.linesize);

                    SDL_UnlockYUVOverlay(bmp);

                    rect.w = video_width;

                    rect.h = video_height;

                    SDL_DisplayYUVOverlay(bmp, &rect);

                    break;

                }

            }

#if CHECK_LIBAVCODEC_VERSION (55, 45, 101, 55, 28, 1)

            av_frame_free (& frame);

#elif CHECK_LIBAVCODEC_VERSION (54, 59, 100, 54, 28, 0)

            avcodec_free_frame (& frame);

#else

            av_free (frame);

#endif

            if (play_video)

            {

                SDL_PollEvent(&event);

                switch(event.type) {

                case SDL_QUIT:

                    SDL_Quit();

                    play_video = false;

                    //goto error_exit;

                    break;

                case SDL_VIDEORESIZE:

                    //Resize the screen

                    float new_aspect_ratio;  //FOR SOME REASON C++ REQUIRES 2 LINES HERE?!

                    new_aspect_ratio = event.resize.h

                        ? (float)event.resize.w / (float)event.resize.h : 1.0;

AUDDBG("-Resize:  w=%d= h=%d=\n", vcinfo.context->width, vcinfo.context->height);

                    if (new_aspect_ratio > video_aspect_ratio)

                    {

                        video_height = event.resize.h;

      //FIXEDNOW?!                  if (video_height > vcinfo.context->height)  //JWT:SEGFAULTS OTHERWISE?!

      //                      video_height = vcinfo.context->height;

                        video_width = (int)(video_aspect_ratio * (float)video_height);

                    }

                    else

                    {

                        video_width = event.resize.w;

      //                  if (video_width > vcinfo.context->width)  //JWT:SEGFAULTS OTHERWISE?!

      //                      video_width = vcinfo.context->width;

                        video_height = (int)((float)video_width / video_aspect_ratio);

                    }

AUDDBG("-RESIZE to %d x %d, %d x %d! aspect=%f=\n", event.resize.w, event.resize.h, video_width, video_height, video_aspect_ratio);

#ifndef __DARWIN__

                    screen = SDL_SetVideoMode( video_width, video_height, 0, SDL_RESIZABLE );

#else

                    screen = SDL_SetVideoMode( video_width, video_height, 24, SDL_RESIZABLE );

#endif

                    //If there's an error

                    if( screen == NULL )

                        break;

                default:

                    break;

                }

            }

        }

        if (pkt.data)

            av_free_packet(&pkt);

    }

error_exit:

AUDDBG("-at error exit...\n");

    if (play_video)

        SDL_Quit();

    if (pkt.data)

        av_free_packet(&pkt);

    if (ic != nullptr)

        close_input_file(ic, & cinfo, & vcinfo);

    return ! error;

}

const char FFaudio::about[] =

 N_("Multi-format audio decoding plugin for Audacious using\n"

    "FFmpeg multimedia framework (http://www.ffmpeg.org/)\n"

    "\n"

    "Audacious plugin by:\n"

    "William Pitcock <nenolod@nenolod.net>\n"

    "Matti Hämäläinen <ccr@tnsp.org>");

const char * const FFaudio::exts[] = {

    /* musepack, SV7/SV8 */

    "mpc", "mp+", "mpp",

    /* windows media audio */

    "wma",

    /* shorten */

    "shn",

    /* atrac3 */

    "aa3", "oma",

    /* MPEG 2/4 AC3 */

    "ac3",

    /* monkey's audio */

    "ape",

    /* DTS */

    "dts",

    /* VQF */

    "vqf",

    /* MPEG-4 */

    "m4a", "mp4",

    /* WAV (there are some WAV formats sndfile can't handle) */

    "wav",

    /* Handle OGG streams (FLAC/Vorbis etc.) */

    "ogg", "oga",

    /* Opus */

    "opus",

    /* Speex */

    "spx",

    /* end of table */

    nullptr

};

const char * const FFaudio::mimes[] = {"application/ogg", nullptr};