h.264 "fixer" tool

lib/bitstream.h

@@ -40,6 +40,8 @@ namespace Utils{
  return i;
  }
 
+ size_t getOffset(){return offset;}
+
  private:
  bool checkBufferSize(unsigned int size);
  long long unsigned int golombGetter();

lib/h264.cpp

@@ -8,6 +8,7 @@
 #include <cmath>
 #include <cstring>
 #include <iomanip>
+#include <sstream>
 
 namespace h264{
 
@@ -479,7 +480,13 @@ namespace h264{
  log2MaxPicOrderCntLsbMinus4 = bs.getUExpGolomb();
  derived_maxPicOrderCntLsb = pow(2, log2MaxPicOrderCntLsbMinus4 + 4);
  }else if (picOrderCntType == 1){
- WARN_MSG("picOrderCntType == 1 encountered, which has not-yet implemented parameters");
+ deltaPicOrderAlwaysZeroFlag = bs.get(1);
+ bs.getExpGolomb(); // offset_for_non_ref_pic
+ bs.getExpGolomb(); // offset_for_top_to_bottom_field
+ numRefFramesInPicOrderCntCycle = bs.getUExpGolomb();
+ for (size_t i = 0; i < numRefFramesInPicOrderCntCycle; i++){
+ bs.getExpGolomb(); // offset_for_ref_frame[i]
+ }
  return;
  }
  maxNumRefFrames = bs.getUExpGolomb();
@@ -974,7 +981,11 @@ namespace h264{
 
  codedSliceUnit::codedSliceUnit(const char *data, size_t len) : nalUnit(data, len){
  Utils::bitstream bs;
- for (size_t i = 1; i < len; i++){
+ // We only want to parse a part of the header here. From standard it seems
+ // that maximum possible lenght will be less than 100 bits, so using 16
+ // bytes for safety
+ size_t l = len < 16 ? len : 16;
+ for (size_t i = 1; i < l; i++){
  if (i + 2 < len && (memcmp(data + i, "\000\000\003", 3) == 0)){// Emulation prevention bytes
  // Yes, we increase i here
  bs.append(data + i, 2);
@@ -989,6 +1000,54 @@ namespace h264{
  picParameterSetId = bs.getUExpGolomb();
  }
 
+ codedSliceUnit::codedSliceUnit(const char *data, size_t len, const spsUnit &sps, const ppsUnit &pps)
+ : nalUnit(data, len){
+ Utils::bitstream bs;
+ // We only want to parse slice header here. Maximum possible length seems
+ // to be around 50 bytes, so using 64 bytes for safety
+ size_t l = len < 64 ? len : 64;
+ for (size_t i = 1; i < l; i++){
+ if (i + 2 < l && (memcmp(data + i, "\000\000\003", 3) == 0)){// Emulation prevention bytes
+ // Yes, we increase i here
+ bs.append(data + i, 2);
+ i += 2;
+ }else{
+ // No we don't increase i here
+ bs.append(data + i, 1);
+ }
+ }
+ firstMbInSlice = bs.getUExpGolomb();
+ sliceType = bs.getUExpGolomb();
+ picParameterSetId = bs.getUExpGolomb();
+
+ frameNum = bs.get(sps.log2MaxFrameNumMinus4 + 4);
+ if (!sps.frameMbsOnlyFlag){
+ fieldPicFlag = bs.get(1);
+ if (fieldPicFlag){bottomFieldFlag = bs.get(1);}
+ }
+
+ // IDR frames have idrPicId here
+ if (5 == getType()){idrPicId = bs.getUExpGolomb();}
+
+ picOrderCntLsb = deltaPicOrderCntBottom = 0;
+ if (0 == sps.picOrderCntType){
+ picOrderCntLsb = bs.get(sps.log2MaxPicOrderCntLsbMinus4 + 4);
+ if (pps.bottomFieldPicOrderInFramePresentFlag && !fieldPicFlag){
+ deltaPicOrderCntBottom = bs.getExpGolomb();
+ }
+ }
+
+ deltaPicOrderCnt[0] = deltaPicOrderCnt[1] = 0;
+ if ((1 == sps.picOrderCntType) && !sps.deltaPicOrderAlwaysZeroFlag){
+ deltaPicOrderCnt[0] = bs.getExpGolomb();
+ if (pps.bottomFieldPicOrderInFramePresentFlag && fieldPicFlag){
+ deltaPicOrderCnt[1] = bs.getExpGolomb();
+ }
+ }
+
+ if (pps.redundantPicCntPresentFlag){redundantPicCnt = bs.getUExpGolomb();}
+ }
+
  void codedSliceUnit::setPPSNumber(size_t newNumber){
  // for now, can only convert from 0 to 16
  if (picParameterSetId != 0){return;}

lib/h264.h

@@ -2,6 +2,7 @@
 #include <cstdio>
 #include <cstdlib>
 #include <deque>
+#include <iostream>
 #include <string>
 
 #include "bitfields.h"
@@ -81,8 +82,9 @@ namespace h264{
  nalUnit(const char *data, size_t len) : payload(data, len){}
  virtual ~nalUnit(){}
 
- uint8_t getType(){return payload[0] & 0x1F;}
- size_t getSize(){return payload.size();}
+ uint8_t getType() const{ return payload[0] & 0x1F;}
+ uint8_t getRefNalIdc() const{ return payload[0] >> 5;}
+ size_t getSize() const{ return payload.size();}
  virtual void toPrettyString(std::ostream &out){
  out << "Nal unit of type " << (((uint8_t)payload[0]) & 0x1F) << ", " << payload.size()
  << " bytes long" << std::endl;
@@ -195,7 +197,8 @@ namespace h264{
  uint64_t picOrderCntType;
  uint64_t log2MaxPicOrderCntLsbMinus4;
 
- // Here go values for pic_order_cnt_type == 1
+ bool deltaPicOrderAlwaysZeroFlag;
+ uint64_t numRefFramesInPicOrderCntCycle;
 
  uint64_t maxNumRefFrames;
  bool gapsInFrameNumValueAllowedFlag;
@@ -284,13 +287,27 @@ namespace h264{
  };
  class codedSliceUnit : public nalUnit{
  public:
+ // "partial" constructor just to get picParameterSetId, as full parsing
+ // is not possible without PPS/SPS pair
  codedSliceUnit(const char *data, size_t len);
+ // "full" constructor when PPS/SPS pair is supplied
+ codedSliceUnit(const char *data, size_t len, const spsUnit &sps, const ppsUnit &pps);
  void setPPSNumber(size_t newNumber);
  void toPrettyString(std::ostream &out);
 
  uint64_t firstMbInSlice;
  uint64_t sliceType;
  uint64_t picParameterSetId;
+
+ uint64_t frameNum;
+ bool fieldPicFlag;
+ bool bottomFieldFlag;
+ uint64_t idrPicId;
+ uint64_t picOrderCntType;
+ uint64_t picOrderCntLsb;
+ uint64_t deltaPicOrderCntBottom;
+ uint64_t deltaPicOrderCnt[2];
+ uint64_t redundantPicCnt;
  };
 
  class seiUnit : public nalUnit{