Audacious - OLD, PLEASE USE GITHUB DISCUSSIONS/ISSUES

/*

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

 * Video-playing capability added Copyright © 2015 Jim Turner <turnerjw784@yahoo.com>

 *

 * 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;

/* 

    JWT: ADDED ALL THIS QUEUE STUFF TO SMOOTH VIDEO PERFORMANCE SO THAT VIDEO FRAMES WOULD 

    BE OUTPUT MORE INTERLACED WITH THE AUDIO FRAMES BY QUEUEING VIDEO FRAMES UNTIL AN 

    AUDIO FRAME IS PROCESSED, THEN DEQUEUEING AND PROCESSING 'EM WITH EACH AUDIO FRAME.  

    THE SIZE OF THIS QUEUE IS SET BY video_qsize CONFIG PARAMETER AND DEFAULTS TO 20.

    HAVING TOO MANY CAN RESULT IN DELAYED VIDEO, SO EXPERIMENT.  IDEALLY, PACKETS SHOULD 

    BE PROCESSED:  V A V A V A..., BUT THIS HANDLES:  

    V1 V2 V3 V4 V5 A1 A2 A3 A4 A5 A6 A7 V7 A8... AS: 

    (Q:V1 V2 V3 V4 V5 V6) A1 A2 V1 A3 A4 V2 A5 A6 V3 A7 A8...

    WE DON'T WANT TO INTERRUPT AUDIO PERFORMANCE AND I DON'T KNOW HOW TO THREAD IT UP,

    BUT THIS SIMPLE APPROACH SEEMS TO WORK PRETTY SMOOTH FOR ME!  OTHERWISE TRY 

    INCREASING video_qsize IN config file OTHERWISE.

    BORROWED THESE FUNCTIONS FROM:

    http://www.thelearningpoint.net/computer-science/data-structures-queues--with-c-program-source-code

*/

typedef struct 

{

    int capacity;

    int size;

    int front;

    int rear;

    AVPacket *elements;

}

pktQueue;

pktQueue * createQueue (int maxElements)

{

    /* Create a Queue */

    pktQueue *Q;

    Q = (pktQueue *)malloc(sizeof(pktQueue));

    /* Initialise its properties */

    Q->elements = (AVPacket *)malloc(sizeof(AVPacket)*maxElements);

    Q->size = 0;

    Q->capacity = maxElements;

    Q->front = 0;

    Q->rear = -1;

    /* Return the pointer */

    return Q;

}

bool Dequeue (pktQueue *Q)

{

    /* If Queue size is zero then it is empty. So we cannot pop */

    if(Q->size==0)

        return false;

    /* Removing an element is equivalent to incrementing index of front by one */

    else

    {

        Q->size--;

        if (Q->elements[Q->front].data)

            av_free_packet(&Q->elements[Q->front]);

        Q->front++;

        /* As we fill elements in circular fashion */

        if(Q->front==Q->capacity)

        {

                Q->front=0;

        }

    }

    return true;

}

AVPacket * QFront (pktQueue *Q)

{

    if(Q->size==0)

    {

            AUDDBG("Queue is Empty\n");

            return nullptr;

    }

    /* Return the element which is at the front*/

    return &Q->elements[Q->front];

}

bool isQueueFull (pktQueue *Q)

{

    return (Q->size == Q->capacity) ? true : false;

}

bool Enqueue (pktQueue *Q, AVPacket element)

{

    /* If the Queue is full, we cannot push an element into it as there is no space for it.*/

    if(Q->size == Q->capacity)

    {

            printf("Queue is Full\n");

            return false;

    }

    else

    {

            Q->size++;

            Q->rear = Q->rear + 1;

            /* As we fill the queue in circular fashion */

            if(Q->rear == Q->capacity)

            {

                    Q->rear = 0;

            }

            /* Insert the element in its rear side */ 

            Q->elements[Q->rear] = element;

    }

    return true;

}

/* JWT:END OF ADDED VIDEO PACKET QUEUEING FUNCTIONS */

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

    /* JWT:SAVE config OPTION VALUE FOR CLOSING THINGS, IN CASE USER KILLS VIDEO WINDOW 

        THUS TURNING "play_video" OFF DURING PLAY.

    */

    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 IF USER WANTS VIDEO, 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;

            }

        }

        else

            play_video = false;  /* turn off video playback, since we could not find stream! */

        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 = (!strcmp(filename, "-") || strstr(filename, "://-.")) ? true : false;

    AUDDBG("Filename =%s=\n", filename);

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

                if (play_video && vcinfo.stream->metadata)

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

            }

            close_input_file (ic, & cinfo, & vcinfo);

        }

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

            audtag::tuple_read (tuple, file);

            /* JWT:BUILD NOTE:  IF USING LATEST AUDACIOUS VERSIONS YOU MAY NEED TO REPLACE ABOVE LINE WITH:

                audtag::read_tag (file, & tuple, nullptr);

            */

    }

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

}

/* JWT: NEW FUNCTION TO WRITE VIDEO FRAMES TO THE POPUP WINDOW: */

bool write_videoframe (SwsContext * sws_ctx, AVFrame * vframe, SDL_Overlay * bmp, 

    AVPacket *pkt, int * frameFinished, int video_width, int video_height)

{

    SDL_Rect rect;

    int len = avcodec_decode_video2 (vcinfo.context, vframe, frameFinished, pkt);

    // Did we get a video frame?

    if (len < 0)

    {

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

        return false;

    }

    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 *)vframe->data,

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

            pict.data, pict.linesize);

        SDL_UnlockYUVOverlay(bmp);

        rect.x = 0;

        rect.y = 0;

        rect.w = video_width;

        rect.h = video_height;

        SDL_DisplayYUVOverlay(bmp, &rect);

        return false;

    }

    return true;

}

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

{

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

    AVPacket pkt = AVPacket();

    int errcount;

    /* bool codec_opened = false;  //JWT:DON'T THINK WE NEED ANYMORE. */

    int out_fmt;

    bool planar;

    bool error = false;

    SDL_Overlay     *bmp = nullptr;    /* JWT: ALL SDL_* STUFF IS FOR PLAYING VIDEOS */

    SDL_Surface     *screen = nullptr;

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

                if (play_video && vcinfo.stream->metadata)

                    read_metadata_dict (tuple, vcinfo.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;

    /* JWT: IF abUSER ALSO WANTS TO PLAY VIDEO THEN WE SET UP POP-UP VIDEO SCREEN: */

    if (play_video)

    {

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

#else

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

#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"))   //USER CAN CHOOSE SWS_SCALE VALUE.

            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

        );

        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;

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

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

        /* JWT:FIXME:FLV AND SWF STREAMS ERROR OUT ON ATTEMPT TO CHANGE SIZE AT STARTUP?!

            THOUGH USER CAN STILL RESIZE WINDOW LATER!  ERROR MSG:

            "Assertion ref->size >= offset + s->mb_stride * ((f->height+15)/16) failed 

            at libavcodec/mpegvideo.c:1963 

        */

        if (! strcmp_nocase (fileext, ".flv") || ! strcmp_nocase (fileext, ".swf"))

            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

            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;

        }

    }

    /* codec_opened = true;  //JWT:DON'T THINK WE NEED ANYMORE. */

    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;

    int seek_value, ret, frameFinished, decoded, len, size, video_qsize, acount, vcount;

    bool knit1perl2;

    acount = 0; vcount = 0;  /* JWT:LET'S COUNT PACKETS OF EACH SIZE FOR DEBUGGING. */

    AVFrame * frame;

    AVFrame * vframe;

    /* JWT:video_qsize:  MAX # VIDEO PACKETS TO QUEUE UP FOR INTERLACING TO SMOOTH VIDEO 

        PLAYBACK - GOOD RANGE IS 8-56, NOT ENOUGH=JITTERY VIDEO, 

        TOO MANY=AUDIO/VIDEO BECOME NOTICABLY OUT OF SYNC!

    */

    video_qsize = (aud_get_int ("ffaudio", "video_qsize"))

        ? aud_get_int ("ffaudio", "video_qsize") : 16;

    if (video_qsize < 1)

        video_qsize = 1;

    pktQueue *pktQ;

    pktQ = createQueue(video_qsize);

    /* 

        JWT: THIS FLAG FORCES THE VIDEO QUEUE TO BE POPPED ONCE FOR EVERY *TWO* AUDIO 

        PACKETS - MOST VIDEOS SEEM TO HAVE A/B 2-1 RATIO OF AUDIO TO VIDEO PACKETS & 

        THIS PRETTY MUCH *ELIMINATED* THE VIDEO JITTER!!!

    */

    knit1perl2 = true;  /* ALTERNATES BETWEEN ON AND OFF EVERY OTHER AUDIO PACKET */

    AUDDBG("video queue size %d\n", video_qsize);

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

    frame = av_frame_alloc ();

    vframe = av_frame_alloc ();

#else

    frame = avcodec_alloc_frame ();

    vframe = avcodec_alloc_frame ();

#endif

    while (! check_stop ())

    {

        seek_value = check_seek ();

        if (seek_value >= 0)

        {

            /* JWT:FIRST, PROCESS VIDEO PACKETS SITTING IN THE QUEUE TO CLEAR THE QUEUE! */

            while (Dequeue (pktQ))

                continue;

            /* JWT: HAD TO CHANGE THIS FROM "AVSEEK_FLAG_ANY" TO AVSEEK_FLAG_BACKWARD 

                TO GET SEEK TO NOT RANDOMLY BRICK?! */

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

                1000, AVSEEK_FLAG_BACKWARD) < 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)

                break;

            decoded = 0;

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

            {

                ++acount;

                /* JWT:IF PLAYING VIDEO, CHECK VIDEO QUEUE. */

                if (play_video)

                {

                    int i,pkts2pop;

                    /* FIRST PROCESS THE NEXT # VIDEO PACKETS, IF ANY IN THE QUEUE:

                        FOR EVERY *OTHER* AUDIO PACKET, GRAB 1 VIDEO PKT. OFF QUEUE,

                        UNLESS QUEUE IS FULL, THEN GRAB 2 SO WE HAVE ROOM FOR THE NEXT ONE!

                    */

                    pkts2pop = knit1perl2 ? ((pktQ->size == pktQ->capacity) ? 2 : 1) : 0;

                    if (pkts2pop > video_qsize)

                        pkts2pop = video_qsize;

                    knit1perl2 = ! knit1perl2;  //WE'RE ASSUMING LIKELY NEAR 2x AUDIO TO VIDEO FRAMES:

                    AVPacket * pktRef;

                    for (i=1; i<=pkts2pop; i++)

                    {

                        pktRef = QFront (pktQ);

                        if (pktRef)

                        {

                            while (1)

                            {

                                if (!write_videoframe (sws_ctx, vframe, bmp, pktRef, &frameFinished, 

                                        video_width, video_height))

                                    break;

                            }

                            if (!Dequeue (pktQ))

                                AUDERR("Queue is Empty\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)

                    /* continue;  // JWT:NOT SURE WHY THIS WAS A CONTINUE INSTEAD OF A BREAK?! */

                    break;

                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 PACKET HERE: */

            {

                ++vcount;

                /* JWT: IF QUEUE IS FULL, PROCESS NEXT 2 VIDEO PACKETS FROM QUEUE. */

                if (isQueueFull (pktQ))

                {

                    int i, pkts2pop;

                    AVPacket * pktRef;

                    pkts2pop = (video_qsize > 1) ? 2 : 1;

                    for (i=1; i<=pkts2pop; i++)

                    {

                        pktRef = QFront (pktQ);

                        if (pktRef)

                        {

                            while (1)

                            {

                                if (!write_videoframe (sws_ctx, vframe, bmp, pktRef, &frameFinished, 

                                        video_width, video_height))

                                    break;

                            }

                            if (!Dequeue (pktQ))

                                AUDERR("Queue is Empty\n");

                        }

                    }

                    AUDDBG("Queue filled.\n");

                }

                if (Enqueue(pktQ, pkt)) {  /* VIDEO PACKETS TAKE A NUMBER & GET IN LINE! */

                    break;

                }

                AUDERR("Could not enqueue packet, refuses to wait in line, so process NOW!\n");

                if (!write_videoframe (sws_ctx, vframe, bmp, &pkt, &frameFinished, 

                        video_width, video_height))

                    break;

            }

            /* JWT: NOW HANDLE VIDEO UI EVENTS SUCH AS RESIZE OR KILL SCREEN: */

            if (play_video)

            {

                SDL_Rect rect;

                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;

                    if (new_aspect_ratio > video_aspect_ratio)

                    {

                        video_height = event.resize.h;

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

                    }

                    else

                    {

                        video_width = event.resize.w;

                        video_height = (int)((float)video_width / 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;

                case SDL_VIDEOEXPOSE:

                    rect.x = 0;

                    rect.y = 0;

                    rect.w = video_width;

                    rect.h = video_height;

                    SDL_DisplayYUVOverlay(bmp, &rect);

                    break;

                default:

                    break;

                }

            }

        }

    }

error_exit:

    AUDDBG("end of playback - % audio frames, % video frames processed.", acount, vcount);

    if (play_video)

        SDL_Quit();

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

    av_frame_free (& vframe);

    av_frame_free (& frame);

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

    avcodec_free_frame (& vframe);

    avcodec_free_frame (& frame);

#else

    av_free (vframe);

    av_free (frame);

#endif

    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",

    /* True Audio */

    "tta",

    /* AVI  // JWT:ADDED */

    "avi",

    /* FLV  // JWT:ADDED */

    "flv",

    /* end of table */

    nullptr

};

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