int CEASpliterFilter::ea_read_packet() { EaDemuxContext *ea = (EaDemuxContext *)m_pea; AVPacket *pkt = (AVPacket *)m_pkt; //ByteIOContext *pb = s->pb; int ret = 0; int packet_read = 0; unsigned int chunk_type, chunk_size; int key = 0; int av_uninit(num_samples); while (!packet_read) { chunk_type = get_le32(pb); chunk_size = (ea->big_endian ? get_be32(pb) : get_le32(pb)) - 8; switch (chunk_type) { /* audio data */ case ISNh_TAG: /* header chunk also contains data; skip over the header portion*/ url_fskip(pb, 32); chunk_size -= 32; case ISNd_TAG: case SCDl_TAG: case SNDC_TAG: case SDEN_TAG: if (!ea->audio_codec) { url_fskip(pb, chunk_size); break; } else if (ea->audio_codec == CODEC_ID_PCM_S16LE_PLANAR || ea->audio_codec == CODEC_ID_MP3) { num_samples = get_le32(pb); url_fskip(pb, 8); chunk_size -= 12; } ret = eav_get_packet( chunk_size); if (ret < 0) return ret; pkt->stream_index = ea->audio_stream_index; pkt->pts = 90000; pkt->pts *= ea->audio_frame_counter; pkt->pts /= ea->sample_rate; switch (ea->audio_codec) { case CODEC_ID_ADPCM_EA: /* 2 samples/byte, 1 or 2 samples per frame depending * on stereo; chunk also has 12-byte header */ ea->audio_frame_counter += ((chunk_size - 12) * 2) / ea->num_channels; break; case CODEC_ID_PCM_S16LE_PLANAR: case CODEC_ID_MP3: ea->audio_frame_counter += num_samples; break; default: ea->audio_frame_counter += chunk_size / (ea->bytes * ea->num_channels); } packet_read = 1; break; /* ending tag */ case 0: case ISNe_TAG: case SCEl_TAG: case SEND_TAG: case SEEN_TAG: ret = AVERROR(EIO); packet_read = 1; break; case MVIh_TAG: case kVGT_TAG: case pQGT_TAG: case TGQs_TAG: case MADk_TAG: key = PKT_FLAG_KEY; case MVIf_TAG: case fVGT_TAG: case MADm_TAG: case MADe_TAG: url_fseek(pb, -8, SEEK_CUR); // include chunk preamble chunk_size += 8; goto get_video_packet; case mTCD_TAG: url_fseek(pb, 8, SEEK_CUR); // skip ea dct header chunk_size -= 8; goto get_video_packet; case MV0K_TAG: case MPCh_TAG: case pIQT_TAG: key = PKT_FLAG_KEY; case MV0F_TAG: get_video_packet: ret = eav_get_packet( chunk_size); if (ret < 0) return ret; pkt->stream_index = ea->video_stream_index; pkt->flags |= key; packet_read = 1; break; default: url_fseek(pb, chunk_size, SEEK_CUR); break; } } return ret; }
/* mmf input */ static int mmf_read_header(AVFormatContext *s, AVFormatParameters *ap) { MMFContext *mmf = s->priv_data; unsigned int tag; ByteIOContext *pb = &s->pb; AVStream *st; offset_t file_size, size; int rate, params; tag = get_le32(pb); if (tag != MKTAG('M', 'M', 'M', 'D')) return -1; file_size = get_be32(pb); /* Skip some unused chunks that may or may not be present */ for(;; url_fseek(pb, size, SEEK_CUR)) { tag = get_le32(pb); size = get_be32(pb); if(tag == MKTAG('C','N','T','I')) continue; if(tag == MKTAG('O','P','D','A')) continue; break; } /* Tag = "ATRx", where "x" = track number */ if ((tag & 0xffffff) == MKTAG('M', 'T', 'R', 0)) { av_log(s, AV_LOG_ERROR, "MIDI like format found, unsupported\n"); return -1; } if ((tag & 0xffffff) != MKTAG('A', 'T', 'R', 0)) { av_log(s, AV_LOG_ERROR, "Unsupported SMAF chunk %08x\n", tag); return -1; } get_byte(pb); /* format type */ get_byte(pb); /* sequence type */ params = get_byte(pb); /* (channel << 7) | (format << 4) | rate */ rate = mmf_rate(params & 0x0f); if(rate < 0) { av_log(s, AV_LOG_ERROR, "Invalid sample rate\n"); return -1; } get_byte(pb); /* wave base bit */ get_byte(pb); /* time base d */ get_byte(pb); /* time base g */ /* Skip some unused chunks that may or may not be present */ for(;; url_fseek(pb, size, SEEK_CUR)) { tag = get_le32(pb); size = get_be32(pb); if(tag == MKTAG('A','t','s','q')) continue; if(tag == MKTAG('A','s','p','I')) continue; break; } /* Make sure it's followed by an Awa chunk, aka wave data */ if ((tag & 0xffffff) != MKTAG('A', 'w', 'a', 0)) { av_log(s, AV_LOG_ERROR, "Unexpected SMAF chunk %08x\n", tag); return -1; } mmf->data_size = size; st = av_new_stream(s, 0); if (!st) return AVERROR_NOMEM; st->codec->codec_type = CODEC_TYPE_AUDIO; st->codec->codec_id = CODEC_ID_ADPCM_YAMAHA; st->codec->sample_rate = rate; st->codec->channels = 1; st->codec->bits_per_sample = 4; st->codec->bit_rate = st->codec->sample_rate * st->codec->bits_per_sample; av_set_pts_info(st, 64, 1, st->codec->sample_rate); return 0; }
static void id3v2_parse(AVFormatContext *s, int len, uint8_t version, uint8_t flags) { int isv34, tlen; uint32_t tag; int64_t next; char tmp[16]; int taghdrlen; const char *reason; switch(version) { case 2: if(flags & 0x40) { reason = "compression"; goto error; } isv34 = 0; taghdrlen = 6; break; case 3: case 4: isv34 = 1; taghdrlen = 10; break; default: reason = "version"; goto error; } if(flags & 0x80) { reason = "unsynchronization"; goto error; } if(isv34 && flags & 0x40) /* Extended header present, just skip over it */ url_fskip(s->pb, id3v2_get_size(s->pb, 4)); while(len >= taghdrlen) { if(isv34) { tag = get_be32(s->pb); tlen = id3v2_get_size(s->pb, 4); get_be16(s->pb); /* flags */ } else { tag = get_be24(s->pb); tlen = id3v2_get_size(s->pb, 3); } len -= taghdrlen + tlen; if(len < 0) break; next = url_ftell(s->pb) + tlen; switch(tag) { case MKBETAG('T', 'I', 'T', '2'): case MKBETAG(0, 'T', 'T', '2'): id3v2_read_ttag(s, tlen, s->title, sizeof(s->title)); break; case MKBETAG('T', 'P', 'E', '1'): case MKBETAG(0, 'T', 'P', '1'): id3v2_read_ttag(s, tlen, s->author, sizeof(s->author)); break; case MKBETAG('T', 'A', 'L', 'B'): case MKBETAG(0, 'T', 'A', 'L'): id3v2_read_ttag(s, tlen, s->album, sizeof(s->album)); break; case MKBETAG('T', 'C', 'O', 'N'): case MKBETAG(0, 'T', 'C', 'O'): id3v2_read_ttag(s, tlen, s->genre, sizeof(s->genre)); break; case MKBETAG('T', 'C', 'O', 'P'): case MKBETAG(0, 'T', 'C', 'R'): id3v2_read_ttag(s, tlen, s->copyright, sizeof(s->copyright)); break; case MKBETAG('T', 'R', 'C', 'K'): case MKBETAG(0, 'T', 'R', 'K'): id3v2_read_ttag(s, tlen, tmp, sizeof(tmp)); s->track = atoi(tmp); break; case 0: /* padding, skip to end */ url_fskip(s->pb, len); len = 0; continue; } /* Skip to end of tag */ url_fseek(s->pb, next, SEEK_SET); } if(version == 4 && flags & 0x10) /* Footer preset, always 10 bytes, skip over it */ url_fskip(s->pb, 10); return; error: av_log(s, AV_LOG_INFO, "ID3v2.%d tag skipped, cannot handle %s\n", version, reason); url_fskip(s->pb, len); }
} bool RTMPSession::handleMessage(uint8_t *p, uint8_t msgTypeId) { bool ret = true; switch(msgTypeId) { case RTMP_PT_BYTES_READ: { //DLog("received bytes read: %d\n", get_be32(p)); } break; case RTMP_PT_CHUNK_SIZE: { unsigned long newChunkSize = get_be32(p); DLog("Request to change incoming chunk size from %zu -> %zu\n", m_inChunkSize, newChunkSize); m_inChunkSize = newChunkSize; } break; case RTMP_PT_PING: { DLog("received ping, sending pong.\n"); sendPong(); } break; case RTMP_PT_SERVER_WINDOW: { DLog("received server window size: %d\n", get_be32(p)); } break; case RTMP_PT_PEER_BW: { DLog("received peer bandwidth limit: %d type: %d\n", get_be32(p), p[4]); } break; case RTMP_PT_INVOKE: { DLog("Received invoke\n"); handleInvoke(p); } break; case RTMP_PT_VIDEO: { DLog("received video\n"); } break; case RTMP_PT_AUDIO: { DLog("received audio\n"); } break; case RTMP_PT_METADATA: { DLog("received metadata\n"); } break; case RTMP_PT_NOTIFY: { DLog("received notify\n"); } break; default: { DLog("received unknown packet type: 0x%02X\n", msgTypeId); ret = false; } break; } return ret; }
/* aiff input */ static int aiff_read_header(AVFormatContext *s, AVFormatParameters *ap) { int size, filesize, offset; uint32_t tag; unsigned version = AIFF_C_VERSION1; ByteIOContext *pb = &s->pb; AVStream * st = s->streams[0]; /* check FORM header */ filesize = get_tag(pb, &tag); if (filesize < 0 || tag != MKTAG('F', 'O', 'R', 'M')) return AVERROR_INVALIDDATA; /* AIFF data type */ tag = get_le32(pb); if (tag == MKTAG('A', 'I', 'F', 'F')) /* Got an AIFF file */ version = AIFF; else if (tag != MKTAG('A', 'I', 'F', 'C')) /* An AIFF-C file then */ return AVERROR_INVALIDDATA; filesize -= 4; st = av_new_stream(s, 0); if (!st) return AVERROR_NOMEM; while (filesize > 0) { /* parse different chunks */ size = get_tag(pb, &tag); if (size < 0) return size; filesize -= size + 8; switch (tag) { case MKTAG('C', 'O', 'M', 'M'): /* Common chunk */ /* Then for the complete header info */ st->nb_frames = get_aiff_header (pb, st->codec, size, version); if (st->nb_frames < 0) return st->nb_frames; break; case MKTAG('F', 'V', 'E', 'R'): /* Version chunk */ version = get_be32(pb); break; case MKTAG('N', 'A', 'M', 'E'): /* Sample name chunk */ get_meta (pb, s->title, sizeof(s->title), size); break; case MKTAG('A', 'U', 'T', 'H'): /* Author chunk */ get_meta (pb, s->author, sizeof(s->author), size); break; case MKTAG('(', 'c', ')', ' '): /* Copyright chunk */ get_meta (pb, s->copyright, sizeof(s->copyright), size); break; case MKTAG('A', 'N', 'N', 'O'): /* Annotation chunk */ get_meta (pb, s->comment, sizeof(s->comment), size); break; case MKTAG('S', 'S', 'N', 'D'): /* Sampled sound chunk */ get_be32(pb); /* Block align... don't care */ offset = get_be32(pb); /* Offset of sound data */ goto got_sound; default: /* Jump */ if (size & 1) /* Always even aligned */ size++; url_fskip (pb, size); } } /* End of loop and didn't get sound */ return AVERROR_INVALIDDATA; got_sound: /* Now positioned, get the sound data start and end */ if (st->nb_frames) s->file_size = st->nb_frames * st->codec->block_align; av_set_pts_info(st, 64, 1, st->codec->sample_rate); st->start_time = 0; st->duration = st->nb_frames; /* Position the stream at the first block */ url_fskip(pb, offset); return 0; }
void MSC_ProcessCmd(void) { uint8_t u8Len; int32_t i; uint32_t Hcount, Dcount; if (g_u8EP3Ready) { g_u8EP3Ready = 0; if (g_u8BulkState == BULK_CBW) { u8Len = USBD_GET_PAYLOAD_LEN(EP3); /* Check Signature & length of CBW */ /* Bulk Out buffer */ if ((*(uint32_t *) ((uint32_t)USBD_BUF_BASE + g_u32BulkBuf0) != CBW_SIGNATURE) || (u8Len != 31)) { /* Invalid CBW */ g_u8Prevent = 1; USBD_SET_EP_STALL(EP2); USBD_SET_EP_STALL(EP3); USBD_LockEpStall((1 << EP2) | (1 << EP3)); return; } /* Get the CBW */ for (i = 0; i < u8Len; i++) *((uint8_t *) (&g_sCBW.dCBWSignature) + i) = *(uint8_t *)((uint32_t)USBD_BUF_BASE + g_u32BulkBuf0 + i); /* Prepare to echo the tag from CBW to CSW */ g_sCSW.dCSWTag = g_sCBW.dCBWTag; Hcount = g_sCBW.dCBWDataTransferLength; /* Parse Op-Code of CBW */ switch (g_sCBW.u8OPCode) { case UFI_PREVENT_ALLOW_MEDIUM_REMOVAL: { if (g_sCBW.au8Data[2] & 0x01) { g_au8SenseKey[0] = 0x05; //INVALID COMMAND g_au8SenseKey[1] = 0x24; g_au8SenseKey[2] = 0; g_u8Prevent = 1; } else g_u8Prevent = 0; g_u8BulkState = BULK_IN; MSC_AckCmd(); return; } case UFI_TEST_UNIT_READY: { if (Hcount != 0) { if (g_sCBW.bmCBWFlags == 0) /* Ho > Dn (Case 9) */ { g_u8Prevent = 1; USBD_SET_EP_STALL(EP3); g_sCSW.bCSWStatus = 0x1; g_sCSW.dCSWDataResidue = Hcount; } } else /* Hn == Dn (Case 1) */ { if (g_u8Remove) { g_sCSW.dCSWDataResidue = 0; g_sCSW.bCSWStatus = 1; g_au8SenseKey[0] = 0x02; /* Not ready */ g_au8SenseKey[1] = 0x3A; g_au8SenseKey[2] = 0; g_u8Prevent = 1; } else { g_sCSW.dCSWDataResidue = 0; g_sCSW.bCSWStatus = 0; } } g_u8BulkState = BULK_IN; MSC_AckCmd(); return; } case UFI_START_STOP: { if ((g_sCBW.au8Data[2] & 0x03) == 0x2) { g_u8Remove = 1; } } case UFI_VERIFY_10: { g_u8BulkState = BULK_IN; MSC_AckCmd(); return; } case UFI_REQUEST_SENSE: { if ((Hcount > 0) && (Hcount <= 18)) { MSC_RequestSense(); USBD_SET_PAYLOAD_LEN(EP2, Hcount); g_u8BulkState = BULK_IN; g_sCSW.bCSWStatus = 0; g_sCSW.dCSWDataResidue = 0; return; } else { USBD_SET_EP_STALL(EP2); g_u8Prevent = 1; g_sCSW.bCSWStatus = 0x01; g_sCSW.dCSWDataResidue = 0; g_u8BulkState = BULK_IN; MSC_AckCmd(); return; } } case UFI_READ_FORMAT_CAPACITY: { if (g_u32Length == 0) { g_u32Length = g_sCBW.dCBWDataTransferLength; g_u32Address = MassCMD_BUF; } MSC_ReadFormatCapacity(); g_u8BulkState = BULK_IN; if (g_u32Length > 0) { if (g_u32Length > EP2_MAX_PKT_SIZE) g_u8Size = EP2_MAX_PKT_SIZE; else g_u8Size = g_u32Length; /* Bulk IN buffer */ USBD_MemCopy((uint8_t *)(USBD_BUF_BASE + g_u32BulkBuf1), (uint8_t *)g_u32Address, g_u8Size); g_u32Address += g_u8Size; USBD_SET_EP_BUF_ADDR(EP2, g_u32BulkBuf0); MSC_Read(); } return; } case UFI_READ_CAPACITY: { if (g_u32Length == 0) { g_u32Length = g_sCBW.dCBWDataTransferLength; g_u32Address = MassCMD_BUF; } MSC_ReadCapacity(); g_u8BulkState = BULK_IN; if (g_u32Length > 0) { if (g_u32Length > EP2_MAX_PKT_SIZE) g_u8Size = EP2_MAX_PKT_SIZE; else g_u8Size = g_u32Length; /* Bulk IN buffer */ USBD_MemCopy((uint8_t *)((uint32_t)USBD_BUF_BASE + g_u32BulkBuf1), (uint8_t *)g_u32Address, g_u8Size); g_u32Address += g_u8Size; USBD_SET_EP_BUF_ADDR(EP2, g_u32BulkBuf0); MSC_Read(); } return; } case UFI_MODE_SELECT_6: case UFI_MODE_SELECT_10: { g_u32Length = g_sCBW.dCBWDataTransferLength; g_u32Address = MassCMD_BUF; if (g_u32Length > 0) { USBD_SET_PAYLOAD_LEN(EP3, EP3_MAX_PKT_SIZE); g_u8BulkState = BULK_OUT; } return; } case UFI_MODE_SENSE_6: { *(uint8_t *)((uint32_t)USBD_BUF_BASE + g_u32BulkBuf1+0) = 0x3; *(uint8_t *)((uint32_t)USBD_BUF_BASE + g_u32BulkBuf1+1) = 0x0; *(uint8_t *)((uint32_t)USBD_BUF_BASE + g_u32BulkBuf1+2) = 0x0; *(uint8_t *)((uint32_t)USBD_BUF_BASE + g_u32BulkBuf1+3) = 0x0; USBD_SET_PAYLOAD_LEN(EP2, 4); g_u8BulkState = BULK_IN; g_sCSW.bCSWStatus = 0; g_sCSW.dCSWDataResidue = Hcount - 4;; return; } case UFI_MODE_SENSE_10: { if (g_u32Length == 0) { g_u32Length = g_sCBW.dCBWDataTransferLength; g_u32Address = MassCMD_BUF; } MSC_ModeSense10(); g_u8BulkState = BULK_IN; if (g_u32Length > 0) { if (g_u32Length > EP2_MAX_PKT_SIZE) g_u8Size = EP2_MAX_PKT_SIZE; else g_u8Size = g_u32Length; /* Bulk IN buffer */ USBD_MemCopy((uint8_t *)((uint32_t)USBD_BUF_BASE + g_u32BulkBuf1), (uint8_t *)g_u32Address, g_u8Size); g_u32Address += g_u8Size; USBD_SET_EP_BUF_ADDR(EP2, g_u32BulkBuf0); MSC_Read(); } return; } case UFI_INQUIRY: { if ((Hcount > 0) && (Hcount <= 36)) { /* Bulk IN buffer */ USBD_MemCopy((uint8_t *)((uint32_t)USBD_BUF_BASE + g_u32BulkBuf1), (uint8_t *)g_au8InquiryID, Hcount); USBD_SET_PAYLOAD_LEN(EP2, Hcount); g_u8BulkState = BULK_IN; g_sCSW.bCSWStatus = 0; g_sCSW.dCSWDataResidue = 0; return; } else { USBD_SET_EP_STALL(EP2); g_u8Prevent = 1; g_sCSW.bCSWStatus = 0x01; g_sCSW.dCSWDataResidue = 0; g_u8BulkState = BULK_IN; MSC_AckCmd(); return; } } case UFI_READ_12: case UFI_READ_10: { /* Check if it is a new transfer */ if(g_u32Length == 0) { Dcount = (get_be32(&g_sCBW.au8Data[4])>>8) * 512; if (g_sCBW.bmCBWFlags == 0x80) /* IN */ { if (Hcount == Dcount) /* Hi == Di (Case 6)*/ { } else if (Hcount < Dcount) /* Hn < Di (Case 2) || Hi < Di (Case 7) */ { if (Hcount) /* Hi < Di (Case 7) */ { g_u8Prevent = 1; g_sCSW.bCSWStatus = 0x01; g_sCSW.dCSWDataResidue = 0; } else /* Hn < Di (Case 2) */ { g_u8Prevent = 1; g_sCSW.bCSWStatus = 0x01; g_sCSW.dCSWDataResidue = 0; g_u8BulkState = BULK_IN; MSC_AckCmd(); return; } } else if (Hcount > Dcount) /* Hi > Dn (Case 4) || Hi > Di (Case 5) */ { g_u8Prevent = 1; g_sCSW.bCSWStatus = 0x01; g_sCSW.dCSWDataResidue = 0; } } else /* Ho <> Di (Case 10) */ { g_u8Prevent = 1; USBD_SET_EP_STALL(EP3); g_sCSW.bCSWStatus = 0x01; g_sCSW.dCSWDataResidue = Hcount; g_u8BulkState = BULK_IN; MSC_AckCmd(); return; } } /* Get LBA address */ g_u32Address = get_be32(&g_sCBW.au8Data[0]); g_u32LbaAddress = g_u32Address * UDC_SECTOR_SIZE; g_u32Length = g_sCBW.dCBWDataTransferLength; g_u32BytesInStorageBuf = g_u32Length; i = g_u32Length; if (i > STORAGE_BUFFER_SIZE) i = STORAGE_BUFFER_SIZE; MSC_ReadMedia(g_u32Address * UDC_SECTOR_SIZE, i, (uint8_t *)STORAGE_DATA_BUF); g_u32BytesInStorageBuf = i; g_u32LbaAddress += i; g_u32Address = STORAGE_DATA_BUF; /* Indicate the next packet should be Bulk IN Data packet */ g_u8BulkState = BULK_IN; if (g_u32BytesInStorageBuf > 0) { /* Set the packet size */ if (g_u32BytesInStorageBuf > EP2_MAX_PKT_SIZE) g_u8Size = EP2_MAX_PKT_SIZE; else g_u8Size = g_u32BytesInStorageBuf; /* Prepare the first data packet (DATA1) */ /* Bulk IN buffer */ USBD_MemCopy((uint8_t *)((uint32_t)USBD_BUF_BASE + g_u32BulkBuf1), (uint8_t *)g_u32Address, g_u8Size); g_u32Address += g_u8Size; /* kick - start */ USBD_SET_EP_BUF_ADDR(EP2, g_u32BulkBuf1); /* Trigger to send out the data packet */ USBD_SET_PAYLOAD_LEN(EP2, g_u8Size); g_u32Length -= g_u8Size; g_u32BytesInStorageBuf -= g_u8Size; } return; } case UFI_WRITE_12: case UFI_WRITE_10: { if (g_u32Length == 0) { Dcount = (get_be32(&g_sCBW.au8Data[4])>>8) * 512; if (g_sCBW.bmCBWFlags == 0x00) /* OUT */ { if (Hcount == Dcount) /* Ho == Do (Case 12)*/ { g_sCSW.dCSWDataResidue = 0; g_sCSW.bCSWStatus = 0; } else if (Hcount < Dcount) /* Hn < Do (Case 3) || Ho < Do (Case 13) */ { g_u8Prevent = 1; g_sCSW.dCSWDataResidue = 0; g_sCSW.bCSWStatus = 0x1; if (Hcount == 0) /* Hn < Do (Case 3) */ { g_u8BulkState = BULK_IN; MSC_AckCmd(); return; } } else if (Hcount > Dcount) /* Ho > Do (Case 11) */ { g_u8Prevent = 1; g_sCSW.dCSWDataResidue = 0; g_sCSW.bCSWStatus = 0x1; } g_u32Length = g_sCBW.dCBWDataTransferLength; g_u32Address = STORAGE_DATA_BUF; g_u32DataFlashStartAddr = get_be32(&g_sCBW.au8Data[0]) * UDC_SECTOR_SIZE; } else /* Hi <> Do (Case 8) */ { g_u8Prevent = 1; g_sCSW.dCSWDataResidue = Hcount; g_sCSW.bCSWStatus = 0x1; USBD_SET_EP_STALL(EP2); g_u8BulkState = BULK_IN; MSC_AckCmd(); return; } } if ((g_u32Length > 0)) { USBD_SET_PAYLOAD_LEN(EP3, EP3_MAX_PKT_SIZE); g_u8BulkState = BULK_OUT; } return; } case UFI_READ_16: { USBD_SET_EP_STALL(EP2); g_u8Prevent = 1; g_sCSW.bCSWStatus = 0x01; g_sCSW.dCSWDataResidue = 0; g_u8BulkState = BULK_IN; MSC_AckCmd(); return; } default: { /* Unsupported command */ g_au8SenseKey[0] = 0x05; g_au8SenseKey[1] = 0x20; g_au8SenseKey[2] = 0x00; /* If CBW request for data phase, just return zero packet to end data phase */ if (g_sCBW.dCBWDataTransferLength > 0) { /* Data Phase, zero/short packet */ if ((g_sCBW.bmCBWFlags & 0x80) != 0) { /* Data-In */ g_u8BulkState = BULK_IN; USBD_SET_PAYLOAD_LEN(EP2, 0); } } else { /* Status Phase */ g_u8BulkState = BULK_IN; MSC_AckCmd(); } return; } }
static gboolean listener_event(GIOChannel *channel, GIOCondition condition, gpointer user_data) { GDHCPServer *dhcp_server = user_data; struct dhcp_packet packet; struct dhcp_lease *lease; uint32_t requested_nip = 0; uint8_t type, *server_id_option, *request_ip_option; int re; if (condition & (G_IO_NVAL | G_IO_ERR | G_IO_HUP)) { dhcp_server->listener_watch = 0; return FALSE; } re = dhcp_recv_l3_packet(&packet, dhcp_server->listener_sockfd); if (re < 0) return TRUE; type = check_packet_type(&packet); if (type == 0) return TRUE; server_id_option = dhcp_get_option(&packet, DHCP_SERVER_ID); if (server_id_option) { uint32_t server_nid = get_be32(server_id_option); if (server_nid != dhcp_server->server_nip) return TRUE; } request_ip_option = dhcp_get_option(&packet, DHCP_REQUESTED_IP); if (request_ip_option) requested_nip = get_be32(request_ip_option); lease = find_lease_by_mac(dhcp_server, packet.chaddr); switch (type) { case DHCPDISCOVER: debug(dhcp_server, "Received DISCOVER"); send_offer(dhcp_server, &packet, lease, requested_nip); break; case DHCPREQUEST: debug(dhcp_server, "Received REQUEST NIP %d", requested_nip); if (requested_nip == 0) { requested_nip = packet.ciaddr; if (requested_nip == 0) break; } if (!lease) { /* check if requested address free */ lease = add_lease(dhcp_server, OFFER_TIME, packet.chaddr, htonl(requested_nip)); } if (lease && requested_nip == lease->lease_nip) { debug(dhcp_server, "Sending ACK"); send_ACK(dhcp_server, &packet, lease->lease_nip); break; } if (server_id_option || !lease) { debug(dhcp_server, "Sending NAK"); send_NAK(dhcp_server, &packet); } break; case DHCPDECLINE: debug(dhcp_server, "Received DECLINE"); if (!server_id_option) break; if (!request_ip_option) break; if (!lease) break; if (requested_nip == lease->lease_nip) remove_lease(dhcp_server, lease); break; case DHCPRELEASE: debug(dhcp_server, "Received RELEASE"); if (!server_id_option) break; if (!lease) break; if (packet.ciaddr == lease->lease_nip) lease_set_expire(dhcp_server, lease, time(NULL)); break; case DHCPINFORM: debug(dhcp_server, "Received INFORM"); send_inform(dhcp_server, &packet); break; } return TRUE; }
static int read_part_of_packet(AVFormatContext *s, int64_t *pts, int *len, int *strid, int read_packet) { ByteIOContext *pb = s->pb; PVAContext *pvactx = s->priv_data; int syncword, streamid, reserved, flags, length, pts_flag; int64_t pva_pts = AV_NOPTS_VALUE, startpos; recover: startpos = url_ftell(pb); syncword = get_be16(pb); streamid = get_byte(pb); get_byte(pb); /* counter not used */ reserved = get_byte(pb); flags = get_byte(pb); length = get_be16(pb); pts_flag = flags & 0x10; if (syncword != PVA_MAGIC) { pva_log(s, AV_LOG_ERROR, "invalid syncword\n"); return AVERROR(EIO); } if (streamid != PVA_VIDEO_PAYLOAD && streamid != PVA_AUDIO_PAYLOAD) { pva_log(s, AV_LOG_ERROR, "invalid streamid\n"); return AVERROR(EIO); } if (reserved != 0x55) { pva_log(s, AV_LOG_WARNING, "expected reserved byte to be 0x55\n"); } if (length > PVA_MAX_PAYLOAD_LENGTH) { pva_log(s, AV_LOG_ERROR, "invalid payload length %u\n", length); return AVERROR(EIO); } if (streamid == PVA_VIDEO_PAYLOAD && pts_flag) { pva_pts = get_be32(pb); length -= 4; } else if (streamid == PVA_AUDIO_PAYLOAD) { /* PVA Audio Packets either start with a signaled PES packet or * are a continuation of the previous PES packet. New PES packets * always start at the beginning of a PVA Packet, never somewhere in * the middle. */ if (!pvactx->continue_pes) { int pes_signal, pes_header_data_length, pes_packet_length, pes_flags; unsigned char pes_header_data[256]; pes_signal = get_be24(pb); get_byte(pb); pes_packet_length = get_be16(pb); pes_flags = get_be16(pb); pes_header_data_length = get_byte(pb); if (pes_signal != 1) { pva_log(s, AV_LOG_WARNING, "expected signaled PES packet, " "trying to recover\n"); url_fskip(pb, length - 9); if (!read_packet) return AVERROR(EIO); goto recover; } get_buffer(pb, pes_header_data, pes_header_data_length); length -= 9 + pes_header_data_length; pes_packet_length -= 3 + pes_header_data_length; pvactx->continue_pes = pes_packet_length; if (pes_flags & 0x80 && (pes_header_data[0] & 0xf0) == 0x20) pva_pts = ff_parse_pes_pts(pes_header_data); } pvactx->continue_pes -= length; if (pvactx->continue_pes < 0) { pva_log(s, AV_LOG_WARNING, "audio data corruption\n"); pvactx->continue_pes = 0; } } if (pva_pts != AV_NOPTS_VALUE) av_add_index_entry(s->streams[streamid-1], startpos, pva_pts, 0, 0, AVINDEX_KEYFRAME); *pts = pva_pts; *len = length; *strid = streamid; return 0; }
void learn_execute(const struct nx_action_learn *learn, const struct flow *flow, struct ofputil_flow_mod *fm) { const void *p, *end; struct ofpbuf actions; cls_rule_init_catchall(&fm->cr, ntohs(learn->priority)); fm->cookie = learn->cookie; fm->table_id = learn->table_id; fm->command = OFPFC_MODIFY_STRICT; fm->idle_timeout = ntohs(learn->idle_timeout); fm->hard_timeout = ntohs(learn->hard_timeout); fm->buffer_id = UINT32_MAX; fm->out_port = OFPP_NONE; fm->flags = ntohs(learn->flags) & OFPFF_SEND_FLOW_REM; fm->actions = NULL; fm->n_actions = 0; ofpbuf_init(&actions, 64); for (p = learn + 1, end = (char *) learn + ntohs(learn->len); p != end; ) { uint16_t header = ntohs(get_be16(&p)); int n_bits = header & NX_LEARN_N_BITS_MASK; int src_type = header & NX_LEARN_SRC_MASK; int dst_type = header & NX_LEARN_DST_MASK; uint64_t value; struct nx_action_reg_load *load; ovs_be32 dst_field; int dst_ofs; if (!header) { break; } if (src_type == NX_LEARN_SRC_FIELD) { ovs_be32 src_field = get_be32(&p); int src_ofs = ntohs(get_be16(&p)); value = nxm_read_field_bits(src_field, nxm_encode_ofs_nbits(src_ofs, n_bits), flow); } else { value = get_bits(n_bits, &p); } switch (dst_type) { case NX_LEARN_DST_MATCH: dst_field = get_be32(&p); dst_ofs = ntohs(get_be16(&p)); mf_set_subfield(mf_from_nxm_header(ntohl(dst_field)), value, dst_ofs, n_bits, &fm->cr); break; case NX_LEARN_DST_LOAD: dst_field = get_be32(&p); dst_ofs = ntohs(get_be16(&p)); load = ofputil_put_NXAST_REG_LOAD(&actions); load->ofs_nbits = nxm_encode_ofs_nbits(dst_ofs, n_bits); load->dst = dst_field; load->value = htonll(value); break; case NX_LEARN_DST_OUTPUT: ofputil_put_OFPAT_OUTPUT(&actions)->port = htons(value); break; } } fm->actions = ofpbuf_steal_data(&actions); fm->n_actions = actions.size / sizeof(struct ofp_action_header); }
/* Checks that 'learn' (which must be at least 'sizeof *learn' bytes long) is a * valid action on 'flow'. */ int learn_check(const struct nx_action_learn *learn, const struct flow *flow) { struct cls_rule rule; const void *p, *end; cls_rule_init_catchall(&rule, 0); if (learn->flags & ~htons(OFPFF_SEND_FLOW_REM) || !is_all_zeros(learn->pad, sizeof learn->pad) || learn->table_id == 0xff) { return ofp_mkerr(OFPET_BAD_ACTION, OFPBAC_BAD_ARGUMENT); } end = (char *) learn + ntohs(learn->len); for (p = learn + 1; p != end; ) { uint16_t header = ntohs(get_be16(&p)); int n_bits = header & NX_LEARN_N_BITS_MASK; int src_type = header & NX_LEARN_SRC_MASK; int dst_type = header & NX_LEARN_DST_MASK; uint64_t value; int error; if (!header) { break; } error = learn_check_header(header, (char *) end - (char *) p); if (error) { return error; } /* Check the source. */ if (src_type == NX_LEARN_SRC_FIELD) { ovs_be32 src_field = get_be32(&p); int src_ofs = ntohs(get_be16(&p)); error = nxm_src_check(src_field, src_ofs, n_bits, flow); if (error) { return error; } value = 0; } else { value = get_bits(n_bits, &p); } /* Check the destination. */ if (dst_type == NX_LEARN_DST_MATCH || dst_type == NX_LEARN_DST_LOAD) { ovs_be32 dst_field = get_be32(&p); int dst_ofs = ntohs(get_be16(&p)); int error; error = (dst_type == NX_LEARN_DST_LOAD ? nxm_dst_check(dst_field, dst_ofs, n_bits, &rule.flow) : nxm_src_check(dst_field, dst_ofs, n_bits, &rule.flow)); if (error) { return error; } if (dst_type == NX_LEARN_DST_MATCH && src_type == NX_LEARN_SRC_IMMEDIATE) { mf_set_subfield(mf_from_nxm_header(ntohl(dst_field)), value, dst_ofs, n_bits, &rule); } } } if (!is_all_zeros(p, (char *) end - (char *) p)) { return ofp_mkerr(OFPET_BAD_ACTION, OFPBAC_BAD_ARGUMENT); } return 0; }
/** * Process file as it being Exif, will extract Exif as well as other * JPEG markers (comment, size). */ static int _exif_data_get(int fd, int len, struct lms_image_info *info) { const unsigned char exif_hdr[6] = "Exif\0"; unsigned char buf[9]; unsigned int little_endian, offset, count; off_t abs_offset, tiff_base; abs_offset = lseek(fd, 0, SEEK_CUR); if (abs_offset == -1) { perror("lseek"); return -1; } if (read(fd, buf, 6) != 6) { perror("read"); return -2; } memset(info, 0, sizeof(*info)); info->orientation = 1; if (memcmp(buf, exif_hdr, 6) != 0) return _exif_extra_get(fd, abs_offset, len, info); if (read(fd, buf, 8) != 8) { perror("read"); return -4; } buf[sizeof(buf) -1] = '\0'; if (buf[0] == 'I' && buf[1] == 'I') { little_endian = 1; offset = get_le32(buf + 4); } else if (buf[0] == 'M' && buf[1] == 'M') { little_endian = 0; offset = get_be32(buf + 4); } else { fprintf(stderr, "ERROR: undefined byte sex \"%2.2s\".\n", buf); return -5; } offset -= 8; if (offset > 0 && lseek(fd, offset, SEEK_CUR) == -1) { perror("lseek"); return -6; } tiff_base = abs_offset + 6; /* offsets are relative to TIFF base */ if (read(fd, buf, 2) != 2) { perror("read"); return -7; } count = E_2BTYE(little_endian, buf); _exif_ifd_process(fd, count, 8 + 2, tiff_base, little_endian, info); return _exif_extra_get(fd, abs_offset, len, info); }
static bool read_super(fs_context& fs) { superblock sb; ssize_t rc = read_raw(*fs.io_ctx, &sb, sizeof(superblock), 0); if (rc < 0) { log().critical("reading super block failed"); return false; } debug_update(fs, debug_metric::read_raw, static_cast<uint64_t>(rc)); // The super block is only read once and its content is saved // inside the ffsp structure. fs.fsid = get_be32(sb.s_fsid); fs.flags = get_be32(sb.s_flags); fs.neraseblocks = get_be32(sb.s_neraseblocks); fs.nino = get_be32(sb.s_nino); fs.blocksize = get_be32(sb.s_blocksize); fs.clustersize = get_be32(sb.s_clustersize); fs.erasesize = get_be32(sb.s_erasesize); fs.ninoopen = get_be32(sb.s_ninoopen); fs.neraseopen = get_be32(sb.s_neraseopen); fs.nerasereserve = get_be32(sb.s_nerasereserve); fs.nerasewrites = get_be32(sb.s_nerasewrites); return true; }