Adapted cFemonBitStream for vdr-1.7.22.

HISTORY

@@ -414,3 +414,10 @@ VDR Plugin 'femon' Revision History
 
 - Updated for vdr-1.7.18.
 - Added scaling for symbols.
+
+2011-12-04: Version 1.7.11
+
+- Updated for vdr-1.7.22: New API functions for signal strength
+  and quality used to provide information for the OSD.
+- Added cppcheck target into Makefile.
+- Refactored bitstream code.

Makefile

@@ -96,7 +96,7 @@ I18Npot   = $(PODIR)/$(PLUGIN).pot
 	msgfmt -c -o $@ $<
 
 $(I18Npot): $(wildcard *.c)
-	xgettext -C -cTRANSLATORS --no-wrap --no-location -k -ktr -ktrNOOP --package-name='vdr-$(PLUGIN)' --package-version='$(VERSION)' --msgid-bugs-address='<see README>' -o $@ $^
+	xgettext -C -cTRANSLATORS --no-wrap --no-location -k -ktr -ktrNOOP --package-name='vdr-$(PLUGIN)' --package-version='$(VERSION)' --msgid-bugs-address='<see README>' -o $@ `ls $^`
 
 %.po: $(I18Npot)
 	msgmerge -U --no-wrap --no-location --backup=none -q $@ $<
@@ -128,3 +128,6 @@ dist: $(I18Npo) clean
 
 clean:
 	@-rm -f $(OBJS) $(DEPFILE) *.so *.tgz core* *~ $(PODIR)/*.mo $(PODIR)/*.pot
+
+cppcheck: $(OBJS)
+	@cppcheck --enable=information,style,unusedFunction -v -f $(OBJS:%.o=%.c)

README

@@ -32,15 +32,15 @@ Terminology:
 
 --------------------------------------------------------------
 |## Channel Name ################### [SVDRP][AR][VF][A/DD][D]|
-|[=====Signal Strength in % ==============|=================]|
-|[=====Signal-to-Noise Ratio in % ========|=================]|
+|[=====Signal Strength ===================|=================]|
+|[=====Signal Quality ================|=====================]|
 | STR: #0000 (0%)       BER: #00000000       Video: 0 Mbit/s |
 | SNR: #0000 (0%)       UNC: #00000000       Audio: 0 kbit/s |
 | [LOCK]     [SIGNAL]     [CARRIER]     [VITERBI]     [SYNC] |
 --------------------------------------------------------------
 
-STR     - Signal strength
-SNR     - Signal-to-noise ratio
+STR     - Signal strength from driver
+SNR     - Signal-to-noise ratio from driver
 BER     - Bit error rate
 UNC     - Uncorrected blocks
 Video   - Calculated video bitrate in Mbit/s

femon.c

@@ -14,11 +14,11 @@
 #include "femonservice.h"
 #include "femontools.h"
 
-#if defined(APIVERSNUM) && APIVERSNUM < 10718
-#error "VDR-1.7.18 API version or greater is required!"
+#if defined(APIVERSNUM) && APIVERSNUM < 10722
+#error "VDR-1.7.22 API version or greater is required!"
 #endif
 
-static const char VERSION[]       = "1.7.10";
+static const char VERSION[]       = "1.7.11";
 static const char DESCRIPTION[]   = trNOOP("DVB Signal Information Monitor (OSD)");
 static const char MAINMENUENTRY[] = trNOOP("Signal Information");
 
@@ -169,10 +169,14 @@ const char **cPluginFemon::SVDRPHelpPages(void)
     "    Print the current frontend name.",
     "STAT\n"
     "    Print the current frontend status.",
-    "SGNL\n"
+    "STRG\n"
     "    Print the current signal strength.",
+    "QUAL\n"
+    "    Print the current signal quality.",
+    "SGNL\n"
+    "    Print the current signal strength from driver.",
     "SNRA\n"
-    "    Print the current signal-to-noise ratio.",
+    "    Print the current signal-to-noise ratio from driver.",
     "BERA\n"
     "    Print the current bit error rate.",
     "UNCB\n"
@@ -225,6 +229,12 @@ cString cPluginFemon::SVDRPCommand(const char *Command, const char *Option, int
   else if (strcasecmp(Command, "STAT") == 0) {
      return getFrontendStatus(cDevice::ActualDevice()->CardIndex());
      }
+  else if (strcasecmp(Command, "STRG") == 0) {
+     return cString::sprintf("%d on device #%d", cDevice::ActualDevice()->SignalStrength(), cDevice::ActualDevice()->CardIndex());
+     }
+  else if (strcasecmp(Command, "QUAL") == 0) {
+     return cString::sprintf("%d on device #%d", cDevice::ActualDevice()->SignalQuality(), cDevice::ActualDevice()->CardIndex());
+     }
   else if (strcasecmp(Command, "SGNL") == 0) {
      int value = getSignal(cDevice::ActualDevice()->CardIndex());
      return cString::sprintf("%04X (%02d%%) on device #%d", value, value / 655, cDevice::ActualDevice()->CardIndex());

femonaac.c

@@ -26,7 +26,7 @@ cFemonAAC::~cFemonAAC()
 
 bool cFemonAAC::processAudio(const uint8_t *buf, int len)
 {
-  cBitStream bs(buf, len * 8);
+  cFemonBitStream bs(buf, len * 8);
 
   if (!m_AudioHandler)
      return false;
@@ -48,23 +48,23 @@ bool cFemonAAC::processAudio(const uint8_t *buf, int len)
   // skip PES header
   if (!PesLongEnough(len))
       return false;
-  bs.skipBits(8 * PesPayloadOffset(buf));
+  bs.SkipBits(8 * PesPayloadOffset(buf));
 
   // HE-AAC audio detection
-  if (bs.getBits(12) != 0xFFF)                  // syncword
+  if (bs.GetBits(12) != 0xFFF)                  // syncword
      return false;
 
-  bs.skipBit();                                 // id
+  bs.SkipBit();                                 // id
 
   // layer must be 0
-  if (bs.getBits(2))                            // layer
+  if (bs.GetBits(2))                            // layer
       return false;
 
-  bs.skipBit();                                 // protection_absent
-  bs.skipBits(2);                               // profile
-  int sampling_frequency_index = bs.getBits(4); // sampling_frequency_index
-  bs.skipBit();                                 // private pid
-  int channel_configuration = bs.getBits(3);    // channel_configuration
+  bs.SkipBit();                                 // protection_absent
+  bs.SkipBits(2);                               // profile
+  int sampling_frequency_index = bs.GetBits(4); // sampling_frequency_index
+  bs.SkipBit();                                 // private pid
+  int channel_configuration = bs.GetBits(3);    // channel_configuration
 
   m_AudioHandler->SetAudioCodec(AUDIO_CODEC_HEAAC);
   m_AudioHandler->SetAudioBitrate(AUDIO_BITRATE_RESERVED);

femonac3.c

@@ -41,7 +41,7 @@ bool cFemonAC3::processAudio(const uint8_t *buf, int len)
   int centermixlevel = AUDIO_CENTER_MIX_LEVEL_INVALID;
   int surroundmixlevel = AUDIO_SURROUND_MIX_LEVEL_INVALID;
   int dolbysurroundmode = AUDIO_DOLBY_SURROUND_MODE_INVALID;
-  cBitStream bs(buf, len * 8);
+  cFemonBitStream bs(buf, len * 8);
 
   if (!m_AudioHandler)
      return false;
@@ -49,34 +49,34 @@ bool cFemonAC3::processAudio(const uint8_t *buf, int len)
   // skip PES header
   if (!PesLongEnough(len))
       return false;
-  bs.skipBits(8 * PesPayloadOffset(buf));
+  bs.SkipBits(8 * PesPayloadOffset(buf));
 
   // http://rmworkshop.com/dvd_info/related_info/ac3hdr.htm
 
   // AC3 audio detection
-  if (bs.getU16() != 0x0B77)        // syncword
+  if (bs.GetBits(16) != 0x0B77)     // syncword
      return false;
 
-  bs.skipBits(16);                  // CRC1
+  bs.SkipBits(16);                  // CRC1
 
-  fscod = bs.getBits(2);            // sampling rate values
-  frmsizcod = bs.getBits(6);        // frame size code
+  fscod = bs.GetBits(2);            // sampling rate values
+  frmsizcod = bs.GetBits(6);        // frame size code
 
-  bs.skipBits(5);                   // bitstream id
-  bsmod = bs.getBits(3);            // bitstream mode
-  acmod = bs.getBits(3);            // audio coding mode
+  bs.SkipBits(5);                   // bitstream id
+  bsmod = bs.GetBits(3);            // bitstream mode
+  acmod = bs.GetBits(3);            // audio coding mode
 
   // 3 front channels
   if ((acmod & 0x01) && (acmod != 0x01))
-     centermixlevel = bs.getBits(2);
+     centermixlevel = bs.GetBits(2);
 
   // if a surround channel exists
   if (acmod & 0x04)
-     surroundmixlevel = bs.getBits(2);
+     surroundmixlevel = bs.GetBits(2);
 
   // if in 2/0 mode
   if (acmod == 0x02)
-      dolbysurroundmode = bs.getBits(2);
+      dolbysurroundmode = bs.GetBits(2);
 
   m_AudioHandler->SetAC3Bitrate(1000 * s_Bitrates[frmsizcod >> 1]);
   m_AudioHandler->SetAC3SamplingFrequency(100 * s_Frequencies[fscod]);
@@ -86,8 +86,8 @@ bool cFemonAC3::processAudio(const uint8_t *buf, int len)
   m_AudioHandler->SetAC3SurroundMix(surroundmixlevel);
   m_AudioHandler->SetAC3DolbySurround(dolbysurroundmode);
 
-  m_AudioHandler->SetAC3LFE(bs.getBit());       // low frequency effects on
-  m_AudioHandler->SetAC3Dialog(bs.getBits(5));  // dialog normalization
+  m_AudioHandler->SetAC3LFE(bs.GetBit());       // low frequency effects on
+  m_AudioHandler->SetAC3Dialog(bs.GetBits(5));  // dialog normalization
 
   return true;
 }

femonh264.c

@@ -163,16 +163,16 @@ bool cFemonH264::processVideo(const uint8_t *buf, int len)
   if (aud_found) {
      m_VideoHandler->SetVideoCodec(VIDEO_CODEC_H264);
      if (sps_found) {
-        //debug("H.264 SPS: size %dx%d, aspect %d format %d framerate %.2f bitrate %.0f\n", m_Width, m_Height, m_AspectRatio, m_Format, m_FrameRate, m_BitRate);
+        //debug("H.264: size %dx%d, aspect %d format %d bitrate %.0f\n", m_Width, m_Height, m_AspectRatio, m_Format, m_BitRate);
         m_VideoHandler->SetVideoFormat(m_Format);
         m_VideoHandler->SetVideoSize(m_Width, m_Height);
         m_VideoHandler->SetVideoAspectRatio(m_AspectRatio);
-        m_VideoHandler->SetVideoFramerate(m_FrameRate);
         m_VideoHandler->SetVideoBitrate(m_BitRate);
         }
-     if (sei_found) {
-        //debug("H.264 SEI: scan %d\n", m_Scan);
+     if (sps_found || sei_found) {
+        //debug("H.264: scan %d framerate %.2f\n", m_Scan, (m_Scan == VIDEO_SCAN_PROGRESSIVE) ? (m_FrameRate / 2) : m_FrameRate);
         m_VideoHandler->SetVideoScan(m_Scan);
+        m_VideoHandler->SetVideoFramerate((m_Scan == VIDEO_SCAN_PROGRESSIVE) ? (m_FrameRate / 2) : m_FrameRate);
         }
   }
 
@@ -222,7 +222,7 @@ int cFemonH264::nalUnescape(uint8_t *dst, const uint8_t *src, int len)
 int cFemonH264::parseSPS(const uint8_t *buf, int len)
 {
   int profile_idc, level_idc, constraint_set3_flag, pic_order_cnt_type, i, j;
-  cBitStream bs(buf, len);
+  cFemonBitStream bs(buf, len);
 
   uint32_t width = m_Width;
   uint32_t height = m_Height;
@@ -236,14 +236,14 @@ int cFemonH264::parseSPS(const uint8_t *buf, int len)
   bool mb_adaptive_frame_field_flag = m_MbAdaptiveFrameFieldFlag;
   uint32_t time_offset_length = m_TimeOffsetLength;
 
-  profile_idc = bs.getU8();                 // profile_idc
-  bs.skipBit();                             // constraint_set0_flag
-  bs.skipBit();                             // constraint_set1_flag
-  bs.skipBit();                             // constraint_set2_flag
-  constraint_set3_flag = bs.getBit();       // constraint_set3_flag
-  bs.skipBits(4);                           // reserved_zero_4bits
-  level_idc = bs.getU8();                   // level_idc
-  bs.skipUeGolomb();                        // seq_parameter_set_id
+  profile_idc = bs.GetBits(8);              // profile_idc
+  bs.SkipBit();                             // constraint_set0_flag
+  bs.SkipBit();                             // constraint_set1_flag
+  bs.SkipBit();                             // constraint_set2_flag
+  constraint_set3_flag = bs.GetBit();       // constraint_set3_flag
+  bs.SkipBits(4);                           // reserved_zero_4bits
+  level_idc = bs.GetBits(8);                // level_idc
+  bs.SkipUeGolomb();                        // seq_parameter_set_id
   //debug("H.264 SPS: profile_idc %d level_idc %d\n", profile_idc, level_idc);
   switch (profile_idc) {
     case 66:                                // baseline profile
@@ -457,55 +457,55 @@ int cFemonH264::parseSPS(const uint8_t *buf, int len)
          break;
   }
   if ((profile_idc == 100) || (profile_idc == 110) || (profile_idc == 122) || (profile_idc == 144)) {
-     if (bs.getUeGolomb() == 3)             // chroma_format_idc
-        bs.skipBit();                       // residual_colour_transform_flag
-     bs.skipUeGolomb();                     // bit_depth_luma_minus8
-     bs.skipUeGolomb();                     // bit_depth_chroma_minus8
-     bs.skipBit();                          // qpprime_y_zero_transform_bypass_flag
-     if (bs.getBit()) {                     // seq_scaling_matrix_present_flag
+     if (bs.GetUeGolomb() == 3)             // chroma_format_idc
+        bs.SkipBit();                       // residual_colour_transform_flag
+     bs.SkipUeGolomb();                     // bit_depth_luma_minus8
+     bs.SkipUeGolomb();                     // bit_depth_chroma_minus8
+     bs.SkipBit();                          // qpprime_y_zero_transform_bypass_flag
+     if (bs.GetBit()) {                     // seq_scaling_matrix_present_flag
         for (i = 0; i < 8; ++i) {
-            if (bs.getBit()) {              // seq_scaling_list_present_flag[i]
+            if (bs.GetBit()) {              // seq_scaling_list_present_flag[i]
                int last = 8, next = 8, size = (i < 6) ? 16 : 64;
                for (j = 0; j < size; ++j) {
                    if (next)
-                      next = (last + bs.getSeGolomb()) & 0xff;
+                      next = (last + bs.GetSeGolomb()) & 0xff;
                    last = next ?: last;
                    }
                }
             }
         }
      }
-  bs.skipUeGolomb();                        // log2_max_frame_num_minus4
-  pic_order_cnt_type = bs.getUeGolomb();    // pic_order_cnt_type
+  bs.SkipUeGolomb();                        // log2_max_frame_num_minus4
+  pic_order_cnt_type = bs.GetUeGolomb();    // pic_order_cnt_type
   if (pic_order_cnt_type == 0)
-     bs.skipUeGolomb();                     // log2_max_pic_order_cnt_lsb_minus4
+     bs.SkipUeGolomb();                     // log2_max_pic_order_cnt_lsb_minus4
   else if (pic_order_cnt_type == 1) {
-     bs.skipBit();                          // delta_pic_order_always_zero
-     bs.skipSeGolomb();                     // offset_for_non_ref_pic
-     bs.skipSeGolomb();                     // offset_for_top_to_bottom_field
-     j = bs.getUeGolomb();                  // num_ref_frames_in_pic_order_cnt_cycle
+     bs.SkipBit();                          // delta_pic_order_always_zero
+     bs.SkipSeGolomb();                     // offset_for_non_ref_pic
+     bs.SkipSeGolomb();                     // offset_for_top_to_bottom_field
+     j = bs.GetUeGolomb();                  // num_ref_frames_in_pic_order_cnt_cycle
      for (i = 0; i < j; ++i)
-         bs.skipSeGolomb();                 // offset_for_ref_frame[i]
+         bs.SkipSeGolomb();                 // offset_for_ref_frame[i]
      }
-  bs.skipUeGolomb();                        // num_ref_frames
-  bs.skipBit();                             // gaps_in_frame_num_value_allowed_flag
-  width  = bs.getUeGolomb() + 1;            // pic_width_in_mbs_minus1
-  height = bs.getUeGolomb() + 1;            // pic_height_in_mbs_minus1
-  frame_mbs_only_flag = bs.getBit();        // frame_mbs_only_flag
+  bs.SkipUeGolomb();                        // num_ref_frames
+  bs.SkipBit();                             // gaps_in_frame_num_value_allowed_flag
+  width  = bs.GetUeGolomb() + 1;            // pic_width_in_mbs_minus1
+  height = bs.GetUeGolomb() + 1;            // pic_height_in_mbs_minus1
+  frame_mbs_only_flag = bs.GetBit();        // frame_mbs_only_flag
   //debug("H.264 SPS: pic_width:  %u mbs\n", width);
   //debug("H.264 SPS: pic_height: %u mbs\n", height);
   //debug("H.264 SPS: frame only flag: %d\n", frame_mbs_only_flag);
   width  *= 16;
   height *= 16 * (frame_mbs_only_flag ? 1 : 2);
   if (!frame_mbs_only_flag)
-     mb_adaptive_frame_field_flag = bs.getBit(); // mb_adaptive_frame_field_flag
-  bs.skipBit();                             // direct_8x8_inference_flag
-  if (bs.getBit()) {                        // frame_cropping_flag
+     mb_adaptive_frame_field_flag = bs.GetBit(); // mb_adaptive_frame_field_flag
+  bs.SkipBit();                             // direct_8x8_inference_flag
+  if (bs.GetBit()) {                        // frame_cropping_flag
      uint32_t crop_left, crop_right, crop_top, crop_bottom;
-     crop_left   = bs.getUeGolomb();        // frame_crop_left_offset
-     crop_right  = bs.getUeGolomb();        // frame_crop_rigth_offset
-     crop_top    = bs.getUeGolomb();        // frame_crop_top_offset
-     crop_bottom = bs.getUeGolomb();        // frame_crop_bottom_offset
+     crop_left   = bs.GetUeGolomb();        // frame_crop_left_offset
+     crop_right  = bs.GetUeGolomb();        // frame_crop_rigth_offset
+     crop_top    = bs.GetUeGolomb();        // frame_crop_top_offset
+     crop_bottom = bs.GetUeGolomb();        // frame_crop_bottom_offset
      //debug("H.264 SPS: cropping %d %d %d %d\n", crop_left, crop_top, crop_right, crop_bottom);
      width -= 2 * (crop_left + crop_right);
      if (frame_mbs_only_flag)
@@ -514,14 +514,14 @@ int cFemonH264::parseSPS(const uint8_t *buf, int len)
         height -= 4 * (crop_top + crop_bottom);
      }
   // VUI parameters
-  if (bs.getBit()) {                        // vui_parameters_present_flag
-     if (bs.getBit()) {                     // aspect_ratio_info_present
+  if (bs.GetBit()) {                        // vui_parameters_present_flag
+     if (bs.GetBit()) {                     // aspect_ratio_info_present
         uint32_t aspect_ratio_idc, sar_width = 0, sar_height = 0;
-        aspect_ratio_idc = bs.getU8();      // aspect_ratio_idc
+        aspect_ratio_idc = bs.GetBits(8);   // aspect_ratio_idc
         //debug("H.264 SPS: aspect_ratio_idc %d\n", aspect_ratio_idc);
         if (aspect_ratio_idc == 255) {      // extended sar
-           sar_width  = bs.getU16();        // sar_width
-           sar_height = bs.getU16();        // sar_height
+           sar_width  = bs.GetBits(16);     // sar_width
+           sar_height = bs.GetBits(16);     // sar_height
            }
         else if (aspect_ratio_idc < ELEMENTS(s_SAR)) {
            sar_width  = s_SAR[aspect_ratio_idc].w;
@@ -546,78 +546,78 @@ int cFemonH264::parseSPS(const uint8_t *buf, int len)
            //debug("H.264 SPS: DAR %dx%d (%d)\n", sar_width, sar_height, aspect_ratio);
            }
         }
-     if (bs.getBit())                       // overscan_info_present_flag
-        bs.skipBit();                       // overscan_approriate_flag
-     if (bs.getBit()) {                     // video_signal_type_present_flag
+     if (bs.GetBit())                       // overscan_info_present_flag
+        bs.SkipBit();                       // overscan_approriate_flag
+     if (bs.GetBit()) {                     // video_signal_type_present_flag
         uint32_t video_format;
-        video_format = bs.getBits(3);       // video_format
+        video_format = bs.GetBits(3);       // video_format
         if (video_format < sizeof(s_VideoFormats) / sizeof(s_VideoFormats[0])) {
            format = s_VideoFormats[video_format];
            //debug("H.264 SPS: video format %d\n", format);
            }
-        bs.skipBit();                       // video_full_range_flag
-        if (bs.getBit()) {                  // colour_description_present_flag
-           bs.skipBits(8);                  // colour_primaries
-           bs.skipBits(8);                  // transfer_characteristics
-           bs.skipBits(8);                  // matrix_coefficients
+        bs.SkipBit();                       // video_full_range_flag
+        if (bs.GetBit()) {                  // colour_description_present_flag
+           bs.SkipBits(8);                  // colour_primaries
+           bs.SkipBits(8);                  // transfer_characteristics
+           bs.SkipBits(8);                  // matrix_coefficients
            }
         }
-     if (bs.getBit()) {                     // chroma_loc_info_present_flag
-        bs.skipUeGolomb();                  // chroma_sample_loc_type_top_field
-        bs.skipUeGolomb();                  // chroma_sample_loc_type_bottom_field
+     if (bs.GetBit()) {                     // chroma_loc_info_present_flag
+        bs.SkipUeGolomb();                  // chroma_sample_loc_type_top_field
+        bs.SkipUeGolomb();                  // chroma_sample_loc_type_bottom_field
         }
-     if (bs.getBit()) {                     // timing_info_present_flag
+     if (bs.GetBit()) {                     // timing_info_present_flag
         uint32_t num_units_in_tick, time_scale;
-        num_units_in_tick = bs.getU32();    // num_units_in_tick
-        time_scale        = bs.getU32();    // time_scale
+        num_units_in_tick = bs.GetBits(32); // num_units_in_tick
+        time_scale        = bs.GetBits(32); // time_scale
         if (num_units_in_tick > 0)
            frame_rate = time_scale / num_units_in_tick;
-        bs.skipBit();                       // fixed_frame_rate_flag
+        bs.SkipBit();                       // fixed_frame_rate_flag
         }
-     int nal_hrd_parameters_present_flag = bs.getBit(); // nal_hrd_parameters_present_flag
+     int nal_hrd_parameters_present_flag = bs.GetBit(); // nal_hrd_parameters_present_flag
      if (nal_hrd_parameters_present_flag) {
         int cpb_cnt_minus1;
-        cpb_cnt_minus1 = bs.getUeGolomb();  // cpb_cnt_minus1
-        bs.skipBits(4);                     // bit_rate_scale
-        bs.skipBits(4);                     // cpb_size_scale
+        cpb_cnt_minus1 = bs.GetUeGolomb();  // cpb_cnt_minus1
+        bs.SkipBits(4);                     // bit_rate_scale
+        bs.SkipBits(4);                     // cpb_size_scale
         for (int i = 0; i < cpb_cnt_minus1; ++i) {
-            bs.skipUeGolomb();              // bit_rate_value_minus1[i]
-            bs.skipUeGolomb();              // cpb_size_value_minus1[i]
-            bs.skipBit();                   // cbr_flag[i]
+            bs.SkipUeGolomb();              // bit_rate_value_minus1[i]
+            bs.SkipUeGolomb();              // cpb_size_value_minus1[i]
+            bs.SkipBit();                   // cbr_flag[i]
             }
-        bs.skipBits(5);                     // initial_cpb_removal_delay_length_minus1
-        bs.skipBits(5);                     // cpb_removal_delay_length_minus1
-        bs.skipBits(5);                     // dpb_output_delay_length_minus1
-        time_offset_length = bs.getBits(5); // time_offset_length
+        bs.SkipBits(5);                     // initial_cpb_removal_delay_length_minus1
+        bs.SkipBits(5);                     // cpb_removal_delay_length_minus1
+        bs.SkipBits(5);                     // dpb_output_delay_length_minus1
+        time_offset_length = bs.GetBits(5); // time_offset_length
         }
-     int vlc_hrd_parameters_present_flag = bs.getBit(); // vlc_hrd_parameters_present_flag
+     int vlc_hrd_parameters_present_flag = bs.GetBit(); // vlc_hrd_parameters_present_flag
      if (vlc_hrd_parameters_present_flag) {
          int cpb_cnt_minus1;
-         cpb_cnt_minus1 = bs.getUeGolomb(); // cpb_cnt_minus1
-         bs.skipBits(4);                    // bit_rate_scale
-         bs.skipBits(4);                    // cpb_size_scale
+         cpb_cnt_minus1 = bs.GetUeGolomb(); // cpb_cnt_minus1
+         bs.SkipBits(4);                    // bit_rate_scale
+         bs.SkipBits(4);                    // cpb_size_scale
          for (int i = 0; i < cpb_cnt_minus1; ++i) {
-             bs.skipUeGolomb();             // bit_rate_value_minus1[i]
-             bs.skipUeGolomb();             // cpb_size_value_minus1[i]
-             bs.skipBit();                  // cbr_flag[i]
+             bs.SkipUeGolomb();             // bit_rate_value_minus1[i]
+             bs.SkipUeGolomb();             // cpb_size_value_minus1[i]
+             bs.SkipBit();                  // cbr_flag[i]
              }
-         bs.skipBits(5);                    // initial_cpb_removal_delay_length_minus1
-         bs.skipBits(5);                    // cpb_removal_delay_length_minus1
-         bs.skipBits(5);                    // dpb_output_delay_length_minus1
-         time_offset_length = bs.getBits(5);// time_offset_length
+         bs.SkipBits(5);                    // initial_cpb_removal_delay_length_minus1
+         bs.SkipBits(5);                    // cpb_removal_delay_length_minus1
+         bs.SkipBits(5);                    // dpb_output_delay_length_minus1
+         time_offset_length = bs.GetBits(5);// time_offset_length
         }
      cpb_dpb_delays_present_flag = (nal_hrd_parameters_present_flag | vlc_hrd_parameters_present_flag);
      if (cpb_dpb_delays_present_flag)
-        bs.skipBit();                       // low_delay_hrd_flag
-     pic_struct_present_flag = bs.getBit(); // pic_struct_present_flag
-     if (bs.getBit()) {                     // bitstream_restriction_flag
-        bs.skipBit();                       // motion_vectors_over_pic_boundaries_flag
-        bs.skipUeGolomb();                  // max_bytes_per_pic_denom
-        bs.skipUeGolomb();                  // max_bits_per_mb_denom
-        bs.skipUeGolomb();                  // log2_max_mv_length_horizontal
-        bs.skipUeGolomb();                  // log2_max_mv_length_vertical
-        bs.skipUeGolomb();                  // num_reorder_frames
-        bs.skipUeGolomb();                  // max_dec_frame_buffering
+        bs.SkipBit();                       // low_delay_hrd_flag
+     pic_struct_present_flag = bs.GetBit(); // pic_struct_present_flag
+     if (bs.GetBit()) {                     // bitstream_restriction_flag
+        bs.SkipBit();                       // motion_vectors_over_pic_boundaries_flag
+        bs.SkipUeGolomb();                  // max_bytes_per_pic_denom
+        bs.SkipUeGolomb();                  // max_bits_per_mb_denom
+        bs.SkipUeGolomb();                  // log2_max_mv_length_horizontal
+        bs.SkipUeGolomb();                  // log2_max_mv_length_vertical
+        bs.SkipUeGolomb();                  // num_reorder_frames
+        bs.SkipUeGolomb();                  // max_dec_frame_buffering
         }
      }
 
@@ -625,6 +625,7 @@ int cFemonH264::parseSPS(const uint8_t *buf, int len)
   m_Height = height;
   m_AspectRatio = aspect_ratio;
   m_Format = format;
+  m_Scan = frame_mbs_only_flag ? VIDEO_SCAN_PROGRESSIVE : VIDEO_SCAN_INTERLACED;
   m_FrameRate = frame_rate;
   m_BitRate = bit_rate;
   m_CpbDpbDelaysPresentFlag = cpb_dpb_delays_present_flag;
@@ -633,38 +634,38 @@ int cFemonH264::parseSPS(const uint8_t *buf, int len)
   m_MbAdaptiveFrameFieldFlag = mb_adaptive_frame_field_flag;
   m_TimeOffsetLength = time_offset_length;
 
-  return (bs.getIndex() / 8);
+  return (bs.Index() / 8);
 }
 
 int cFemonH264::parseSEI(const uint8_t *buf, int len)
 {
   int num_referenced_subseqs, i;
-  cBitStream bs(buf, len);
+  cFemonBitStream bs(buf, len);
 
   eVideoScan scan = m_Scan;
 
-  while ((bs.getIndex() * 8 + 16) < len) {               // sei_message
+  while ((bs.Index() * 8 + 16) < len) {               // sei_message
     int lastByte, payloadSize = 0, payloadType = 0;
 
     do {
-       lastByte = bs.getU8() & 0xFF;
+       lastByte = bs.GetBits(8) & 0xFF;
        payloadType += lastByte;
     } while (lastByte == 0xFF);                          // last_payload_type_byte
 
     do {
-       lastByte = bs.getU8() & 0xFF;
+       lastByte = bs.GetBits(8) & 0xFF;
        payloadSize += lastByte;
     } while (lastByte == 0xFF);                          // last_payload_size_byte
 
     switch (payloadType) {                               // sei_payload
       case 1:                                            // pic_timing
            if (m_CpbDpbDelaysPresentFlag) {              // cpb_dpb_delays_present_flag
-              bs.skipUeGolomb();                         // cpb_removal_delay
-              bs.skipUeGolomb();                         // dpb_output_delay
+              bs.SkipUeGolomb();                         // cpb_removal_delay
+              bs.SkipUeGolomb();                         // dpb_output_delay
               }
            if (m_PicStructPresentFlag) {                 // pic_struct_present_flag
-              uint32_t pic_struct;
-              pic_struct = bs.getBits(4);                // pic_struct
+              uint32_t pic_struct, ct_type = 0, i = 0;
+              pic_struct = bs.GetBits(4);                // pic_struct
               if (pic_struct >= (sizeof(s_SeiNumClockTsTable)) / sizeof(s_SeiNumClockTsTable[0]))
                  return 0;
               if (m_FrameMbsOnlyFlag && !m_MbAdaptiveFrameFieldFlag)
@@ -690,80 +691,69 @@ int cFemonH264::parseSEI(const uint8_t *buf, int len)
                    }
                 }
               //debug("H.264 SEI: pic struct %d scan type %d\n", pic_struct, scan);
-              for (int i = 0; i < s_SeiNumClockTsTable[pic_struct]; ++i) {
-                  if (bs.getBit()) {                     // clock_timestamp_flag[i]
+              for (i = 0; i < s_SeiNumClockTsTable[pic_struct]; ++i) {
+                  if (bs.GetBit()) {                     // clock_timestamp_flag[i]
                      int full_timestamp_flag;
-                     switch (bs.getBits(2)) {            // ct_type
-                       case 0:
-                            scan = VIDEO_SCAN_PROGRESSIVE;
-                            break;
-                       case 1:
-                            scan = VIDEO_SCAN_INTERLACED;
-                            break;
-                       case 2:
-                            scan = VIDEO_SCAN_UNKNOWN;
-                            break;
-                       default:
-                            scan = VIDEO_SCAN_RESERVED;
-                            break;
-                       }
-                     //debug("H.264 SEI: scan type %d\n", scan);
-                     bs.skipBit();                       // nuit_field_based_flag
-                     bs.skipBits(5);                     // counting_type
-                     full_timestamp_flag = bs.getBit();  // full_timestamp_flag
-                     bs.skipBit();                       // discontinuity_flag
-                     bs.skipBit();                       // cnt_dropped_flag
-                     bs.skipBits(8);                     // n_frames
+                     ct_type |= (1 << bs.GetBits(2));    // ct_type
+                     //debug("H.264 SEI: ct type %04X\n", ct_type);
+                     bs.SkipBit();                       // nuit_field_based_flag
+                     bs.SkipBits(5);                     // counting_type
+                     full_timestamp_flag = bs.GetBit();  // full_timestamp_flag
+                     bs.SkipBit();                       // discontinuity_flag
+                     bs.SkipBit();                       // cnt_dropped_flag
+                     bs.SkipBits(8);                     // n_frames
                      if (full_timestamp_flag) {
-                        bs.skipBits(6);                  // seconds_value
-                        bs.skipBits(6);                  // minutes_value
-                        bs.skipBits(5);                  // hours_value
+                        bs.SkipBits(6);                  // seconds_value
+                        bs.SkipBits(6);                  // minutes_value
+                        bs.SkipBits(5);                  // hours_value
                         }
                      else {
-                        if (bs.getBit()) {               // seconds_flag
-                           bs.skipBits(6);               // seconds_value
-                           if (bs.getBit()) {            // minutes_flag
-                              bs.skipBits(6);            // minutes_value
-                              if (bs.getBit())           // hours_flag
-                                  bs.skipBits(5);        // hours_value
+                        if (bs.GetBit()) {               // seconds_flag
+                           bs.SkipBits(6);               // seconds_value
+                           if (bs.GetBit()) {            // minutes_flag
+                              bs.SkipBits(6);            // minutes_value
+                              if (bs.GetBit())           // hours_flag
+                                  bs.SkipBits(5);        // hours_value
                               }
                            }
                         }
                      if (m_TimeOffsetLength > 0)
-                        bs.skipBits(m_TimeOffsetLength); // time_offset
+                        bs.SkipBits(m_TimeOffsetLength); // time_offset
                      }
                   }
+              if (i > 0)
+                 scan = (ct_type & (1 << 1)) ? VIDEO_SCAN_INTERLACED : VIDEO_SCAN_PROGRESSIVE;
               }
            break;
 
       case 12:                                           // sub_seq_characteristics
-           bs.skipUeGolomb();                            // sub_seq_layer_num
-           bs.skipUeGolomb();                            // sub_seq_id
-           if (bs.getBit())                              // duration_flag
-              bs.skipBits(32);                           // sub_seq_duration
-           if (bs.getBit()) {                            // average_rate_flag
-              bs.skipBit();                              // accurate_statistics_flag
-              bs.skipBits(16);                           // average_bit_rate (1000 bit/s)
-              bs.skipBits(16);                           // average_frame_rate (frames per 256s)
+           bs.SkipUeGolomb();                            // sub_seq_layer_num
+           bs.SkipUeGolomb();                            // sub_seq_id
+           if (bs.GetBit())                              // duration_flag
+              bs.SkipBits(32);                           // sub_seq_duration
+           if (bs.GetBit()) {                            // average_rate_flag
+              bs.SkipBit();                              // accurate_statistics_flag
+              bs.SkipBits(16);                           // average_bit_rate (1000 bit/s)
+              bs.SkipBits(16);                           // average_frame_rate (frames per 256s)
               }
-           num_referenced_subseqs = bs.getUeGolomb();    // num_referenced_subseqs
+           num_referenced_subseqs = bs.GetUeGolomb();    // num_referenced_subseqs
            for (i = 0; i < num_referenced_subseqs; ++i) {
-               bs.skipUeGolomb();                        // ref_sub_seq_layer_num
-               bs.skipUeGolomb();                        // ref_sub_seq_id
-               bs.getBit();                              // ref_sub_seq_direction
+               bs.SkipUeGolomb();                        // ref_sub_seq_layer_num
+               bs.SkipUeGolomb();                        // ref_sub_seq_id
+               bs.GetBit();                              // ref_sub_seq_direction
                }
            break;
 
       default:
-           bs.skipBits(payloadSize * 8);
+           bs.SkipBits(payloadSize * 8);
            break;
       }
 
     // force byte align
-    bs.byteAlign();
+    bs.ByteAlign();
     }
 
   m_Scan = scan;
 
-  return (bs.getIndex() / 8);
+  return (bs.Index() / 8);
 }

femonlatm.c

@@ -31,7 +31,7 @@ cFemonLATM::~cFemonLATM()
 
 bool cFemonLATM::processAudio(const uint8_t *buf, int len)
 {
-  cBitStream bs(buf, len * 8);
+  cFemonBitStream bs(buf, len * 8);
 
   if (!m_AudioHandler)
      return false;
@@ -39,23 +39,23 @@ bool cFemonLATM::processAudio(const uint8_t *buf, int len)
   // skip PES header
   if (!PesLongEnough(len))
       return false;
-  bs.skipBits(8 * PesPayloadOffset(buf));
+  bs.SkipBits(8 * PesPayloadOffset(buf));
 
   // MPEG audio detection
-  if (bs.getBits(12) != 0x56E)              // syncword
+  if (bs.GetBits(12) != 0x56E)              // syncword
      return false;
 
   m_AudioHandler->SetAudioCodec(AUDIO_CODEC_LATM);
 
-  if (bs.getBit() == 0)                     // id: MPEG-1=1, extension to lower sampling frequencies=0
+  if (bs.GetBit() == 0)                     // id: MPEG-1=1, extension to lower sampling frequencies=0
      return true;                           // @todo: lower sampling frequencies support
-  int layer = 3 - bs.getBits(2);            // layer: I=11, II=10, III=01
-  bs.skipBit();                             // protection bit
-  int bit_rate_index = bs.getBits(4);       // bitrate index
-  int sampling_frequency = bs.getBits(2);   // sampling frequency
-  bs.skipBit();                             // padding bit
-  bs.skipBit();                             // private pid
-  int mode = bs.getBits(2);                 // mode
+  int layer = 3 - bs.GetBits(2);            // layer: I=11, II=10, III=01
+  bs.SkipBit();                             // protection bit
+  int bit_rate_index = bs.GetBits(4);       // bitrate index
+  int sampling_frequency = bs.GetBits(2);   // sampling frequency
+  bs.SkipBit();                             // padding bit
+  bs.SkipBit();                             // private pid
+  int mode = bs.GetBits(2);                 // mode
 
   switch (mode) {
     case 0:

femonmpeg.c

@@ -48,7 +48,7 @@ cFemonMPEG::~cFemonMPEG()
 
 bool cFemonMPEG::processAudio(const uint8_t *buf, int len)
 {
-  cBitStream bs(buf, len * 8);
+  cFemonBitStream bs(buf, len * 8);
 
   if (!m_AudioHandler)
      return false;
@@ -56,20 +56,20 @@ bool cFemonMPEG::processAudio(const uint8_t *buf, int len)
   // skip PES header
   if (!PesLongEnough(len))
       return false;
-  bs.skipBits(8 * PesPayloadOffset(buf));
+  bs.SkipBits(8 * PesPayloadOffset(buf));
 
   // MPEG audio detection
-  if (bs.getBits(12) != 0xFFF)              // syncword
+  if (bs.GetBits(12) != 0xFFF)              // syncword
      return false;
 
-  int id = bs.getBit();                     // id: MPEG-2=0, MPEG-1=1
-  int layer = 3 - bs.getBits(2);            // layer: I=11, II=10, III=01
-  bs.skipBit();                             // protection bit
-  int bit_rate_index = bs.getBits(4);       // bitrate index
-  int sampling_frequency = bs.getBits(2);   // sampling frequency
-  bs.skipBit();                             // padding bit
-  bs.skipBit();                             // private pid
-  int mode = bs.getBits(2);                 // mode
+  int id = bs.GetBit();                     // id: MPEG-2=0, MPEG-1=1
+  int layer = 3 - bs.GetBits(2);            // layer: I=11, II=10, III=01
+  bs.SkipBit();                             // protection bit
+  int bit_rate_index = bs.GetBits(4);       // bitrate index
+  int sampling_frequency = bs.GetBits(2);   // sampling frequency
+  bs.SkipBit();                             // padding bit
+  bs.SkipBit();                             // private pid
+  int mode = bs.GetBits(2);                 // mode
 
   m_AudioHandler->SetAudioCodec(s_Formats[id][layer]);
 
@@ -124,7 +124,7 @@ bool cFemonMPEG::processAudio(const uint8_t *buf, int len)
 
 bool cFemonMPEG::processVideo(const uint8_t *buf, int len)
 {
-  cBitStream bs(buf, len * 8);
+  cFemonBitStream bs(buf, len * 8);
 
   if (!m_VideoHandler)
      return false;
@@ -132,20 +132,20 @@ bool cFemonMPEG::processVideo(const uint8_t *buf, int len)
   // skip PES header
   if (!PesLongEnough(len))
       return false;
-  bs.skipBits(8 * PesPayloadOffset(buf));
+  bs.SkipBits(8 * PesPayloadOffset(buf));
 
   // MPEG-2 video detection, search for start code
-  if (bs.getU32() != 0x000001B3)            // sequence header
+  if (bs.GetBits(32) != 0x000001B3)         // sequence header
      return false;
 
   int scan = VIDEO_SCAN_UNKNOWN;
   int format = VIDEO_FORMAT_UNKNOWN;
   int aspect = VIDEO_ASPECT_RATIO_RESERVED;
 
-  int horizontal_size = bs.getBits(12);     // horizontal size value
-  int vertical_size = bs.getBits(12);       // vertical size value
+  int horizontal_size = bs.GetBits(12);     // horizontal size value
+  int vertical_size = bs.GetBits(12);       // vertical size value
 
-  switch (bs.getBits(4)) {                  // aspect ratio information
+  switch (bs.GetBits(4)) {                  // aspect ratio information
     case 1:
          aspect = VIDEO_ASPECT_RATIO_1_1;
          break;
@@ -169,7 +169,7 @@ bool cFemonMPEG::processVideo(const uint8_t *buf, int len)
     }
 
   double frame_rate = 0;
-  switch (bs.getBits(4)) {                  // frame rate code
+  switch (bs.GetBits(4)) {                  // frame rate code
     case 1:
          frame_rate = 24000 / 1001.0;
          format = VIDEO_FORMAT_UNKNOWN;
@@ -217,34 +217,34 @@ bool cFemonMPEG::processVideo(const uint8_t *buf, int len)
          break;
     }
 
-  int bit_rate = bs.getBits(18);            // bit rate value
+  int bit_rate = bs.GetBits(18);            // bit rate value
 
-  bs.skipBit();             // marker bit
-  bs.skipBits(10);          // vbv buffer size value
-  bs.skipBit();             // constrained parameters value
-  if (bs.getBit())          // load intra quantizer matrix
-     bs.skipBits(8 * 64);   // intra quantizer matrix
-  if (bs.getBit())          // load non-intra quantizer matrix
-     bs.skipBits(8 * 64);   // non-intra quantizer matrix
+  bs.SkipBit();             // marker bit
+  bs.SkipBits(10);          // vbv buffer size value
+  bs.SkipBit();             // constrained parameters value
+  if (bs.GetBit())          // load intra quantizer matrix
+     bs.SkipBits(8 * 64);   // intra quantizer matrix
+  if (bs.GetBit())          // load non-intra quantizer matrix
+     bs.SkipBits(8 * 64);   // non-intra quantizer matrix
 
-  if (bs.getU32() != 0x000001B5) {                  // extension start
-     bs.skipBits(4);                                // extension start code identifier
-     bs.skipBits(8);                                // profile and level indicator
-     scan = bs.getBit() ? VIDEO_SCAN_PROGRESSIVE :
+  if (bs.GetBits(32) != 0x000001B5) {               // extension start
+     bs.SkipBits(4);                                // extension start code identifier
+     bs.SkipBits(8);                                // profile and level indicator
+     scan = bs.GetBit() ? VIDEO_SCAN_PROGRESSIVE :
                           VIDEO_SCAN_INTERLACED;    // progressive sequence
-     bs.skipBits(2);                                // chroma format
-     horizontal_size |= (bs.getBits(2) << 12);      // horizontal size extension
-     vertical_size |= (bs.getBits(2) << 12);        // vertical size extension
-     bit_rate |= (bs.getBits(12) << 18);            // bit rate extension
-     bs.skipBit();                                  // marker bit
-     bs.skipBits(8);                                // vpv buffer size extension
-     bs.skipBit();                                  // low delay
-     bs.skipBits(2);                                // frame rate extension n
-     bs.skipBits(5);                                // frame rate extension d
+     bs.SkipBits(2);                                // chroma format
+     horizontal_size |= (bs.GetBits(2) << 12);      // horizontal size extension
+     vertical_size |= (bs.GetBits(2) << 12);        // vertical size extension
+     bit_rate |= (bs.GetBits(12) << 18);            // bit rate extension
+     bs.SkipBit();                                  // marker bit
+     bs.SkipBits(8);                                // vpv buffer size extension
+     bs.SkipBit();                                  // low delay
+     bs.SkipBits(2);                                // frame rate extension n
+     bs.SkipBits(5);                                // frame rate extension d
 
-     if ((bs.getU32() != 0x000001B5) &&             // extension start code
-         (bs.getBits(4) == 0x0010)) {               // sequence display extension id
-        switch (bs.getBits(3)) {                    // video format
+     if ((bs.GetBits(32) != 0x000001B5) &&          // extension start code
+         (bs.GetBits(4) == 0x0010)) {               // sequence display extension id
+        switch (bs.GetBits(3)) {                    // video format
           case 0x000:
                format = VIDEO_FORMAT_COMPONENT;
                break;

femonosd.c

@@ -171,6 +171,10 @@ cFemonOsd::cFemonOsd()
   m_SvdrpPlugin(NULL),
   m_Number(0),
   m_OldNumber(0),
+  m_Quality(0),
+  m_QualityValid(false),
+  m_Strength(0),
+  m_StrengthValid(false),
   m_SNR(0),
   m_SNRValid(false),
   m_Signal(0),
@@ -241,14 +245,15 @@ cFemonOsd::~cFemonOsd(void)
 void cFemonOsd::DrawStatusWindow(void)
 {
   cMutexLock lock(&m_Mutex);
+  cChannel *channel = Channels.GetByNumber(cDevice::CurrentChannel());
+
+  if (m_Osd && channel) {
      cBitmap *bm = NULL;
      int offset = 0;
      int x = OSDWIDTH - OSDROUNDING;
      int y = 0;
      eTrackType track = cDevice::PrimaryDevice()->GetCurrentAudioTrack();
-  cChannel *channel = Channels.GetByNumber(cDevice::CurrentChannel());
 
-  if (m_Osd && channel) {
      OSDDRAWSTATUSTITLEBAR(*cString::sprintf("%d%s %s", m_Number ? m_Number : channel->Number(), m_Number ? "-" : "", channel->ShortName(true)));
      if (m_SvdrpFrontend >= 0) {
         bm = &OSDSYMBOL(SYMBOL_SVDRP);
@@ -295,14 +300,34 @@ void cFemonOsd::DrawStatusWindow(void)
         OSDDRAWSTATUSBM(OSDSPACING);
         }
      if (m_Receiver) {
-        if (IS_OSDRESOLUTION(m_Receiver->VideoVerticalSize(), 1080))
-           bm = &OSDSYMBOL(SYMBOL_FORMAT_1080);
-        else if (IS_OSDRESOLUTION(m_Receiver->VideoVerticalSize(), 720))
-           bm = &OSDSYMBOL(SYMBOL_FORMAT_720);
-        else if (IS_OSDRESOLUTION(m_Receiver->VideoVerticalSize(), 576))
-           bm = &OSDSYMBOL(SYMBOL_FORMAT_576);
-        else if (IS_OSDRESOLUTION(m_Receiver->VideoVerticalSize(), 480))
-           bm = &OSDSYMBOL(SYMBOL_FORMAT_480);
+        if (IS_OSDRESOLUTION(m_Receiver->VideoVerticalSize(), 1080)) {
+           switch (m_Receiver->VideoScan()) {
+              case VIDEO_SCAN_INTERLACED:  bm = &OSDSYMBOL(SYMBOL_FORMAT_1080i); break;
+              case VIDEO_SCAN_PROGRESSIVE: bm = &OSDSYMBOL(SYMBOL_FORMAT_1080p); break;
+              default:                     bm = &OSDSYMBOL(SYMBOL_FORMAT_1080);  break;
+              }
+           }
+        else if (IS_OSDRESOLUTION(m_Receiver->VideoVerticalSize(), 720)) {
+           switch (m_Receiver->VideoScan()) {
+              case VIDEO_SCAN_INTERLACED:  bm = &OSDSYMBOL(SYMBOL_FORMAT_720i); break;
+              case VIDEO_SCAN_PROGRESSIVE: bm = &OSDSYMBOL(SYMBOL_FORMAT_720p); break;
+              default:                     bm = &OSDSYMBOL(SYMBOL_FORMAT_720);  break;
+              }
+           }
+        else if (IS_OSDRESOLUTION(m_Receiver->VideoVerticalSize(), 576)) {
+           switch (m_Receiver->VideoScan()) {
+              case VIDEO_SCAN_INTERLACED:  bm = &OSDSYMBOL(SYMBOL_FORMAT_576i); break;
+              case VIDEO_SCAN_PROGRESSIVE: bm = &OSDSYMBOL(SYMBOL_FORMAT_576p); break;
+              default:                     bm = &OSDSYMBOL(SYMBOL_FORMAT_576);  break;
+              }
+           }
+        else if (IS_OSDRESOLUTION(m_Receiver->VideoVerticalSize(), 480)) {
+           switch (m_Receiver->VideoScan()) {
+              case VIDEO_SCAN_INTERLACED:  bm = &OSDSYMBOL(SYMBOL_FORMAT_480i); break;
+              case VIDEO_SCAN_PROGRESSIVE: bm = &OSDSYMBOL(SYMBOL_FORMAT_480p); break;
+              default:                     bm = &OSDSYMBOL(SYMBOL_FORMAT_480);  break;
+              }
+           }
         else
            bm = NULL;
         OSDDRAWSTATUSBM(OSDSPACING);
@@ -332,11 +357,11 @@ void cFemonOsd::DrawStatusWindow(void)
         OSDDRAWSTATUSBM(OSDSPACING);
         }
      offset += OSDROWHEIGHT;
-     if (m_SignalValid)
-        OSDDRAWSTATUSBAR(m_Signal / 655);
+     if (m_StrengthValid)
+        OSDDRAWSTATUSBAR(m_Strength);
      offset += OSDROWHEIGHT;
-     if (m_SNRValid)
-        OSDDRAWSTATUSBAR(m_SNR / 655);
+     if (m_QualityValid)
+        OSDDRAWSTATUSBAR(m_Quality);
      offset += OSDROWHEIGHT;
      OSDDRAWSTATUSVALUES("STR:", m_SignalValid ? *cString::sprintf("%04x", m_Signal) : "", m_SignalValid ? *cString::sprintf("(%2d%%)", m_Signal / 655) : "",
                          "BER:", m_BERValid ? *cString::sprintf("%08x", m_BER) : "", *cString::sprintf("%s:", tr("Video")),
@@ -364,12 +389,13 @@ void cFemonOsd::DrawStatusWindow(void)
 void cFemonOsd::DrawInfoWindow(void)
 {
   cMutexLock lock(&m_Mutex);
-  int offset = 0;
   cChannel *channel = Channels.GetByNumber(cDevice::CurrentChannel());
-  eTrackType track = cDevice::PrimaryDevice()->GetCurrentAudioTrack();
 
   if (m_Osd && channel) {
+     int offset = 0;
+     eTrackType track = cDevice::PrimaryDevice()->GetCurrentAudioTrack();
      cDvbTransponderParameters dtp(channel->Parameters());
+
      switch (m_DisplayMode) {
        case eFemonModeTransponder:
             OSDDRAWINFOTITLEBAR(tr("Transponder Information"));
@@ -519,6 +545,10 @@ void cFemonOsd::Action(void)
     m_SvdrpVideoBitrate = -1.0;
     m_SvdrpAudioBitrate = -1.0;
     if (m_Frontend != -1) {
+       m_Quality = cDevice::ActualDevice()->SignalQuality();
+       m_QualityValid = (m_Quality >= 0);
+       m_Strength = cDevice::ActualDevice()->SignalStrength();
+       m_StrengthValid = (m_Strength >= 0);
        m_FrontendStatusValid = (ioctl(m_Frontend, FE_READ_STATUS, &m_FrontendStatus) >= 0);
        m_SignalValid = (ioctl(m_Frontend, FE_READ_SIGNAL_STRENGTH, &m_Signal) >= 0);
        m_SNRValid = (ioctl(m_Frontend, FE_READ_SNR, &m_SNR) >= 0);
@@ -531,6 +561,8 @@ void cFemonOsd::Action(void)
        cmd.handle = m_SvdrpConnection.handle;
        m_SvdrpPlugin->Service("SvdrpCommand-v1.0", &cmd);
        if (cmd.responseCode == 900) {
+          m_StrengthValid = false;
+          m_QualityValid = false;
           m_FrontendStatusValid = false;
           m_SignalValid = false;
           m_SNRValid = false;
@@ -540,6 +572,14 @@ void cFemonOsd::Action(void)
               const char *s = line->Text();
 	      if (!strncasecmp(s, "CARD:", 5))
                  m_SvdrpFrontend = (int)strtol(s + 5, NULL, 10);
+              else if (!strncasecmp(s, "STRG:", 5)) {
+                 m_Strength = (int)strtol(s + 5, NULL, 10);
+                 m_StrengthValid = (m_Strength >= 0);
+                 }
+              else if (!strncasecmp(s, "QUAL:", 5)) {
+                 m_Quality = (int)strtol(s + 5, NULL, 10);
+                 m_QualityValid = (m_Quality >= 0);
+                 }
               else if (!strncasecmp(s, "TYPE:", 5))
                  m_FrontendInfo.type = (fe_type_t)strtol(s + 5, NULL, 10);
               else if (!strncasecmp(s, "NAME:", 5)) {
@@ -811,7 +851,7 @@ eOSState cFemonOsd::ProcessKey(eKeys Key)
 {
   eOSState state = cOsdObject::ProcessKey(Key);
   if (state == osUnknown) {
-     switch (Key) {
+     switch (int(Key)) {
        case k0:
             if ((m_Number == 0) && (m_OldNumber != 0)) {
                m_Number = m_OldNumber;

femonosd.h

@@ -36,6 +36,10 @@ private:
   cPlugin          *m_SvdrpPlugin;
   int               m_Number;
   int               m_OldNumber;
+  int               m_Quality;
+  bool              m_QualityValid;
+  int               m_Strength;
+  bool              m_StrengthValid;
   uint16_t          m_SNR;
   bool              m_SNRValid;
   uint16_t          m_Signal;

femonsymbol.c

@@ -41,9 +41,17 @@
 #include "symbols/seven.xpm"
 #include "symbols/eight.xpm"
 #include "symbols/format1080.xpm"
+#include "symbols/format1080i.xpm"
+#include "symbols/format1080p.xpm"
 #include "symbols/format720.xpm"
+#include "symbols/format720i.xpm"
+#include "symbols/format720p.xpm"
 #include "symbols/format576.xpm"
+#include "symbols/format576i.xpm"
+#include "symbols/format576p.xpm"
 #include "symbols/format480.xpm"
+#include "symbols/format480i.xpm"
+#include "symbols/format480p.xpm"
 
 static cBitmap bmStereo(stereo_xpm);
 static cBitmap bmMonoLeft(monoleft_xpm);
@@ -77,9 +85,17 @@ static cBitmap bmSix(six_xpm);
 static cBitmap bmSeven(seven_xpm);
 static cBitmap bmEight(eight_xpm);
 static cBitmap bmFormat1080(format1080_xpm);
+static cBitmap bmFormat1080i(format1080i_xpm);
+static cBitmap bmFormat1080p(format1080p_xpm);
 static cBitmap bmFormat720(format720_xpm);
+static cBitmap bmFormat720i(format720i_xpm);
+static cBitmap bmFormat720p(format720p_xpm);
 static cBitmap bmFormat576(format576_xpm);
+static cBitmap bmFormat576i(format576i_xpm);
+static cBitmap bmFormat576p(format576p_xpm);
 static cBitmap bmFormat480(format480_xpm);
+static cBitmap bmFormat480i(format480i_xpm);
+static cBitmap bmFormat480p(format480p_xpm);
 
 cFemonSymbolCache femonSymbols;
 
@@ -150,9 +166,17 @@ bool cFemonSymbolCache::Populate(void)
      cacheM.Append(bmSeven.Scaled(yFactorM, yFactorM, antiAliasM)); // SYMBOL_SEVEN
      cacheM.Append(bmEight.Scaled(yFactorM, yFactorM, antiAliasM)); // SYMBOL_EIGHT
      cacheM.Append(bmFormat1080.Scaled(yFactorM, yFactorM, antiAliasM)); // SYMBOL_FORMAT_1080
+     cacheM.Append(bmFormat1080i.Scaled(yFactorM, yFactorM, antiAliasM)); // SYMBOL_FORMAT_1080i
+     cacheM.Append(bmFormat1080p.Scaled(yFactorM, yFactorM, antiAliasM)); // SYMBOL_FORMAT_1080p
      cacheM.Append(bmFormat720.Scaled(yFactorM, yFactorM, antiAliasM)); // SYMBOL_FORMAT_720
+     cacheM.Append(bmFormat720i.Scaled(yFactorM, yFactorM, antiAliasM)); // SYMBOL_FORMAT_720i
+     cacheM.Append(bmFormat720p.Scaled(yFactorM, yFactorM, antiAliasM)); // SYMBOL_FORMAT_720p
      cacheM.Append(bmFormat576.Scaled(yFactorM, yFactorM, antiAliasM)); // SYMBOL_FORMAT_576
+     cacheM.Append(bmFormat576i.Scaled(yFactorM, yFactorM, antiAliasM)); // SYMBOL_FORMAT_576i
+     cacheM.Append(bmFormat576p.Scaled(yFactorM, yFactorM, antiAliasM)); // SYMBOL_FORMAT_576p
      cacheM.Append(bmFormat480.Scaled(yFactorM, yFactorM, antiAliasM)); // SYMBOL_FORMAT_480
+     cacheM.Append(bmFormat480i.Scaled(yFactorM, yFactorM, antiAliasM)); // SYMBOL_FORMAT_480i
+     cacheM.Append(bmFormat480p.Scaled(yFactorM, yFactorM, antiAliasM)); // SYMBOL_FORMAT_480p
 
      return true;
      }

femonsymbol.h

@@ -44,9 +44,17 @@ enum eSymbols {
   SYMBOL_SEVEN,
   SYMBOL_EIGHT,
   SYMBOL_FORMAT_1080,
+  SYMBOL_FORMAT_1080i,
+  SYMBOL_FORMAT_1080p,
   SYMBOL_FORMAT_720,
+  SYMBOL_FORMAT_720i,
+  SYMBOL_FORMAT_720p,
   SYMBOL_FORMAT_576,
+  SYMBOL_FORMAT_576i,
+  SYMBOL_FORMAT_576p,
   SYMBOL_FORMAT_480,
+  SYMBOL_FORMAT_480i,
+  SYMBOL_FORMAT_480p,
   SYMBOL_MAX_COUNT
   };
 

femontools.c

@@ -92,7 +92,7 @@ cString getFrontendInfo(int cardIndex)
   if (fe < 0)
      return NULL;
 
-  info = cString::sprintf("CARD:%d", cardIndex);
+  info = cString::sprintf("CARD:%d\nSTRG:%d\nQUAL:%d", cardIndex, cDevice::ActualDevice()->SignalStrength(), cDevice::ActualDevice()->SignalQuality());
 
   if (ioctl(fe, FE_GET_INFO, &value) >= 0)
      info = cString::sprintf("%s\nTYPE:%d\nNAME:%s", *info, value.type, value.name);
@@ -542,84 +542,31 @@ cString getBitrateKbits(double value)
   return cString::sprintf("---");
 }
 
-cBitStream::cBitStream(const uint8_t *buf, const int len)
-: data(buf),
-  count(len),
-  index(0)
-{
-}
+// --- cFemonBitStream -------------------------------------------------------
 
-cBitStream::~cBitStream()
-{
-}
-
-int cBitStream::getBit()
-{
-  if (index >= count)
-     return (1); // -> no infinite colomb's ...
-
-  int r = (data[index >> 3] >> (7 - (index & 7))) & 1;
-  ++index;
-
-  return (r);
-}
-
-uint32_t cBitStream::getBits(uint32_t n)
-{
-  uint32_t r = 0;
-
-  while (n--)
-    r = (r | (getBit() << n));
-
-  return (r);
-}
-
-void cBitStream::skipBits(uint32_t n)
-{
-  index += n;
-}
-
-uint32_t cBitStream::getUeGolomb()
+uint32_t cFemonBitStream::GetUeGolomb()
 {
   int n = 0;
 
-  while (!getBit() && (n < 32))
+  while (!GetBit() && (n < 32))
     n++;
 
-  return (n ? ((1 << n) - 1) + getBits(n) : 0);
+  return (n ? ((1 << n) - 1) + GetBits(n) : 0);
 }
 
-int32_t cBitStream::getSeGolomb()
+int32_t cFemonBitStream::GetSeGolomb()
 {
-  uint32_t r = getUeGolomb() + 1;
+  uint32_t r = GetUeGolomb() + 1;
 
   return ((r & 1) ? -(r >> 1) : (r >> 1));
 }
 
-void cBitStream::skipGolomb()
+void cFemonBitStream::SkipGolomb()
 {
   int n = 0;
 
-  while (!getBit() && (n < 32))
+  while (!GetBit() && (n < 32))
     n++;
 
-  skipBits(n);
-}
-
-void cBitStream::skipUeGolomb()
-{
-  skipGolomb();
-}
-
-void cBitStream::skipSeGolomb()
-{
-  skipGolomb();
-}
-
-void cBitStream::byteAlign()
-{
-  int n = index % 8;
-
-  if (n > 0)
-     skipBits(8 - n);
+  SkipBits(n);
 }

femontools.h

@@ -71,35 +71,14 @@ cString getVideoBitrate(double value, double stream);
 cString getBitrateMbits(double value);
 cString getBitrateKbits(double value);
 
-class cBitStream {
-private:
-  const uint8_t *data;
-  int            count; // in bits
-  int            index; // in bits
-
+class cFemonBitStream : public cBitStream {
 public:
-  cBitStream(const uint8_t *buf, const int len);
-  ~cBitStream();
-
-  int            getBit();
-  uint32_t       getBits(uint32_t n);
-  void           skipBits(uint32_t n);
-  uint32_t       getUeGolomb();
-  int32_t        getSeGolomb();
-  void           skipGolomb();
-  void           skipUeGolomb();
-  void           skipSeGolomb();
-  void           byteAlign();
-
-  void           skipBit()  { skipBits(1); }
-  uint32_t       getU8()    { return getBits(8); }
-  uint32_t       getU16()   { return ((getBits(8) << 8) | getBits(8)); }
-  uint32_t       getU24()   { return ((getBits(8) << 16) | (getBits(8) << 8) | getBits(8)); }
-  uint32_t       getU32()   { return ((getBits(8) << 24) | (getBits(8) << 16) | (getBits(8) << 8) | getBits(8)); }
-  bool           isEOF()    { return (index >= count); }
-  void           reset()    { index = 0; }
-  int            getIndex() { return (isEOF() ? count : index); }
-  const uint8_t *getData()  { return (isEOF() ? NULL : data + (index / 8)); }
-};
+  cFemonBitStream(const uint8_t *Data, const int Length) : cBitStream(Data, Length) {}
+  uint32_t       GetUeGolomb();
+  int32_t        GetSeGolomb();
+  void           SkipGolomb();
+  void           SkipUeGolomb() { SkipGolomb(); }
+  void           SkipSeGolomb() { SkipGolomb(); }
+  };
 
 #endif // __FEMONTOOLS_H

symbols/format1080i.xpm

@@ -0,0 +1,23 @@
+/* XPM */
+static const char *const format1080i_xpm[] = {
+"42 18 2 1",
+".	c #FFFFFF",
+"+	c #000000",
+"++++++++++++++++++++++++++++++++++++++++++",
+"+........................................+",
+"+......++...++++.....++++.....++++.......+",
+"+...+++++..++++++...++++++...++++++......+",
+"+...+++++..++..++...++..++...++..++......+",
+"+......++.++....++.++....++.++....++.....+",
+"+......++.++....++.++....++.++....++.++..+",
+"+......++.++....++..++..++..++....++.++..+",
+"+......++.++....++...++++...++....++.....+",
+"+......++.++....++...++++...++....++.++..+",
+"+......++.++....++..++..++..++....++.++..+",
+"+......++.++....++.++....++.++....++.++..+",
+"+......++.++....++.++....++.++....++.++..+",
+"+......++..++..++...++..++...++..++..++..+",
+"+......++..++++++...++++++...++++++..++..+",
+"+......++...++++.....++++.....++++...++..+",
+"+........................................+",
+"++++++++++++++++++++++++++++++++++++++++++"};

symbols/format1080p.xpm

@@ -0,0 +1,23 @@
+/* XPM */
+static const char *const format1080p_xpm[] = {
+"47 18 2 1",
+".	c #FFFFFF",
+"+	c #000000",
+"+++++++++++++++++++++++++++++++++++++++++++++++",
+"+.............................................+",
+"+......++...++++.....++++.....++++............+",
+"+...+++++..++++++...++++++...++++++...........+",
+"+...+++++..++..++...++..++...++..++...........+",
+"+......++.++....++.++....++.++....++..........+",
+"+......++.++....++.++....++.++....++..........+",
+"+......++.++....++..++..++..++....++.++++.....+",
+"+......++.++....++...++++...++....++.+++++....+",
+"+......++.++....++...++++...++....++.++..++...+",
+"+......++.++....++..++..++..++....++.++..++...+",
+"+......++.++....++.++....++.++....++.+++++....+",
+"+......++.++....++.++....++.++....++.++++.....+",
+"+......++..++..++...++..++...++..++..++.......+",
+"+......++..++++++...++++++...++++++..++.......+",
+"+......++...++++.....++++.....++++...++.......+",
+"+.............................................+",
+"+++++++++++++++++++++++++++++++++++++++++++++++"};

symbols/format480i.xpm

@@ -0,0 +1,23 @@
+/* XPM */
+static const char *const format480i_xpm[] = {
+"38 18 2 1",
+".	c #FFFFFF",
+"+	c #000000",
+"++++++++++++++++++++++++++++++++++++++",
+"+....................................+",
+"+.........++....++++.....++++........+",
+"+........+++...++++++...++++++.......+",
+"+.......++++...++..++...++..++.......+",
+"+......++.++..++....++.++....++......+",
+"+.....++..++..++....++.++....++.++...+",
+"+.....++..++...++..++..++....++.++...+",
+"+....++...++....++++...++....++......+",
+"+...++....++....++++...++....++.++...+",
+"+...+++++++++..++..++..++....++.++...+",
+"+...+++++++++.++....++.++....++.++...+",
+"+.........++..++....++.++....++.++...+",
+"+.........++...++..++...++..++..++...+",
+"+.........++...++++++...++++++..++...+",
+"+.........++....++++.....++++...++...+",
+"+....................................+",
+"++++++++++++++++++++++++++++++++++++++"};

symbols/format480p.xpm

@@ -0,0 +1,23 @@
+/* XPM */
+static const char *const format480p_xpm[] = {
+"42 18 2 1",
+".	c #FFFFFF",
+"+	c #000000",
+"++++++++++++++++++++++++++++++++++++++++++",
+"+........................................+",
+"+.........++....++++.....++++............+",
+"+........+++...++++++...++++++...........+",
+"+.......++++...++..++...++..++...........+",
+"+......++.++..++....++.++....++..........+",
+"+.....++..++..++....++.++....++..........+",
+"+.....++..++...++..++..++....++.++++.....+",
+"+....++...++....++++...++....++.+++++....+",
+"+...++....++....++++...++....++.++..++...+",
+"+...+++++++++..++..++..++....++.++..++...+",
+"+...+++++++++.++....++.++....++.+++++....+",
+"+.........++..++....++.++....++.++++.....+",
+"+.........++...++..++...++..++..++.......+",
+"+.........++...++++++...++++++..++.......+",
+"+.........++....++++.....++++...++.......+",
+"+........................................+",
+"++++++++++++++++++++++++++++++++++++++++++"};

symbols/format576i.xpm

@@ -0,0 +1,23 @@
+/* XPM */
+static const char *const format576i_xpm[] = {
+"36 18 2 1",
+".	c #FFFFFF",
+"+	c #000000",
+"++++++++++++++++++++++++++++++++++++",
+"+..................................+",
+"+...+++++++.++++++++..++++++.......+",
+"+...+++++++.++++++++.++++++++......+",
+"+...++......++....++.+++...++......+",
+"+...++............++.++............+",
+"+...++...........+++.++.......++...+",
+"+...++++++.......++..++.+++...++...+",
+"+...+++++++......++..+++++++.......+",
+"+...++...+++....+++..+++..+++.++...+",
+"+.........++....++...++....++.++...+",
+"+.........++....++...++....++.++...+",
+"+...++....++...+++...++....++.++...+",
+"+...++...+++...++....+++..+++.++...+",
+"+...+++++++....++....+++++++..++...+",
+"+....+++++.....++.....+++++...++...+",
+"+..................................+",
+"++++++++++++++++++++++++++++++++++++"};

symbols/format576p.xpm

@@ -0,0 +1,23 @@
+/* XPM */
+static const char *const format576p_xpm[] = {
+"40 18 2 1",
+".	c #FFFFFF",
+"+	c #000000",
+"++++++++++++++++++++++++++++++++++++++++",
+"+......................................+",
+"+...+++++++.++++++++..++++++...........+",
+"+...+++++++.++++++++.++++++++..........+",
+"+...++......++....++.+++...++..........+",
+"+...++............++.++................+",
+"+...++...........+++.++................+",
+"+...++++++.......++..++.+++...++++.....+",
+"+...+++++++......++..+++++++..+++++....+",
+"+...++...+++....+++..+++..+++.++..++...+",
+"+.........++....++...++....++.++..++...+",
+"+.........++....++...++....++.+++++....+",
+"+...++....++...+++...++....++.++++.....+",
+"+...++...+++...++....+++..+++.++.......+",
+"+...+++++++....++....+++++++..++.......+",
+"+....+++++.....++.....+++++...++.......+",
+"+......................................+",
+"++++++++++++++++++++++++++++++++++++++++"};

symbols/format720i.xpm

@@ -0,0 +1,23 @@
+/* XPM */
+static const char *const format720i_xpm[] = {
+"37 18 2 1",
+".	c #FFFFFF",
+"+	c #000000",
+"+++++++++++++++++++++++++++++++++++++",
+"+...................................+",
+"+...++++++++...++++.....++++........+",
+"+...++++++++.+++++++...++++++.......+",
+"+...++....++.++....++..++..++.......+",
+"+.........++.......++.++....++......+",
+"+.........++.......++.++....++.++...+",
+"+.........++.......++.++....++.++...+",
+"+........++......+++..++....++......+",
+"+.......+++.....+++...++....++.++...+",
+"+.......++.....+++....++....++.++...+",
+"+.......++....+++.....++....++.++...+",
+"+......+++...+++......++....++.++...+",
+"+......++....++........++..++..++...+",
+"+......++....++++++++..++++++..++...+",
+"+......++....++++++++...++++...++...+",
+"+...................................+",
+"+++++++++++++++++++++++++++++++++++++"};

symbols/format720p.xpm

@@ -0,0 +1,23 @@
+/* XPM */
+static const char *const format720p_xpm[] = {
+"41 18 2 1",
+".	c #FFFFFF",
+"+	c #000000",
+"+++++++++++++++++++++++++++++++++++++++++",
+"+.......................................+",
+"+...++++++++...++++.....++++............+",
+"+...++++++++.+++++++...++++++...........+",
+"+...++....++.++....++..++..++...........+",
+"+.........++.......++.++....++..........+",
+"+.........++.......++.++....++..........+",
+"+.........++.......++.++....++.++++.....+",
+"+........++......+++..++....++.+++++....+",
+"+.......+++.....+++...++....++.++..++...+",
+"+.......++.....+++....++....++.++..++...+",
+"+.......++....+++.....++....++.+++++....+",
+"+......+++...+++......++....++.++++.....+",
+"+......++....++........++..++..++.......+",
+"+......++....++++++++..++++++..++.......+",
+"+......++....++++++++...++++...++.......+",
+"+.......................................+",
+"+++++++++++++++++++++++++++++++++++++++++"};