spark-streaming系列------- 3. Kafka DirectDStream方式数据的接收
spark-streaming系列------- 2. spark-streaming的Job调度 下
日期: 14:09:02
来源：csdn
spark-streaming系列------- 3. Kafka DirectDStream方式数据的接收
spark-streaming系列------- 2. spark-streaming的Job调度 下
KafkaRDD分区个数的确定和每个分区数据接收的计算
在KafkUtils.createDirectStream创建了DirectDStream，代码如下：
def createDirectStream[
K: ClassTag,
V: ClassTag,
KD &: Decoder[K]: ClassTag,
VD &: Decoder[V]: ClassTag] (
ssc: StreamingContext,
kafkaParams: Map[String, String],
topics: Set[String]
): InputDStream[(K, V)] = {
val messageHandler = (mmd: MessageAndMetadata[K, V]) =& (mmd.key, mmd.message)
val kc = new KafkaCluster(kafkaParams)
val reset = kafkaParams.get("auto.offset.reset").map(_.toLowerCase)
val result = for {
* 通过跟Kafka集群通信，获得Kafka某个topic的partition信息，topicPartitions是一个数组，数组大小跟Kafka topic的分区个数相同
* 数组元素包含话题名和parition的index
topicPartitions &- kc.getPartitions(topics).right
leaderOffsets &- (if (reset == Some("smallest")) {
kc.getEarliestLeaderOffsets(topicPartitions)
kc.getLatestLeaderOffsets(topicPartitions)
//计算Kafka topic的每个partition的offset
val fromOffsets = leaderOffsets.map { case (tp, lo) =&
(tp, lo.offset)
new DirectKafkaInputDStream[K, V, KD, VD, (K, V)](
ssc, kafkaParams, fromOffsets, messageHandler)
KafkaCluster.checkErrors(result)
在这里，通过跟Kafka集群通信，获得Kafka topic每个partition的消息偏移量，作为参数继续创建DirectKafkaInputDstream.
DirectKafkaInputDstream的部分代码如下：
class DirectKafkaInputDStream[
K: ClassTag,
V: ClassTag,
U &: Decoder[K]: ClassTag,
T &: Decoder[V]: ClassTag,
R: ClassTag](
@transient ssc_ : StreamingContext,
val kafkaParams: Map[String, String],
val fromOffsets: Map[TopicAndPartition, Long],
messageHandler: MessageAndMetadata[K, V] =& R
) extends InputDStream[R](ssc_) with Logging {
val maxRetries = context.sparkContext.getConf.getInt(
"spark.streaming.kafka.maxRetries", 1)
// Keep this consistent with how other streams are named (e.g. "Flume polling stream [2]")
private[streaming] override def name: String = s"Kafka direct stream [$id]"
protected[streaming] override val checkpointData =
new DirectKafkaInputDStreamCheckpointData
protected val kc = new KafkaCluster(kafkaParams)
protected val maxMessagesPerPartition: Option[Long] = {
val ratePerSec = context.sparkContext.getConf.getInt(
"spark.streaming.kafka.maxRatePerPartition", 0)
if (ratePerSec & 0) {
val secsPerBatch = context.graph.batchDuration.milliseconds.toDouble / 1000
Some((secsPerBatch * ratePerSec).toLong)
//将topic的分区个数和偏移量信息保存在currentOffsets中
protected var currentOffsets = fromOffsets
protected final def latestLeaderOffsets(retries: Int): Map[TopicAndPartition, LeaderOffset] = {
val o = kc.getLatestLeaderOffsets(currentOffsets.keySet)
// Either.fold would confuse @tailrec, do it manually
if (o.isLeft) {
val err = o.left.get.toString
if (retries &= 0) {
throw new SparkException(err)
log.error(err)
Thread.sleep(kc.config.refreshLeaderBackoffMs)
latestLeaderOffsets(retries - 1)
o.right.get
// limits the maximum number of messages per partition
* 当没有设置最大接收速率的时候，接收终止点是当前时间的每个partition的offset
protected def clamp(
leaderOffsets: Map[TopicAndPartition, LeaderOffset]): Map[TopicAndPartition, LeaderOffset] = {
maxMessagesPerPartition.map { mmp =&
leaderOffsets.map { case (tp, lo) =&
tp -& lo.copy(offset = Math.min(currentOffsets(tp) + mmp, lo.offset))
}.getOrElse(leaderOffsets)
override def compute(validTime: Time): Option[KafkaRDD[K, V, U, T, R]] = {
//计算本次数据接收终止的每个paritition的offset
val untilOffsets = clamp(latestLeaderOffsets(maxRetries))
val rdd = KafkaRDD[K, V, U, T, R](
context.sparkContext, kafkaParams, currentOffsets, untilOffsets, messageHandler)
// Report the record number of this batch interval to InputInfoTracker.
val inputInfo = InputInfo(id, rdd.count)
ssc.scheduler.inputInfoTracker.reportInfo(validTime, inputInfo)
currentOffsets = untilOffsets.map(kv =& kv._1 -& kv._2.offset)
结论：spark-streaming DirectDStream数据接受方式，如果没有设置最大接收速率，每个batch的数据接收量为一个batch时间间隔内，Kafka topic接收到的消息量
Kafka的分区信息在DirectKafkaInputDStream的类初始化操作中，通过fromOffsets参数传递给它的currentOffsets成员，这个成员在创建KafkaRDD的时候作为初始化成员将Kafka的分区信息传递给KafkaRDD，作为生成KafkaRDD paritition的依据。
object KafkaRDD {
import KafkaCluster.LeaderOffset
* @param kafkaParams Kafka &a href=#>
class KafkaRDD[
K: ClassTag,
V: ClassTag,
U &: Decoder[_]: ClassTag,
T &: Decoder[_]: ClassTag,
R: ClassTag] private[spark] (
sc: SparkContext,
kafkaParams: Map[String, String],
val offsetRanges: Array[OffsetRange],
leaders: Map[TopicAndPartition, (String, Int)],
messageHandler: MessageAndMetadata[K, V] =& R
) extends RDD[R](sc, Nil) with Logging with HasOffsetRanges {
//根据OffsetRanges生成RDD的partition
override def getPartitions: Array[Partition] = {
offsetRanges.zipWithIndex.map { case (o, i) =&
val (host, port) = leaders(TopicAndPartition(o.topic, o.partition))//host是Kafka broker的ip地址， port是Kafka broker的端口号
new KafkaRDDPartition(i, o.topic, o.partition, o.fromOffset, o.untilOffset, host, port)
在创建RDD的时候，会最终调用到getPartitions方法，这样确定了KafkaRDD每个partition所在的IP地址和端口号，KafkaRDD每个Paritition所在的IP地址为Kafka broker的地址从前面的文章：
知道，pute方法被Spark-streaming的调度模块周期调用产生DStream的RDD
通过上面的代码分析，知道了Kafka的分区个数和RDD的分区个数相同，并且RDD的一个paritition和Kafka的一个partition一一对应。
KafkaRDD的数据接收
Spark-streaming任务启动之后，调用了SparkContext.runJob将数据接收和处理任务提交到Spark的Task调度系统。Spark的Task调度系统经过一系列的RDD依赖运算之后找到Root RDD是KafkaRDD。然后根据KafkaRDD的partition首先将KafkaRDD的处理任务添加到任务等待HashMap。实现代码在TaskSetManager.addPendingTask方法
private def addPendingTask(index: Int, readding: Boolean = false) {
// Utility method that adds `index` to a list only if readding=false or it's not already there
def addTo(list: ArrayBuffer[Int]) {
if (!readding || !list.contains(index)) {
list += index
for (loc &- tasks(index).preferredLocations) {//preferredLocation方法返回partition所在的IP地址
loc match {
case e: ExecutorCacheTaskLocation =&
addTo(pendingTasksForExecutor.getOrElseUpdate(e.executorId, new ArrayBuffer))
case e: HDFSCacheTaskLocation =& {
val exe = sched.getExecutorsAliveOnHost(loc.host)
exe match {
case Some(set) =& {
for (e &- set) {
addTo(pendingTasksForExecutor.getOrElseUpdate(e, new ArrayBuffer))
logInfo(s"Pending task $index has a cached location at ${e.host} " +
", where there are executors " + set.mkString(","))
case None =& logDebug(s"Pending task $index has a cached location at ${e.host} " +
", but there are no executors alive there.")
case _ =& Unit
addTo(pendingTasksForHost.getOrElseUpdate(loc.host, new ArrayBuffer))//由于DirectDStream方式的loc.host地址不属于Spark集群和HDFS集群，所以Task加到了这个HashMap
for (rack &- sched.getRackForHost(loc.host)) {
addTo(pendingTasksForRack.getOrElseUpdate(rack, new ArrayBuffer))
if (tasks(index).preferredLocations == Nil) {
addTo(pendingTasksWithNoPrefs)
if (!readding) {
allPendingTasks += index
// No point scanning this whole list to find the old task there
所有的Task都会加入到这个HashMap，包括DirectDStream情况下的Task
在这个方法里面，KafkaRDD的处理Task加入到了pendingTasksForHost和allPendingTasks两个Task等待HashMap中
任务加入到等待HashMap之后，会发送ReviveOffers消息，调用CoarseGrainedScheduleBackend.makeOffers方法确定Task在那些Executor执行，并且启动Task
CoarseGrainedScheduleBackend.makeOffers方法最终调用到TaskSchedulerImpl.resourceOfferSingleTaskSet为一个TaskSet分配资源
//每次调用这个方法，会为轮询每个Executor分配一个Task。当TaskSet的task个数比executor的个数多的时候，剩余的Task这次调用就不执行。
//当一个Executor上的task执行完毕之后，会发送StatusUpdate事件，driver会重新调用到这个方法，继续从TaskSet中取出Task让这个Executor执行
private def resourceOfferSingleTaskSet(
taskSet: TaskSetManager,
maxLocality: TaskLocality,
shuffledOffers: Seq[WorkerOffer],
availableCpus: Array[Int],
tasks: Seq[ArrayBuffer[TaskDescription]]) : Boolean = {
var launchedTask = false
for (i &- 0 until shuffledOffers.size) {
val execId = shuffledOffers(i).executorId
val host = shuffledOffers(i).host
if (availableCpus(i) &= CPUS_PER_TASK) {//按照cpu cores个数分配task
for (task &- taskSet.resourceOffer(execId, host, maxLocality)) {
tasks(i) += task //将这个task放在了第i个worker(worker顺序已经shuffle了)
val tid = task.taskId
taskIdToTaskSetId(tid) = taskSet.taskSet.id//记录task所在的taskset
taskIdToExecutorId(tid) = execId//记录task所在的executor
executorsByHost(host) += execId
availableCpus(i) -= CPUS_PER_TASK
assert(availableCpus(i) &= 0)
launchedTask = true
case e: TaskNotSerializableException =&
logError(s"Resource offer failed, task set ${taskSet.name} was not serializable")
// Do not offer resources for this task, but don't throw an error to allow other
// task sets to be submitted.
return launchedTask
return launchedTask
在上面的resourceOfferSingleTaskSet方法中，将产生的Task轮询分配到了各个Executor
下面看看Task是如何产生的：
TaskSetManager.resourceOffer定义：
def resourceOffer(
execId: String,
host: String,
maxLocality: TaskLocality.TaskLocality)
: Option[TaskDescription] =
if (!isZombie) {
val curTime = clock.getTimeMillis()
var allowedLocality = maxLocality
if (maxLocality != TaskLocality.NO_PREF) {
allowedLocality = getAllowedLocalityLevel(curTime)
if (allowedLocality & maxLocality) {
// We're not allowed to search for farther-away tasks
allowedLocality = maxLocality
dequeueTask(execId, host, allowedLocality) match {
case Some((index, taskLocality, speculative)) =& {
// F do some bookkeeping and return a task description
val task = tasks(index)
val taskId = sched.newTaskId()
// Do various bookkeeping
copiesRunning(index) += 1
val attemptNum = taskAttempts(index).size
val info = new TaskInfo(taskId, index, attemptNum, curTime,
execId, host, taskLocality, speculative)
taskInfos(taskId) = info
taskAttempts(index) = info :: taskAttempts(index)
// Update our locality level for delay scheduling
// NO_PREF will not affect the variables related to delay scheduling
if (maxLocality != TaskLocality.NO_PREF) {
currentLocalityIndex = getLocalityIndex(taskLocality)
lastLaunchTime = curTime
// Serialize and return the task
val startTime = clock.getTimeMillis()
val serializedTask: ByteBuffer = try {
Task.serializeWithDependencies(task, sched.sc.addedFiles, sched.sc.addedJars, ser)
// If the task cannot be serialized, then there's no point to re-attempt the task,
// as it will always fail. So just abort the whole task-set.
case NonFatal(e) =&
val msg = s"Failed to serialize task $taskId, not attempting to retry it."
logError(msg, e)
abort(s"$msg Exception during serialization: $e")
throw new TaskNotSerializableException(e)
if (serializedTask.limit & TaskSetManager.TASK_SIZE_TO_WARN_KB * 1024 &&
!emittedTaskSizeWarning) {
emittedTaskSizeWarning = true
logWarning(s"Stage ${task.stageId} contains a task of very large size " +
s"(${serializedTask.limit / 1024} KB). The maximum recommended task size is " +
s"${TaskSetManager.TASK_SIZE_TO_WARN_KB} KB.")
addRunningTask(taskId)
// We used to log the time it takes to serialize the task, but task size is already
// a good proxy to task serialization time.
// val timeTaken = clock.getTime() - startTime
val taskName = s"task ${info.id} in stage ${taskSet.id}"
logInfo("Starting %s (TID %d, %s, %s, %d bytes)".format(
taskName, taskId, host, taskLocality, serializedTask.limit))
sched.dagScheduler.taskStarted(task, info)
return Some(new TaskDescription(taskId = taskId, attemptNumber = attemptNum, execId,
taskName, index, serializedTask))
从上面的方法可知道，Task的获取是在TaskSetManager.dequeueTask方法，定义如下：
//优先返回本地性最高的task
private def dequeueTask(execId: String, host: String, maxLocality: TaskLocality.Value)
: Option[(Int, TaskLocality.Value, Boolean)] =
//如果这个Executor有等待任务，则从等待队列取下来，返回
for (index &- dequeueTaskFromList(execId, getPendingTasksForExecutor(execId))) {
return Some((index, TaskLocality.PROCESS_LOCAL, false))
if (TaskLocality.isAllowed(maxLocality, TaskLocality.NODE_LOCAL)) {//由于KafkaRDD partition所在的Ip地址跟Executor的IP地址不同，所以Task不能从这个HashMap获取
for (index &- dequeueTaskFromList(execId, getPendingTasksForHost(host))) {
return Some((index, TaskLocality.NODE_LOCAL, false))
if (TaskLocality.isAllowed(maxLocality, TaskLocality.NO_PREF)) {
// Look for noPref tasks after NODE_LOCAL for minimize cross-rack traffic
for (index &- dequeueTaskFromList(execId, pendingTasksWithNoPrefs)) {
return Some((index, TaskLocality.PROCESS_LOCAL, false))
if (TaskLocality.isAllowed(maxLocality, TaskLocality.RACK_LOCAL)) {
rack &- sched.getRackForHost(host)
index &- dequeueTaskFromList(execId, getPendingTasksForRack(rack))
return Some((index, TaskLocality.RACK_LOCAL, false))
if (TaskLocality.isAllowed(maxLocality, TaskLocality.ANY)) {//KafkaRDD的处理Task从addPendingTasks这个HashMap获取
for (index &- dequeueTaskFromList(execId, allPendingTasks)) {
return Some((index, TaskLocality.ANY, false))
// find a speculative task if all others tasks have been scheduled
dequeueSpeculativeTask(execId, host, maxLocality).map {
case (taskIndex, allowedLocality) =& (taskIndex, allowedLocality, true)}
在产生任务的时候，尽量优先产生本地性高的任务，由于KafkaRDD各个Partition所在的IP地址跟Spark Executor的IP地址不同，只能从allPendingTask这个HashMap获取任务了。
根据上面3个方法的分析得出结论：KafkaRDD的接收Task个数跟KafkaRDD的partition个数是相同的，并且所有的KafkaRDD处理Task轮询分配到了各个Executor上
KafkaRDD的实际开始处理是在ShuffleMapTask.runTask方法，源码如下：
override def runTask(context: TaskContext): MapStatus = {
// Deserialize the RDD using the broadcast variable.
val deserializeStartTime = System.currentTimeMillis()
val ser = SparkEnv.get.closureSerializer.newInstance()
val (rdd, dep) = ser.deserialize[(RDD[_], ShuffleDependency[_, _, _])](
ByteBuffer.wrap(taskBinary.value), Thread.currentThread.getContextClassLoader)
_executorDeserializeTime = System.currentTimeMillis() - deserializeStartTime
metrics = Some(context.taskMetrics)
var writer: ShuffleWriter[Any, Any] = null
val manager = SparkEnv.get.shuffleManager
writer = manager.getWriter[Any, Any](dep.shuffleHandle, partitionId, context)
writer.write(rdd.iterator(partition, context).asInstanceOf[Iterator[_ &: Product2[Any, Any]]])//rdd.iterator读取并处理数据，把处理结果返回
return writer.stop(success = true).get
case e: Exception =&
if (writer != null) {
writer.stop(success = false)
case e: Exception =&
log.debug("Could not stop writer", e)
这个方法根据RDD的依赖关系，调用到了pute方法，由于KafkaRDD是root RDD，所以pute在一系列依赖RDD中最先执行，返回从Kafka broker接收到的消息的Iterator ，而Spark在处理RDD partition的时候，RDD paritition中的数据最原始的组织形式就是Iterator
结论：Spark-streaming 采用DirectDStream接收数据，把接收过来的数据直接组织成RDD进行处理
版权声明：本文为博主原创文章，未经博主允许不得转载。
本页内容版权归属为原作者，如有侵犯您的权益，请通知我们删除。
http://blog.csdn.net/yueqian_zhu/ 一、 RDD创建的操作（SparkContext.scala） 1、从内存集合中创建RDD，RDD中包含的是类型为T的集合 def parallelize[T: ClassTag]( seq: Seq[T], numSlices: Int = defaultParallelism): RDD[T]def makeRDD[T: ClassTag]( seq: Seq[T], numSlices: Int = defaultPa
Openfire使用上的一些技巧 作者：chszs，版权所有，未经同意，不得转载。博主主页： http://blog.csdn.net/chszs 1、把Openfire安装为系统服务 对于RedHat、CentOS、Fedora之类的系统，可以采用RPM包安装Openfire，安装后自然有了Openfire服务。此时可以通过命令启动或停止Openfire： # /etc/init.d/openfire stop/start/restart/reload 如果是通过.tar.gz解压安装的Openfire
short nMAsciiHexToBinary(unsigned char* vspSourceStr,short vnSourceStrL,unsigned char* vspDestStr) {if(vnSourceStrL % 2)return -1;for(; vnSourceStrL 0; vnSourceStrL -= 2) {if(*vspSourceStr = '0' *vspSourceStr = '9')*vspDestStr = ((*vspSourceStr++) - '0')
本文原文出处: http://blog.csdn.net/bluishglc/article/details/ 严禁任何形式的转载，否则将委托CSDN官方维护权益！ 文档 安装与配置： /hadoop-hue-3-on-hdp-installation-tutorial/ Hue依赖的第三方组件列表： /cloudera/hue#development-prerequisites 安装 安装依赖的第三方组件 yum -y
现在各大网站销售中！ 京东： /.html 当当： /.html 亚马逊： /SparkI nternals 前言和目录附上，以便有需要了解的同学： 诞生于2005年的Hadoop解决了大数据的存储和计算问题，已经成为大数据处理的事实标准。但是，随着数据规模的爆炸式增长和计算场景的丰富细化，使得Hadoop越来越难以满足用户的需求。针对不同的计算
作者：周志湖 网名：摇摆少年梦 微信号：zhouzhihubeyond 本文主要内容 RDD 常用Transformation函数 1. RDD 常用Transformation函数 （1）union union将两个RDD数据集元素合并，类似两个集合的并集 union函数参数： /** * Return the union of this RDD and another one. Any identical elements will appear multiple * times (use `.dis
作者：周志湖 网名：摇摆少年梦 微信号：zhouzhihubeyond 本节主要内容 Spark重要概念 弹性分布式数据集（RDD）基础 1. Spark重要概念 本节部分内容源自官方文档： http://spark.apache.org/docs/latest/cluster-overview.html （1）Spark运行模式 目前最为常用的Spark运行模式有： - local：本地线程方式运行，主要用于开发调试Spark应用程序 - Standalone：利用Spark自带的资源管理与调度器运行S
作者：周志湖 网名：摇摆少年梦 微信号：zhouzhihubeyond 本节主要内容 操作系统环境准备 Hadoop 2.4.1集群搭建 Spark 1.5.0 集群部署 注：在利用CentOS 6.5操作系统安装spark 1.5集群过程中，本人发现Hadoop 2.4.1集群可以顺利搭建，但在Spark 1.5.0集群启动时出现了问题（可能原因是64位操作系统原因，源码需要重新编译，但本人没经过测试），经本人测试在ubuntu 10.04 操作系统上可以顺利成功搭建。大家可以利用CentOS 6.5进
Smack 4.1.x升级指南 作者：chszs，版权所有，未经同意，不得转载。博主主页： http://blog.csdn.net/chszs 一、Smack 4.1的主要改进 Smack 4.1.x最大的改进有两点： 1）支持XEP-198规范，即流管理 2）原生支持Android Smack 4.1使得原先的aSmack库可以丢入垃圾堆了。注意aSmack的最新版本只到4.0.7版。 二、流管理 流管理（Stream Management） Smack 4.1默认流管理是关闭的。可以通过下面的方法开
作者：周志湖 网名：摇摆少年梦 微信号：zhouzhihubeyond 本节主要内容 Intellij IDEA 14.1.4开发环境配置 Spark应用程序开发 1. Intellij IDEA 14.1.4开发环境配置 Intellij IDEA 功能十分强大，能够开发JAVA、Scala等相关应用程序，在依赖管理 智能提示等方面做到了极致，大家可以到: /idea/download/ 下载，目前有两种：Ultimate Edition Free 30-
Copyright (C)
ITfish.net>>>>>>>>进入主站...............................还没有帐号？ 赶紧
用户版块帖子
飞利浦 Spark III 代 spark3 4G MP3拆解分析【参赛】
UID：970496
在线时间1143小时
M币976专家2
这个MP3是彩屏的，屏幕的四边是四个按键，设计的不错，按键手感也不错，就是容易吴按，开机键是波动的带弹簧的，也不错，就是时间一长弹簧弹不回来，手再拨动回来，滴一滴缝纫机油解决问题 下面就是这个MP3的样子，小方块 这是播放界面，看着显示的信息也挺全面的 还可以显示时间和日期，主题样式可以更换 音量界面，音量按钮在侧面 后面的样子，带个小夹子，可以拆掉的小夹子 拆开后，屏幕的排线部分 排线的卡口，要十分小心，看样子也不是很脆弱的 拆开了，排线的黑胶下面有东西，看着不知道是芯片还是电容什么的这边的IC是著名的 台湾的吧 这一张看的清楚些 电池是221MAH不算很大，但是听音乐时间也不算短了 插头 接口 部分 4GB闪存&&主控是Sigmatel ST770主控芯片这个芯片也不错，索尼的那个也是用的这玩意下面是引用的论坛的主控说明 2007年Sigmatel发布了带有视频播放功能的STMP37XX系列芯片组。该款芯片组专门针对视频类MP3而开发，采用90纳米ARM 11内核，在处理性能、功耗和成本上都比以往的产品有较大的提升，其产品在性能表现上也延续了过去一贯的优良品质。STMP37XX系列主要特性：　　1.采用业界标准90纳米工艺和ARM处理器，提供高效、稳定的视频播放功能　　2.优异的影像质量：支持每秒30帧的QVGA MPEG4、H.264、以及WMV等视频格式　　3.具有出色的音质：失真率低于0.05％，信噪比可以达到98dB　　4.支持无线蓝牙技术　　5.弹性化的内存与LCD支持能力　　6.在视频与音频播放方面，提供业界领先的电池续航力　　7.高整合度、降低系统成本，无需外部电源管理或音频编译码器等组件&&&&SigmaTel STMP37XX系列芯片采用了320MHz ARM9内核架构及90纳米工艺，在结构上经过优化后不仅能降低物料清单成本，还可在 QVGA分辨率下支持多种视频格式。如使用400mAh 锂离子电池即可支持4小时的视频播放或60小时音频播放，降低功耗提高续航时间，可以算是 STMP37XX芯片的最大特色之一。STMP37XX支持视频格式包括MPEG-4(Divx、Xvid)、H.264、以及WMV等30帧/秒 QVGA分辨率的视频。&&&&音频播放方面将会支持高音质的MP3 ,WMA, WAV, AAC, Ogg，其中STMP3710系列还能支持APE、FLAC双无损格式，同时它还内置了存储器与LCD控制，且无需外部电源管理器件与音频编解码器，从而节省了总器件成本。除此之外STMP37XX可支持 Microsoft PlaysForSure 2.2x版及Vista操作系统。STMP37XX系列产品广泛支持多种NAND Flash解决方案，并可随闪存技术不断进步提供相应支持。&&&&Sigmatel 37XX系列目前包括Sigmatel 两款。&&&&采用Sigmatel 3710的数码产品在2008年初投放市场。在国内 蓝魔V7是首款使用3710芯片的机型。由于Sigmatel 3710续航出众、品质优良，众多厂家争相采用。相关产品比较多，这里不一一列举。&&&&Sigmatel 年投放市场。 与Sigmatel 3710的技术参数基本一致 只是在Embedded SRAM的参数上有所不同。KB而KB，Embedded SRAM是芯片内集成的嵌入式静态随机存储器，作用相当于CPU的高速缓冲存储器一样，提高缓冲可以提升系统的性能。 在国内 台电X19+第一个采用Sigmatel 3770芯片的产品，随后 昂达VX898S, 蓝魔 V7nano, 艾利和 E50, 歌美E300。 发现隐患，电池的红线焊接的很糟糕 这个是开机键的弹簧弹不回的主要原因，塑料部分磨损严重 音量按键，设计的不错，有些MP3主板拿下来音量键就掉了，这个是有卡扣的，好安装一些 一层图只能放15张图片，楼下接着
本文内容包含图片或附件，获取更多资讯，请
后查看；或者
成为会员获得更多权限
UID：875705
在线时间975小时
M币1313专家18
这个飞利浦MP3容量大，带收音机，很喜欢。
UID：970496
在线时间1143小时
M币976专家2
一块小主板，电池的红线还没等加固我就把它晃断了 屏幕部分 等着烙铁加热了接线 把胶扣掉，红线根本就没有焊好，连了一点 小心 焊上了，焊工很差劲，加上用的不是白光，20快在杂货店买的烙铁 装回去 安装完成 没有了，希望给准备买的同学一些参考，这个MP3噪音小，但不是没有，夜深的时候能听的到吱吱的电流声已经算不错了，比我以前用的强多了完
本文内容包含图片或附件，获取更多资讯，请
后查看；或者
成为会员获得更多权限
UID：970496
在线时间1143小时
M币976专家2
回 2楼(jayli) 的帖子
你太快了，我准备两楼连着呢，
UID：777663
在线时间9129小时
M币67053专家20
不是很流行菲芯吗?为什么这个不用自家芯片的.....奇怪..
UID：841986
在线时间6834小时
M币1919专家47
很漂亮的机器，电路板做工很精致。。。
UID：970496
在线时间1143小时
M币976专家2
回 5楼(benny3848hk) 的帖子
是啊，不知道为什么，成本也是问题吧
UID：141362
在线时间4555小时
M币518专家29
飞芯也是被人炒出来了
UID：829161
在线时间1815小时
M币132专家5
屏幕排线的黑胶下的都是电容什么的，除了电容屏，否则不会有芯片的，而且排线上也印刷了贴片元件的类型
UID：783410
在线时间2936小时
M币16专家42
都知道飞芯是公认的音质王，很多高端机都是飞芯的解决方案。就是不明白，自己怎么就不用自己的方案。我真怀凝是不是真飞利浦。
访问内容超出本站范围，不能确定是否安全
如果您提交过一次失败了，可以用”恢复数据”来恢复帖子内容
您目前还是游客，请
&回复后跳转到最后一页
Code by , Time now is:11-15 03:32, Total 0.117076(s) query 11,
Gzip enabled&