static int is_rtjpeg_inited = 0;

                    is_rtjpeg_inited = 1;

/* stolen from libmp3lame -mdz */

/* Used to find nearest matching bitrate

 * we need bitrate-based values

 * determined using tables

 *

 * bitrate in kbps

 *

 * Gabriel Bouvigne 2002-11-03

 */

int nearestBitrate(const int bitrate)

{

    /* borrowed from DM abr presets*/    

    int index; // resolved range

    const int bitrate_table[] = {8, 16, 24, 32, 40, 48, 56, 64, 80, 96, 112, 128, 160, 192, 224, 256, 320};

    int lower_range = 0, lower_range_kbps = 0,

        upper_range = 0, upper_range_kbps = 0;

    int b;

    // We assume specified bitrate will be 320kbps

    upper_range_kbps = bitrate_table[16];

    upper_range = 16;

    lower_range_kbps = bitrate_table[16];

    lower_range = 16;

    // Determine which significant bitrates the value specified falls between,

    // if loop ends without breaking then we were correct above that the value was 320

    for (b = 0; b < 16; b++) {

        if (bitrate < bitrate_table[b+1]) {

              upper_range_kbps = bitrate_table[b+1];

              upper_range = b+1;

              lower_range_kbps = bitrate_table[b];

              lower_range = (b);

              break; // We found upper range 

        }

    }

    // Determine which range the value specified is closer to

    if ((upper_range_kbps - bitrate) > (bitrate - lower_range_kbps))

        index = lower_range;

    else

        index = upper_range;

    return bitrate_table[index];

}

#define MKTAG(a,b,c,d) (a | (b << 8) | (c << 16) | (d << 24))

/* Scan for the extended data in MythTV nuv streams */

int demux_xscan_nuv ( demuxer_t* demuxer, int width, int height )

{

  int i;

  struct rtframeheader rtjpeg_frameheader;

  struct extendeddata ext;

  sh_video_t* sh_video = demuxer->video->sh;

  sh_audio_t* sh_audio = demuxer->audio->sh;

  for( i = 0 ; i < 2 ; ++i ) {

    if (stream_read ( demuxer->stream, (char*)& rtjpeg_frameheader, sizeof ( rtjpeg_frameheader ) ) < sizeof(rtjpeg_frameheader))

      return 0; /* EOF */

    if (rtjpeg_frameheader.frametype != 'X')

      stream_skip( demuxer->stream, rtjpeg_frameheader.packetlength );

  }

  if ( rtjpeg_frameheader.frametype != 'X' ) {

    stream_reset( demuxer->stream );

    return 0; /* No X frame in the expected place */

  }

  if ( rtjpeg_frameheader.packetlength != sizeof(ext) ) {

    printf("NUV extended frame does not have expected length, ignoring\n");

    stream_reset( demuxer->stream );

    return 0;

  }

  if (stream_read( demuxer->stream, (char*)& ext, sizeof(ext)) < sizeof(ext)) {

    stream_reset( demuxer->stream );

    return 0; /* EOF */

  }

  if ( ext.version != 1 ) {

    printf("NUV extended frame has unknown version number (%d), ignoring\n",

           ext.version);

    stream_reset( demuxer->stream );

    return 0;

  }

  printf("Detected MythTV stream, reading extended format information\n");

  /* Video parameters */

  printf("FOURCC: %c%c%c%c\n",

         (ext.video_fourcc >> 24) & 0xff,

         (ext.video_fourcc >> 16) & 0xff,

         (ext.video_fourcc >> 8) & 0xff,

         (ext.video_fourcc) & 0xff);

  if ( ext.video_fourcc == mmioFOURCC('R', 'J', 'P', 'G') ) {

    long buf[128];

    /* Ignore the fact that this is initialising the compression

       Doing this will set the quality factor correctly */

    RTjpeg_init_compress(buf,width,height,ext.rtjpeg_quality);

    RTjpeg_init_decompress(buf,width,height);

    sh_video->format = mmioFOURCC('N', 'U', 'V', '1');

  } else {

    sh_video->format = ext.video_fourcc;

    sh_video->i_bps = ext.lavc_bitrate;

  }

  /* Audio parameters */

  if ( ext.audio_fourcc == mmioFOURCC('L', 'A', 'M', 'E') ) {

    sh_audio->format = 0x55;

  } else if ( ext.audio_fourcc == mmioFOURCC('R', 'A', 'W', 'A') ) {

    sh_audio->format = 0x1;

  } else {

    printf("Warning! unknown audio format %d\n", ext.audio_fourcc);

  }

  sh_audio->samplerate = ext.audio_sample_rate;

  sh_audio->channels = ext.audio_channels;

  /* this is a little silly so that we can use libmp3lame's

     nearestBitrate verbatim */

  if (sh_audio->format != 0x1)

       sh_audio->i_bps = nearestBitrate(ext.audio_channels

                                        * ext.audio_bits_per_sample

                                        * ext.audio_sample_rate /

                                        ext.audio_compression_ratio / 1000) * 1000;

  sh_audio->wf->wBitsPerSample = ext.audio_bits_per_sample;

  sh_audio->wf->nAvgBytesPerSec = sh_audio->i_bps / 8;

  sh_audio->wf->nBlockAlign = sh_audio->channels * 2;

  sh_audio->wf->cbSize = 0;

  sh_audio->wf->nSamplesPerSec = ext.audio_sample_rate;

  sh_audio->wf->wFormatTag = sh_audio->format;

  sh_audio->wf->nChannels = ext.audio_channels;

  printf("channels=%d bitspersample=%d samplerate=%d audio_compression_ratio=%d\n", ext.audio_channels, ext.audio_bits_per_sample, ext.audio_sample_rate, ext.audio_compression_ratio);

  stream_reset( demuxer->stream );

  return 1;

}

/* for MythTV */

typedef struct extendeddata

{

   int version;            // yes, this is repeated from the file header

   int video_fourcc;       // video encoding method used 

   int audio_fourcc;       // audio encoding method used

   // generic data

   int audio_sample_rate;

   int audio_bits_per_sample;

   int audio_channels;

   // codec specific

   // mp3lame

   int audio_compression_ratio;

   int audio_quality;

   // rtjpeg

   int rtjpeg_quality;

   int rtjpeg_luma_filter;

   int rtjpeg_chroma_filter;

   // libavcodec

   int lavc_bitrate;

   int lavc_qmin;

   int lavc_qmax;

   int lavc_maxqdiff;

   // unused for later -- total size of 128 integers.

   // new fields must be added at the end, above this comment.

   int expansion[113];

} extendeddata;