Beispiel #1
0
int write_avcc(avcc_t* avcc, h264_stream_t* h, bs_t* b)
{
  bs_write_u8(b, 1); // configurationVersion = 1;
  bs_write_u8(b, avcc->AVCProfileIndication);
  bs_write_u8(b, avcc->profile_compatibility);
  bs_write_u8(b, avcc->AVCLevelIndication);
  bs_write_u(b, 6, 0x3F); // reserved = '111111'b;
  bs_write_u(b, 2, avcc->lengthSizeMinusOne);
  bs_write_u(b, 3, 0x07); // reserved = '111'b;

  bs_write_u(b, 5, avcc->numOfSequenceParameterSets);
  int i;
  for (i = 0; i < avcc->numOfSequenceParameterSets; i++)
  {
    int max_len = 1024; // FIXME
    uint8_t* buf = (uint8_t*)malloc(max_len);
    h->nal->nal_ref_idc = 3; // NAL_REF_IDC_PRIORITY_HIGHEST;
    h->nal->nal_unit_type = NAL_UNIT_TYPE_SPS;
    h->sps = avcc->sps_table[i];
    int len = write_nal_unit(h, buf, max_len);
    if (len < 0) { free(buf); continue; } // TODO report errors
    int sequenceParameterSetLength = len;
    bs_write_u(b, 16, sequenceParameterSetLength);
    bs_write_bytes(b, buf, len);
    free(buf);
  }

  bs_write_u(b, 8, avcc->numOfPictureParameterSets);
  for (i = 0; i < avcc->numOfPictureParameterSets; i++)
  {
    int max_len = 1024; // FIXME
    uint8_t* buf = (uint8_t*)malloc(max_len);
    h->nal->nal_ref_idc = 3; // NAL_REF_IDC_PRIORITY_HIGHEST;
    h->nal->nal_unit_type = NAL_UNIT_TYPE_PPS;
    h->pps = avcc->pps_table[i];
    int len = write_nal_unit(h, buf, max_len);
    if (len < 0) { free(buf); continue; } // TODO report errors
    int pictureParameterSetLength = len;
    bs_write_u(b, 16, pictureParameterSetLength);
    bs_write_bytes(b, buf, len);
    free(buf);
  }

  if (bs_overrun(b)) { return -1; }
  return bs_pos(b);
}
Beispiel #2
0
int main()
{
    h264_stream_t* h = h264_new();

    int bufsiz = fread(filebuf, 1, sizeof(filebuf), stdin);
    uint8_t* e;
    uint8_t* p = filebuf;
    uint8_t* end = filebuf + bufsiz;

    for (int pp[2]; find_nal_unit(p, end-p, pp, pp+1) > 0; p = e) {
        e = p + pp[1];
        p += pp[0];

        if (FILE* fp = fopen("sps.0","w")) {
            fwrite(p, 1, e-p, fp);
            fclose(fp);
        }
        read_nal_unit(h, p, e-p);

        debug_nal(h, h->nal);
        printf("\n");

//h->sps->profile_idc = 0x42;
//h->sps->level_idc = 0x33;
//h->sps->log2_max_frame_num_minus4 = 0x05;
//h->sps->log2_max_pic_order_cnt_lsb_minus4 = 0x06;
//h->sps->num_ref_frames = 0x01;

//h->sps->profile_idc = 66;
//h->sps->level_idc = 10;
h->sps->num_ref_frames = 0;
//h->sps->log2_max_frame_num_minus4 = 0x05;
//h->sps->log2_max_pic_order_cnt_lsb_minus4 = 0x06;
//h->sps->direct_8x8_inference_flag = 0;

#if 1
h->sps->vui_parameters_present_flag = 1;
    h->sps->vui.bitstream_restriction_flag = 1;
        //h->sps->vui.motion_vectors_over_pic_boundaries_flag = 1;
        //h->sps->vui.log2_max_mv_length_horizontal = 10;
        //h->sps->vui.log2_max_mv_length_vertical = 10;
        h->sps->vui.num_reorder_frames = 1;
        h->sps->vui.max_dec_frame_buffering = 2;
#endif
        debug_nal(h, h->nal);

        uint8_t out[1024];
        int outlen = write_nal_unit(h, out, sizeof(out));
        if (FILE* fp = fopen("sps.1","w")) {
            fwrite(out+1, outlen-1, 1, fp);
            fclose(fp);
        }

        if (h->nal->nal_unit_type == NAL_UNIT_TYPE_SPS)
            break;
        p = e;
    }
}
Beispiel #3
0
static void ProcessSpsNalu(unsigned char* data, int length) {
    const char naluHeader[] = {0x00, 0x00, 0x00, 0x01};
    h264_stream_t* stream = h264_new();
    
    // Read the old NALU
    read_nal_unit(stream, &data[sizeof(naluHeader)], length-sizeof(naluHeader));
    
    // Fixup the SPS to what OS X needs to use hardware acceleration
    stream->sps->num_ref_frames = 1;
    stream->sps->vui.max_dec_frame_buffering = 1;
    
    // Copy the NALU prefix over from the original SPS
    memcpy(s_LastSps, naluHeader, sizeof(naluHeader));
    
    // Copy the modified NALU data
    s_LastSpsLength = sizeof(naluHeader) + write_nal_unit(stream,
                                                          &s_LastSps[sizeof(naluHeader)],
                                                          sizeof(s_LastSps)-sizeof(naluHeader));
    
    h264_free(stream);
}
Beispiel #4
0
PLENTRY gs_sps_fix(PLENTRY *head, int flags) {
  PLENTRY entry = *head;
  const char naluHeader[] = {0x00, 0x00, 0x00, 0x01};

  if (replay_sps == 1) {
    PLENTRY replay_entry = (PLENTRY) malloc(sizeof(*replay_entry) + 128);
    if (replay_entry == NULL)
      return NULL;

    replay_entry->data = (char *) (entry + 1);
    memcpy(replay_entry->data, naluHeader, sizeof(naluHeader));
    h264_stream->sps->profile_idc = H264_PROFILE_HIGH;
    replay_entry->length = write_nal_unit(h264_stream, replay_entry->data+4, 124) + 4;

    replay_entry->next = entry;
    entry = replay_entry;
    replay_sps = 2;
  } else if ((entry->data[4] & 0x1F) == NAL_UNIT_TYPE_SPS) {
    read_nal_unit(h264_stream, entry->data+4, entry->length-4);

    // Some decoders rely on H264 level to decide how many buffers are needed
    // Since we only need one frame buffered, we'll set level as low as we can
    // for known resolution combinations. Otherwise leave the profile alone (currently 5.0)
    if (initial_width == 1280 && initial_height == 720)
      h264_stream->sps->level_idc = 32; // Max 5 buffered frames at 1280x720x60
    else if (initial_width = 1920 && initial_height == 1080)
      h264_stream->sps->level_idc = 42; // Max 4 buffered frames at 1920x1080x60

    // Some decoders requires a reference frame count of 1 to decode successfully.
    h264_stream->sps->num_ref_frames = 1;

    // GFE 2.5.11 changed the SPS to add additional extensions
    // Some devices don't like these so we remove them here.
    h264_stream->sps->vui.video_signal_type_present_flag = 0;
    h264_stream->sps->vui.chroma_loc_info_present_flag = 0;

    if ((flags & GS_SPS_BITSTREAM_FIXUP) == GS_SPS_BITSTREAM_FIXUP) {
      // The SPS that comes in the current H264 bytestream doesn't set the bitstream_restriction_flag
      // or the max_dec_frame_buffering which increases decoding latency on some devices
      // log2_max_mv_length_horizontal and log2_max_mv_length_vertical are set to more
      // conservite values by GFE 25.11. We'll let those values stand.
      if (!h264_stream->sps->vui.bitstream_restriction_flag) {
        h264_stream->sps->vui.bitstream_restriction_flag = 1;
        h264_stream->sps->vui.motion_vectors_over_pic_boundaries_flag = 1;
        h264_stream->sps->vui.max_bits_per_mb_denom = 1;
        h264_stream->sps->vui.log2_max_mv_length_horizontal = 16;
        h264_stream->sps->vui.log2_max_mv_length_vertical = 16;
        h264_stream->sps->vui.num_reorder_frames = 0;
      }

      // Some devices throw errors if max_dec_frame_buffering < num_ref_frames
      h264_stream->sps->vui.max_dec_frame_buffering = 1;

      // These values are the default for the fields, but they are more aggressive
      // than what GFE sends in 2.5.11, but it doesn't seem to cause picture problems.
      h264_stream->sps->vui.max_bytes_per_pic_denom = 2;
      h264_stream->sps->vui.max_bits_per_mb_denom = 1;
    } else // Devices that didn't/couldn't get bitstream restrictions before GFE 2.5.11 will continue to not receive them now
      h264_stream->sps->vui.bitstream_restriction_flag = 0;

    if ((flags & GS_SPS_BASELINE_HACK) == GS_SPS_BASELINE_HACK && !replay_sps)
      h264_stream->sps->profile_idc = H264_PROFILE_BASELINE;

    PLENTRY sps_entry = (PLENTRY) malloc(sizeof(*sps_entry) + 128);
    if (sps_entry == NULL)
      return NULL;

    PLENTRY next = entry->next;
    free(entry);
    sps_entry->data = (char*) (sps_entry + 1);
    memcpy(sps_entry->data, naluHeader, sizeof(naluHeader));
    sps_entry->length = write_nal_unit(h264_stream, sps_entry->data+4, 124) + 4;
    sps_entry->next = next;
    entry = sps_entry;
  } else if ((entry->data[4] & 0x1F) == NAL_UNIT_TYPE_PPS) {
    if ((flags & GS_SPS_BASELINE_HACK) == GS_SPS_BASELINE_HACK && !replay_sps)
      replay_sps = 1;

  }
  *head = entry;
  return entry;
}